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