/* read node from file */
static void rtree_read_node(struct NodeBuffer *nb,
off_t nodepos, struct RTree *t, struct Plus_head *Plus)
{
int i, maxcard;
off_t pos;
struct gvfile *file = &(Plus->spidx_fp);
dig_fseek(file, nodepos, SEEK_SET);
/* read with dig__fread_port_* fns */
dig__fread_port_I(&(nb->n.count), 1, file);
dig__fread_port_I(&(nb->n.level), 1, file);
maxcard = nb->n.level ? t->nodecard : t->leafcard;
for (i = 0; i < maxcard; i++) {
dig__fread_port_D(nb->n.branch[i].rect.boundary, NUMSIDES,
file);
dig__fread_port_O(&pos, 1, file,
Plus->spidx_port.off_t_size);
/* leaf node: vector object IDs are stored in child.id */
if (nb->n.level == 0) {
nb->n.branch[i].child.id = (int)pos;
}
else {
nb->n.branch[i].child.pos = pos;
}
}
}
/* plus_t is defined as int so we only retype pointer and use int function */
int dig__fread_port_P(plus_t * buf, int cnt, GVFILE * fp)
{
int *ibuf;
ibuf = (int *)buf;
return (dig__fread_port_I(ibuf, cnt, fp));
}
/*!
\brief Read spatial index file
\param fp pointer to gvfile structure
\param[in,out] plus pointer to Plus_head structure
\param head_only non-zero to read only head
\return 0 OK
\return 1 error
*/
int dig_read_cidx(struct gvfile * fp, struct Plus_head *plus, int head_only)
{
int i;
G_debug(3, "dig_read_cidx()");
dig_cidx_free(plus);
dig_cidx_init(plus);
dig_rewind(fp);
if (dig_read_cidx_head(fp, plus) == -1) {
G_debug(3, "Cannot read cidx head");
return 1;
}
if (head_only) {
plus->cidx_up_to_date = 1; /* OK ? */
return 0;
}
dig_set_cur_port(&(plus->cidx_port));
/* Read category-type-id for each field */
for (i = 0; i < plus->n_cidx; i++) {
int j;
struct Cat_index *ci;
ci = &(plus->cidx[i]);
ci->a_cats = ci->n_cats;
ci->cat = G_malloc(ci->a_cats * 3 * sizeof(int));
if (dig_fseek(fp, ci->offset, 0) == -1)
return 1;
if (0 >= dig__fread_port_I((int *)ci->cat, 3 * ci->n_cats, fp))
return 1;
/* convert type */
for (j = 0; j < ci->n_cats; j++)
ci->cat[j][1] = dig_type_from_store(ci->cat[j][1]);
}
plus->cidx_up_to_date = 1;
return 0;
}
/* read_line() reads element from file
returns element type
*/
int read_line(struct gvfile * Gvf, struct line_pnts *nline)
{
int n_points;
long itype;
if (0 >= dig__fread_port_L(&itype, 1, Gvf))
return (-2);
itype = dig_old_to_new_type((char)itype);
if (0 >= dig__fread_port_I(&n_points, 1, Gvf))
return (-2);
if (0 > dig_alloc_points(nline, n_points))
G_fatal_error("Cannot allocate points");
nline->n_points = n_points;
if (0 >= dig__fread_port_D(nline->x, n_points, Gvf))
return (-2);
if (0 >= dig__fread_port_D(nline->y, n_points, Gvf))
return (-2);
return ((int)itype);
}
int dig_Rd_P_line(struct Plus_head *Plus, int n, struct gvfile * fp)
{
int n_edges;
char tp;
struct P_line *ptr;
G_debug(4, "dig_Rd_P_line()");
if (0 >= dig__fread_port_C(&tp, 1, fp))
return (-1);
if (tp == 0) { /* dead */
G_debug(4, " line is dead");
Plus->Line[n] = NULL;
return 0;
}
ptr = dig_alloc_line();
/* type */
ptr->type = dig_type_from_store(tp);
G_debug(5, " line type %d -> %d", tp, ptr->type);
/* offset */
if (0 >= dig__fread_port_O(&(ptr->offset), 1, fp, Plus->off_t_size))
return (-1);
if (ptr->type == GV_POINT) {
ptr->topo = NULL;
}
else {
ptr->topo = dig_alloc_topo(ptr->type);
}
/* centroids */
if (ptr->type & GV_CENTROID) {
struct P_topo_c *topo = (struct P_topo_c *)ptr->topo;
if (0 >= dig__fread_port_P(&(topo->area), 1, fp))
return -1;
}
/* lines */
else if (ptr->type & GV_LINE) {
struct P_topo_l *topo = (struct P_topo_l *)ptr->topo;
if (0 >= dig__fread_port_P(&(topo->N1), 1, fp))
return -1;
if (0 >= dig__fread_port_P(&(topo->N2), 1, fp))
return -1;
}
/* boundaries */
else if (ptr->type & GV_BOUNDARY) {
struct P_topo_b *topo = (struct P_topo_b *)ptr->topo;
if (0 >= dig__fread_port_P(&(topo->N1), 1, fp))
return -1;
if (0 >= dig__fread_port_P(&(topo->N2), 1, fp))
return -1;
if (0 >= dig__fread_port_P(&(topo->left), 1, fp))
return -1;
if (0 >= dig__fread_port_P(&(topo->right), 1, fp))
return -1;
}
/* faces */
else if ((ptr->type & GV_FACE) && Plus->with_z) { /* reserved for face edges */
struct P_topo_f *topo = (struct P_topo_f *)ptr->topo;
if (0 >= dig__fread_port_I(&n_edges, 1, fp))
return -1;
/* here will be list of edges */
/* left / right volume */
if (0 >= dig__fread_port_P(&(topo->left), 1, fp))
return -1;
if (0 >= dig__fread_port_P(&(topo->left), 1, fp))
return -1;
}
/* kernels */
else if ((ptr->type & GV_KERNEL) && Plus->with_z) { /* reserved for kernel (volume number) */
struct P_topo_k *topo = (struct P_topo_k *)ptr->topo;
if (0 >= dig__fread_port_P(&(topo->volume), 1, fp))
return -1;
}
Plus->Line[n] = ptr;
return (0);
}
/* return: 0 OK, -1 error */
int dig_read_cidx_head(GVFILE * fp, struct Plus_head *plus)
{
unsigned char buf[5];
int i, byte_order;
dig_rewind(fp);
/* bytes 1 - 5 */
if (0 >= dig__fread_port_C(buf, 5, fp))
return (-1);
plus->cidx_Version_Major = buf[0];
plus->cidx_Version_Minor = buf[1];
plus->cidx_Back_Major = buf[2];
plus->cidx_Back_Minor = buf[3];
byte_order = buf[4];
G_debug(3,
"Cidx header: file version %d.%d , supported from GRASS version %d.%d",
plus->cidx_Version_Major, plus->cidx_Version_Minor,
plus->cidx_Back_Major, plus->cidx_Back_Minor);
G_debug(3, " byte order %d", byte_order);
/* check version numbers */
if (plus->cidx_Version_Major > GV_CIDX_VER_MAJOR ||
plus->cidx_Version_Minor > GV_CIDX_VER_MINOR) {
/* The file was created by GRASS library with higher version than this one */
if (plus->cidx_Back_Major > GV_CIDX_VER_MAJOR ||
plus->cidx_Back_Minor > GV_CIDX_VER_MINOR) {
/* This version of GRASS lib is lower than the oldest which can read this format */
G_debug(1, "Category index format version %d.%d",
plus->cidx_Version_Major, plus->cidx_Version_Minor);
G_fatal_error
("This version of GRASS (%d.%d) is too old to read this category index format."
" Try to rebuild topology or upgrade GRASS to at least version %d.",
GRASS_VERSION_MAJOR, GRASS_VERSION_MINOR, GRASS_VERSION_MAJOR + 1);
return (-1);
}
G_warning
("Your GRASS version does not fully support category index format %d.%d of the vector."
" Consider to rebuild topology or upgrade GRASS.",
plus->cidx_Version_Major, plus->cidx_Version_Minor);
}
dig_init_portable(&(plus->cidx_port), byte_order);
dig_set_cur_port(&(plus->cidx_port));
/* bytes 6 - 9 : header size */
if (0 >= dig__fread_port_L(&(plus->cidx_head_size), 1, fp))
return (-1);
G_debug(3, " header size %ld", plus->cidx_head_size);
/* Body of header - info about all fields */
/* Number of fields */
if (0 >= dig__fread_port_I(&(plus->n_cidx), 1, fp))
return (-1);
/* alloc space */
plus->a_cidx = plus->n_cidx;
plus->cidx =
(struct Cat_index *)G_malloc(plus->a_cidx * sizeof(struct Cat_index));
for (i = 0; i < plus->n_cidx; i++) {
int t;
struct Cat_index *ci;
ci = &(plus->cidx[i]);
ci->cat = NULL;
ci->a_cats = 0;
/* Field number */
if (0 >= dig__fread_port_I(&(ci->field), 1, fp))
return (-1);
/* Number of categories */
if (0 >= dig__fread_port_I(&(ci->n_cats), 1, fp))
return (-1);
/* Number of unique categories */
if (0 >= dig__fread_port_I(&(ci->n_ucats), 1, fp))
return (-1);
/* Number of types */
if (0 >= dig__fread_port_I(&(ci->n_types), 1, fp))
return (-1);
/* Types */
for (t = 0; t < ci->n_types; t++) {
int rtype;
/* type */
if (0 >= dig__fread_port_I(&rtype, 1, fp))
return (-1);
ci->type[t][0] = dig_type_from_store(rtype);
/* number of items */
if (0 >= dig__fread_port_I(&(ci->type[t][1]), 1, fp))
return (-1);
}
/* Offset */
if (0 >= dig__fread_port_L(&(ci->offset), 1, fp))
return (0);
}
if (dig_fseek(fp, plus->cidx_head_size, SEEK_SET) == -1)
return (-1);
return (0);
}
static void rtree_load_to_memory(struct gvfile *fp, off_t rootpos,
struct RTree *t, int off_t_size)
{
struct RTree_Node *newnode = NULL;
int i, j, loadnode, maxcard;
struct spidxstack *last;
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));
}
}
}
/* stack size of t->rootlevel + 1 would be enough because of
* depth-first postorder traversal:
* only one node per level on stack at any given time */
/* add root node position to stack */
last = &(s[top]);
G_fseek(fp->file, rootpos, SEEK_SET);
/* read with dig__fread_port_* fns */
dig__fread_port_I(&(s[top].sn.count), 1, fp);
dig__fread_port_I(&(s[top].sn.level), 1, fp);
maxcard = s[top].sn.level ? t->nodecard : t->leafcard;
for (j = 0; j < maxcard; j++) {
dig__fread_port_D(s[top].sn.branch[j].rect.boundary, NUMSIDES, fp);
dig__fread_port_O(&(s[top].pos[j]), 1, fp, off_t_size);
/* leaf node: vector object IDs are stored in child.id */
if (s[top].sn.level == 0) {
s[top].sn.branch[j].child.id = (int)s[top].pos[j];
}
else {
s[top].sn.branch[j].child.ptr = NULL;
}
}
s[top].branch_id = i = 0;
/* some sort of postorder traversal */
/* root node is loaded last and returned */
while (top >= 0) {
last = &(s[top]);
loadnode = 1;
/* this is an internal node in the RTree
* all its children are read first,
* before it is transferred to the RTree in memory */
if (s[top].sn.level > 0) {
for (i = s[top].branch_id; i < t->nodecard; i++) {
if (s[top].pos[i] > 0) {
s[top++].branch_id = i + 1;
G_fseek(fp->file, last->pos[i], SEEK_SET);
/* read with dig__fread_port_* fns */
dig__fread_port_I(&(s[top].sn.count), 1, fp);
dig__fread_port_I(&(s[top].sn.level), 1, fp);
maxcard = s[top].sn.level ? t->nodecard : t->leafcard;
for (j = 0; j < maxcard; j++) {
dig__fread_port_D(s[top].sn.branch[j].rect.boundary,
NUMSIDES, fp);
dig__fread_port_O(&(s[top].pos[j]), 1, fp,
off_t_size);
/* leaf node
* vector object IDs are stored in file as
* off_t but always fit into an int, see dig_structs.h
* vector object IDs are transferred to child.id */
if (s[top].sn.level == 0) {
s[top].sn.branch[j].child.id =
(int)s[top].pos[j];
}
else {
s[top].sn.branch[j].child.ptr = NULL;
}
}
s[top].branch_id = 0;
loadnode = 0;
break;
}
else if (last->pos[i] < 0)
G_fatal_error("corrupt spatial index");
}
if (loadnode) {
/* nothing else found, ready to load */
s[top].branch_id = t->nodecard;
}
}
if (loadnode) {
/* ready to load node to memory */
newnode = RTreeAllocNode(t, s[top].sn.level);
/* copy from stack node */
RTreeCopyNode(newnode, &(s[top].sn), t);
top--;
/* update child 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 point to the next nodes down the tree */
if (top >= 0) {
s[top].sn.branch[s[top].branch_id - 1].child.ptr = newnode;
}
}
}
t->root = newnode;
}
/*!
\brief Read spatial index header from sidx file
\param fp pointer to struct gvfile
\param[in,out] ptr pointer to Plus_head structure
\return 0 on success
\return -1 on error
*/
int dig_Rd_spidx_head(struct gvfile * fp, struct Plus_head *ptr)
{
unsigned char buf[6];
int byte_order;
struct RTree *t;
dig_rewind(fp);
/* bytes 1 - 6 */
if (0 >= dig__fread_port_C((char *)buf, 6, fp))
return (-1);
ptr->version.spidx.major = buf[0];
ptr->version.spidx.minor = buf[1];
ptr->version.spidx.back_major = buf[2];
ptr->version.spidx.back_minor = buf[3];
byte_order = buf[4];
ptr->spidx_port.off_t_size = buf[5];
G_debug(2,
"Spidx header: file version %d.%d , supported from GRASS version %d.%d",
ptr->version.spidx.major, ptr->version.spidx.minor,
ptr->version.spidx.back_major, ptr->version.spidx.back_minor);
G_debug(2, " byte order %d", byte_order);
/* check version numbers */
if (ptr->version.spidx.major > GV_SIDX_VER_MAJOR ||
ptr->version.spidx.minor > GV_SIDX_VER_MINOR) {
/* The file was created by GRASS library with higher version than this one */
if (ptr->version.spidx.back_major > GV_SIDX_VER_MAJOR ||
ptr->version.spidx.back_minor > GV_SIDX_VER_MINOR) {
/* This version of GRASS lib is lower than the oldest which can read this format */
G_debug(1, "Spatial index format version %d.%d",
ptr->version.spidx.major, ptr->version.spidx.minor);
G_fatal_error
(_("This version of GRASS (%d.%d) is too old to read this spatial index format."
" Try to rebuild topology or upgrade GRASS to at least version %d."),
GRASS_VERSION_MAJOR, GRASS_VERSION_MINOR, GRASS_VERSION_MAJOR + 1);
return (-1);
}
G_warning(_("Your GRASS version does not fully support "
"spatial index format %d.%d of the vector."
" Consider to rebuild topology or upgrade GRASS."),
ptr->version.spidx.major, ptr->version.spidx.minor);
}
if (ptr->version.spidx.major < GV_SIDX_VER_MAJOR ||
(ptr->version.spidx.major == GV_SIDX_VER_MAJOR &&
ptr->version.spidx.minor < GV_SIDX_VER_MINOR)) {
/* The file was created by GRASS library with lower version than this one */
G_fatal_error(_("Spatial index format version %d.%d is not "
"supported by this release."
" Please rebuild topology."),
ptr->version.spidx.major, ptr->version.spidx.minor);
return (-1);
}
/* can this library read the sidx file ? */
if (ptr->spidx_port.off_t_size > (int)sizeof(off_t)) {
G_fatal_error("Spatial index was written with LFS but this "
"GRASS version does not support LFS. "
"Please get a GRASS version with LFS support.");
}
dig_init_portable(&(ptr->spidx_port), byte_order);
dig_set_cur_port(&(ptr->spidx_port));
/* bytes 7 - 10 : header size */
if (0 >= dig__fread_port_L(&(ptr->spidx_head_size), 1, fp))
return (-1);
G_debug(2, " header size %ld", ptr->spidx_head_size);
/* byte 11 : dimension 2D or 3D */
if (0 >= dig__fread_port_C((char *)buf, 1, fp))
return (-1);
ptr->spidx_with_z = buf[0];
G_debug(2, " with_z %d", ptr->spidx_with_z);
/* identical for all spatial indices: */
t = ptr->Node_spidx;
/* byte 12 : n dimensions */
if (0 >= dig__fread_port_C((char *)&(t->ndims), 1, fp))
return (-1);
ptr->Node_spidx->ndims = t->ndims;
ptr->Line_spidx->ndims = t->ndims;
ptr->Area_spidx->ndims = t->ndims;
ptr->Isle_spidx->ndims = t->ndims;
/* byte 13 : n sides */
if (0 >= dig__fread_port_C((char *)&(t->nsides), 1, fp))
return (-1);
ptr->Node_spidx->nsides = t->nsides;
ptr->Line_spidx->nsides = t->nsides;
ptr->Area_spidx->nsides = t->nsides;
ptr->Isle_spidx->nsides = t->nsides;
/* bytes 14 - 17 : nodesize */
if (0 >= dig__fread_port_I(&(t->nodesize), 1, fp))
return (-1);
ptr->Node_spidx->nodesize = t->nodesize;
ptr->Line_spidx->nodesize = t->nodesize;
ptr->Area_spidx->nodesize = t->nodesize;
ptr->Isle_spidx->nodesize = t->nodesize;
/* bytes 18 - 21 : nodecard */
if (0 >= dig__fread_port_I(&(t->nodecard), 1, fp))
return (-1);
ptr->Node_spidx->nodecard = t->nodecard;
ptr->Line_spidx->nodecard = t->nodecard;
ptr->Area_spidx->nodecard = t->nodecard;
ptr->Isle_spidx->nodecard = t->nodecard;
/* bytes 22 - 25 : leafcard */
if (0 >= dig__fread_port_I(&(t->leafcard), 1, fp))
return (-1);
ptr->Node_spidx->leafcard = t->leafcard;
ptr->Line_spidx->leafcard = t->leafcard;
ptr->Area_spidx->leafcard = t->leafcard;
ptr->Isle_spidx->leafcard = t->leafcard;
/* bytes 26 - 29 : min node fill */
if (0 >= dig__fread_port_I(&(t->min_node_fill), 1, fp))
return (-1);
ptr->Node_spidx->min_node_fill = t->min_node_fill;
ptr->Line_spidx->min_node_fill = t->min_node_fill;
ptr->Area_spidx->min_node_fill = t->min_node_fill;
ptr->Isle_spidx->min_node_fill = t->min_node_fill;
/* bytes 30 - 33 : min leaf fill */
if (0 >= dig__fread_port_I(&(t->min_leaf_fill), 1, fp))
return (-1);
ptr->Node_spidx->min_leaf_fill = t->min_leaf_fill;
ptr->Line_spidx->min_leaf_fill = t->min_leaf_fill;
ptr->Area_spidx->min_leaf_fill = t->min_leaf_fill;
ptr->Isle_spidx->min_leaf_fill = t->min_leaf_fill;
/* for each spatial index : */
/* Node spatial index */
/* bytes 34 - 37 : n nodes */
if (0 >= dig__fread_port_I((int *)&(t->n_nodes), 1, fp))
return (-1);
/* bytes 38 - 41 : n leafs */
if (0 >= dig__fread_port_I((int *)&(t->n_leafs), 1, fp))
return (-1);
/* bytes 42 - 45 : n levels */
if (0 >= dig__fread_port_I(&(t->rootlevel), 1, fp))
return (-1);
/* bytes 46 - 49 (LFS 53) : root node offset */
if (0 >=
dig__fread_port_O(&(ptr->Node_spidx_offset), 1, fp,
ptr->spidx_port.off_t_size))
return (-1);
t->rootpos = ptr->Node_spidx_offset;
/* Line spatial index */
t = ptr->Line_spidx;
/* bytes 50 - 53 (LFS 54 - 57) : n nodes */
if (0 >= dig__fread_port_I((int *)&(t->n_nodes), 1, fp))
return (-1);
/* bytes 54 - 57 (LFS 58 - 61) : n leafs */
if (0 >= dig__fread_port_I((int *)&(t->n_leafs), 1, fp))
return (-1);
/* bytes 58 - 61 (LFS 62 - 65) : n levels */
if (0 >= dig__fread_port_I(&(t->rootlevel), 1, fp))
return (-1);
/* bytes 62 - 65 (LFS 66 - 73) : root node offset */
if (0 >=
dig__fread_port_O(&(ptr->Line_spidx_offset), 1, fp,
ptr->spidx_port.off_t_size))
return (-1);
ptr->Line_spidx->rootpos = ptr->Line_spidx_offset;
/* Area spatial index */
t = ptr->Area_spidx;
/* bytes 66 - 69 (LFS 74 - 77) : n nodes */
if (0 >= dig__fread_port_I((int *)&(t->n_nodes), 1, fp))
return (-1);
/* bytes 70 - 73 (LFS 78 - 81) : n leafs */
if (0 >= dig__fread_port_I((int *)&(t->n_leafs), 1, fp))
return (-1);
/* bytes 74 - 77 (LFS 82 - 85) : n levels */
if (0 >= dig__fread_port_I(&(t->rootlevel), 1, fp))
return (-1);
/* bytes 78 - 81 (LFS 86 - 93) : root node offset */
if (0 >=
dig__fread_port_O(&(ptr->Area_spidx_offset), 1, fp,
ptr->spidx_port.off_t_size))
return (-1);
ptr->Area_spidx->rootpos = ptr->Area_spidx_offset;
/* Isle spatial index */
t = ptr->Isle_spidx;
/* bytes 82 - 85 (LFS 94 - 97) : n nodes */
if (0 >= dig__fread_port_I((int *)&(t->n_nodes), 1, fp))
return (-1);
/* bytes 86 - 89 (LFS 98 - 101) : n leafs */
if (0 >= dig__fread_port_I((int *)&(t->n_leafs), 1, fp))
return (-1);
/* bytes 90 - 93 (LFS 102 - 105) : n levels */
if (0 >= dig__fread_port_I(&(t->rootlevel), 1, fp))
return (-1);
/* bytes 94 - 97 (LFS 106 - 113) : root node offset */
if (0 >=
dig__fread_port_O(&(ptr->Isle_spidx_offset), 1, fp,
ptr->spidx_port.off_t_size))
return (-1);
ptr->Isle_spidx->rootpos = ptr->Isle_spidx_offset;
/* 3D future : */
/* Face spatial index */
/* bytes 98 - 101 (LFS 114 - 121) : root node offset */
if (0 >=
dig__fread_port_O(&(ptr->Face_spidx_offset), 1, fp,
ptr->spidx_port.off_t_size))
return (-1);
/* ptr->Face_spidx->rootpos = ptr->Face_spidx_offset; */
/* Volume spatial index */
/* bytes 102 - 105 (LFS 122 - 129) : root node offset */
if (0 >=
dig__fread_port_O(&(ptr->Volume_spidx_offset), 1, fp,
ptr->spidx_port.off_t_size))
return (-1);
/* ptr->Volume_spidx->rootpos = ptr->Volume_spidx_offset; */
/* Hole spatial index */
/* bytes 106 - 109 (LFS 130 - 137) : root node offset */
if (0 >=
dig__fread_port_O(&(ptr->Hole_spidx_offset), 1, fp,
ptr->spidx_port.off_t_size))
return (-1);
/* ptr->Hole_spidx->rootpos = ptr->Hole_spidx_offset; */
/* coor file size : bytes 110 - 113 (117) (LFS: 138 - 145) */
if (ptr->off_t_size == -1)
ptr->off_t_size = ptr->spidx_port.off_t_size;
if (0 >= dig__fread_port_O(&(ptr->coor_size), 1, fp, ptr->off_t_size))
return (-1);
G_debug(2, " coor size %lu", (long unsigned)ptr->coor_size);
dig_fseek(fp, ptr->spidx_head_size, SEEK_SET);
return (0);
}
/*!
\brief Search spatial index file
Can't use regular RTreeSearch() here because sidx must be read
with dig__fread_port_*() functions
\param t pointer to RTree
\param r search rectangle
\param shcb user-provided callback
\param cbarg argument for shcb
\param Plus pointer to Plus_head structure
\return number of qualifying rectangles
*/
int rtree_search(struct RTree *t, struct RTree_Rect *r,
SearchHitCallback shcb, void *cbarg, struct Plus_head *Plus)
{
int hitCount = 0, found;
/* int j, maxcard; */
int i;
struct spidxpstack s[MAXLEVEL];
int top = 0, level;
off_t lastpos;
assert(r);
assert(t);
/* stack size of t->rootlevel + 1 is enough because of depth first search */
/* only one node per level on stack at any given time */
dig_set_cur_port(&(Plus->spidx_port));
/* add root node position to stack */
s[top].sn = rtree_get_node(t->rootpos, t->rootlevel, t, Plus);
#if 0
dig_fseek(&(Plus->spidx_fp), t->rootpos, SEEK_SET);
/* read with dig__fread_port_* fns */
dig__fread_port_I(&(s[top].sn.count), 1, &(Plus->spidx_fp));
dig__fread_port_I(&(s[top].sn.level), 1, &(Plus->spidx_fp));
maxcard = t->rootlevel ? t->nodecard : t->leafcard;
for (j = 0; j < maxcard; j++) {
dig__fread_port_D(s[top].sn.branch[j].rect.boundary, NUMSIDES,
&(Plus->spidx_fp));
dig__fread_port_O(&(s[top].pos[j]), 1, &(Plus->spidx_fp),
Plus->spidx_port.off_t_size);
/* leaf node: vector object IDs are stored in child.id */
if (s[top].sn.level == 0) {
s[top].sn.branch[j].child.id = (int)s[top].pos[j];
}
else {
s[top].sn.branch[j].child.pos = s[top].pos[j];
}
}
#endif
s[top].branch_id = i = 0;
while (top >= 0) {
level = s[top].sn->level;
if (level > 0) { /* this is an internal node in the tree */
found = 1;
for (i = s[top].branch_id; i < t->nodecard; i++) {
lastpos = s[top].sn->branch[i].child.pos;
if (lastpos > 0 &&
RTreeOverlap(r, &(s[top].sn->branch[i].rect), t)) {
s[top++].branch_id = i + 1;
s[top].sn = rtree_get_node(lastpos, level - 1, t, Plus);
#if 0
dig_fseek(&(Plus->spidx_fp), lastpos, SEEK_SET);
/* read with dig__fread_port_* fns */
dig__fread_port_I(&(s[top].sn.count), 1,
&(Plus->spidx_fp));
dig__fread_port_I(&(s[top].sn.level), 1,
&(Plus->spidx_fp));
maxcard = s[top].sn.level ? t->nodecard : t->leafcard;
for (j = 0; j < maxcard; j++) {
dig__fread_port_D(s[top].sn.branch[j].rect.boundary,
NUMSIDES, &(Plus->spidx_fp));
dig__fread_port_O(&(s[top].pos[j]), 1,
&(Plus->spidx_fp),
Plus->spidx_port.off_t_size);
if (s[top].sn.level == 0) {
s[top].sn.branch[j].child.id = (int)s[top].pos[j];
}
else {
s[top].sn.branch[j].child.pos = s[top].pos[j];
}
}
#endif
s[top].branch_id = 0;
found = 0;
break;
}
}
if (found) {
/* nothing else found, go back up */
s[top].branch_id = t->nodecard;
top--;
}
}
else { /* this is a leaf node */
for (i = 0; i < t->leafcard; i++) {
if (s[top].sn->branch[i].child.id &&
RTreeOverlap(r, &(s[top].sn->branch[i].rect), t)) {
hitCount++;
if (shcb) { /* call the user-provided callback */
if (!shcb((int)s[top].sn->branch[i].child.id,
&s[top].sn->branch[i].rect, cbarg)) {
/* callback wants to terminate search early */
return hitCount;
}
}
}
}
top--;
}
}
return hitCount;
}
/* read old 3.0 or 4.0 dig file into array
returns number of elements read into array
or -1 on error */
int read_dig(FILE * Digin, struct Map_info *Mapout,
struct Line **plines, int endian, int att)
{
char buf[100];
struct dig_head In_head;
int lalloc, line = 0, type, portable = 1;
int npoints = 0, nlines = 0, nbounds = 0;
int ndpoints = 0, ndlines = 0, ndbounds = 0, nunknown = 0;
struct Line *lines;
struct line_pnts *nline;
struct line_cats *cat_out;
double dbuf;
int ibuf;
long lbuf;
struct gvfile gvf;
dig_file_init(&gvf);
gvf.file = Digin;
Vect__init_head(Mapout);
/* set conversion matrices */
dig_init_portable(&(In_head.port), endian);
/* Version 3 dig files were not portable and some version 4
* files may be also non portable */
G_message(_("Reading dig file..."));
/* read and copy head */
dig_fseek(&gvf, 0L, SEEK_SET); /* set to beginning */
if (0 >= dig__fread_port_C(buf, DIG4_ORGAN_LEN, &gvf))
return -1;
buf[DIG4_ORGAN_LEN - 1] = '\0';
Vect_set_organization(Mapout, buf);
if (0 >= dig__fread_port_C(buf, DIG4_DATE_LEN, &gvf))
return -1;
buf[DIG4_DATE_LEN - 1] = '\0';
Vect_set_date(Mapout, buf);
if (0 >= dig__fread_port_C(buf, DIG4_YOUR_NAME_LEN, &gvf))
return -1;
buf[DIG4_YOUR_NAME_LEN - 1] = '\0';
Vect_set_person(Mapout, buf);
if (0 >= dig__fread_port_C(buf, DIG4_MAP_NAME_LEN, &gvf))
return -1;
buf[DIG4_MAP_NAME_LEN - 1] = '\0';
Vect_set_map_name(Mapout, buf);
if (0 >= dig__fread_port_C(buf, DIG4_SOURCE_DATE_LEN, &gvf))
return -1;
buf[DIG4_SOURCE_DATE_LEN - 1] = '\0';
Vect_set_map_date(Mapout, buf);
if (0 >= dig__fread_port_C(buf, DIG4_LINE_3_LEN, &gvf))
return -1;
buf[DIG4_LINE_3_LEN - 1] = '\0';
Vect_set_comment(Mapout, buf);
if (0 >= dig__fread_port_C(buf, VERS_4_DATA_SIZE, &gvf))
return -1;
if (buf[0] != '%' || buf[1] != '%') { /* Version3.0 */
In_head.Version_Major = 3;
portable = 0; /* input vector is not portable format */
G_message(_("Input file is version 3."));
}
else {
In_head.Version_Major = 4;
G_message(_("Input file is version 4."));
/* determine if in portable format or not */
if (buf[6] == 1 && (~buf[6] & 0xff) == (buf[7] & 0xff)) { /* portable ? */
portable = 1; /* input vector is portable format */
}
else {
portable = 0; /* input vector is not portable format */
}
}
if (portable == 1) {
G_message(_("Input file is portable."));
}
else {
G_warning(_("Input file is not portable. "
"We will attempt to convert anyway but conversion may fail. "
"Please read manual for detail information."));
}
/* set Cur_Head because it is used by dig__*_convert()
called by dig__fread_port_*() */
dig_set_cur_port(&(In_head.port));
if (0 >= dig__fread_port_L(&lbuf, 1, &gvf))
return -1;
Vect_set_scale(Mapout, (int)lbuf);
if (0 >= dig__fread_port_I(&ibuf, 1, &gvf))
return -1;
Vect_set_zone(Mapout, ibuf);
if (0 >= dig__fread_port_D(&dbuf, 1, &gvf))
return -1; /* W */
if (0 >= dig__fread_port_D(&dbuf, 1, &gvf))
return -1; /* E */
if (0 >= dig__fread_port_D(&dbuf, 1, &gvf))
return -1; /* S */
if (0 >= dig__fread_port_D(&dbuf, 1, &gvf))
return -1; /* N */
if (0 >= dig__fread_port_D(&dbuf, 1, &gvf))
return -1;
Vect_set_thresh(Mapout, dbuf);
/* reading dig file body (elements) */
nline = Vect_new_line_struct();
cat_out = Vect_new_cats_struct();
lalloc = 0;
lines = NULL;
line = 0;
while (1) {
type = read_line(&gvf, nline);
G_debug(3, "read line = %d, type = %d", line, type);
if (type == -2)
break; /* EOF */
switch (type) {
case GV_POINT:
npoints++;
break;
case GV_LINE:
nlines++;
break;
case GV_BOUNDARY:
nbounds++;
break;
case 0: /* dead */
break;
default:
nunknown++;
break;
}
if (!(type & (GV_POINT | GV_LINE | GV_BOUNDARY)))
continue;
if ((type & GV_BOUNDARY) || !att) {
Vect_write_line(Mapout, type, nline, cat_out);
/* reset In_head */
dig_set_cur_port(&(In_head.port));
}
else { /* GV_POINT or GV_LINE */
if (line >= lalloc) {
lalloc += 10000;
lines =
(struct Line *)G_realloc(lines,
lalloc * sizeof(struct Line));
}
lines[line].type = type;
lines[line].n_points = nline->n_points;
lines[line].cat = -1;
lines[line].x =
(double *)G_malloc(nline->n_points * sizeof(double));
lines[line].y =
(double *)G_malloc(nline->n_points * sizeof(double));
memcpy((void *)lines[line].x, (void *)nline->x,
nline->n_points * sizeof(double));
memcpy((void *)lines[line].y, (void *)nline->y,
nline->n_points * sizeof(double));
line++;
}
}
if (att) {
G_message(_("[%d] points read to memory"), npoints);
G_message(_("[%d] lines read to memory"), nlines);
}
else {
G_message(_("[%d] points read and written to output"), npoints);
G_message(_("[%d] lines read and written to output"), nlines);
}
G_message(_("[%d] area boundaries read and written to output"), nbounds);
G_message(_("[%d] dead points skipped"), ndpoints);
G_message(_("[%d] dead lines skipped"), ndlines);
G_message(_("[%d] dead area boundaries skipped"), ndbounds);
G_message(_("[%d] elements of unknown type skipped"), nunknown);
G_message(_("[%d] elements read to memory"), line);
*plines = lines;
return (line);
}
/*!
\brief Read line from coor file
\param Map vector map layer
\param[out] p container used to store line points within
\param[out] c container used to store line categories within
\param offset given offset
\return line type ( > 0 )
\return 0 dead line
\return -1 out of memory
\return -2 end of file
*/
int read_line_nat(struct Map_info *Map,
struct line_pnts *p, struct line_cats *c, off_t offset)
{
register int i, dead = 0;
int n_points;
off_t size;
int n_cats, do_cats;
int type;
char rhead, nc;
short field;
G_debug(3, "Vect__Read_line_nat: offset = %lu", (unsigned long) offset);
Map->head.last_offset = offset;
/* reads must set in_head, but writes use default */
dig_set_cur_port(&(Map->head.port));
dig_fseek(&(Map->dig_fp), offset, 0);
if (0 >= dig__fread_port_C(&rhead, 1, &(Map->dig_fp)))
return (-2);
if (!(rhead & 0x01)) /* dead line */
dead = 1;
if (rhead & 0x02) /* categories exists */
do_cats = 1; /* do not return here let file offset moves forward to next */
else /* line */
do_cats = 0;
rhead >>= 2;
type = dig_type_from_store((int)rhead);
G_debug(3, " type = %d, do_cats = %d dead = %d", type, do_cats, dead);
if (c != NULL)
c->n_cats = 0;
if (do_cats) {
if (Map->head.Version_Minor == 1) { /* coor format 5.1 */
if (0 >= dig__fread_port_I(&n_cats, 1, &(Map->dig_fp)))
return (-2);
}
else { /* coor format 5.0 */
if (0 >= dig__fread_port_C(&nc, 1, &(Map->dig_fp)))
return (-2);
n_cats = (int)nc;
}
G_debug(3, " n_cats = %d", n_cats);
if (c != NULL) {
c->n_cats = n_cats;
if (n_cats > 0) {
if (0 > dig_alloc_cats(c, (int)n_cats + 1))
return (-1);
if (Map->head.Version_Minor == 1) { /* coor format 5.1 */
if (0 >=
dig__fread_port_I(c->field, n_cats, &(Map->dig_fp)))
return (-2);
}
else { /* coor format 5.0 */
for (i = 0; i < n_cats; i++) {
if (0 >= dig__fread_port_S(&field, 1, &(Map->dig_fp)))
return (-2);
c->field[i] = (int)field;
}
}
if (0 >= dig__fread_port_I(c->cat, n_cats, &(Map->dig_fp)))
return (-2);
}
}
else {
if (Map->head.Version_Minor == 1) { /* coor format 5.1 */
size = (off_t) (2 * PORT_INT) * n_cats;
}
else { /* coor format 5.0 */
size = (off_t) (PORT_SHORT + PORT_INT) * n_cats;
}
dig_fseek(&(Map->dig_fp), size, SEEK_CUR);
}
}
if (type & GV_POINTS) {
n_points = 1;
}
else {
if (0 >= dig__fread_port_I(&n_points, 1, &(Map->dig_fp)))
return (-2);
}
G_debug(3, " n_points = %d", n_points);
if (p != NULL) {
if (0 > dig_alloc_points(p, n_points + 1))
return (-1);
p->n_points = n_points;
if (0 >= dig__fread_port_D(p->x, n_points, &(Map->dig_fp)))
return (-2);
if (0 >= dig__fread_port_D(p->y, n_points, &(Map->dig_fp)))
return (-2);
if (Map->head.with_z) {
if (0 >= dig__fread_port_D(p->z, n_points, &(Map->dig_fp)))
return (-2);
}
else {
for (i = 0; i < n_points; i++)
p->z[i] = 0.0;
}
}
else {
if (Map->head.with_z)
size = (off_t) n_points * 3 * PORT_DOUBLE;
else
size = (off_t) n_points * 2 * PORT_DOUBLE;
dig_fseek(&(Map->dig_fp), size, SEEK_CUR);
}
G_debug(3, " off = %lu", (unsigned long) dig_ftell(&(Map->dig_fp)));
if (dead)
return 0;
return type;
}
/*!
\brief Open feature index file
\param[in,out] Map pointer to Map_info struct
\param[out] offset pointer to Format_info_offset (OGR or PG)
\return 0 on success
\return -1 on error
*/
int Vect_open_fidx(struct Map_info *Map, struct Format_info_offset *offset)
{
char elem[GPATH_MAX];
char buf[5]; /* used for format version */
long length;
int Version_Major, Version_Minor, Back_Major, Back_Minor, byte_order;
struct gvfile fp;
struct Port_info port;
G_debug(1, "Vect_open_fidx(): name = %s mapset = %s format = %d",
Map->name, Map->mapset, Map->format);
sprintf(elem, "%s/%s", GV_DIRECTORY, Map->name);
dig_file_init(&fp);
fp.file = G_fopen_old(elem, GV_FIDX_ELEMENT, Map->mapset);
if (fp.file == NULL) {
G_debug(1, "unable to open fidx file for vector map <%s>",
Vect_get_full_name(Map));
return -1;
}
/* Header */
if (0 >= dig__fread_port_C(buf, 5, &fp))
return -1;
Version_Major = buf[0];
Version_Minor = buf[1];
Back_Major = buf[2];
Back_Minor = buf[3];
byte_order = buf[4];
/* check version numbers */
if (Version_Major > 5 || Version_Minor > 0) {
if (Back_Major > 5 || Back_Minor > 0) {
G_fatal_error(_("Feature index format version %d.%d is not supported by this release."
" Try to rebuild topology or upgrade GRASS."),
Version_Major, Version_Minor);
return -1;
}
G_warning(_("Your GRASS version does not fully support feature index format %d.%d of the vector."
" Consider to rebuild topology or upgrade GRASS."),
Version_Major, Version_Minor);
}
dig_init_portable(&port, byte_order);
dig_set_cur_port(&port);
/* Body */
/* bytes 6 - 9 : header size */
if (0 >= dig__fread_port_L(&length, 1, &fp))
return -1;
G_debug(4, " header size %ld", length);
G_fseek(fp.file, length, SEEK_SET);
/* number of records */
if (0 >= dig__fread_port_I(&(offset->array_num), 1, &fp))
return -1;
/* alloc space */
offset->array = (int *) G_malloc(offset->array_num * sizeof(int));
offset->array_alloc = offset->array_num;
/* offsets */
if (0 >= dig__fread_port_I(offset->array,
offset->array_num, &fp))
return -1;
fclose(fp.file);
G_debug(3, "%d records read from fidx", offset->array_num);
return 0;
}
