Пример #1
0
 /// <summary>
 /// Recursively searches the tree for all intersecting entries.
 /// Calls the passed function when a matching entry is found. Return if the passed function returns false;
 /// </summary>
 /// <param name="r"></param>
 /// <param name="v"></param>
 /// <param name="n"></param>
 /// <returns></returns>
 // TODO rewrite this to be non-recursive.
 private bool intersects(Rectangle r, Func <Rectangle, bool> v, NodeBase n)
 {
     for (int i = 0; i < n.entryCount; i++)
     {
         if (r.Intersects(ref n.entries[i]))
         {
             if (n.IsLeaf)
             {
                 if (!v(n.entries[i].Value))
                 {
                     return(false);
                 }
             }
             else
             {
                 NodeInternal nodeInternal = n as NodeInternal;
                 NodeInternal childNode    = nodeInternal.childNodes[i] as NodeInternal;
                 if (!intersects(r, v, childNode))
                 {
                     return(false);
                 }
             }
         }
     }
     return(true);
 }
Пример #2
0
        /// <summary>
        /// Adds a new entry at a specified level in the tree
        /// </summary>
        /// <param name="r">the rectangle added</param>
        /// <param name="level">the level of the tree to add it at</param>
        internal void AddInternal(Rectangle r, int level, NodeBase childNode)
        {
            // I1 [Find position for new record] Invoke ChooseLeaf to select a leaf node L in which to place r
            NodeInternal n           = (NodeInternal)chooseNode(r, level);
            NodeInternal newInternal = null;

            // I2 [Add record to leaf node] If L has room for another entry, install E. Otherwise invoke SplitNode to obtain L and LL containing E and all the old entries of L
            if (n.entryCount < maxNodeEntries)
            {
                n.addEntry(ref r, childNode);
            }
            else
            {
                newInternal = n.splitNode(this, ref r, childNode);
            }

            // I3 [Propagate changes upwards] Invoke AdjustTree on L, also passing LL if a split was performed
            NodeBase newNode = n.adjustTree(this, newInternal);

            // I4 [Grow tree taller] If node split propagation caused the root to split, create a new root whose children are the two resulting nodes.
            if (newNode != null)
            {
                NodeBase     oldRoot = rootNode;
                NodeInternal root    = new NodeInternal(++treeHeight, maxNodeEntries);
                rootNode = root;
                root.addEntry(ref newNode.minimumBoundingRectangle, newNode);
                root.addEntry(ref oldRoot.minimumBoundingRectangle, oldRoot);
            }
        }
Пример #3
0
        /// <summary>
        /// Used by delete(). Ensures that all nodes from the passed node up to the root have the minimum number of entries.
        /// Note that the parent and parentEntry stacks are expected to contain the nodeIds of all parents up to the root.
        /// </summary>
        /// <param name="rTree"></param>
        internal void condenseTree(RTree rTree)
        {
            // CT1 [Initialize] Set n=l. Set the list of eliminated nodes to be empty.
            NodeBase         n               = this;
            NodeInternal     parent          = null;
            int              parentEntry     = 0;
            Stack <NodeBase> eliminatedNodes = new Stack <NodeBase>();

            // CT2 [Find parent entry] If N is the root, go to CT6. Otherwise
            // let P be the parent of N, and let En be N's entry in P
            while (n.level != rTree.treeHeight)
            {
                parent      = rTree.parents.Pop() as NodeInternal;
                parentEntry = rTree.parentsEntry.Pop();

                // CT3 [Eliminiate under-full node] If N has too few entries,
                // delete En from P and add N to the list of eliminated nodes
                if (n.entryCount < rTree.minNodeEntries)
                {
                    parent.deleteEntry(parentEntry);
                    eliminatedNodes.Push(n);
                }
                else
                {
                    // CT4 [Adjust covering rectangle] If N has not been eliminated,
                    // adjust EnI to tightly contain all entries in N
                    if (n.minimumBoundingRectangle.MinX != parent.entries[parentEntry].Value.MinX || n.minimumBoundingRectangle.MinY != parent.entries[parentEntry].Value.MinY ||
                        n.minimumBoundingRectangle.MaxX != parent.entries[parentEntry].Value.MaxX || n.minimumBoundingRectangle.MaxY != parent.entries[parentEntry].Value.MaxY)
                    {
                        Rectangle d = parent.entries[parentEntry].Value;
                        parent.entries[parentEntry] = n.minimumBoundingRectangle;
                        parent.recalculateMBRIfInfluencedBy(ref d);
                    }
                }
                // CT5 [Move up one level in tree] Set N=P and repeat from CT2
                n = parent;
            }

            // CT6 [Reinsert orphaned entries] Reinsert all entries of nodes in set Q. Entries from eliminated leaf nodes are reinserted in tree leaves as in
            // Insert(), but entries from higher level nodes must be placed higher in the tree, so that leaves of their dependent subtrees will be on the same
            // level as leaves of the main tree
            while (eliminatedNodes.Count > 0)
            {
                NodeBase e = eliminatedNodes.Pop();
                for (int j = 0; j < e.entryCount; j++)
                {
                    if (e.level == 1)
                    {
                        rTree.AddInternal(e.entries[j].Value);
                    }
                    else
                    {
                        NodeInternal nInternal = e as NodeInternal;
                        rTree.AddInternal(e.entries[j].Value, e.level, nInternal.childNodes[j]);
                    }
                }
            }
        }
Пример #4
0
        /// <summary>
        /// Finds all rectangles contained by the passed rectangle
        /// </summary>
        /// <param name="r">The rectangle for which this method finds contained rectangles.</param>
        /// <param name="v">if return true, continue seach</param>
        public void Contains(Rectangle r, Func <Rectangle, bool> v)
        {
            // find all rectangles in the tree that are contained by the passed rectangle written to be non-recursive (should model other searches on this?)
            parents.Clear();
            parents.Push(rootNode);

            parentsEntry.Clear();
            parentsEntry.Push(-1);

            // TODO: possible shortcut here - could test for intersection with the MBR of the root node. If no intersection, return immediately.
            while (parents.Count > 0)
            {
                NodeBase n          = parents.Peek();
                int      startIndex = parentsEntry.Peek() + 1;

                if (!n.IsLeaf)
                {
                    NodeInternal nodeInternal = n as NodeInternal;
                    // go through every entry in the index node to check if it intersects the passed rectangle. If so, it could contain entries that are contained.
                    bool intersects = false;
                    for (int i = startIndex; i < n.entryCount; i++)
                    {
                        if (r.Intersects(ref n.entries[i]))
                        {
                            parents.Push(nodeInternal.childNodes[i]);
                            parentsEntry.Pop();
                            parentsEntry.Push(i); // this becomes the start index when the child has been searched
                            parentsEntry.Push(-1);
                            intersects = true;
                            break; // ie go to next iteration of while()
                        }
                    }
                    if (intersects)
                    {
                        continue;
                    }
                }
                else
                {
                    // go through every entry in the leaf to check if it is contained by the passed rectangle
                    for (int i = 0; i < n.entryCount; i++)
                    {
                        if (r.Contains(n.entries[i].Value))
                        {
                            if (!v(n.entries[i].Value))
                            {
                                return;
                            }
                        }
                    }
                }
                parents.Pop();
                parentsEntry.Pop();
            }
        }
Пример #5
0
        internal NodeInternal adjustTree(RTree rTree, NodeInternal nn)
        {
            // AT1 [Initialize] Set N=L. If L was split previously, set NN to be the resulting second node.

            // AT2 [Check if done] If N is the root, stop
            NodeInternal n = this;

            while (n.level != rTree.treeHeight)
            {
                // AT3 [Adjust covering rectangle in parent entry] Let P be the parent node of N, and let En be N's entry in P. Adjust EnI so that it tightly encloses all entry rectangles in N.
                NodeInternal parent = rTree.parents.Pop() as NodeInternal;
                int          entry  = rTree.parentsEntry.Pop();

                if (parent.childNodes[entry] != n)
                {
                    throw new UnexpectedException("Error: entry " + entry + " in node " + parent + " should point to node " + n + "; actually points to node " + parent.childNodes[entry]);
                }

                Rectangle r = (Rectangle)parent.entries[entry];
                if (r.MinX != n.minimumBoundingRectangle.MinX || r.MinY != n.minimumBoundingRectangle.MinY ||
                    r.MaxX != n.minimumBoundingRectangle.MaxX || r.MaxY != n.minimumBoundingRectangle.MaxY)
                {
                    r = n.minimumBoundingRectangle;
                    Update();
                    parent.entries[entry] = r;
                    parent.recalculateMBR();
                }

                // AT4 [Propagate node split upward] If N has a partner NN resulting from an earlier split, create a new entry Enn with Ennp pointing to NN and
                // Enni enclosing all rectangles in NN. Add Enn to P if there is room. Otherwise, invoke splitNode to produce P and PP containing Enn and all P's old entries.
                NodeInternal newNode = null;
                if (nn != null)
                {
                    if (parent.entryCount < rTree.maxNodeEntries)
                    {
                        parent.addEntry(ref nn.minimumBoundingRectangle, nn);
                    }
                    else
                    {
                        newNode = parent.splitNode(rTree, ref nn.minimumBoundingRectangle, nn);
                    }
                }

                // AT5 [Move up to next level] Set N = P and set NN = PP if a split occurred. Repeat from AT2
                n  = parent;
                nn = newNode;

                parent  = null;
                newNode = null;
            }

            return(nn);
        }
Пример #6
0
        /// <summary>
        /// Used by add(). Chooses a leaf to add the rectangle to.
        /// </summary>
        /// <param name="r"></param>
        /// <param name="level"></param>
        /// <returns></returns>
        private NodeBase chooseNode(Rectangle r, int level)
        {
            // CL1 [Initialize] Set N to be the root node
            NodeBase n = rootNode;

            parents.Clear();
            parentsEntry.Clear();

            // CL2 [Leaf check] If N is a leaf, return N
            while (true)
            {
                if (n == null)
                {
                    throw new UnexpectedException("Could not get root node (" + rootNode + ")");
                }

                if (n.level == level)
                {
                    return(n);
                }

                NodeInternal nodeInternal = n as NodeInternal;
                // CL3 [Choose subtree] If N is not at the desired level, let F be the entry in N whose rectangle FI needs least enlargement to include EI. Resolve
                // ties by choosing the entry with the rectangle of smaller area.
                double leastEnlargement = n.entries[0].Value.Enlargement(ref r);
                int    index            = 0; // index of rectangle in subtree
                for (int i = 1; i < n.entryCount; i++)
                {
                    double tempEnlargement = n.entries[i].Value.Enlargement(ref r);
                    if (tempEnlargement < leastEnlargement || (tempEnlargement == leastEnlargement && n.entries[i].Value.Area < n.entries[index].Value.Area))
                    {
                        index            = i;
                        leastEnlargement = tempEnlargement;
                    }
                }

                parents.Push(n);
                parentsEntry.Push(index);

                // CL4 [Descend until a leaf is reached] Set N to be the child node pointed to by Fp and repeat from CL2
                n = nodeInternal.childNodes[index];
            }
        }
Пример #7
0
        internal NodeInternal splitNode(RTree rTree, ref Rectangle r, NodeBase childNode)
        {
            // [Pick first entry for each group] Apply algorithm pickSeeds to
            // choose two entries to be the first elements of the groups. Assign
            // each to a group.

            // debug code

            /*double initialArea = 0;
             *   if (log.isDebugEnabled())
             *   {
             *     double unionMinX = Math.Min(n.mbrMinX, newRectMinX);
             *     double unionMinY = Math.Min(n.mbrMinY, newRectMinY);
             *     double unionMaxX = Math.Max(n.mbrMaxX, newRectMaxX);
             *     double unionMaxY = Math.Max(n.mbrMaxY, newRectMaxY);
             *
             *     initialArea = (unionMaxX - unionMinX) * (unionMaxY - unionMinY);
             *   }*/

            System.Array.Copy(rTree.initialEntryStatus, 0, rTree.entryStatus, 0, rTree.maxNodeEntries);

            NodeInternal newNode = null;

            newNode = new NodeInternal(level, rTree.maxNodeEntries);
            Update();
            pickSeeds(rTree, ref r, newNode, childNode); // this also sets the entryCount to 1

            // [Check if done] If all entries have been assigned, stop. If one group has so few entries that all the rest must be assigned to it in
            // order for it to have the minimum number m, assign them and stop.
            while (entryCount + newNode.entryCount < rTree.maxNodeEntries + 1)
            {
                if (rTree.maxNodeEntries + 1 - newNode.entryCount == rTree.minNodeEntries)
                {
                    // assign all remaining entries to original node
                    for (int i = 0; i < rTree.maxNodeEntries; i++)
                    {
                        if (rTree.entryStatus[i] == ((byte)RTree.EntryStatus.unassigned))
                        {
                            rTree.entryStatus[i] = ((byte)RTree.EntryStatus.assigned);

                            if (entries[i].Value.MinX < minimumBoundingRectangle.MinX)
                            {
                                minimumBoundingRectangle.MinX = entries[i].Value.MinX;
                            }
                            if (entries[i].Value.MinY < minimumBoundingRectangle.MinY)
                            {
                                minimumBoundingRectangle.MinY = entries[i].Value.MinY;
                            }
                            if (entries[i].Value.MaxX > minimumBoundingRectangle.MaxX)
                            {
                                minimumBoundingRectangle.MaxX = entries[i].Value.MaxX;
                            }
                            if (entries[i].Value.MaxY > minimumBoundingRectangle.MaxY)
                            {
                                minimumBoundingRectangle.MaxY = entries[i].Value.MaxY;
                            }
                            entryCount++;
                        }
                    }
                    break;
                }
                if (rTree.maxNodeEntries + 1 - entryCount == rTree.minNodeEntries)
                {
                    // assign all remaining entries to new node
                    for (int i = 0; i < rTree.maxNodeEntries; i++)
                    {
                        if (rTree.entryStatus[i] == ((byte)RTree.EntryStatus.unassigned))
                        {
                            rTree.entryStatus[i] = ((byte)RTree.EntryStatus.assigned);
                            Rectangle entriesR = entries[i].Value;
                            newNode.addEntry(ref entriesR, childNodes[i]);
                            entries[i]    = null;
                            childNodes[i] = null;
                        }
                    }
                    break;
                }

                // [Select entry to assign] Invoke algorithm pickNext to choose the next entry to assign. Add it to the group whose covering rectangle
                // will have to be enlarged least to accommodate it. Resolve ties by adding the entry to the group with smaller area, then to the
                // the one with fewer entries, then to either. Repeat from S2
                pickNext(rTree, newNode);
            }

            reorganize(rTree);

            // check that the MBR stored for each node is correct.
#if RtreeCheck
            if (!minimumBoundingRectangle.Equals(calculateMBR()))
            {
                throw new UnexpectedException("Error: splitNode old node MBR wrong");
            }
            if (!newNode.minimumBoundingRectangle.Equals(newNode.calculateMBR()))
            {
                throw new UnexpectedException("Error: splitNode new node MBR wrong");
            }
#endif

#if RtreeCheck
            double newArea            = minimumBoundingRectangle.Area + newNode.minimumBoundingRectangle.Area;
            double percentageIncrease = (100 * (newArea - initialArea)) / initialArea;
            Console.WriteLine("Node " + this + " split. New area increased by " + percentageIncrease + "%");
#endif

            return(newNode);
        }
Пример #8
0
        private int pickNext(RTree rTree, NodeInternal newNode)
        {
            double maxDifference = double.NegativeInfinity;
            int    next          = 0;
            int    nextGroup     = 0;

            maxDifference = double.NegativeInfinity;

#if RtreeCheck
            Console.WriteLine("pickNext()");
#endif

            for (int i = 0; i < rTree.maxNodeEntries; i++)
            {
                if (rTree.entryStatus[i] == ((byte)RTree.EntryStatus.unassigned))
                {
                    if (entries[i] == null)
                    {
                        throw new UnexpectedException("Error: Node " + this + ", entry " + i + " is null");
                    }
                    Rectangle entryR          = entries[i].Value;
                    double    nIncrease       = minimumBoundingRectangle.Enlargement(ref entryR);
                    double    newNodeIncrease = newNode.minimumBoundingRectangle.Enlargement(ref entryR);
                    double    difference      = Math.Abs(nIncrease - newNodeIncrease);

                    if (difference > maxDifference)
                    {
                        next = i;

                        if (nIncrease < newNodeIncrease)
                        {
                            nextGroup = 0;
                        }
                        else if (newNodeIncrease < nIncrease)
                        {
                            nextGroup = 1;
                        }
                        else if (minimumBoundingRectangle.Area < newNode.minimumBoundingRectangle.Area)
                        {
                            nextGroup = 0;
                        }
                        else if (newNode.minimumBoundingRectangle.Area < minimumBoundingRectangle.Area)
                        {
                            nextGroup = 1;
                        }
                        else if (newNode.entryCount < rTree.maxNodeEntries / 2)
                        {
                            nextGroup = 0;
                        }
                        else
                        {
                            nextGroup = 1;
                        }
                        maxDifference = difference;
                    }
#if RtreeCheck
                    Console.WriteLine("Entry " + i + " group0 increase = " + nIncrease + ", group1 increase = " + newNodeIncrease + ", diff = " + difference + ", MaxDiff = " + maxDifference + " (entry " + next + ")");
#endif
                }
            }

            rTree.entryStatus[next] = ((byte)RTree.EntryStatus.assigned);

            if (nextGroup == 0)
            {
                Update();
                Rectangle r = entries[next].Value;
                if (r.MinX < minimumBoundingRectangle.MinX)
                {
                    minimumBoundingRectangle.MinX = r.MinX;
                }
                if (r.MinY < minimumBoundingRectangle.MinY)
                {
                    minimumBoundingRectangle.MinY = r.MinY;
                }
                if (r.MaxX > minimumBoundingRectangle.MaxX)
                {
                    minimumBoundingRectangle.MaxX = r.MaxX;
                }
                if (r.MaxY > minimumBoundingRectangle.MaxY)
                {
                    minimumBoundingRectangle.MaxY = r.MaxY;
                }
                entryCount++;
            }
            else
            {
                // move to new node.
                Rectangle entriesR = entries[next].Value;
                newNode.addEntry(ref entriesR, childNodes[next]);
                entries[next]    = null;
                childNodes[next] = null;
            }

            return(next);
        }
Пример #9
0
        private void pickSeeds(RTree rTree, ref Rectangle r, NodeInternal newNode, NodeBase childNode)
        {
            // Find extreme rectangles along all dimension. Along each dimension, find the entry whose rectangle has the highest low side, and the one
            // with the lowest high side. Record the separation.
            double maxNormalizedSeparation = -1; // initialize to -1 so that even overlapping rectangles will be considered for the seeds
            int    highestLowIndex         = -1;
            int    lowestHighIndex         = -1;

            Update();
            // for the purposes of picking seeds, take the MBR of the node to include the new rectangle aswell.
            if (r.MinX < minimumBoundingRectangle.MinX)
            {
                minimumBoundingRectangle.MinX = r.MinX;
            }
            if (r.MinY < minimumBoundingRectangle.MinY)
            {
                minimumBoundingRectangle.MinY = r.MinY;
            }
            if (r.MaxX > minimumBoundingRectangle.MaxX)
            {
                minimumBoundingRectangle.MaxX = r.MaxX;
            }
            if (r.MaxY > minimumBoundingRectangle.MaxY)
            {
                minimumBoundingRectangle.MaxY = r.MaxY;
            }

            double mbrLenX = minimumBoundingRectangle.MaxX - minimumBoundingRectangle.MinX;
            double mbrLenY = minimumBoundingRectangle.MaxY - minimumBoundingRectangle.MinY;

#if RtreeCheck
            Console.WriteLine("pickSeeds(): NodeI = " + this);
#endif

            double tempHighestLow      = r.MinX;
            int    tempHighestLowIndex = -1; // -1 indicates the new rectangle is the seed

            double tempLowestHigh      = r.MaxX;
            int    tempLowestHighIndex = -1; // -1 indicates the new rectangle is the seed

            for (int i = 0; i < entryCount; i++)
            {
                double tempLow = entries[i].Value.MinX;
                if (tempLow >= tempHighestLow)
                {
                    tempHighestLow      = tempLow;
                    tempHighestLowIndex = i;
                } // ensure that the same index cannot be both lowestHigh and highestLow
                else
                {
                    double tempHigh = entries[i].Value.MaxX;
                    if (tempHigh <= tempLowestHigh)
                    {
                        tempLowestHigh      = tempHigh;
                        tempLowestHighIndex = i;
                    }
                }

                // PS2 [Adjust for shape of the rectangle cluster] Normalize the separations by dividing by the widths of the entire set along the corresponding dimension
                double normalizedSeparation = mbrLenX == 0 ? 1 : (tempHighestLow - tempLowestHigh) / mbrLenX;
                if (normalizedSeparation > 1 || normalizedSeparation < -1)
                {
                    Console.WriteLine("Invalid normalized separation X");
                }

#if RtreeCheck
                Console.WriteLine("Entry " + i + ", dimension X: HighestLow = " + tempHighestLow + " (index " + tempHighestLowIndex + ")" + ", LowestHigh = " + tempLowestHigh + " (index " + tempLowestHighIndex + ", NormalizedSeparation = " + normalizedSeparation);
#endif
                // PS3 [Select the most extreme pair] Choose the pair with the greatest normalized separation along any dimension.
                // Note that if negative it means the rectangles overlapped. However still include overlapping rectangles if that is the only choice available.
                if (normalizedSeparation >= maxNormalizedSeparation)
                {
                    highestLowIndex         = tempHighestLowIndex;
                    lowestHighIndex         = tempLowestHighIndex;
                    maxNormalizedSeparation = normalizedSeparation;
                }
            }

            // Repeat for the Y dimension
            tempHighestLow      = r.MinY;
            tempHighestLowIndex = -1; // -1 indicates the new rectangle is the seed

            tempLowestHigh      = r.MaxY;
            tempLowestHighIndex = -1; // -1 indicates the new rectangle is the seed

            for (int i = 0; i < entryCount; i++)
            {
                double tempLow = entries[i].Value.MinY;
                if (tempLow >= tempHighestLow)
                {
                    tempHighestLow      = tempLow;
                    tempHighestLowIndex = i;
                } // ensure that the same index cannot be both lowestHigh and highestLow
                else
                {
                    double tempHigh = entries[i].Value.MaxY;
                    if (tempHigh <= tempLowestHigh)
                    {
                        tempLowestHigh      = tempHigh;
                        tempLowestHighIndex = i;
                    }
                }

                // PS2 [Adjust for shape of the rectangle cluster] Normalize the separations by dividing by the widths of the entire set along the corresponding dimension
                double normalizedSeparation = mbrLenY == 0 ? 1 : (tempHighestLow - tempLowestHigh) / mbrLenY;
                if (normalizedSeparation > 1 || normalizedSeparation < -1)
                {
                    throw new UnexpectedException("Invalid normalized separation Y");
                }
#if RtreeCheck
                Console.WriteLine("Entry " + i + ", dimension Y: HighestLow = " + tempHighestLow + " (index " + tempHighestLowIndex + ")" + ", LowestHigh = " + tempLowestHigh + " (index " + tempLowestHighIndex + ", NormalizedSeparation = " + normalizedSeparation);
#endif
                // PS3 [Select the most extreme pair] Choose the pair with the greatest normalized separation along any dimension.
                // Note that if negative it means the rectangles overlapped. However still include overlapping rectangles if that is the only choice available.
                if (normalizedSeparation >= maxNormalizedSeparation)
                {
                    highestLowIndex         = tempHighestLowIndex;
                    lowestHighIndex         = tempLowestHighIndex;
                    maxNormalizedSeparation = normalizedSeparation;
                }
            }

            // At this point it is possible that the new rectangle is both highestLow and lowestHigh. This can happen if all rectangles in the node overlap the new rectangle.
            // Resolve this by declaring that the highestLowIndex is the lowest Y and, the lowestHighIndex is the largest X (but always a different rectangle)
            if (highestLowIndex == lowestHighIndex)
            {
                highestLowIndex = -1;
                double tempMinY = r.MinY;
                lowestHighIndex = 0;
                double tempMaxX = entries[0].Value.MaxX;

                for (int i = 1; i < entryCount; i++)
                {
                    if (entries[i].Value.MinY < tempMinY)
                    {
                        tempMinY        = entries[i].Value.MinY;
                        highestLowIndex = i;
                    }
                    else if (entries[i].Value.MaxX > tempMaxX)
                    {
                        tempMaxX        = entries[i].Value.MaxX;
                        lowestHighIndex = i;
                    }
                }
            }

            // highestLowIndex is the seed for the new node.
            if (highestLowIndex == -1)
            {
                newNode.addEntry(ref r, childNode);
            }
            else
            {
                Rectangle entriesR = entries[highestLowIndex].Value;
                newNode.addEntry(ref entriesR, childNodes[highestLowIndex]);
                entries[highestLowIndex]    = r; // move the new rectangle into the space vacated by the seed for the new node
                childNodes[highestLowIndex] = childNode;
            }

            // lowestHighIndex is the seed for the original node.
            if (lowestHighIndex == -1)
            {
                lowestHighIndex = highestLowIndex;
            }

            rTree.entryStatus[lowestHighIndex] = ((byte)RTree.EntryStatus.assigned);
            entryCount = 1;
            minimumBoundingRectangle = entries[lowestHighIndex].Value;
        }
Пример #10
0
        private bool checkConsistency(NodeBase n, int expectedLevel, Rectangle?expectedMBR)
        {
            // go through the tree, and check that the internal data structures of the tree are not corrupted.

            if (n == null)
            {
                throw new UnexpectedException($"Error: Could not read node {this}");
            }

            // if tree is empty, then there should be exactly one node, at level 1
            // TODO: also check the MBR is as for a new node
            if (n == rootNode && Count == 0)
            {
                if (n.level != 1)
                {
                    throw new UnexpectedException("Error: tree is empty but root node is not at level 1");
                }
            }

            if (n.level != expectedLevel)
            {
                throw new UnexpectedException("Error: Node " + this + ", expected level " + expectedLevel + ", actual level " + n.level);
            }

            Rectangle calculatedMBR = n.calculateMinimumBoundingRectangle();
            Rectangle actualMBR     = n.minimumBoundingRectangle;

            if (!actualMBR.Equals(calculatedMBR))
            {
                if (actualMBR.MinX != n.minimumBoundingRectangle.MinX)
                {
                    throw new UnexpectedException($"  actualMinX={actualMBR.MinX}, calc={calculatedMBR.MinX}");
                }
                if (actualMBR.MinY != n.minimumBoundingRectangle.MinY)
                {
                    throw new UnexpectedException($"  actualMinY={actualMBR.MinY}, calc={calculatedMBR.MinY}");
                }
                if (actualMBR.MaxX != n.minimumBoundingRectangle.MaxX)
                {
                    throw new UnexpectedException($"  actualMaxX={actualMBR.MaxX}, calc={calculatedMBR.MaxX}");
                }
                if (actualMBR.MaxY != n.minimumBoundingRectangle.MaxY)
                {
                    throw new UnexpectedException($"  actualMaxY={actualMBR.MaxY}, calc={calculatedMBR.MaxY}");
                }
                throw new UnexpectedException("Error: Node " + this + ", calculated MBR does not equal stored MBR");
            }

            if (expectedMBR != null && !actualMBR.Equals(expectedMBR))
            {
                throw new UnexpectedException("Error: Node " + this + ", expected MBR (from parent) does not equal stored MBR");
            }

            for (int i = 0; i < n.entryCount; i++)
            {
                if (n.level > 1) // if not a leaf
                {
                    NodeInternal nodeInternal = n as NodeInternal;
                    if (nodeInternal.childNodes[i] == null)
                    {
                        throw new UnexpectedException("Error: Node " + this + ", Entry " + i + " is null");
                    }
                    if (!checkConsistency(nodeInternal.childNodes[i], n.level - 1, n.entries[i]))
                    {
                        return(false);
                    }
                }
            }
            return(true);
        }
Пример #11
0
        private PriorityQueueRTree createNearestNDistanceQueue(Point p, UInt32 count, double furthestDistance)
        {
            PriorityQueueRTree distanceQueue = new PriorityQueueRTree();

            //  return immediately if given an invalid "count" parameter
            if (count == 0)
            {
                return(distanceQueue);
            }

            parents.Clear();
            parents.Push(rootNode);

            parentsEntry.Clear();
            parentsEntry.Push(-1);

            // TODO: possible shortcut here - could test for intersection with the MBR of the root node. If no intersection, return immediately.
            double furthestDistanceSq = furthestDistance * furthestDistance;

            while (parents.Count > 0)
            {
                NodeBase n          = parents.Peek();
                int      startIndex = parentsEntry.Peek() + 1;

                if (!n.IsLeaf)
                {
                    // go through every entry in the index node to check if it could contain an entry closer than the farthest entry currently stored.
                    bool         near         = false;
                    NodeInternal nodeInternal = n as NodeInternal;
                    for (int i = startIndex; i < n.entryCount; i++)
                    {
                        if (n.entries[i].Value.distanceSq(p.x, p.y) <= furthestDistanceSq)
                        {
                            parents.Push(nodeInternal.childNodes[i]);
                            parentsEntry.Pop();
                            parentsEntry.Push(i); // this becomes the start index when the child has been searched
                            parentsEntry.Push(-1);
                            near = true;
                            break; // ie go to next iteration of while()
                        }
                    }
                    if (near)
                    {
                        continue;
                    }
                }
                else
                {
                    // go through every entry in the leaf to check if it is currently one of the nearest N entries.
                    for (int i = 0; i < n.entryCount; i++)
                    {
                        double entryDistanceSq = n.entries[i].Value.distanceSq(p.x, p.y);

                        if (entryDistanceSq <= furthestDistanceSq)
                        {
                            distanceQueue.Insert(n.entries[i].Value, entryDistanceSq);

                            while (distanceQueue.Count > count)
                            {
                                // normal case - we can simply remove the lowest priority (highest distance) entry
                                Rectangle value      = distanceQueue.ValuePeek;
                                double    distanceSq = distanceQueue.PriorityPeek;
                                distanceQueue.Pop();

                                // rare case - multiple items of the same priority (distance)
                                if (distanceSq == distanceQueue.PriorityPeek)
                                {
                                    savedValues.Add(value);
                                    savedPriority = distanceSq;
                                }
                                else
                                {
                                    savedValues.Clear();
                                }
                            }

                            // if the saved values have the same distance as the next one in the tree, add them back in.
                            if (savedValues.Count > 0 && savedPriority == distanceQueue.PriorityPeek)
                            {
                                for (int svi = 0; svi < savedValues.Count; svi++)
                                {
                                    distanceQueue.Insert(savedValues[svi], savedPriority);
                                }
                                savedValues.Clear();
                            }

                            // narrow the search, if we have already found N items
                            if (distanceQueue.PriorityPeek < furthestDistanceSq && distanceQueue.Count >= count)
                            {
                                furthestDistanceSq = distanceQueue.PriorityPeek;
                            }
                        }
                    }
                }
                parents.Pop();
                parentsEntry.Pop();
            }
            return(distanceQueue);
        }
Пример #12
0
        /// <summary>
        /// Removes a rectangle from the Rtree
        /// </summary>
        /// <param name="r">the rectangle to delete</param>
        /// <returns>true if rectangle deleted otherwise false</returns>
        public bool Remove(Rectangle r)
        {
            // FindLeaf algorithm inlined here. Note the "official" algorithm searches all overlapping entries. This seems inefficient,
            // as an entry is only worth searching if it contains (NOT overlaps) the rectangle we are searching for.

            // FL1 [Search subtrees] If root is not a leaf, check each entry to determine if it contains r. For each entry found, invoke
            // findLeaf on the node pointed to by the entry, until r is found or all entries have been checked.
            parents.Clear();
            parents.Push(rootNode);

            parentsEntry.Clear();
            parentsEntry.Push(-1);
            NodeBase n          = null;
            int      foundIndex = -1; // index of entry to be deleted in leaf

            while (foundIndex == -1 && parents.Count > 0)
            {
                n = parents.Peek();
                int startIndex = parentsEntry.Peek() + 1;

                if (!n.IsLeaf)
                {
                    NodeInternal internalNode = n as NodeInternal;
                    bool         Contains     = false;
                    for (int i = startIndex; i < n.entryCount; i++)
                    {
                        if (n.entries[i].Value.Contains(r))
                        {
                            parents.Push(internalNode.childNodes[i]);
                            parentsEntry.Pop();
                            parentsEntry.Push(i); // this becomes the start index when the child has been searched
                            parentsEntry.Push(-1);
                            Contains = true;
                            break; // ie go to next iteration of while()
                        }
                    }
                    if (Contains)
                    {
                        continue;
                    }
                }
                else
                {
                    NodeLeaf leaf = n as NodeLeaf;
                    foundIndex = leaf.findEntry(ref r);
                }

                parents.Pop();
                parentsEntry.Pop();
            } // while not found

            if (foundIndex != -1)
            {
                NodeLeaf leaf = n as NodeLeaf;
                leaf.deleteEntry(foundIndex);
                leaf.condenseTree(this);
                size--;
            }

            // shrink the tree if possible (i.e. if root node has exactly one entry, and that entry is not a leaf node, delete the root (it's entry becomes the new root)
            NodeBase root = rootNode;

            while (root.entryCount == 1 && treeHeight > 1)
            {
                NodeInternal rootInternal = root as NodeInternal;
                root.entryCount = 0;
                rootNode        = rootInternal.childNodes[0];
                treeHeight--;
            }

            // if the tree is now empty, then set the MBR of the root node back to it's original state (this is only needed when the tree is empty,
            // as this is the only state where an empty node is not eliminated)
            if (size == 0)
            {
                rootNode.minimumBoundingRectangle = new Rectangle(true);
            }

#if RtreeCheck
            checkConsistency();
#endif

            return(foundIndex != -1);
        }