/* allocate room for 'num' fields and category arrays
** in struct line_cats
** returns -1 on out of memory
*/
int dig_alloc_cats(struct line_cats *cats, int num)
{
int alloced;
char *p;
/* alloc_space will just return if no space is needed */
alloced = cats->alloc_cats;
if (!(p =
dig__alloc_space(num, &alloced, 1, (int *)cats->field,
sizeof(int)))) {
return (dig_out_of_memory());
}
cats->field = (int *)p;
alloced = cats->alloc_cats;
if (!(p =
dig__alloc_space(num, &alloced, 1, (int *)cats->cat,
sizeof(int)))) {
return (dig_out_of_memory());
}
cats->cat = (int *)p;
cats->alloc_cats = alloced;
return (0);
}
/* allocate room for 'num' X and Y arrays in struct line_pnts
** returns -1 on out of memory
*/
int dig_alloc_points(struct line_pnts *points, int num)
{
int alloced;
char *p;
alloced = points->alloc_points;
/* alloc_space will just return if no space is needed */
if (!(p =
dig__alloc_space(num, &alloced, 50, (char *)points->x,
sizeof(double)))) {
return (dig_out_of_memory());
}
points->x = (double *)p;
alloced = points->alloc_points;
/* alloc_space will just return if no space is needed */
if (!(p =
dig__alloc_space(num, &alloced, 50, (char *)points->y,
sizeof(double)))) {
return (dig_out_of_memory());
}
points->y = (double *)p;
alloced = points->alloc_points;
/* alloc_space will just return if no space is needed */
if (!(p =
dig__alloc_space(num, &alloced, 50, (char *)points->z,
sizeof(double)))) {
return (dig_out_of_memory());
}
points->z = (double *)p;
points->alloc_points = alloced;
return (0);
}
static int buf_alloc(int needed)
{
char *p;
int cnt;
if (needed <= buf_alloced)
return (0);
cnt = buf_alloced;
p = dig__alloc_space(needed, &cnt, 100, buffer, 1);
if (p == NULL)
return (dig_out_of_memory());
buffer = p;
buf_alloced = cnt;
return (0);
}
/*!
* \brief Build topo for area from lines
*
* Area is built in clockwise order.
* Take a given line and start off to the RIGHT/LEFT and try to complete
* an area.
*
* Possible Scenarios:
* - I. path runs into first line. : AREA!
* - II. path runs into a dead end (no other area lines at node) : no area
* - III. path runs into a previous line that is not 1st line or to 1st line but not to start node : no area
*
* After we find an area then we call point_in_area() to see if the
* specified point is w/in the area
*
* Old returns -1: error 0: no area (1: point in area)
* -2: island !!
*
* \param[in] plus pointer to Plus_head structure
* \param[in] first_line line id of first line
* \param[in] side side of line to build area on (GV_LEFT | GV_RIGHT)
* \param[in] lines pointer to array of lines
*
* \return -1 on error
* \return 0 no area
* \return number of lines
*/
int
dig_build_area_with_line(struct Plus_head *plus, plus_t first_line, int side,
plus_t ** lines)
{
register int i;
int prev_line, next_line;
static plus_t *array;
char *p;
static int array_size; /* 0 on startup */
int n_lines;
struct P_line *Line;
struct P_topo_b *topo;
int node;
if (debug_level == -1) {
const char *dstr = G__getenv("DEBUG");
if (dstr != NULL)
debug_level = atoi(dstr);
else
debug_level = 0;
}
G_debug(3, "dig_build_area_with_line(): first_line = %d, side = %d",
first_line, side);
/* First check if line is not degenerated (degenerated lines have angle -9)
* Following degenerated lines are skip by dig_angle_next_line() */
Line = plus->Line[first_line];
if (Line->type != GV_BOUNDARY)
return -1;
topo = (struct P_topo_b *)Line->topo;
node = topo->N1; /* to check one is enough, because if degenerated N1 == N2 */
if (dig_node_line_angle(plus, node, first_line) == -9.) {
G_debug(3, "First line degenerated");
return (0);
}
if (array_size == 0) { /* first time */
array_size = 1000;
array = (plus_t *) dig__falloc(array_size, sizeof(plus_t));
if (array == NULL)
return (dig_out_of_memory());
}
if (side == GV_LEFT) {
first_line = -first_line; /* start at node1, reverse direction */
}
array[0] = first_line;
prev_line = -first_line; /* start at node2 for direct and node1 for
reverse direction */
/* angle of first line */
n_lines = 1;
while (1) {
next_line =
dig_angle_next_line(plus, prev_line, GV_RIGHT, GV_BOUNDARY);
G_debug(3, "next_line = %d", next_line);
if (next_line == 0)
return (-1); /* Not found */
/* Check if adjacent lines do not have the same angle */
if (!dig_node_angle_check(plus, next_line, GV_BOUNDARY)) {
G_debug(3,
"Cannot build area, a neighbour of the line %d has the same angle at the node",
next_line);
return 0;
}
/* I. Area closed. This also handles the problem w/ 1 single area line */
if (first_line == next_line) {
/* GOT ONE! fill area struct and return */
G_debug(3, "Got one! :");
/* avoid loop when not debugging */
if (debug_level > 2) {
for (i = 0; i < n_lines; i++) {
G_debug(3, " area line (%d) = %d", i, array[i]);
}
}
*lines = array;
return (n_lines);
}
/* II. Note this is a dead end */
/* ( if prev_line != -first_line so it goes after the previous test) ? */
if (prev_line == next_line) {
G_debug(3, "Dead_end:");
return (0); /* dead end */
}
/* III. Unclosed ?, I would say started from free end */
for (i = 0; i < n_lines; i++)
if (abs(next_line) == abs(array[i])) {
G_debug(3, "Unclosed area:");
return (0); /* ran into a different area */
}
/* otherwise keep going */
if (n_lines >= array_size) {
p = dig__frealloc(array, array_size + 100, sizeof(plus_t),
array_size);
if (p == NULL)
return (dig_out_of_memory());
array = (plus_t *) p;
array_size += 100;
}
array[n_lines++] = next_line;
prev_line = -next_line;
}
return 0;
}
