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