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