/* get node from buffer or file */
void RTreeGetNode(struct RTree_Node *n, off_t nodepos, int level, struct RTree *t)
{
int which = (nodepos == t->nb[level][2].pos ? 2 : nodepos == t->nb[level][1].pos);
if (t->nb[level][which].pos != nodepos) {
/* replace least recently used (fastest method of lru, pseudo-lru, mru) */
which = t->used[level][2];
/* rewrite node in buffer */
if (t->nb[level][which].dirty) {
RTreeRewriteNode(&(t->nb[level][which].n), t->nb[level][which].pos, t);
t->nb[level][which].dirty = 0;
}
RTreeReadNode(&(t->nb[level][which].n), nodepos, t);
t->nb[level][which].pos = nodepos;
}
/* make it mru */
if (t->used[level][2] == which) {
t->used[level][2] = t->used[level][1];
t->used[level][1] = t->used[level][0];
t->used[level][0] = which;
}
else if (t->used[level][1] == which) {
t->used[level][1] = t->used[level][0];
t->used[level][0] = which;
}
*n = t->nb[level][which].n;
}
/*!
\brief Dump R-tree node from temp file to the file
\param fp pointer to FILE
\param pos position of Node in temp file
\param with_z non-zero value for 3D vector data
\param t RTree to dump
\return 0
*/
int rtree_dump_node_file(FILE * fp, off_t pos, int with_z, struct RTree *t)
{
int i;
static struct RTree_Node *n = NULL;
if (!n) {
n = RTreeAllocNode(t, 1);
}
/* recursive nearly-but-a-bit-messy depth-first pre-order traversal
* potentially filling up memory */
/* TODO: change to non-recursive depth-first post-order traversal */
/* left for comparison with GRASS6.x */
RTreeReadNode(n, pos, t);
fprintf(fp, "Node level=%d count=%d\n", n->level, n->count);
if (n->level > 0)
for (i = 0; i < NODECARD; i++) {
if (n->branch[i].child.pos >= 0) {
fprintf(fp, " Branch %d", i);
rtree_dump_branch_file(fp, &(n->branch[i]), with_z, n->level, t);
}
}
else
for (i = 0; i < LEAFCARD; i++) {
if (n->branch[i].child.id) {
fprintf(fp, " Branch %d", i);
rtree_dump_branch_file(fp, &(n->branch[i]), with_z, n->level, t);
}
}
return 0;
}
static off_t rtree_write_from_file(struct gvfile *fp, off_t startpos,
struct RTree *t, int off_t_size)
{
off_t nextfreepos = startpos;
int sidx_nodesize, sidx_leafsize;
struct RTree_Node *n;
int i, j, writeout, maxcard;
static struct spidxstack *s = NULL;
int top = 0;
if (!s) {
s = G_malloc(MAXLEVEL * sizeof(struct spidxstack));
for (i = 0; i < MAXLEVEL; i++) {
s[i].sn.branch = G_malloc(MAXCARD * sizeof(struct RTree_Branch));
for (j = 0; j < MAXCARD; j++) {
s[i].sn.branch[j].rect.boundary = G_malloc(6 * sizeof(RectReal));
}
}
}
/* write pending changes to file */
RTreeFlushBuffer(t);
/* should be foolproof */
sidx_nodesize =
(int)(2 * PORT_INT + t->nodecard * (off_t_size + NUMSIDES * PORT_DOUBLE));
sidx_leafsize =
(int)(2 * PORT_INT + t->leafcard * (off_t_size + NUMSIDES * PORT_DOUBLE));
/* stack size of t->rootlevel + 1 would be enough because of
* depth-first post-order traversal:
* only one node per level on stack at any given time */
/* add root node position to stack */
s[top].branch_id = i = 0;
RTreeReadNode(&s[top].sn, t->rootpos, t);
/* depth-first postorder traversal
* all children of a node are visitied and written out first
* when a child is written out, its position in file is stored in pos[] for
* the parent node and written out with the parent node */
/* root node is written out last and its position returned */
while (top >= 0) {
n = &(s[top].sn);
writeout = 1;
/* this is an internal node in the RTree
* all its children are processed first,
* before it is written out to the sidx file */
if (s[top].sn.level > 0) {
for (i = s[top].branch_id; i < t->nodecard; i++) {
s[top].pos[i] = 0;
if (n->branch[i].child.pos >= 0) {
s[top++].branch_id = i + 1;
RTreeReadNode(&s[top].sn, n->branch[i].child.pos, t);
s[top].branch_id = 0;
writeout = 0;
break;
}
}
if (writeout) {
/* nothing else found, ready to write out */
s[top].branch_id = t->nodecard;
}
}
if (writeout) {
/* write node to sidx file */
if (G_ftell(fp->file) != nextfreepos)
G_fatal_error("Unable to write spatial index. "
"Wrong node position (%"PRI_OFF_T") in file (should be %"PRI_OFF_T").",
G_ftell(fp->file), nextfreepos);
/* write with dig__fwrite_port_* fns */
dig__fwrite_port_I(&(s[top].sn.count), 1, fp);
dig__fwrite_port_I(&(s[top].sn.level), 1, fp);
maxcard = s[top].sn.level ? t->nodecard : t->leafcard;
for (j = 0; j < maxcard; j++) {
dig__fwrite_port_D(s[top].sn.branch[j].rect.boundary,
NUMSIDES, fp);
/* leaf node: vector object IDs are stored in child.id */
if (s[top].sn.level == 0)
s[top].pos[j] = (off_t) s[top].sn.branch[j].child.id;
dig__fwrite_port_O(&(s[top].pos[j]), 1, fp, off_t_size);
}
top--;
/* update corresponding child position of parent node
* this node is only updated if its level is > 0, i.e.
* this is an internal node
* children of internal nodes do not have an ID, instead
* they hold the position in file of the next nodes down the tree */
if (top >= 0) {
s[top].pos[s[top].branch_id - 1] = nextfreepos;
nextfreepos += (s[top + 1].sn.level ? sidx_nodesize : sidx_leafsize);
}
}
}
close(t->fd);
return nextfreepos;
}
