Inheritance: NodeBase
コード例 #1
0
ファイル: RTree.cs プロジェクト: timotrob/VelocityDB
        /// <summary>
        /// Adds a new entry at a specified level in the tree
        /// </summary>
        /// <param name="r">the rectangle added</param>
        internal void AddInternal(Rectangle r)
        {
            // I1 [Find position for new record] Invoke ChooseLeaf to select a leaf node L in which to place r
            NodeLeaf n       = (NodeLeaf)chooseNode(r, 1);
            NodeLeaf newLeaf = 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);
            }
            else
            {
                newLeaf = n.splitNode(this, r);
            }

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

            // 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);
            }
        }
コード例 #2
0
ファイル: NodeLeaf.cs プロジェクト: VelocityDB/VelocityDB
    internal NodeBase adjustTree(RTree rTree, NodeLeaf 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
      while (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] != this)
          throw new UnexpectedException("Error: entry " + entry + " in node " + parent + " should point to node " + this + "; actually points to node " + parent.childNodes[entry]);
        if (parent.entries[entry].Value.MinX != minimumBoundingRectangle.MinX || parent.entries[entry].Value.MinY != minimumBoundingRectangle.MinY ||
            parent.entries[entry].Value.MaxX != minimumBoundingRectangle.MaxX || parent.entries[entry].Value.MaxY != minimumBoundingRectangle.MaxY)
        {
          parent.entries[entry] = minimumBoundingRectangle;
          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
        return parent.adjustTree(rTree, newNode);
      }
      return nn;
    }
コード例 #3
0
ファイル: NodeLeaf.cs プロジェクト: philipjadler/VelocityDB
        internal NodeBase adjustTree(RTree rTree, NodeLeaf 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
            while (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] != this)
                {
                    throw new UnexpectedException("Error: entry " + entry + " in node " + parent + " should point to node " + this + "; actually points to node " + parent.childNodes[entry]);
                }
                if (parent.entries[entry].Value.MinX != minimumBoundingRectangle.MinX || parent.entries[entry].Value.MinY != minimumBoundingRectangle.MinY ||
                    parent.entries[entry].Value.MaxX != minimumBoundingRectangle.MaxX || parent.entries[entry].Value.MaxY != minimumBoundingRectangle.MaxY)
                {
                    parent.entries[entry] = minimumBoundingRectangle;
                    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
                return(parent.adjustTree(rTree, newNode));
            }
            return(nn);
        }
コード例 #4
0
ファイル: NodeLeaf.cs プロジェクト: philipjadler/VelocityDB
        private int pickNext(RTree rTree, NodeLeaf 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 r = entries[next].Value;
                newNode.addEntry(ref r);
                entries[next] = null;
            }
            return(next);
        }
コード例 #5
0
ファイル: NodeLeaf.cs プロジェクト: philipjadler/VelocityDB
        internal NodeLeaf splitNode(RTree rTree, Rectangle r)
        {
            // [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);
            Update();
            NodeLeaf newNode = null;

            newNode = new NodeLeaf(level, rTree.maxNodeEntries);

            pickSeeds(rTree, ref r, newNode); // 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 entryR = entries[i].Value;
                            newNode.addEntry(ref entryR);
                            entries[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 (!this.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);
        }
コード例 #6
0
ファイル: NodeLeaf.cs プロジェクト: philipjadler/VelocityDB
        private void pickSeeds(RTree rTree, ref Rectangle r, NodeLeaf newNode)
        {
            // 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(): Node = " + 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);
            }
            else
            {
                Rectangle entryRectangle = entries[highestLowIndex].Value;
                newNode.addEntry(ref entryRectangle);
                entries[highestLowIndex] = r; // move the new rectangle into the space vacated by the seed for the new node
            }

            // 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;
        }
コード例 #7
0
ファイル: RTree.cs プロジェクト: timotrob/VelocityDB
        /// <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);
        }
コード例 #8
0
ファイル: NodeLeaf.cs プロジェクト: VelocityDB/VelocityDB
    private int pickNext(RTree rTree, NodeLeaf 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 r = entries[next].Value;
        newNode.addEntry(ref r);
        entries[next] = null;
      }
      return next;
    }
コード例 #9
0
ファイル: NodeLeaf.cs プロジェクト: VelocityDB/VelocityDB
    internal NodeLeaf splitNode(RTree rTree, Rectangle r)
    {
      // [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);
      Update();
      NodeLeaf newNode = null;
      newNode = new NodeLeaf(level, rTree.maxNodeEntries);

      pickSeeds(rTree, ref r, newNode); // 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 entryR = entries[i].Value;
              newNode.addEntry(ref entryR);
              entries[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 (!this.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;
    }
コード例 #10
0
ファイル: NodeLeaf.cs プロジェクト: VelocityDB/VelocityDB
    private void pickSeeds(RTree rTree, ref Rectangle r, NodeLeaf newNode)
    {
      // 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(): Node = " + 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);
      else
      {
        Rectangle entryRectangle = entries[highestLowIndex].Value;
        newNode.addEntry(ref entryRectangle);
        entries[highestLowIndex] = r;  // move the new rectangle into the space vacated by the seed for the new node
      }

      // 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;
    }