protected rtree handleOverflowElements(rtree node, Edge e)
{
List <Edge> set_one = new List <Edge>();
List <Edge> set_two = new List <Edge>();
MBR mbr_one = new MBR();
MBR mbr_two = new MBR();
List <Edge> oldItems = new List <Edge>();
foreach (Edge p in node.elements)
{
oldItems.Add(p);
}
quadraticSplitElements(oldItems, e, set_one, set_two, mbr_one, mbr_two);
rtree child_one = buildNode(set_one, mbr_one);
node.setElement(set_two, mbr_two);
if (node.isRoot())
{
return(node.makeNewRoot(child_one));
}
else
{
return(node.parent.insert(child_one));
}
}
private void searchEdgeWithMaximumRadiusAngle(rtree rt, Point p, HashSet <Edge> cands, double radius, double step, int leastNum, double max_radius, double angle)
{
double xmin, ymin, xmax, ymax;
ymin = p.Y - radius;
ymax = p.Y + radius;
xmin = p.X - radius;
xmax = p.X + radius;
double current_radius = radius;
while (cands.Count < leastNum && current_radius <= max_radius)
{
MBR rect = new MBR(xmin, ymin, xmax, ymax);
rt.search(rect, cands, p, angle);
ymin = ymin - step;
ymax = ymax + step;
xmin = xmin - step;
xmax = xmax + step;
current_radius += step;
}
}
protected rtree handleOverflowNodes(rtree node)
{
List <rtree> set_one = new List <rtree>();
List <rtree> set_two = new List <rtree>();
MBR mbr_one = new MBR();
MBR mbr_two = new MBR();
List <rtree> oldItems = new List <rtree>();
foreach (rtree tr in this.children)
{
oldItems.Add(tr);
}
this.children.Clear();
quadraticSplitNodes(oldItems, node, set_one, set_two, mbr_one, mbr_two);
rtree child_one = buildNode(set_one, mbr_one);
setChildren(set_two, mbr_two);
if (this.isRoot())
{
return(makeNewRoot(child_one));
}
else
{
return(this.parent.insert(child_one));
}
}
private void searchEdgeWithinRadiusOneStep(rtree rt, Point p, HashSet <Edge> cands, double radius)
{
double xmin, ymin, xmax, ymax;
ymin = p.Y - radius;
ymax = p.Y + radius;
xmin = p.X - radius;
xmax = p.X + radius;
MBR rect = new MBR(xmin, ymin, xmax, ymax);
rt.search(rect, cands);
}
protected rtree buildNode(List <Edge> input, MBR newMbr)
{
rtree ret = new rtree(minItems, maxItems);
foreach (Edge pt in input)
{
ret.elements.Add(pt);
}
ret.m_br = new MBR(newMbr);
return(ret);
}
private void build_rtree_index(int minItem, int maxItem)
{
if (_rtree_edge == null)
{
_rtree_edge = new rtree(minItem, maxItem);
}
foreach (int eid in _E.Keys)
{
Edge e = _E[eid];
e.createMBR();
_rtree_edge = _rtree_edge.insert(e);
}
}
protected rtree makeNewRoot(rtree child)
{
rtree newRoot = new rtree(minItems, maxItems);
newRoot.children.Add(this);
newRoot.children.Add(child);
this.parent = newRoot;
child.parent = newRoot;
newRoot.updateMBRLocal();
return(newRoot);
}
public rtree insert(rtree node)
{
if (full())
{
return(handleOverflowNodes(node));
}
else
{
this.children.Add(node);
node.parent = this;
this.updateMBR();
return(getRoot());
}
}
public rtree insert(Edge e)
{
rtree node = chooseLeaf(this, e);
if (!node.full())
{
node.elements.Add(e);
node.updateMBR();
}
else
{
handleOverflowElements(node, e);
}
return(node.getRoot());
}
protected rtree buildNode(List <rtree> input, MBR newMbr)
{
rtree ret = new rtree(minItems, maxItems);
for (int i = 0; i < input.Count; i++)
{
ret.children.Add(input[i]);
ret.children[i].parent = ret;
}
if (newMbr != null)
{
ret.m_br = new MBR(newMbr);
}
return(ret);
}
protected rtree chooseLeaf(rtree v, Edge e)
{
if (v.isLeaf())
{
return(v);
}
double areamin = areaEnlarge(v.children[0].m_br, e);
int j = 0;
for (int i = 1; i < v.children.Count; i++)
{
double area1 = areaEnlarge(v.children[i].m_br, e);
if (area1 < areamin)
{
j = i;
areamin = area1;
}
}
return(chooseLeaf(v.children[j], e));
}
protected void quadraticSplitNodes(List <rtree> oldItems, rtree newItem, List <rtree> set_one, List <rtree> set_two, MBR br_one, MBR br_two)
{
oldItems.Add(newItem);
int m = 0, n = 1;
double maxArea = areaExpand(oldItems[0].m_br, oldItems[1].m_br);
for (int i = 0; i < oldItems.Count; i++)
{
for (int j = i + 1; j < oldItems.Count; j++)
{
double area = areaExpand(oldItems[i].m_br, oldItems[j].m_br);
if (area > maxArea)
{
maxArea = area;
m = i;
n = j;
}
}
}
set_one.Add(oldItems[m]);
set_two.Add(oldItems[n]);
MBR set_one_mbr = new MBR(oldItems[m].m_br);
MBR set_two_mbr = new MBR(oldItems[n].m_br);
oldItems.RemoveAt(m);
if (m < n)
{
oldItems.RemoveAt(n - 1);
}
else
{
oldItems.RemoveAt(n);
}
while (!(oldItems.Count == 0))
{
if (minItems - set_one.Count == oldItems.Count)
{
for (int i = 0; i < oldItems.Count; i++)
{
set_one.Add(oldItems[i]);
set_one_mbr.unionWith(oldItems[i].m_br);
}
break;
}
else if (oldItems.Count == minItems - set_two.Count)
{
for (int i = 0; i < oldItems.Count; i++)
{
set_two.Add(oldItems[i]);
set_two_mbr.unionWith(oldItems[i].m_br);
}
break;
}
int k = 0;
double s = areaExpand(set_one_mbr, oldItems[k].m_br);
double t = areaExpand(set_two_mbr, oldItems[k].m_br);
if (s < t)
{
set_one.Add(oldItems[k]);
set_one_mbr.unionWith(oldItems[k].m_br);
}
else
{
set_two.Add(oldItems[k]);
set_two_mbr.unionWith(oldItems[k].m_br);
}
oldItems.RemoveAt(k);
}
br_one.become(set_one_mbr);
br_two.become(set_two_mbr);
}
