GRASS GIS 8 Programmer's Manual 8.4.1(2025)-45ca3179ab
Loading...
Searching...
No Matches
zones.c
Go to the documentation of this file.
1#include <grass/config.h>
2#include <stdio.h>
3#include <stdlib.h>
4#include <string.h>
5#include <math.h>
6#include <grass/lidar.h>
7
8/*----------------------------------------------------------------------------------------*/
9void P_zero_dim(struct Reg_dimens *dim)
10{
11 dim->edge_h = 0.0;
12 dim->edge_v = 0.0;
13 dim->overlap = 0.0;
14 dim->sn_size = 0.0;
15 dim->ew_size = 0.0;
16 return;
17}
18
19/*----------------------------------------------------------------------------------------*/
20/*
21 --------------------------------------------
22 | Elaboration region |
23 | ------------------------------------ |
24 | | General region | |
25 | | ---------------------------- | |
26 | | | | | |
27 | | | | | |
28 | | | | | |
29 | | | Overlap region | | |
30 | | | | | |
31 | | | | | |
32 | | | | | |
33 | | ---------------------------- | |
34 | | | |
35 | ------------------------------------ |
36 | |
37 --------------------------------------------
38
39 The terminology is misleading:
40 The Overlap region does NOT overlap with neighbouring segments,
41 but the Elaboration and General region do overlap
42
43 Elaboration is used for interpolation
44 Interpolated points in Elaboration but outside General are discarded
45 Interpolated points in General but outside Overlap are weighed by
46 their distance to Overlap and summed up
47 Interpolated points in Overlap are taken as they are
48
49 The buffer zones Elaboration - General and General - Overlap must be
50 large enough to avoid artifacts
51 */
52
53int P_set_regions(struct Cell_head *Elaboration, struct bound_box *General,
54 struct bound_box *Overlap, struct Reg_dimens dim, int type)
55{
56 /* Set the Elaboration, General, and Overlap region limits
57 * Returns 0 on success; -1 on failure*/
58 struct Cell_head orig;
59
60 G_get_window(&orig);
61
62 switch (type) {
63 case GENERAL_ROW: /* General case N-S direction */
64 Elaboration->north =
65 Elaboration->south + dim.overlap + (2 * dim.edge_h);
66 Elaboration->south = Elaboration->north - dim.sn_size;
67 General->N = Elaboration->north - dim.edge_h;
68 General->S = Elaboration->south + dim.edge_h;
69 Overlap->N = General->N - dim.overlap;
70 Overlap->S = General->S + dim.overlap;
71 return 0;
72
73 case GENERAL_COLUMN: /* General case E-W direction */
74 Elaboration->west = Elaboration->east - dim.overlap - (2 * dim.edge_v);
75 Elaboration->east = Elaboration->west + dim.ew_size;
76 General->W = Elaboration->west + dim.edge_v;
77 General->E = Elaboration->east - dim.edge_v;
78 Overlap->W = General->W + dim.overlap;
79 Overlap->E = General->E - dim.overlap;
80 return 0;
81
82 case FIRST_ROW: /* Just started with first row */
83 Elaboration->north = orig.north + 2 * dim.edge_h;
84 Elaboration->south = Elaboration->north - dim.sn_size;
85 General->N = orig.north;
86 General->S = Elaboration->south + dim.edge_h;
87 Overlap->N = General->N;
88 Overlap->S = General->S + dim.overlap;
89 return 0;
90
91 case LAST_ROW: /* Reached last row */
92 Elaboration->south = orig.south - 2 * dim.edge_h;
93 General->S = orig.south;
94 Overlap->S = General->S;
95 return 0;
96
97 case FIRST_COLUMN: /* Just started with first column */
98 Elaboration->west = orig.west - 2 * dim.edge_v;
99 Elaboration->east = Elaboration->west + dim.ew_size;
100 General->W = orig.west;
101 General->E = Elaboration->east - dim.edge_v;
102 Overlap->W = General->W;
103 Overlap->E = General->E - dim.overlap;
104 return 0;
105
106 case LAST_COLUMN: /* Reached last column */
107 Elaboration->east = orig.east + 2 * dim.edge_v;
108 General->E = orig.east;
109 Overlap->E = General->E;
110 return 0;
111 }
112
113 return -1;
114}
115
116/*----------------------------------------------------------------------------------------*/
117int P_set_dim(struct Reg_dimens *dim, double pe, double pn, int *nsplx,
118 int *nsply)
119{
120 int total_splines, edge_splines, n_windows;
121 int lastsplines, lastsplines_min, lastsplines_max;
122 double E_extension, N_extension, edgeE, edgeN;
123 struct Cell_head orig;
124 int ret = 0;
125
126 G_get_window(&orig);
127
128 E_extension = orig.east - orig.west;
129 N_extension = orig.north - orig.south;
130 dim->ew_size = *nsplx * pe;
131 dim->sn_size = *nsply * pn;
132 edgeE = dim->ew_size - dim->overlap - 2 * dim->edge_v;
133 edgeN = dim->sn_size - dim->overlap - 2 * dim->edge_h;
134
135 /* number of moving windows: E_extension / edgeE */
136 /* remaining steps: total steps - (floor(E_extension / edgeE) * E_extension)
137 * / passoE */
138 /* remaining steps must be larger than edge_v + overlap + half of overlap
139 * window */
140 total_splines = ceil(E_extension / pe);
141 edge_splines = edgeE / pe;
142 n_windows = E_extension / edgeE; /* without last one */
143 if (n_windows > 0) {
144 /* min size of the last overlap window = half of current overlap window
145 */
146 /* max size of the last overlap window = elaboration - 3 * edge -
147 * overlap */
148 lastsplines_min =
149 ceil((dim->ew_size / 2.0 - (dim->edge_v + dim->overlap)) / pe);
150 lastsplines_max =
151 ceil((dim->ew_size - 3 * dim->edge_v - dim->overlap) / pe);
152 lastsplines = total_splines - edge_splines * n_windows;
153 while (lastsplines > lastsplines_max || lastsplines < lastsplines_min) {
154 *nsplx -= 1;
155 dim->ew_size = *nsplx * pe;
156 edgeE = dim->ew_size - dim->overlap - 2 * dim->edge_v;
157
158 edge_splines = edgeE / pe;
159 n_windows = E_extension / edgeE; /* without last one */
160 lastsplines = total_splines - edge_splines * n_windows;
161 if (ret == 0)
162 ret = 1;
163 }
164 }
165
166 total_splines = ceil(N_extension / pn);
167 edge_splines = edgeN / pn;
168 n_windows = N_extension / edgeN; /* without last one */
169 if (n_windows > 0) {
170 /* min size of the last overlap window = half of current overlap window
171 */
172 /* max size of the last overlap window = elaboration - 3 * edge -
173 * overlap */
174 lastsplines_min =
175 ceil((dim->sn_size / 2.0 - (dim->edge_h + dim->overlap)) / pn);
176 lastsplines_max =
177 ceil((dim->sn_size - 3 * dim->edge_h - dim->overlap) / pn);
178 lastsplines = total_splines - edge_splines * n_windows;
179 while (lastsplines > lastsplines_max || lastsplines < lastsplines_min) {
180 *nsply -= 1;
181 dim->sn_size = *nsply * pn;
182 edgeN = dim->sn_size - dim->overlap - 2 * dim->edge_h;
183
184 edge_splines = edgeN / pn;
185 n_windows = N_extension / edgeN; /* without last one */
186 lastsplines = total_splines - edge_splines * n_windows;
187 if (ret < 2)
188 ret += 2;
189 }
190 }
191
192 return ret;
193}
194
195/*----------------------------------------------------------------------------------------*/
196int P_get_edge(int interpolator, struct Reg_dimens *dim, double pe, double pn)
197{
198 /* Set the edge regions dimension
199 * Returns 1 on success of bilinear; 2 on success of bicubic, 0 on failure
200 */
201 if (interpolator == P_BILINEAR) {
202 /* in case of edge artifacts, increase as multiples of 3 */
203 dim->edge_v = 9 * pe;
204 dim->edge_h = 9 * pn;
205 return 1;
206 }
207 else if (interpolator == P_BICUBIC) {
208 /* in case of edge artifacts, increase as multiples of 4 */
209 dim->edge_v = 12 * pe; /*3 */
210 dim->edge_h = 12 * pn;
211 return 2;
212 }
213 else
214 return 0; /* The interpolator is neither bilinear nor bicubic!! */
215}
216
217/*----------------------------------------------------------------------------------------*/
218int P_get_BandWidth(int interpolator, int nsplines)
219{
220 /* Returns the interpolation matrixes BandWidth dimension */
221
222 if (interpolator == P_BILINEAR) {
223 return (2 * nsplines + 1);
224 }
225 else {
226 return (4 * nsplines + 3);
227 }
228}
229
230/*----------------------------------------------------------------------------------------*/
231double P_Mean_Calc(struct Cell_head *Elaboration, struct Point *obs,
232 int npoints)
233{
234 int i, mean_count = 0;
235 double mean = 0.0;
236 struct bound_box mean_box;
237
238 Vect_region_box(Elaboration, &mean_box);
239 mean_box.W -= CONTOUR;
240 mean_box.E += CONTOUR;
241 mean_box.N += CONTOUR;
242 mean_box.S -= CONTOUR;
243
244 for (i = 0; i < npoints; i++) { /* */
245 if (Vect_point_in_box(obs[i].coordX, obs[i].coordY, obs[i].coordZ,
246 &mean_box)) {
247 mean_count++;
248 mean += obs[i].coordZ;
249 }
250 }
251 if (mean_count == 0)
252 mean = .0;
253 else
254 mean /= (double)mean_count;
255
256 return mean;
257}
258
259double P_estimate_splinestep(struct Map_info *Map, double *dens, double *dist)
260{
261 int type, npoints = 0;
262 double xmin = 0, xmax = 0, ymin = 0, ymax = 0;
263 double x, y, z;
264 struct line_pnts *points;
265 struct line_cats *categories;
266 struct bound_box region_box;
267 struct Cell_head orig;
268
269 G_get_set_window(&orig);
270 Vect_region_box(&orig, &region_box);
271
272 points = Vect_new_line_struct();
273 categories = Vect_new_cats_struct();
274
275 Vect_rewind(Map);
276 while ((type = Vect_read_next_line(Map, points, categories)) > 0) {
277 if (!(type & GV_POINT))
278 continue;
279
280 x = points->x[0];
281 y = points->y[0];
282 if (points->z != NULL)
283 z = points->z[0];
284 else
285 z = 0.0;
286
287 /* only use points in current region */
288 if (Vect_point_in_box(x, y, z, &region_box)) {
289 npoints++;
290
291 if (npoints > 1) {
292 if (xmin > x)
293 xmin = x;
294 else if (xmax < x)
295 xmax = x;
296 if (ymin > y)
297 ymin = y;
298 else if (ymax < y)
299 ymax = y;
300 }
301 else {
302 xmin = xmax = x;
303 ymin = ymax = y;
304 }
305 }
306 }
307 Vect_destroy_cats_struct(categories);
308 Vect_destroy_line_struct(points);
309
310 if (npoints > 0) {
311 /* estimated average distance between points in map units */
312 *dist = sqrt(((xmax - xmin) * (ymax - ymin)) / npoints);
313 /* estimated point density as number of points per square map unit */
314 *dens = npoints / ((xmax - xmin) * (ymax - ymin));
315 return 0;
316 }
317 else {
318 return -1;
319 }
320}
321
322struct Point *P_Read_Vector_Region_Map(struct Map_info *Map,
323 struct Cell_head *Elaboration,
324 int *num_points, int dim_vect, int layer)
325{
326 int line_num, pippo, npoints, cat, type;
327 double x, y, z;
328 struct Point *obs;
329 struct line_pnts *points;
330 struct line_cats *categories;
331 struct bound_box elaboration_box;
332
333 pippo = dim_vect;
334 obs = (struct Point *)G_calloc(pippo, sizeof(struct Point));
335
336 points = Vect_new_line_struct();
337 categories = Vect_new_cats_struct();
338
339 /* Reading points inside elaboration zone */
340 Vect_region_box(Elaboration, &elaboration_box);
341
342 npoints = 0;
343 line_num = 0;
344
345 Vect_rewind(Map);
346 while ((type = Vect_read_next_line(Map, points, categories)) > 0) {
347
348 if (!(type & GV_POINT))
349 continue;
350
351 line_num++;
352
353 x = points->x[0];
354 y = points->y[0];
355 if (points->z != NULL)
356 z = points->z[0];
357 else
358 z = 0.0;
359
360 /* Reading and storing points only if in elaboration_reg */
361 if (Vect_point_in_box(x, y, z, &elaboration_box)) {
362 npoints++;
363 if (npoints >= pippo) {
364 pippo += dim_vect;
365 obs = (struct Point *)G_realloc(
366 (void *)obs, (signed int)pippo * sizeof(struct Point));
367 }
368
369 /* Storing observation vector */
370 obs[npoints - 1].coordX = x;
371 obs[npoints - 1].coordY = y;
372 obs[npoints - 1].coordZ = z;
373 obs[npoints - 1].lineID =
374 line_num; /* Storing also the line's number */
375
376 Vect_cat_get(categories, layer, &cat);
377 obs[npoints - 1].cat = cat;
378 }
379 }
380 Vect_destroy_line_struct(points);
381 Vect_destroy_cats_struct(categories);
382
383 *num_points = npoints;
384 return obs;
385}
386
387struct Point *P_Read_Raster_Region_Map(SEGMENT *in_seg,
388 struct Cell_head *Elaboration,
389 struct Cell_head *Original,
390 int *num_points, int dim_vect)
391{
392 int col, row, startcol, endcol, startrow, endrow, nrows, ncols;
393 int pippo, npoints;
394 double x, y, z;
395 struct Point *obs;
396 struct bound_box elaboration_box;
397
398 pippo = dim_vect;
399 obs = (struct Point *)G_calloc(pippo, sizeof(struct Point));
400
401 /* Reading points inside elaboration zone */
402 Vect_region_box(Elaboration, &elaboration_box);
403
404 npoints = 0;
405 nrows = Original->rows;
406 ncols = Original->cols;
407
408 if (Original->north > Elaboration->north)
409 startrow =
410 (Original->north - Elaboration->north) / Original->ns_res - 1;
411 else
412 startrow = 0;
413 if (Original->north > Elaboration->south) {
414 endrow = (Original->north - Elaboration->south) / Original->ns_res + 1;
415 if (endrow > nrows)
416 endrow = nrows;
417 }
418 else
419 endrow = nrows;
420 if (Elaboration->west > Original->west)
421 startcol = (Elaboration->west - Original->west) / Original->ew_res - 1;
422 else
423 startcol = 0;
424 if (Elaboration->east > Original->west) {
425 endcol = (Elaboration->east - Original->west) / Original->ew_res + 1;
426 if (endcol > ncols)
427 endcol = ncols;
428 }
429 else
430 endcol = ncols;
431
432 for (row = startrow; row < endrow; row++) {
433 for (col = startcol; col < endcol; col++) {
434
435 Segment_get(in_seg, &z, row, col);
436
437 if (!Rast_is_d_null_value(&z)) {
438
439 x = Rast_col_to_easting((double)(col) + 0.5, Original);
440 y = Rast_row_to_northing((double)(row) + 0.5, Original);
441
442 if (Vect_point_in_box(x, y, 0, &elaboration_box)) {
443 npoints++;
444 if (npoints >= pippo) {
445 pippo += dim_vect;
446 obs = (struct Point *)G_realloc(
447 (void *)obs,
448 (signed int)pippo * sizeof(struct Point));
449 }
450
451 /* Storing observation vector */
452 obs[npoints - 1].coordX = x;
453 obs[npoints - 1].coordY = y;
454 obs[npoints - 1].coordZ = z;
455 }
456 }
457 }
458 }
459
460 *num_points = npoints;
461 return obs;
462}
463
464/*------------------------------------------------------------------------------------------------*/
465int P_Create_Aux2_Table(dbDriver *driver, char *tab_name)
466{
467 dbTable *auxiliar_tab;
468 dbColumn *column;
469
470 auxiliar_tab = db_alloc_table(2);
471 db_set_table_name(auxiliar_tab, tab_name);
472 db_set_table_description(auxiliar_tab, "Intermediate interpolated values");
473
474 column = db_get_table_column(auxiliar_tab, 0);
475 db_set_column_name(column, "ID");
476 db_set_column_sqltype(column, DB_SQL_TYPE_INTEGER);
477
478 column = db_get_table_column(auxiliar_tab, 1);
479 db_set_column_name(column, "Interp");
480 db_set_column_sqltype(column, DB_SQL_TYPE_REAL);
481
482 if (db_create_table(driver, auxiliar_tab) == DB_OK) {
483 G_debug(1, _("<%s> created in database."), tab_name);
484 return TRUE;
485 }
486 else
487 G_warning(_("<%s> has not been created in database."), tab_name);
488
489 return FALSE;
490}
491
492/*------------------------------------------------------------------------------------------------*/
493int P_Create_Aux4_Table(dbDriver *driver, char *tab_name)
494{
495 dbTable *auxiliar_tab;
496 dbColumn *column;
497
498 auxiliar_tab = db_alloc_table(4);
499 db_set_table_name(auxiliar_tab, tab_name);
500 db_set_table_description(auxiliar_tab, "Intermediate interpolated values");
501
502 column = db_get_table_column(auxiliar_tab, 0);
503 db_set_column_name(column, "ID");
504 db_set_column_sqltype(column, DB_SQL_TYPE_INTEGER);
505
506 column = db_get_table_column(auxiliar_tab, 1);
507 db_set_column_name(column, "Interp");
508 db_set_column_sqltype(column, DB_SQL_TYPE_REAL);
509
510 column = db_get_table_column(auxiliar_tab, 2);
511 db_set_column_name(column, "X");
512 db_set_column_sqltype(column, DB_SQL_TYPE_DOUBLE_PRECISION);
513
514 column = db_get_table_column(auxiliar_tab, 3);
515 db_set_column_name(column, "Y");
516 db_set_column_sqltype(column, DB_SQL_TYPE_DOUBLE_PRECISION);
517
518 if (db_create_table(driver, auxiliar_tab) == DB_OK) {
519 G_debug(1, _("<%s> created in database."), tab_name);
520 return TRUE;
521 }
522 else
523 G_warning(_("<%s> has not been created in database."), tab_name);
524
525 return FALSE;
526}
527
528/*------------------------------------------------------------------------------------------------*/
529int P_Drop_Aux_Table(dbDriver *driver, char *tab_name)
530{
531 dbString drop;
532
533 db_init_string(&drop);
534 db_append_string(&drop, "drop table ");
535 db_append_string(&drop, tab_name);
536 return db_execute_immediate(driver, &drop);
537}
538
539/*---------------------------------------------------------------------------------------*/
540void P_Aux_to_Raster(double **matrix, int fd)
541{
542 int ncols, col, nrows, row;
543 void *ptr, *raster;
544
545 nrows = Rast_window_rows();
546 ncols = Rast_window_cols();
547
548 raster = Rast_allocate_buf(DCELL_TYPE);
549
550 for (row = 0; row < nrows; row++) {
551 G_percent(row, nrows, 2);
552
553 Rast_set_d_null_value(raster, ncols);
554
555 for (col = 0, ptr = raster; col < ncols;
556 col++, ptr = G_incr_void_ptr(ptr, Rast_cell_size(DCELL_TYPE))) {
557 Rast_set_d_value(ptr, (DCELL)(matrix[row][col]), DCELL_TYPE);
558 }
559 Rast_put_d_row(fd, raster);
560 }
561 G_percent(row, nrows, 2);
562}
563
564/*------------------------------------------------------------------------------------------------*/
565void P_Aux_to_Vector(struct Map_info *Map UNUSED, struct Map_info *Out,
566 dbDriver *driver, char *tab_name)
567{
568
569 int more, type;
570 double coordX, coordY, coordZ;
571
572 struct line_pnts *point;
573 struct line_cats *cat;
574 dbTable *table;
575 dbColumn *column;
576 dbValue *value;
577 dbCursor cursor;
578 dbString sql;
579
580 char buf[1024];
581
582 point = Vect_new_line_struct();
583 cat = Vect_new_cats_struct();
584
585 db_init_string(&sql);
586 db_zero_string(&sql);
587
588 sprintf(buf, "select ID, X, Y, sum(Interp) from %s group by ID, X, Y",
589 tab_name);
590
591 db_append_string(&sql, buf);
592 db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL);
593
594 while (db_fetch(&cursor, DB_NEXT, &more) == DB_OK && more) {
595 table = db_get_cursor_table(&cursor);
596
597 column = db_get_table_column(table, 0);
598 type = db_sqltype_to_Ctype(db_get_column_sqltype(column));
599 if (type == DB_C_TYPE_INT)
600 value = db_get_column_value(column);
601 else
602 continue;
603
604 column = db_get_table_column(table, 1);
605 type = db_sqltype_to_Ctype(db_get_column_sqltype(column));
606 if (type == DB_C_TYPE_DOUBLE)
607 value = db_get_column_value(column);
608 else
609 continue;
610 coordZ = db_get_value_double(value);
611
612 column = db_get_table_column(table, 2);
613 type = db_sqltype_to_Ctype(db_get_column_sqltype(column));
614 if (type == DB_C_TYPE_DOUBLE)
615 value = db_get_column_value(column);
616 else
617 continue;
618 coordX = db_get_value_double(value);
619
620 column = db_get_table_column(table, 3);
621 type = db_sqltype_to_Ctype(db_get_column_sqltype(column));
622 if (type == DB_C_TYPE_DOUBLE)
623 value = db_get_column_value(column);
624 else
625 continue;
626 coordY = db_get_value_double(value);
627
628 Vect_copy_xyz_to_pnts(point, &coordX, &coordY, &coordZ, 1);
629 Vect_reset_cats(cat);
630 Vect_cat_set(cat, 1, 1);
631 Vect_write_line(Out, GV_POINT, point, cat);
632 }
633 return;
634}
635
636/*! DEFINITION OF THE SUBZONES
637
638 5: inside Overlap region
639 all others: inside General region but outside Overlap region
640
641 ---------------------------------
642 | | | | | | | |
643 ---------------------------------
644 | | | | | | | |
645 | | | | | | | |
646 | | | | | | | |
647 ---------------------------------
648 | | |4| 3 |3| | |
649 ---------------------------------
650 | | | | | | | |
651 | | |2| 5 |1| | |
652 | | | | | | | |
653 ---------------------------------
654 | | |2| 1 |1| | |
655 ---------------------------------
656 | | | | | | | |
657 | | | | | | | |
658 | | | | | | | |
659 ---------------------------------
660 | | | | | | | |
661 ---------------------------------
662 */
void * G_incr_void_ptr(const void *ptr, size_t size)
Advance void pointer.
Definition alloc.c:187
#define NULL
Definition ccmath.h:32
#define TRUE
Definition dbfopen.c:75
#define FALSE
Definition dbfopen.c:74
int G_debug(int level, const char *msg,...)
Print debugging message.
Definition debug.c:66
void G_get_window(struct Cell_head *window)
Get the current region.
Definition get_window.c:47
void G_warning(const char *msg,...)
Print a warning message to stderr.
Definition gis/error.c:203
void G_get_set_window(struct Cell_head *window)
Get the current working window (region)
#define GENERAL_ROW
Definition lidar.h:40
#define P_BILINEAR
Definition lidar.h:64
#define LAST_COLUMN
Definition lidar.h:45
#define FIRST_ROW
Definition lidar.h:42
#define FIRST_COLUMN
Definition lidar.h:44
#define LAST_ROW
Definition lidar.h:43
#define CONTOUR
Definition lidar.h:39
#define GENERAL_COLUMN
Definition lidar.h:41
#define P_BICUBIC
Definition lidar.h:65
void G_percent(long n, long d, int s)
Print percent complete messages.
Definition percent.c:61
int Segment_get(SEGMENT *SEG, void *buf, off_t row, off_t col)
Get value from segment file.
Definition segment/get.c:37
Definition lidar.h:77
int cat
Definition lidar.h:82
int lineID
Definition lidar.h:81
double coordY
Definition lidar.h:79
double coordX
Definition lidar.h:78
double coordZ
Definition lidar.h:80
double edge_v
Definition lidar.h:71
double edge_h
Definition lidar.h:70
double ew_size
Definition lidar.h:74
double overlap
Definition lidar.h:72
double sn_size
Definition lidar.h:73
#define x
void P_Aux_to_Raster(double **matrix, int fd)
Definition zones.c:540
double P_Mean_Calc(struct Cell_head *Elaboration, struct Point *obs, int npoints)
Definition zones.c:231
double P_estimate_splinestep(struct Map_info *Map, double *dens, double *dist)
Definition zones.c:259
void P_Aux_to_Vector(struct Map_info *Map UNUSED, struct Map_info *Out, dbDriver *driver, char *tab_name)
Definition zones.c:565
struct Point * P_Read_Vector_Region_Map(struct Map_info *Map, struct Cell_head *Elaboration, int *num_points, int dim_vect, int layer)
Definition zones.c:322
int P_get_edge(int interpolator, struct Reg_dimens *dim, double pe, double pn)
Definition zones.c:196
void P_zero_dim(struct Reg_dimens *dim)
Definition zones.c:9
int P_get_BandWidth(int interpolator, int nsplines)
Definition zones.c:218
struct Point * P_Read_Raster_Region_Map(SEGMENT *in_seg, struct Cell_head *Elaboration, struct Cell_head *Original, int *num_points, int dim_vect)
Definition zones.c:387
int P_Create_Aux2_Table(dbDriver *driver, char *tab_name)
Definition zones.c:465
int P_set_dim(struct Reg_dimens *dim, double pe, double pn, int *nsplx, int *nsply)
Definition zones.c:117
int P_Drop_Aux_Table(dbDriver *driver, char *tab_name)
Definition zones.c:529
int P_Create_Aux4_Table(dbDriver *driver, char *tab_name)
Definition zones.c:493
int P_set_regions(struct Cell_head *Elaboration, struct bound_box *General, struct bound_box *Overlap, struct Reg_dimens dim, int type)
Definition zones.c:53