Beispiel #1
0
 ////////////////////////////////////////////////////NEED ADJUSTMENT IN DISTANCE MEASURE
 /// <summary>
 /// Recursively searches the tree for the nearest entry. Other queries
 /// call execute() on an IntProcedure when a matching entry is found;
 /// however nearest() must store the entry Ids as it searches the tree,
 /// in case a nearer entry is found.
 /// Uses the member variable nearestIds to store the nearest
 /// entry IDs.
 /// </summary>
 /// <remarks>TODO rewrite this to be non-recursive?</remarks>
 private double nearest(SubSequence p, Node <T> n, double nearestDistance)
 {
     for (int i = 0; i < n.entryCount; i++)
     {
         double tempDistance = n.entries[i].distance(p);
         if (n.isLeaf())
         { // for leaves, the distance is an actual nearest distance
             if (tempDistance < nearestDistance)
             {
                 nearestDistance = tempDistance;
                 nearestIds.Clear();
             }
             if (tempDistance <= nearestDistance)
             {
                 nearestIds.Add(n.ids[i]);
             }
         }
         else
         { // for index nodes, only go into them if they potentially could have
             // a rectangle nearer than actualNearest
             if (tempDistance <= nearestDistance)
             {
                 // search the child node
                 nearestDistance = nearest(p, getNode(n.ids[i]), nearestDistance);
             }
         }
     }
     return(nearestDistance);
 }
Beispiel #2
0
        /// <summary>
        /// Retrieve nearest items to a point in radius furthestDistance
        /// </summary>
        public List <T> Nearest(SubSequence p, double furthestDistance)
        {
            List <T> retval = new List <T>();

            nearest(p, delegate(int id)
            {
                retval.Add(IdsToItems[id]);
            }, furthestDistance);
            return(retval);
        }
Beispiel #3
0
        private void nearest(SubSequence p, intproc v, double furthestDistance)
        {
            Node <T> rootNode = getNode(rootNodeId);

            nearest(p, rootNode, furthestDistance);

            foreach (int id in nearestIds)
            {
                v(id);
            }
            nearestIds.Clear();
        }
        /**
         * Return the distance between this rectangle and the passed point.
         * If the rectangle contains the point, the distance is zero.
         *
         * @param p Point to find the distance to
         *
         * @return distance beween this rectangle and the passed point.
         */
        internal double distance(SubSequence p)
        {
            double distanceSquared = 0;

            for (int i = 0; i < DIMENSIONS; i++)
            {
                double greatestMin = Math.Max(min[i], p.coordinates[i]);
                double leastMax    = Math.Min(max[i], p.coordinates[i]);
                if (greatestMin > leastMax)
                {
                    distanceSquared += ((greatestMin - leastMax) * (greatestMin - leastMax));
                }
            }
            return((double)Math.Sqrt(distanceSquared));
        }