static int RTreeInsertNode (node_t n, int level,
rect_t r, void *data,
node_t *new_node)
{
int i;
node_t n2;
branch_t b;
assert(n && new_node);
assert(level >= 0 && level <= n->level);
if (n->level > level)
{
i = RTreePickBranch(r,n);
if (!RTreeInsertNode((node_t) n->branch[i].child, level,
r, data,&n2)) /* not split */
{
n->branch[i].mbr = RectCombine(r,n->branch[i].mbr);
return FALSE;
}
else /* node split */
{
n->branch[i].mbr = RTreeNodeCover(n->branch[i].child);
b.child = n2;
b.mbr = RTreeNodeCover(n2);
return RTreeAddBranch(n, b, new_node);
}
}
else /*insert level*/
{
b.mbr = r;
b.child = data;
return RTreeAddBranch(n, b, new_node);
}
}
/*
* Inserts a new data rectangle into the index structure.
* Recursively descends tree, propagates splits back up.
* Returns 0 if node was not split. Old node updated.
* If node was split, returns 1 and sets the pointer pointed to by
* new_node to point to the new node. Old node updated to become one of two.
* The level argument specifies the number of steps up from the leaf
* level to insert; e.g. a data rectangle goes in at level = 0.
*/
static int RTreeInsertRect2(struct Rect *r,
long tid, struct Node *n, struct Node **new_node, int level)
{
/*
register struct Rect *r = R;
register long tid = Tid;
register struct Node *n = N, **new_node = New_node;
register int level = Level;
*/
register int i;
struct Branch b;
struct Node *n2;
assert(r && n && new_node);
assert(level >= 0 && level <= n->level);
/* Still above level for insertion, go down tree recursively */
if (n->level > level)
{
i = RTreePickBranch(r, n);
if (!RTreeInsertRect2(r, tid, n->branch[i].child, &n2, level))
{
/* child was not split */
n->branch[i].rect =
RTreeCombineRect(r,&(n->branch[i].rect));
return 0;
}
else /* child was split */
{
n->branch[i].rect = RTreeNodeCover(n->branch[i].child);
b.child = n2;
b.rect = RTreeNodeCover(n2);
return RTreeAddBranch(&b, n, new_node);
}
}
/* Have reached level for insertion. Add rect, split if necessary */
else if (n->level == level)
{
b.rect = *r;
b.child = (struct Node *) (tid);
/* child field of leaves contains tid of data record */
return RTreeAddBranch(&b, n, new_node);
}
else
{
/* Not supposed to happen */
assert (FALSE);
return 0;
}
}
/*-----------------------------------------------------------------------------
| Copy branches from the buffer into two nodes according to the partition.
-----------------------------------------------------------------------------*/
static void RTreeLoadNodes(struct Node *n, struct Node *q,
struct PartitionVars *p)
{
register int i;
assert(n);
assert(q);
assert(p);
for (i=0; i<p->total; i++)
{
assert(p->partition[i] == 0 || p->partition[i] == 1);
if (p->partition[i] == 0)
RTreeAddBranch(&BranchBuf[i], n, NULL);
else if (p->partition[i] == 1)
RTreeAddBranch(&BranchBuf[i], q, NULL);
}
}
/*
* Insert a data rectangle into an index structure.
* RTreeInsertRect provides for splitting the root;
* returns 1 if root was split, 0 if it was not.
* The level argument specifies the number of steps up from the leaf
* level to insert; e.g. a data rectangle goes in at level = 0.
* RTreeInsertRect2 does the recursion.
*/
int RTreeInsertRect(struct Rect *R, long Tid, struct Node **Root, int Level)
{
register struct Rect *r = R;
register long tid = Tid;
register struct Node **root = Root;
register int level = Level;
register int i;
register struct Node *newroot;
struct Node *newnode;
struct Branch b;
int result;
assert(r && root);
assert(level >= 0 && level <= (*root)->level);
for (i=0; i<NUMDIMS; i++) {
assert(r->boundary[i] <= r->boundary[NUMDIMS+i]);
}
if (RTreeInsertRect2(r, tid, *root, &newnode, level)) /* root split */
{
newroot = RTreeNewNode(); /* grow a new root, & tree taller */
newroot->level = (*root)->level + 1;
rootID = newroot->id;
if(newroot->level > maxLevel)
maxLevel = newroot->level;
b.rect = RTreeNodeCover(*root);
b.child = *root;
RTreeAddBranch(&b, newroot, NULL);
b.rect = RTreeNodeCover(newnode);
b.child = newnode;
RTreeAddBranch(&b, newroot, NULL);
*root = newroot;
result = 1;
}
else
result = 0;
return result;
}
void RTreeInsert (rtree_t *t, rect_t r, void *data)
{
node_t n2;
node_t new_root;
branch_t b;
assert(t && *t);
if (RTreeInsertNode(*t, 0, r, data, &n2))
/* deal with root split */
{
new_root = RTreeNewNode();
new_root->level = (*t)->level + 1;
b.mbr = RTreeNodeCover(*t);
b.child = (void *) *t;
RTreeAddBranch(new_root, b, NULL);
b.mbr = RTreeNodeCover(n2);
b.child = (void *) n2;
RTreeAddBranch(new_root, b, NULL);
*t = new_root;
}
}
/*
* Insert a data rectangle into an index structure.
* RTreeInsertRect provides for splitting the root;
* returns 1 if root was split, 0 if it was not.
* The level argument specifies the number of steps up from the leaf
* level to insert; e.g. a data rectangle goes in at level = 0.
* RTreeInsertRect2 does the actual insertion.
*/
int RTreeInsertRectF(struct RTree_Rect *r, union RTree_Child child, int level,
struct RTree *t)
{
struct RTree_ListBranch *reInsertList = NULL;
struct RTree_ListBranch *e;
int result;
char overflow[MAXLEVEL];
struct RTree_Branch *b = &(t->tmpb1);
off_t newnode_pos = -1;
struct RTree_Node *oldroot;
static struct RTree_Node *newroot = NULL, *newnode = NULL;
if (!newroot) {
newroot = RTreeAllocNode(t, 1);
newnode = RTreeAllocNode(t, 1);
}
/* R*-tree forced reinsertion: for each level only once */
memset(overflow, t->overflow, MAXLEVEL);
result = RTreeInsertRect2F(r, child, level, newnode, &newnode_pos,
t, &reInsertList, overflow);
if (result == 1) { /* root split */
oldroot = RTreeGetNode(t->rootpos, t->rootlevel, t);
/* grow a new root, & tree taller */
t->rootlevel++;
RTreeInitNode(t, newroot, NODETYPE(t->rootlevel, t->fd));
newroot->level = t->rootlevel;
/* branch for old root */
RTreeNodeCover(oldroot, &(b->rect), t);
b->child.pos = t->rootpos;
RTreeAddBranch(b, newroot, NULL, NULL, NULL, NULL, t);
/* branch for new node created by RTreeInsertRect2() */
RTreeNodeCover(newnode, &(b->rect), t);
b->child.pos = newnode_pos; /* offset to new node as returned by RTreeInsertRect2F() */
RTreeAddBranch(b, newroot, NULL, NULL, NULL, NULL, t);
/* write new root node */
t->rootpos = RTreeGetNodePos(t);
RTreeWriteNode(newroot, t);
t->n_nodes++;
return result;
}
if (result == 2) { /* branches were removed */
while (reInsertList) {
/* get next branch in list */
RTreeCopyBranch(b, &(reInsertList->b), t);
level = reInsertList->level;
e = reInsertList;
reInsertList = reInsertList->next;
RTreeFreeListBranch(e);
/* reinsert branches */
result =
RTreeInsertRect2F(&(b->rect), b->child, level, newnode, &newnode_pos, t,
&reInsertList, overflow);
if (result == 1) { /* root split */
oldroot = RTreeGetNode(t->rootpos, t->rootlevel, t);
/* grow a new root, & tree taller */
t->rootlevel++;
RTreeInitNode(t, newroot, NODETYPE(t->rootlevel, t->fd));
newroot->level = t->rootlevel;
/* branch for old root */
RTreeNodeCover(oldroot, &(b->rect), t);
b->child.pos = t->rootpos;
RTreeAddBranch(b, newroot, NULL, NULL, NULL, NULL, t);
/* branch for new node created by RTreeInsertRect2() */
RTreeNodeCover(newnode, &(b->rect), t);
b->child.pos = newnode_pos;
RTreeAddBranch(b, newroot, NULL, NULL, NULL, NULL, t);
/* write new root node */
t->rootpos = RTreeGetNodePos(t);
RTreeWriteNode(newroot, t);
t->n_nodes++;
}
}
}
return result;
}
/*
* Inserts a new data rectangle into the index structure.
* Non-recursively descends tree, propagates splits back up.
* Returns 0 if node was not split. Old node updated.
* If node was split, returns 1 and sets the pointer pointed to by
* new_node to point to the new node. Old node updated to become one of two.
* The level argument specifies the number of steps up from the leaf
* level to insert; e.g. a data rectangle goes in at level = 0.
*/
static int RTreeInsertRect2F(struct RTree_Rect *r, union RTree_Child child, int level,
struct RTree_Node *newnode, off_t *newnode_pos,
struct RTree *t,
struct RTree_ListBranch **ee, char *overflow)
{
int i, currlevel;
struct RTree_Node *n, *n2;
struct RTree_Rect *cover;
int top = 0, down = 0;
int result;
struct RTree_Branch *b = &(t->tmpb2);
struct nstack *s = t->ns;
struct RTree_Rect *nr = &(t->orect);
n2 = newnode;
/* add root node position to stack */
currlevel = t->rootlevel;
s[top].pos = t->rootpos;
s[top].sn = RTreeGetNode(s[top].pos, currlevel, t);
/* go down to level of insertion */
while (s[top].sn->level > level) {
n = s[top].sn;
currlevel = s[top].sn->level - 1;
i = RTreePickBranch(r, n, t);
s[top++].branch_id = i;
/* add next node to stack */
s[top].pos = n->branch[i].child.pos;
s[top].sn = RTreeGetNode(s[top].pos, currlevel, t);
}
/* Have reached level for insertion. Add rect, split if necessary */
RTreeCopyRect(&(b->rect), r, t);
/* child field of leaves contains tid of data record */
b->child = child;
/* add branch, may split node or remove branches */
cover = NULL;
if (top)
cover = &(s[top - 1].sn->branch[s[top - 1].branch_id].rect);
result = RTreeAddBranch(b, s[top].sn, &n2, ee, cover, overflow, t);
/* update node */
RTreeNodeChanged(s[top].sn, s[top].pos, t);
/* write out new node if node was split */
if (result == 1) {
*newnode_pos = RTreeGetNodePos(t);
RTreeWriteNode(n2, t);
t->n_nodes++;
}
/* go back up */
while (top) {
down = top--;
i = s[top].branch_id;
if (result == 0) { /* branch was added */
if (RTreeExpandRect(&(s[top].sn->branch[i].rect), r, t)) {
RTreeNodeChanged(s[top].sn, s[top].pos, t);
}
}
else if (result == 2) { /* branches were removed */
/* get node cover of previous node */
RTreeNodeCover(s[down].sn, nr, t);
/* rewrite rect */
if (!RTreeCompareRect(nr, &(s[top].sn->branch[i].rect), t)) {
RTreeCopyRect(&(s[top].sn->branch[i].rect), nr, t);
RTreeNodeChanged(s[top].sn, s[top].pos, t);
}
}
else if (result == 1) { /* node was split */
/* get node cover of previous node */
RTreeNodeCover(s[down].sn, &(s[top].sn->branch[i].rect), t);
/* add new branch for new node previously added by RTreeAddBranch() */
b->child.pos = *newnode_pos;
RTreeNodeCover(n2, &(b->rect), t);
/* add branch, may split node or remove branches */
cover = NULL;
if (top)
cover = &(s[top - 1].sn->branch[s[top - 1].branch_id].rect);
result =
RTreeAddBranch(b, s[top].sn, &n2, ee, cover, overflow, t);
/* update node */
RTreeNodeChanged(s[top].sn, s[top].pos, t);
/* write out new node if node was split */
if (result == 1) {
*newnode_pos = RTreeGetNodePos(t);
RTreeWriteNode(n2, t);
t->n_nodes++;
}
}
}
return result;
}