internal RTreeNode(int maxKeysPerNode, RTreeNode parent)
{
Parent = parent;
Children = new RTreeNode[maxKeysPerNode];
}
/// <summary>
/// Clear all data in this R-tree.
/// </summary>
public void Clear()
{
Root = null;
leafMappings.Clear();
Count = 0;
}
private void deleteNode(RTreeNode nodeToDelete)
{
removeAt(nodeToDelete.Parent.Children, nodeToDelete.Index);
nodeToDelete.Parent.KeyCount--;
updateIndex(nodeToDelete.Parent.Children, nodeToDelete.Parent.KeyCount, nodeToDelete.Index);
}
/// <summary>
/// Insert and split recursively up until no split is required.
/// </summary>
private void insertAndSplit(RTreeNode node, RTreeNode newValue)
{
//newValue have room to fit in this node
if (node.KeyCount < maxKeysPerNode)
{
node.AddChild(newValue);
expandAncestorMBRs(node);
return;
}
var e = new List <RTreeNode>(new RTreeNode[] { newValue });
e.AddRange(node.Children);
var distantPairs = getDistantPairs(e);
//Let E be the set consisting of all current entries and new entry.
//Select as seeds two entries e1, e2 ∈ E, where the distance between
//left and right is the maximum among all other pairs of entries from E
var e1 = new RTreeNode(maxKeysPerNode, null);
var e2 = new RTreeNode(maxKeysPerNode, null);
e1.AddChild(distantPairs.Item1);
e2.AddChild(distantPairs.Item2);
e = e.Where(x => x != distantPairs.Item1 && x != distantPairs.Item2)
.ToList();
/*Examine the remaining members of E one by one and assign them
* to e1 or e2, depending on which of the MBRs of these nodes
* will require the minimum area enlargement so as to cover this entry.
* If a tie occurs, assign the entry to the node whose MBR has the smaller area.
* If a tie occurs again, assign the entry to the node that contains the smaller number of entries*/
while (e.Count > 0)
{
var current = e[e.Count - 1];
var leftEnlargementArea = e1.MBRectangle.GetEnlargementArea(current.MBRectangle);
var rightEnlargementArea = e2.MBRectangle.GetEnlargementArea(current.MBRectangle);
if (leftEnlargementArea == rightEnlargementArea)
{
var leftArea = e1.MBRectangle.Area();
var rightArea = e2.MBRectangle.Area();
if (leftArea == rightArea)
{
if (e1.KeyCount < e2.KeyCount)
{
e1.AddChild(current);
}
else
{
e2.AddChild(current);
}
}
else if (leftArea < rightArea)
{
e1.AddChild(current);
}
else
{
e2.AddChild(current);
}
}
else if (leftEnlargementArea < rightEnlargementArea)
{
e1.AddChild(current);
}
else
{
e2.AddChild(current);
}
e.RemoveAt(e.Count - 1);
var remaining = e.Count;
/*if during the assignment of entries, there remain λ entries to be assigned
* and the one node contains minKeysPerNode − λ entries then
* assign all the remaining entries to this node without considering
* the aforementioned criteria
* so that the node will contain at least minKeysPerNode entries */
if (e1.KeyCount == minKeysPerNode - remaining)
{
foreach (var entry in e)
{
e1.AddChild(entry);
}
e.Clear();
}
else if (e2.KeyCount == minKeysPerNode - remaining)
{
foreach (var entry in e)
{
e2.AddChild(entry);
}
e.Clear();
}
}
var parent = node.Parent;
if (parent != null)
{
//replace current node with e1
parent.SetChild(node.Index, e1);
//insert overflow element to parent
insertAndSplit(parent, e2);
}
else
{
//node is the root.
//increase the height of RTree by one by adding a new root.
Root = new RTreeNode(maxKeysPerNode, null);
Root.AddChild(e1);
Root.AddChild(e2);
}
}
internal void AddChild(RTreeNode child)
{
SetChild(KeyCount, child);
KeyCount++;
}
/// <summary>
/// Inserts the given internal node to the level where it belongs using its height.
/// </summary>
/// <param name="internalNode"></param>
private void insertInternalNode(RTreeNode internalNode)
{
insertInternalNode(Root, internalNode);
}
