/*!
\brief Get node cost
For each node in the map, finds the category of the point on it (if
there is any) and stores the value associated with this category in
the array node_costs. If there is no point with a category,
node_costs=0.
node_costs are multiplied by 1000000 and truncated to integers (as
is done in Vect_net_build_graph)
\param In pointer to Map_info structure
\param layer layer number
\param column name of column
\param[out] node_costs list of node costs
\returns 1 on success
\return 0 on failure
*/
int NetA_get_node_costs(struct Map_info *In, int layer, char *column,
int *node_costs)
{
int i, nlines, nnodes;
dbCatValArray vals;
struct line_cats *Cats;
struct line_pnts *Points;
dbDriver *driver;
struct field_info *Fi;
Fi = Vect_get_field(In, layer);
driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
nlines = Vect_get_num_lines(In);
nnodes = Vect_get_num_nodes(In);
Cats = Vect_new_cats_struct();
Points = Vect_new_line_struct();
for (i = 1; i <= nnodes; i++)
node_costs[i] = 0;
db_CatValArray_init(&vals);
if (db_select_CatValArray(driver, Fi->table, Fi->key, column, NULL, &vals)
== -1)
return 0;
for (i = 1; i <= nlines; i++) {
int type = Vect_read_line(In, Points, Cats, i);
if (type == GV_POINT) {
int node, cat;
double value;
if (!Vect_cat_get(Cats, layer, &cat))
continue;
Vect_get_line_nodes(In, i, &node, NULL);
if (db_CatValArray_get_value_double(&vals, cat, &value) == DB_OK)
node_costs[node] = value * 1000000.0;
}
}
Vect_destroy_cats_struct(Cats);
db_CatValArray_free(&vals);
db_close_database_shutdown_driver(driver);
return 1;
}
int main(int argc, char *argv[])
{
char *p;
int i, j, k;
int method, half, use_catno;
const char *mapset;
struct GModule *module;
struct Option *point_opt, /* point vector */
*area_opt, /* area vector */
*point_type_opt, /* point type */
*point_field_opt, /* point layer */
*area_field_opt, /* area layer */
*method_opt, /* stats method */
*point_column_opt, /* point column for stats */
*count_column_opt, /* area column for point count */
*stats_column_opt, /* area column for stats result */
*fs_opt; /* field separator for printed output */
struct Flag *print_flag;
char *fs;
struct Map_info PIn, AIn;
int point_type, point_field, area_field;
struct line_pnts *Points;
struct line_cats *ACats, *PCats;
AREA_CAT *Area_cat;
int pline, ptype, count;
int area, nareas, nacats, nacatsalloc;
int ctype, nrec;
struct field_info *PFi, *AFi;
dbString stmt;
dbDriver *Pdriver, *Adriver;
char buf[2000];
int update_ok, update_err;
struct boxlist *List;
struct bound_box box;
dbCatValArray cvarr;
dbColumn *column;
struct pvalcat
{
double dval;
int catno;
} *pvalcats;
int npvalcats, npvalcatsalloc;
stat_func *statsvalue = NULL;
double result;
column = NULL;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("attribute table"));
G_add_keyword(_("database"));
G_add_keyword(_("univariate statistics"));
G_add_keyword(_("zonal statistics"));
module->description = _("Count points in areas, calculate statistics from point attributes.");
point_opt = G_define_standard_option(G_OPT_V_INPUT);
point_opt->key = "points";
point_opt->description = _("Name of existing vector map with points");
/* point_opt->guisection = _("Required"); */
area_opt = G_define_standard_option(G_OPT_V_INPUT);
area_opt->key = "areas";
area_opt->description = _("Name of existing vector map with areas");
/* area_opt->guisection = _("Required"); */
point_type_opt = G_define_standard_option(G_OPT_V_TYPE);
point_type_opt->key = "type";
point_type_opt->options = "point,centroid";
point_type_opt->answer = "point";
point_type_opt->label = _("Feature type");
point_type_opt->required = NO;
point_field_opt = G_define_standard_option(G_OPT_V_FIELD);
point_field_opt->key = "player";
point_field_opt->label = _("Layer number for points map");
area_field_opt = G_define_standard_option(G_OPT_V_FIELD);
area_field_opt->key = "alayer";
area_field_opt->label = _("Layer number for area map");
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = NO;
method_opt->multiple = NO;
p = G_malloc(1024);
for (i = 0; menu[i].name; i++) {
if (i)
strcat(p, ",");
else
*p = 0;
strcat(p, menu[i].name);
}
method_opt->options = p;
method_opt->description = _("Method for aggregate statistics");
point_column_opt = G_define_standard_option(G_OPT_DB_COLUMN);
point_column_opt->key = "pcolumn";
point_column_opt->required = NO;
point_column_opt->multiple = NO;
point_column_opt->label =
_("Column name of points map to use for statistics");
point_column_opt->description = _("Column of points map must be numeric");
count_column_opt = G_define_option();
count_column_opt->key = "ccolumn";
count_column_opt->type = TYPE_STRING;
count_column_opt->required = NO;
count_column_opt->multiple = NO;
count_column_opt->label = _("Column name to upload points count");
count_column_opt->description =
_("Column to hold points count, must be of type integer, will be created if not existing");
stats_column_opt = G_define_option();
stats_column_opt->key = "scolumn";
stats_column_opt->type = TYPE_STRING;
stats_column_opt->required = NO;
stats_column_opt->multiple = NO;
stats_column_opt->label = _("Column name to upload statistics");
stats_column_opt->description =
_("Column to hold statistics, must be of type double, will be created if not existing");
fs_opt = G_define_standard_option(G_OPT_F_SEP);
print_flag = G_define_flag();
print_flag->key = 'p';
print_flag->label =
_("Print output to stdout, do not update attribute table");
print_flag->description = _("First column is always area category");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
point_type = Vect_option_to_types(point_type_opt);
point_field = atoi(point_field_opt->answer);
area_field = atoi(area_field_opt->answer);
if (print_flag->answer)
/* get field separator */
fs = G_option_to_separator(fs_opt);
else
fs = NULL;
/* check for stats */
if (method_opt->answer) {
if (!point_column_opt->answer) {
G_fatal_error("Method but no point column selected");
}
if (!print_flag->answer && !stats_column_opt->answer)
G_fatal_error("Name for stats column is missing");
}
if (point_column_opt->answer) {
if (!method_opt->answer)
G_fatal_error("No method for statistics selected");
if (!print_flag->answer && !stats_column_opt->answer)
G_fatal_error("Name for stats column is missing");
}
/* Open points vector */
if ((mapset = G_find_vector2(point_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), point_opt->answer);
Vect_set_open_level(2);
if (Vect_open_old(&PIn, point_opt->answer, mapset) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), point_opt->answer);
/* Open areas vector */
if ((mapset = G_find_vector2(area_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), area_opt->answer);
if (!print_flag->answer && strcmp(mapset, G_mapset()) != 0)
G_fatal_error(_("Vector map <%s> is not in user mapset and cannot be updated"),
area_opt->answer);
Vect_set_open_level(2);
if (Vect_open_old(&AIn, area_opt->answer, mapset) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), area_opt->answer);
method = -1;
use_catno = 0;
half = 0;
if (method_opt->answer) {
/* get the method */
for (method = 0; (p = menu[method].name); method++)
if ((strcmp(p, method_opt->answer) == 0))
break;
if (!p) {
G_warning(_("<%s=%s> unknown %s"),
method_opt->key, method_opt->answer,
method_opt->answer);
G_usage();
exit(EXIT_FAILURE);
}
/* establish the statsvalue routine */
statsvalue = menu[method].method;
/* category number of lowest/highest value */
if ((strcmp(menu[method].name, menu[5].name) == 0) ||
(strcmp(menu[method].name, menu[7].name) == 0))
use_catno = 1;
G_debug(1, "method: %s, use cat value: %s", menu[method].name,
(use_catno == 1 ? "yes" : "no"));
}
/* Open database driver */
db_init_string(&stmt);
Adriver = NULL;
if (!print_flag->answer) {
AFi = Vect_get_field(&AIn, area_field);
if (AFi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
area_field);
Adriver = db_start_driver_open_database(AFi->driver, AFi->database);
if (Adriver == NULL)
G_fatal_error(_("Unable to open database <%s> with driver <%s>"),
AFi->database, AFi->driver);
if (!count_column_opt->answer)
G_fatal_error(_("ccolumn is required to upload point counts"));
/* check if count column exists */
G_debug(1, "check if count column exists");
db_get_column(Adriver, AFi->table, count_column_opt->answer, &column);
if (column) {
/* check count column type */
if (db_column_Ctype(Adriver, AFi->table, count_column_opt->answer)
!= DB_C_TYPE_INT)
G_fatal_error(_("ccolumn must be of type integer"));
db_free_column(column);
column = NULL;
}
else {
/* create count column */
/* db_add_column() exists but is not implemented,
* see lib/db/stubs/add_col.c */
sprintf(buf, "alter table %s add column %s integer",
AFi->table, count_column_opt->answer);
db_set_string(&stmt, buf);
if (db_execute_immediate(Adriver, &stmt) != DB_OK)
G_fatal_error(_("Unable to add column <%s>"),
count_column_opt->answer);
}
if (method_opt->answer) {
if (!stats_column_opt->answer)
G_fatal_error(_("scolumn is required to upload point stats"));
/* check if stats column exists */
G_debug(1, "check if stats column exists");
db_get_column(Adriver, AFi->table, stats_column_opt->answer,
&column);
if (column) {
/* check stats column type */
if (db_column_Ctype
(Adriver, AFi->table,
stats_column_opt->answer) != DB_C_TYPE_DOUBLE)
G_fatal_error(_("scolumn must be of type double"));
db_free_column(column);
column = NULL;
}
else {
/* create stats column */
/* db_add_column() exists but is not implemented,
* see lib/db/stubs/add_col.c */
sprintf(buf, "alter table %s add column %s double",
AFi->table, stats_column_opt->answer);
db_set_string(&stmt, buf);
if (db_execute_immediate(Adriver, &stmt) != DB_OK)
G_fatal_error(_("Unable to add column <%s>"),
stats_column_opt->answer);
}
}
}
else
AFi = NULL;
Pdriver = NULL;
if (method_opt->answer) {
G_verbose_message(_("collecting attributes from points vector..."));
PFi = Vect_get_field(&PIn, point_field);
if (PFi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
point_field);
Pdriver = db_start_driver_open_database(PFi->driver, PFi->database);
if (Pdriver == NULL)
G_fatal_error(_("Unable to open database <%s> with driver <%s>"),
PFi->database, PFi->driver);
/* check if point column exists */
db_get_column(Pdriver, PFi->table, point_column_opt->answer, &column);
if (column) {
db_free_column(column);
column = NULL;
}
else {
G_fatal_error(_("Column <%s> not found in table <%s>"),
point_column_opt->answer, PFi->table);
}
/* Check column type */
ctype =
db_column_Ctype(Pdriver, PFi->table, point_column_opt->answer);
if (ctype == DB_C_TYPE_INT)
half = menu[method].half;
else if (ctype == DB_C_TYPE_DOUBLE)
half = 0;
else
G_fatal_error(_("column for points vector must be numeric"));
db_CatValArray_init(&cvarr);
nrec = db_select_CatValArray(Pdriver, PFi->table, PFi->key,
point_column_opt->answer, NULL, &cvarr);
G_debug(1, "selected values = %d", nrec);
db_close_database_shutdown_driver(Pdriver);
}
Points = Vect_new_line_struct();
ACats = Vect_new_cats_struct();
PCats = Vect_new_cats_struct();
List = Vect_new_boxlist(0);
/* Allocate space ( may be more than needed (duplicate cats and elements without cats) ) */
if ((nareas = Vect_get_num_areas(&AIn)) <= 0)
G_fatal_error("No areas in area input vector");
nacatsalloc = nareas;
Area_cat = (AREA_CAT *) G_calloc(nacatsalloc, sizeof(AREA_CAT));
/* Read all cats from 'area' */
nacats = 0;
for (area = 1; area <= nareas; area++) {
Vect_get_area_cats(&AIn, area, ACats);
if (ACats->n_cats <= 0)
continue;
for (i = 0; i < ACats->n_cats; i++) {
if (ACats->field[i] == area_field) {
Area_cat[nacats].area_cat = ACats->cat[i];
Area_cat[nacats].count = 0;
Area_cat[nacats].nvalues = 0;
Area_cat[nacats].nalloc = 0;
nacats++;
if (nacats >= nacatsalloc) {
nacatsalloc += 100;
Area_cat =
(AREA_CAT *) G_realloc(Area_cat,
nacatsalloc *
sizeof(AREA_CAT));
}
}
}
}
G_debug(1, "%d cats loaded from vector (including duplicates)", nacats);
/* Sort by category */
qsort((void *)Area_cat, nacats, sizeof(AREA_CAT), cmp_area);
/* remove duplicate categories */
for (i = 1; i < nacats; i++) {
if (Area_cat[i].area_cat == Area_cat[i - 1].area_cat) {
for (j = i; j < nacats - 1; j++) {
Area_cat[j].area_cat = Area_cat[j + 1].area_cat;
}
nacats--;
}
}
G_debug(1, "%d cats loaded from vector (unique)", nacats);
/* Go through all areas in area vector and find points in points vector
* falling into the area */
npvalcatsalloc = 10;
npvalcats = 0;
pvalcats =
(struct pvalcat *)G_calloc(npvalcatsalloc, sizeof(struct pvalcat));
G_message(_("Selecting points for each area..."));
count = 0;
for (area = 1; area <= nareas; area++) {
dbCatVal *catval;
G_debug(3, "area = %d", area);
G_percent(area, nareas, 2);
Vect_get_area_cats(&AIn, area, ACats);
if (ACats->n_cats <= 0)
continue;
/* select points by box */
Vect_get_area_box(&AIn, area, &box);
box.T = PORT_DOUBLE_MAX;
box.B = -PORT_DOUBLE_MAX;
Vect_select_lines_by_box(&PIn, &box, point_type, List);
G_debug(4, "%d points selected by box", List->n_values);
/* For each point in box check if it is in the area */
for (i = 0; i < List->n_values; i++) {
pline = List->id[i];
G_debug(4, "%d: point %d", i, pline);
ptype = Vect_read_line(&PIn, Points, PCats, pline);
if (!(ptype & point_type))
continue;
/* point in area */
if (Vect_point_in_area(Points->x[0], Points->y[0], &AIn, area, &box)) {
AREA_CAT *area_info, search_ai;
int tmp_cat;
/* stats on point column */
if (method_opt->answer) {
npvalcats = 0;
tmp_cat = -1;
for (j = 0; j < PCats->n_cats; j++) {
if (PCats->field[j] == point_field) {
if (tmp_cat >= 0)
G_debug(3,
"More cats found in point layer (point=%d)",
pline);
tmp_cat = PCats->cat[j];
/* find cat in array */
db_CatValArray_get_value(&cvarr, tmp_cat,
&catval);
if (catval) {
pvalcats[npvalcats].catno = tmp_cat;
switch (cvarr.ctype) {
case DB_C_TYPE_INT:
pvalcats[npvalcats].dval = catval->val.i;
npvalcats++;
break;
case DB_C_TYPE_DOUBLE:
pvalcats[npvalcats].dval = catval->val.d;
npvalcats++;
break;
}
if (npvalcats >= npvalcatsalloc) {
npvalcatsalloc += 10;
pvalcats =
(struct pvalcat *)G_realloc(pvalcats,
npvalcatsalloc
*
sizeof
(struct
pvalcat));
}
}
}
}
}
/* update count for all area cats of given field */
search_ai.area_cat = -1;
for (j = 0; j < ACats->n_cats; j++) {
if (ACats->field[j] == area_field) {
if (search_ai.area_cat >= 0)
G_debug(3,
"More cats found in area layer (area=%d)",
area);
search_ai.area_cat = ACats->cat[j];
/* find cat in array */
area_info =
(AREA_CAT *) bsearch((void *)&search_ai, Area_cat,
nacats, sizeof(AREA_CAT),
cmp_area);
if (area_info->area_cat != search_ai.area_cat)
G_fatal_error(_("could not find area category %d"),
search_ai.area_cat);
/* each point is counted once, also if it has
* more than one category or no category
* OK? */
area_info->count++;
if (method_opt->answer) {
/* ensure enough space */
if (area_info->nvalues + npvalcats >=
area_info->nalloc) {
if (area_info->nalloc == 0) {
area_info->nalloc = npvalcats + 10;
area_info->values =
(double *)G_calloc(area_info->nalloc,
sizeof(double));
area_info->cats =
(int *)G_calloc(area_info->nalloc,
sizeof(int));
}
else
area_info->nalloc +=
area_info->nvalues + npvalcats + 10;
area_info->values =
(double *)G_realloc(area_info->values,
area_info->nalloc *
sizeof(double));
area_info->cats =
(int *)G_realloc(area_info->cats,
area_info->nalloc *
sizeof(int));
}
for (k = 0; k < npvalcats; k++) {
area_info->cats[area_info->nvalues] =
pvalcats[k].catno;
area_info->values[area_info->nvalues] =
pvalcats[k].dval;
area_info->nvalues++;
}
}
}
}
count++;
}
} /* next point in box */
} /* next area */
G_debug(1, "count = %d", count);
/* release catval array */
if (method_opt->answer)
db_CatValArray_free(&cvarr);
Vect_close(&PIn);
/* Update table or print to stdout */
if (print_flag->answer) { /* print header */
fprintf(stdout, "area_cat%scount", fs);
if (method_opt->answer)
fprintf(stdout, "%s%s", fs, menu[method].name);
fprintf(stdout, "\n");
}
else {
G_message("Updating attributes for area vector...");
update_err = update_ok = 0;
}
if (Adriver)
db_begin_transaction(Adriver);
for (i = 0; i < nacats; i++) {
if (!print_flag->answer)
G_percent(i, nacats, 2);
result = 0;
if (Area_cat[i].count > 0 && method_opt->answer) {
/* get stats */
statsvalue(&result, Area_cat[i].values, Area_cat[i].nvalues,
NULL);
if (half)
result += 0.5;
else if (use_catno)
result = Area_cat[i].cats[(int)result];
}
if (print_flag->answer) {
fprintf(stdout, "%d%s%d", Area_cat[i].area_cat, fs,
Area_cat[i].count);
if (method_opt->answer) {
if (Area_cat[i].count > 0)
fprintf(stdout, "%s%.15g", fs, result);
else
fprintf(stdout, "%snull", fs);
}
fprintf(stdout, "\n");
}
else {
sprintf(buf, "update %s set %s = %d", AFi->table,
count_column_opt->answer, Area_cat[i].count);
db_set_string(&stmt, buf);
if (method_opt->answer) {
if (Area_cat[i].count > 0)
sprintf(buf, " , %s = %.15g", stats_column_opt->answer,
result);
else
sprintf(buf, " , %s = null", stats_column_opt->answer);
db_append_string(&stmt, buf);
}
sprintf(buf, " where %s = %d", AFi->key, Area_cat[i].area_cat);
db_append_string(&stmt, buf);
G_debug(2, "SQL: %s", db_get_string(&stmt));
if (db_execute_immediate(Adriver, &stmt) == DB_OK) {
update_ok++;
}
else {
update_err++;
}
}
}
if (Adriver)
db_commit_transaction(Adriver);
if (!print_flag->answer) {
G_percent(nacats, nacats, 2);
db_close_database_shutdown_driver(Adriver);
db_free_string(&stmt);
G_message(_("%d records updated"), update_ok);
if (update_err > 0)
G_message(_("%d update errors"), update_err);
Vect_set_db_updated(&AIn);
}
Vect_close(&AIn);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int INPUT(struct Map_info *In, char *column, char *scol, char *wheresql)
{
struct quadruple *point;
double x, y, z, w, nz = 0., sm;
double c1, c2, c3, c4, c5, c6, nsg;
int i, j, k = 0, a, irev, cfmask;
int ddisk = 0;
double deltx, delty, deltz;
int first_time = 1;
CELL *cellmask;
const char *mapsetm;
char buf[500];
int cat, intval;
struct field_info *Fi;
dbDriver *Driver;
dbCatValArray cvarr, sarray;
int nrec, nrec1, ctype, sctype;
struct line_pnts *Points;
struct line_cats *Cats;
OUTRANGE = 0;
NPOINT = 0;
dmin = dmin * dmin;
/* Read attributes */
db_CatValArray_init(&cvarr);
if (scol != NULL)
db_CatValArray_init(&sarray);
Fi = Vect_get_field(In, 1);
if (Fi == NULL)
G_fatal_error(_("Unable to get layer info for vector map"));
Driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (Driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
nrec =
db_select_CatValArray(Driver, Fi->table, Fi->key, column, wheresql,
&cvarr);
ctype = cvarr.ctype;
G_debug(3, "nrec = %d", nrec);
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type of wcolumn is not supported (must be integer or double)"));
if (nrec < 0)
G_fatal_error(_("Unable to select data from table"));
G_message("%d records selected from table", nrec);
if (scol != NULL) {
nrec1 =
db_select_CatValArray(Driver, Fi->table, Fi->key, scol, wheresql,
&sarray);
sctype = cvarr.ctype;
if (sctype == -1)
G_fatal_error(_("Cannot read column type of smooth column"));
if (sctype == DB_C_TYPE_DATETIME)
G_fatal_error
(_("Column type of smooth column (datetime) is not supported"));
if (sctype != DB_C_TYPE_INT && sctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type of smooth column is not supported (must be integer or double)"));
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_rewind(In);
while (1) {
int ival, type, ret;
if (-1 == (type = Vect_read_next_line(In, Points, Cats)))
G_fatal_error(_("Unable to read vector map"));
if (type == -2)
break; /* EOF */
if (!(type & GV_POINTS))
continue;
Vect_cat_get(Cats, 1, &cat);
if (cat < 0) {
G_warning(_("Point without category"));
continue;
}
x = Points->x[0];
y = Points->y[0];
z = Points->z[0];
if (ctype == DB_C_TYPE_INT) {
ret = db_CatValArray_get_value_int(&cvarr, cat, &ival);
w = ival;
}
else { /* DB_C_TYPE_DOUBLE */
ret = db_CatValArray_get_value_double(&cvarr, cat, &w);
}
if (ret != DB_OK) {
if (wheresql != NULL)
/* G_message(_("Database record for cat %d not used due to SQL statement")); */
/* do nothing in this case to not confuse user. Or implement second cat list */
;
else
G_warning(_("No record for category %d in table <%s>"), cat,
Fi->table);
continue;
}
if (rsm == -1 && scol != NULL) {
if (sctype == DB_C_TYPE_INT) {
ret = db_CatValArray_get_value_int(&sarray, cat, &intval);
sm = intval;
}
else { /* DB_C_TYPE_DOUBLE */
ret = db_CatValArray_get_value_double(&sarray, cat, &sm);
}
}
G_debug(3, "%f %f %f %f", x, y, z, w);
k++;
w = w * wmult;
z = z * zmult;
c1 = x - ((struct octdata *)(root->data))->x_orig;
c2 = ((struct octdata *)(root->data))->x_orig +
((struct octdata *)(root->data))->n_cols * ew_res - x;
c3 = y - ((struct octdata *)(root->data))->y_orig;
c4 = ((struct octdata *)(root->data))->y_orig +
((struct octdata *)(root->data))->n_rows * ns_res - y;
c5 = z - ((struct octdata *)(root->data))->z_orig;
c6 = ((struct octdata *)(root->data))->z_orig +
((struct octdata *)(root->data))->n_levs * tb_res - z;
if (!
((c1 >= 0) && (c2 >= 0) && (c3 >= 0) && (c4 >= 0) && (c5 >= 0) &&
(c6 >= 0))) {
if (!OUTRANGE) {
G_warning(_("Some points outside of region -- will ignore..."));
}
OUTRANGE++;
}
else {
if (!(point = point_new(x, y, z, w, sm))) {
clean();
G_fatal_error(_("Cannot allocate memory for point"));
}
a = OT_insert_oct(point, root);
if (a == 0) {
NPOINT++;
}
if (a < 0) {
G_warning(_("Can't insert %lf,%lf,%lf,%lf,%lf a=%d"), x, y, z,
w, sm, a);
return -1;
}
if (first_time) {
first_time = 0;
xmin = x;
ymin = y;
zmin = z;
wmin = w;
xmax = x;
ymax = y;
zmax = z;
wmax = w;
}
xmin = amin1(xmin, x);
ymin = amin1(ymin, y);
zmin = amin1(zmin, z);
wmin = amin1(wmin, w);
xmax = amax1(xmax, x);
ymax = amax1(ymax, y);
zmax = amax1(zmax, z);
wmax = amax1(wmax, w);
}
} /* while */
db_CatValArray_free(&cvarr);
c1 = xmin - ((struct octdata *)(root->data))->x_orig;
c2 = ((struct octdata *)(root->data))->x_orig +
((struct octdata *)(root->data))->n_cols * ew_res - xmax;
c3 = ymin - ((struct octdata *)(root->data))->y_orig;
c4 = ((struct octdata *)(root->data))->y_orig +
((struct octdata *)(root->data))->n_rows * ns_res - ymax;
c5 = zmin - ((struct octdata *)(root->data))->z_orig;
c6 = ((struct octdata *)(root->data))->z_orig +
((struct octdata *)(root->data))->n_levs * tb_res - zmax;
if ((c1 > 5 * ew_res) || (c2 > 5 * ew_res) ||
(c3 > 5 * ns_res) || (c4 > 5 * ns_res) ||
(c5 > 5 * tb_res) || (c6 > 5 * tb_res)) {
static int once = 0;
if (!once) {
once = 1;
G_warning(_("Strip exists with insufficient data"));
}
}
nz = wmin;
totsegm = translate_oct(root, ((struct octdata *)(root->data))->x_orig,
((struct octdata *)(root->data))->y_orig,
((struct octdata *)(root->data))->z_orig, nz);
if (!totsegm) {
clean();
G_fatal_error(_("Zero segments!"));
}
((struct octdata *)(root->data))->x_orig = 0;
((struct octdata *)(root->data))->y_orig = 0;
((struct octdata *)(root->data))->z_orig = 0; /* was commented out */
if (outz != NULL)
ddisk += disk;
if (gradient != NULL)
ddisk += disk;
if (aspect1 != NULL)
ddisk += disk;
if (ncurv != NULL)
ddisk += disk;
if (gcurv != NULL)
ddisk += disk;
if (mcurv != NULL)
ddisk += disk;
G_message
("Processing all selected output files will require %d bytes of disk space for temp files",
ddisk);
/*
fprintf(stderr,"xmin=%lf,xmax=%lf,ymin=%lf,ymax=%lf,zmin=%lf,zmax=%lf,wmin=%lf,wmax=%lf\n",xmin,xmax,ymin,ymax,zmin,zmax,wmin,wmax);
*/
fprintf(stderr, "\n");
if (OUTRANGE > 0)
G_warning
(_("There are points outside specified 2D/3D region--ignored %d points (total points: %d)"),
OUTRANGE, k);
if (NPOINT > 0)
G_warning
(_("Points are more dense than specified 'DMIN'--ignored %d points (remain %d)"),
NPOINT, k - NPOINT);
NPOINT = k - NPOINT - NPT - OUTRANGE;
if (NPOINT < KMIN) {
if (NPOINT != 0) {
G_warning
(_("%d points given for interpolation (after thinning) is less than given NPMIN=%d"),
NPOINT, KMIN);
KMIN = NPOINT;
}
else {
fprintf(stderr, "ERROR: zero points in the given region!\n");
return -1;
}
}
if (NPOINT > KMAXPOINTS && KMIN <= KMAX) {
fprintf(stderr,
"ERROR: segmentation parameters set to invalid values: npmin = %d, segmax = %d \n",
KMIN, KMAX);
fprintf(stderr,
"for smooth connection of segments, npmin > segmax (see manual) \n");
return -1;
}
if (NPOINT < KMAXPOINTS && KMAX != KMAXPOINTS)
G_warning
(_("There is less than %d points for interpolation, no segmentation is necessary, to run the program faster, set segmax=%d (see manual)"),
KMAXPOINTS, KMAXPOINTS);
deltx = xmax - xmin;
delty = ymax - ymin;
deltz = zmax - zmin;
nsg = (double)NPOINT / (double)KMIN;
dnorm = deltx * delty * deltz / nsg;
nsg = 3.0;
nsg = 1. / nsg;
dnorm = pow(dnorm, nsg);
/* DEBUG
if (fd4 != NULL)
fprintf (fd4, "deltx,delty %f %f \n", deltx, delty);
*/
nsizc = current_region.cols; /* ((int)(deltx/ew_res))+1; */
nsizr = current_region.rows; /* ((int)(delty/ns_res))+1; */
NPT = k;
x0utm = 0.;
y0utm = 0.;
z0utm = 0.;
/** create a bitmap mask from given raster map **/
if (maskmap != NULL) {
mapsetm = G_find_raster2(maskmap, "");
if (!mapsetm) {
clean();
G_fatal_error(_("Mask raster map [%s] not found"), maskmap);
}
bitmask = BM_create(nsizc, nsizr);
cellmask = Rast_allocate_c_buf();
cfmask = Rast_open_old(maskmap, mapsetm);
for (i = 0; i < nsizr; i++) {
irev = nsizr - i - 1;
Rast_get_c_row(cfmask, cellmask, i);
for (j = 0; j < nsizc; j++) {
if ((cellmask[j] == 0) || Rast_is_c_null_value(&cellmask[j]))
BM_set(bitmask, j, irev, 0);
else
BM_set(bitmask, j, irev, 1);
}
}
G_message(_("Bitmap mask created"));
}
return 1;
}
int read_points(const char *name, const char *field_name, const char *col, std::map<Point, Coord_type, K::Less_xy_2>& function_values,
std::vector<K::Point_2>& OutPoints)
{
int nrec, ctype = 0, npoints, field, with_z;
double x, y, z;
Point p;
struct Map_info Map;
struct field_info *Fi;
struct line_pnts *Points;
struct line_cats *Cats;
dbDriver *Driver;
dbCatValArray cvarr;
Vect_set_open_level(1); /* without topology */
if (Vect_open_old2(&Map, name, "", field_name) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), name);
field = Vect_get_field_number(&Map, field_name);
with_z = col == NULL && Vect_is_3d(&Map); /* read z-coordinates
only when column is
not defined */
if (!col) {
if (!with_z)
G_important_message(_("Input vector map <%s> is 2D - using categories to interpolate"),
Vect_get_full_name(&Map));
else
G_important_message(_("Input vector map <%s> is 3D - using z-coordinates to interpolate"),
Vect_get_full_name(&Map));
}
if (col) {
db_CatValArray_init(&cvarr);
Fi = Vect_get_field(&Map, field);
if (Fi == NULL)
G_fatal_error(_("Database connection not defined for layer %s"), field_name);
Driver = db_start_driver_open_database(Fi->driver, Fi->database);
if (Driver == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"), Fi->database, Fi->driver);
nrec = db_select_CatValArray(Driver, Fi->table, Fi->key, col, NULL, &cvarr);
G_debug(3, "nrec = %d", nrec);
ctype = cvarr.ctype;
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type not supported"));
if (nrec < 0)
G_fatal_error(_("Unable to select data from table"));
G_verbose_message("One record selected from table %d records selected from table", nrec);
db_close_database_shutdown_driver(Driver);
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* set constraints */
Vect_set_constraint_type(&Map, GV_POINTS);
if (field > 0)
Vect_set_constraint_field(&Map, field);
/* read points */
npoints = 0;
G_message(_("Reading points..."));
while(TRUE) {
double dval;
if (Vect_read_next_line(&Map, Points, Cats) < 0)
break;
G_progress(npoints, 1e3);
if (Points->n_points != 1) {
G_warning(_("Invalid point skipped"));
continue;
}
if (!with_z) {
int cat, ival, ret;
/* TODO: what to do with multiple cats */
Vect_cat_get(Cats, field, &cat);
if (cat < 0) /* skip features without category */
continue;
if (col) {
if (ctype == DB_C_TYPE_INT) {
ret = db_CatValArray_get_value_int(&cvarr, cat, &ival);
dval = ival;
}
else { /* DB_C_TYPE_DOUBLE */
ret = db_CatValArray_get_value_double(&cvarr, cat, &dval);
}
if (ret != DB_OK) {
G_warning(_("No record for point (cat = %d)"), cat);
continue;
}
}
else {
dval = cat;
}
}
else
dval = Points->z[0];
x = Points->x[0];
y = Points->y[0];
p = Point(x,y);
OutPoints.push_back(p);
function_values.insert(std::make_pair(p, dval));
G_debug(3, "new point added: %f, %f, %f", x, y, dval);
npoints++;
}
G_progress(1, 1);
if (col)
db_CatValArray_free(&cvarr);
Vect_set_release_support(&Map);
Vect_close(&Map);
Vect_destroy_line_struct(Points);
G_debug(1, "read_points(): %d", npoints);
G_message("%d point loaded", npoints);
return npoints;
}
void scan_z(struct Map_info *Map, int field,
const char *style, const char *rules,
const struct FPRange *range, struct Colors *colors)
{
int ltype, line, cat, i;
int items_alloc;
double zmin, zmax;
struct line_pnts *Points;
struct line_cats *Cats;
struct Colors vcolors;
dbCatValArray cvarr;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
items_alloc = 0;
db_CatValArray_init(&cvarr);
cvarr.ctype = DB_C_TYPE_DOUBLE;
Vect_set_constraint_field(Map, field);
Vect_set_constraint_type(Map, GV_POINTS); /* points, centroids or kernels only) */
G_message(_("Reading features..."));
line = i = 0;
while(TRUE) {
ltype = Vect_read_next_line(Map, Points, Cats);
if (ltype == -1)
G_fatal_error(_("Unable to read vector map"));
if (ltype == -2)
break; /* EOF */
G_progress(++line, 1e4);
if (Vect_cat_get(Cats, field, &cat) == -1)
continue; /* skip features without category */
/* add item into cat-value array */
if (i >= items_alloc) {
items_alloc += 1000;
db_CatValArray_realloc(&cvarr, items_alloc);
}
cvarr.n_values++;
cvarr.value[i].cat = cat;
cvarr.value[i++].val.d = Points->z[0];
if (line == 1 || Points->z[0] < zmin)
zmin = Points->z[0];
if (line == 1 || Points->z[0] > zmax)
zmax = Points->z[0];
}
G_progress(1, 1);
/* sort array by z-coordinate */
db_CatValArray_sort_by_value(&cvarr);
if (range) {
if (range->min >= zmin && range->min <= zmax)
zmin = range->min;
else
G_warning(_("Min value (%f) is out of range %f,%f"),
range->min, zmin, zmax);
if (range->max <= zmax && range->max >= zmin)
zmax = range->max;
else
G_warning(_("Max value (%f) is out of range %f,%f"),
range->max, zmin, zmax);
}
if (style)
make_colors(&vcolors, style, (DCELL) zmin, (DCELL) zmax, TRUE);
else if (rules) {
load_colors(&vcolors, rules, (DCELL) zmin, (DCELL) zmax, TRUE);
}
/* color table for categories */
color_rules_to_cats(&cvarr, TRUE, &vcolors, colors);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
db_CatValArray_free(&cvarr);
}
/*!
\brief Lines z-bulk labeling
Automated labeling (z coordinate assignment) of vector lines (iso-lines).
\param Map pointer to Map_info
\param List list of selected lines
\param point_start_end staring and ending point
\param start starting value
\param step step value
\return number of modified features
\return -1 on error
*/
int Vedit_bulk_labeling(struct Map_info *Map, struct ilist *List,
double x1, double y1, double x2, double y2,
double start, double step)
{
int i, cv_i, p_i;
int line, type, temp_line;
int nlines_modified;
double value, dist;
struct line_cats *Cats;
struct line_pnts *Points, *Points_se; /* start - end */
struct bound_box box, box_se;
/* for intersection */
struct line_pnts **Points_a, **Points_b;
int nlines_a, nlines_b;
dbCatValArray cv; /* line_id / dist */
nlines_modified = 0;
value = start;
Points = Vect_new_line_struct();
Points_se = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_CatValArray_alloc(&cv, List->n_values);
cv.ctype = DB_C_TYPE_DOUBLE;
cv.n_values = 0;
Vect_append_point(Points_se, x1, y1, -PORT_DOUBLE_MAX);
Vect_append_point(Points_se, x2, y2, PORT_DOUBLE_MAX);
/* write temporaly line */
temp_line = Vect_write_line(Map, GV_LINE, Points_se, Cats);
if (temp_line < 0) {
return -1;
}
Vect_line_box(Points_se, &box_se);
/* determine order of lines */
cv_i = 0;
for (i = 0; i < List->n_values; i++) {
line = List->value[i];
if (!Vect_line_alive(Map, line))
continue;
type = Vect_read_line(Map, Points, NULL, line);
if (!(type & GV_LINE))
continue;
Vect_line_box(Points, &box);
if (Vect_line_check_intersection(Points_se, Points, WITH_Z)) {
Vect_line_intersection(Points_se, Points, &box_se, &box,
&Points_a, &Points_b, &nlines_a, &nlines_b,
WITHOUT_Z);
if (nlines_a < 2 || nlines_b < 1) /* should not happen */
continue;
/* calculate distance start point -> point of intersection */
for (p_i = 0; p_i < Points_a[0]->n_points; p_i++) {
Points_a[0]->z[p_i] = 0;
}
dist = Vect_line_length(Points_a[0]); /* always first line in array? */
cv.value[cv_i].cat = line;
cv.value[cv_i++].val.d = dist;
cv.n_values++;
}
}
/* sort array by distance */
db_CatValArray_sort_by_value(&cv);
/* z bulk-labeling */
for (cv_i = 0; cv_i < cv.n_values; cv_i++) {
line = cv.value[cv_i].cat;
type = Vect_read_line(Map, Points, Cats, line);
for (p_i = 0; p_i < Points->n_points; p_i++) {
Points->z[p_i] = value;
}
if (Vect_rewrite_line(Map, line, type, Points, Cats) < 0) {
return -1;
}
nlines_modified++;
value += step;
}
if (Vect_delete_line(Map, temp_line) < 0) {
return -1;
}
db_CatValArray_free(&cv);
Vect_destroy_line_struct(Points);
Vect_destroy_line_struct(Points_se);
Vect_destroy_cats_struct(Cats);
return nlines_modified;
}
