int main(int argc, char **argv)
{
int line;
struct line_pnts *points;
struct line_cats *Cats;
struct Map_info map, Out;
struct GModule *module;
struct Option *input;
struct Option *output;
struct Option *cats;
struct Option *type_opt;
char *desc;
int polyline;
int *lines_visited;
int points_in_polyline;
int start_line;
int nlines;
int write_cats, copy_tables;
int type, ltype;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("topology"));
G_add_keyword(_("geometry"));
G_add_keyword(_("line"));
G_add_keyword(_("node"));
G_add_keyword(_("vertex"));
module->description = _("Builds polylines from lines or boundaries.");
/* Define the options */
input = G_define_standard_option(G_OPT_V_INPUT);
output = G_define_standard_option(G_OPT_V_OUTPUT);
cats = G_define_option();
cats->key = "cats";
cats->type = TYPE_STRING;
cats->description = _("Category number mode");
cats->options = "no,first,multi,same";
desc = NULL;
G_asprintf(&desc,
"no;%s;first;%s;multi;%s;same;%s",
_("Do not assign any category number to polyline"),
_("Assign category number of first line to polyline"),
_("Assign multiple category numbers to polyline"),
_("Create polyline from lines with same categories"));
cats->descriptions = desc;
cats->answer = "no";
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->options = "line,boundary";
type_opt->answer = "line,boundary";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
Vect_check_input_output_name(input->answer, output->answer,
G_FATAL_EXIT);
/* Open binary vector map at level 2 */
Vect_set_open_level(2);
if (Vect_open_old(&map, input->answer, "") < 0)
G_fatal_error(_("Unable to open vector map <%s>"), input->answer);
/* Open new vector */
G_find_vector2(output->answer, "");
if (Vect_open_new(&Out, output->answer, Vect_is_3d(&map)) < 0)
G_fatal_error(_("Unable to create vector map <%s>"), output->answer);
/* Copy header info. */
Vect_copy_head_data(&map, &Out);
/* History */
Vect_hist_copy(&map, &Out);
Vect_hist_command(&Out);
/* Get the number of lines in the binary map and set up record of lines visited */
lines_visited =
(int *)G_calloc(Vect_get_num_lines(&map) + 1, sizeof(int));
/* Set up points structure and coordinate arrays */
points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* Write cats */
if (strcmp(cats->answer, "no") == 0)
write_cats = NO_CATS;
else if (strcmp(cats->answer, "first") == 0)
write_cats = ONE_CAT;
else
write_cats = MULTI_CATS;
if (type_opt->answer)
type = Vect_option_to_types(type_opt);
else
type = GV_LINES;
/* Step over all lines in binary map */
polyline = 0;
nlines = 0;
copy_tables = (write_cats != NO_CATS);
for (line = 1; line <= Vect_get_num_lines(&map); line++) {
Vect_reset_cats(Cats);
ltype = Vect_read_line(&map, NULL, NULL, line);
if ((ltype & GV_LINES) && (ltype & type))
nlines++;
else {
/* copy points to output as they are, with cats */
Vect_read_line(&map, points, Cats, line);
Vect_write_line(&Out, ltype, points, Cats);
if (Cats->n_cats > 0)
copy_tables = 1;
continue;
}
/* Skip line if already visited from another */
if (lines_visited[line])
continue;
/* Only get here if line is not previously visited */
/* Find start of this polyline */
start_line = walk_back(&map, line, ltype);
G_debug(1, "Polyline %d: start line = %d", polyline, start_line);
/* Walk forward and pick up coordinates */
points_in_polyline =
walk_forward_and_pick_up_coords(&map, start_line, ltype, points,
lines_visited, Cats, write_cats);
/* Write the line (type of the first line is used) */
Vect_write_line(&Out, ltype, points, Cats);
polyline++;
}
G_verbose_message(n_("%d line or boundaries found in input vector map",
"%d lines or boundaries found in input vector map",
nlines),
nlines, Vect_get_name(&map), Vect_get_mapset(&map));
G_verbose_message(n_("%d polyline stored in output vector map",
"%d polylines stored in output vector map",
polyline),
polyline, Vect_get_name(&Out), Vect_get_mapset(&Out));
/* Copy (all linked) tables if needed */
if (copy_tables) {
if (Vect_copy_tables(&map, &Out, 0))
G_warning(_("Failed to copy attribute table to output map"));
}
/* Tidy up */
Vect_destroy_line_struct(points);
Vect_destroy_cats_struct(Cats);
G_free(lines_visited);
Vect_close(&map);
Vect_build(&Out);
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct GModule *module;
struct opts opt;
struct Map_info In, Out;
BOUND_BOX box;
int field, type;
int ret;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("vector, transformation, 3D");
module->description =
_("Performs transformation of 2D vector features to 3D.");
parse_args(&opt);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
field = atoi(opt.field->answer);
type = Vect_option_to_types(opt.type);
if (!opt.reverse->answer) {
if ((!opt.height->answer && !opt.column->answer) ||
(opt.height->answer && opt.column->answer)) {
G_fatal_error(_("Either '%s' or '%s' parameter have to be used"),
opt.height->key, opt.column->key);
}
}
else {
if (opt.height->answer) {
G_warning(_("Parameters '%s' ignored"), opt.height->key);
}
}
if (opt.reverse->answer && opt.table->answer) {
G_fatal_error(_("Attribute table required"));
}
Vect_check_input_output_name(opt.input->answer, opt.output->answer,
GV_FATAL_EXIT);
/* open input vector, topology not needed */
Vect_set_open_level(1);
if (Vect_open_old(&In, opt.input->answer, "") < 1)
G_fatal_error(_("Unable to open vector map <%s>"), opt.input->answer);
if (opt.reverse->answer && !Vect_is_3d(&In)) {
Vect_close(&In);
G_fatal_error(_("Vector map <%s> is 2D"), opt.input->answer);
}
if (!opt.reverse->answer && Vect_is_3d(&In)) {
Vect_close(&In);
G_fatal_error(_("Vector map <%s> is 3D"), opt.input->answer);
}
/* create output vector */
Vect_set_open_level(2);
if (Vect_open_new(&Out, opt.output->answer,
opt.reverse->answer ? WITHOUT_Z : WITH_Z) == -1)
G_fatal_error(_("Unable to create vector map <%s>"),
opt.output->answer);
/* copy history & header */
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
Vect_copy_head_data(&In, &Out);
if (opt.reverse->answer && !opt.table->answer) {
G_message(_("Copying attributes..."));
if (Vect_copy_tables(&In, &Out, 0) == -1) {
G_warning(_("Unable to copy attributes"));
}
}
G_message(_("Transforming features..."));
ret = 0;
if (opt.reverse->answer) {
/* 3d -> 2d */
ret = trans3d(&In, &Out, type, field, opt.column->answer);
}
else {
/* 2d -> 3d */
double height = 0.;
if (opt.height->answer) {
height = atof(opt.height->answer);
}
ret = trans2d(&In, &Out, type, height, field, opt.column->answer);
}
if (ret < 0) {
Vect_close(&In);
Vect_close(&Out);
Vect_delete(opt.output->answer);
G_fatal_error(_("%s failed"), G_program_name());
}
if (!opt.reverse->answer && !opt.table->answer) {
G_message(_("Copying attributes..."));
if (Vect_copy_tables(&In, &Out, 0) == -1) {
G_warning(_("Unable to copy attributes"));
}
}
Vect_close(&In);
Vect_build(&Out);
if (!opt.reverse->answer) {
Vect_get_map_box(&Out, &box);
G_message(_("Vertical extent of vector map <%s>: B: %f T: %f"),
opt.output->answer, box.B, box.T);
}
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int i, type, stat;
int day, yr, Out_proj;
int out_zone = 0;
int overwrite; /* overwrite output map */
const char *mapset;
const char *omap_name, *map_name, *iset_name, *iloc_name;
struct pj_info info_in;
struct pj_info info_out;
const char *gbase;
char date[40], mon[4];
struct GModule *module;
struct Option *omapopt, *mapopt, *isetopt, *ilocopt, *ibaseopt, *smax;
struct Key_Value *in_proj_keys, *in_unit_keys;
struct Key_Value *out_proj_keys, *out_unit_keys;
struct line_pnts *Points, *Points2;
struct line_cats *Cats;
struct Map_info Map;
struct Map_info Out_Map;
struct bound_box src_box, tgt_box;
int nowrap = 0, recommend_nowrap = 0;
double lmax;
struct
{
struct Flag *list; /* list files in source location */
struct Flag *transformz; /* treat z as ellipsoidal height */
struct Flag *wrap; /* latlon output: wrap to 0,360 */
struct Flag *no_topol; /* do not build topology */
} flag;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("projection"));
G_add_keyword(_("transformation"));
G_add_keyword(_("import"));
module->description = _("Re-projects a vector map from one location to the current location.");
/* set up the options and flags for the command line parser */
ilocopt = G_define_standard_option(G_OPT_M_LOCATION);
ilocopt->required = YES;
ilocopt->label = _("Location containing input vector map");
ilocopt->guisection = _("Source");
isetopt = G_define_standard_option(G_OPT_M_MAPSET);
isetopt->label = _("Mapset containing input vector map");
isetopt->description = _("Default: name of current mapset");
isetopt->guisection = _("Source");
mapopt = G_define_standard_option(G_OPT_V_INPUT);
mapopt->required = NO;
mapopt->label = _("Name of input vector map to re-project");
mapopt->description = NULL;
mapopt->guisection = _("Source");
ibaseopt = G_define_standard_option(G_OPT_M_DBASE);
ibaseopt->label = _("Path to GRASS database of input location");
smax = G_define_option();
smax->key = "smax";
smax->type = TYPE_DOUBLE;
smax->required = NO;
smax->answer = "10000";
smax->label = _("Maximum segment length in meters in output vector map");
smax->description = _("Increases accuracy of reprojected shapes, disable with smax=0");
smax->guisection = _("Target");
omapopt = G_define_standard_option(G_OPT_V_OUTPUT);
omapopt->required = NO;
omapopt->description = _("Name for output vector map (default: input)");
omapopt->guisection = _("Target");
flag.list = G_define_flag();
flag.list->key = 'l';
flag.list->description = _("List vector maps in input mapset and exit");
flag.transformz = G_define_flag();
flag.transformz->key = 'z';
flag.transformz->description = _("3D vector maps only");
flag.transformz->label =
_("Assume z coordinate is ellipsoidal height and "
"transform if possible");
flag.transformz->guisection = _("Target");
flag.wrap = G_define_flag();
flag.wrap->key = 'w';
flag.wrap->description = _("Latlon output only, default is -180,180");
flag.wrap->label =
_("Disable wrapping to -180,180 for latlon output");
flag.transformz->guisection = _("Target");
flag.no_topol = G_define_flag();
flag.no_topol->key = 'b';
flag.no_topol->label = _("Do not build vector topology");
flag.no_topol->description = _("Recommended for massive point projection");
/* The parser checks if the map already exists in current mapset,
we switch out the check and do it
in the module after the parser */
overwrite = G_check_overwrite(argc, argv);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* start checking options and flags */
/* set input vector map name and mapset */
map_name = mapopt->answer;
if (omapopt->answer)
omap_name = omapopt->answer;
else
omap_name = map_name;
if (omap_name && !flag.list->answer && !overwrite &&
G_find_vector2(omap_name, G_mapset()))
G_fatal_error(_("option <%s>: <%s> exists. To overwrite, use the --overwrite flag"), omapopt->key,
omap_name);
if (isetopt->answer)
iset_name = isetopt->answer;
else
iset_name = G_store(G_mapset());
iloc_name = ilocopt->answer;
if (ibaseopt->answer)
gbase = ibaseopt->answer;
else
gbase = G_store(G_gisdbase());
if (!ibaseopt->answer && strcmp(iloc_name, G_location()) == 0)
G_fatal_error(_("Input and output locations can not be the same"));
lmax = atof(smax->answer);
if (lmax < 0)
lmax = 0;
Out_proj = G_projection();
if (Out_proj == PROJECTION_LL && flag.wrap->answer)
nowrap = 1;
G_begin_distance_calculations();
/* Change the location here and then come back */
select_target_env();
G_setenv_nogisrc("GISDBASE", gbase);
G_setenv_nogisrc("LOCATION_NAME", iloc_name);
stat = G_mapset_permissions(iset_name);
if (stat >= 0) { /* yes, we can access the mapset */
/* if requested, list the vector maps in source location - MN 5/2001 */
if (flag.list->answer) {
int i;
char **list;
G_verbose_message(_("Checking location <%s> mapset <%s>"),
iloc_name, iset_name);
list = G_list(G_ELEMENT_VECTOR, G_getenv_nofatal("GISDBASE"),
G_getenv_nofatal("LOCATION_NAME"), iset_name);
if (list[0]) {
for (i = 0; list[i]; i++) {
fprintf(stdout, "%s\n", list[i]);
}
fflush(stdout);
}
else {
G_important_message(_("No vector maps found"));
}
exit(EXIT_SUCCESS); /* leave v.proj after listing */
}
if (mapopt->answer == NULL) {
G_fatal_error(_("Required parameter <%s> not set"), mapopt->key);
}
G_setenv_nogisrc("MAPSET", iset_name);
/* Make sure map is available */
mapset = G_find_vector2(map_name, iset_name);
if (mapset == NULL)
G_fatal_error(_("Vector map <%s> in location <%s> mapset <%s> not found"),
map_name, iloc_name, iset_name);
/*** Get projection info for input mapset ***/
in_proj_keys = G_get_projinfo();
if (in_proj_keys == NULL)
exit(EXIT_FAILURE);
/* apparently the +over switch must be set in the input projection,
* not the output latlon projection */
if (Out_proj == PROJECTION_LL && nowrap == 1)
G_set_key_value("+over", "defined", in_proj_keys);
in_unit_keys = G_get_projunits();
if (in_unit_keys == NULL)
exit(EXIT_FAILURE);
if (pj_get_kv(&info_in, in_proj_keys, in_unit_keys) < 0)
exit(EXIT_FAILURE);
Vect_set_open_level(1);
G_debug(1, "Open old: location: %s mapset : %s", G_location_path(),
G_mapset());
if (Vect_open_old(&Map, map_name, mapset) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), map_name);
}
else if (stat < 0)
{ /* allow 0 (i.e. denied permission) */
/* need to be able to read from others */
if (stat == 0)
G_fatal_error(_("Mapset <%s> in input location <%s> - permission denied"),
iset_name, iloc_name);
else
G_fatal_error(_("Mapset <%s> in input location <%s> not found"),
iset_name, iloc_name);
}
select_current_env();
/****** get the output projection parameters ******/
out_proj_keys = G_get_projinfo();
if (out_proj_keys == NULL)
exit(EXIT_FAILURE);
out_unit_keys = G_get_projunits();
if (out_unit_keys == NULL)
exit(EXIT_FAILURE);
if (pj_get_kv(&info_out, out_proj_keys, out_unit_keys) < 0)
exit(EXIT_FAILURE);
G_free_key_value(in_proj_keys);
G_free_key_value(in_unit_keys);
G_free_key_value(out_proj_keys);
G_free_key_value(out_unit_keys);
if (G_verbose() == G_verbose_max()) {
pj_print_proj_params(&info_in, &info_out);
}
/* Initialize the Point / Cat structure */
Points = Vect_new_line_struct();
Points2 = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* test if latlon wrapping to -180,180 should be disabled */
if (Out_proj == PROJECTION_LL && nowrap == 0) {
int first = 1, counter = 0;
double x, y;
/* Cycle through all lines */
Vect_rewind(&Map);
while (1) {
type = Vect_read_next_line(&Map, Points, Cats); /* read line */
if (type == 0)
continue; /* Dead */
if (type == -1)
G_fatal_error(_("Reading input vector map"));
if (type == -2)
break;
if (first && Points->n_points > 0) {
first = 0;
src_box.E = src_box.W = Points->x[0];
src_box.N = src_box.S = Points->y[0];
src_box.T = src_box.B = Points->z[0];
}
for (i = 0; i < Points->n_points; i++) {
if (src_box.E < Points->x[i])
src_box.E = Points->x[i];
if (src_box.W > Points->x[i])
src_box.W = Points->x[i];
if (src_box.N < Points->y[i])
src_box.N = Points->y[i];
if (src_box.S > Points->y[i])
src_box.S = Points->y[i];
}
counter++;
}
if (counter == 0) {
G_warning(_("Input vector map <%s> is empty"), omap_name);
exit(EXIT_SUCCESS);
}
/* NW corner */
x = src_box.W;
y = src_box.N;
if (pj_do_transform(1, &x, &y, NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Error in pj_do_transform"));
}
tgt_box.E = x;
tgt_box.W = x;
tgt_box.N = y;
tgt_box.S = y;
/* SW corner */
x = src_box.W;
y = src_box.S;
if (pj_do_transform(1, &x, &y, NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Error in pj_do_transform"));
}
if (tgt_box.W > x)
tgt_box.W = x;
if (tgt_box.E < x)
tgt_box.E = x;
if (tgt_box.N < y)
tgt_box.N = y;
if (tgt_box.S > y)
tgt_box.S = y;
/* NE corner */
x = src_box.E;
y = src_box.N;
if (pj_do_transform(1, &x, &y, NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Error in pj_do_transform"));
}
if (tgt_box.W > x) {
tgt_box.E = x + 360;
recommend_nowrap = 1;
}
if (tgt_box.N < y)
tgt_box.N = y;
if (tgt_box.S > y)
tgt_box.S = y;
/* SE corner */
x = src_box.E;
y = src_box.S;
if (pj_do_transform(1, &x, &y, NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Error in pj_do_transform"));
}
if (tgt_box.W > x) {
if (tgt_box.E < x + 360)
tgt_box.E = x + 360;
recommend_nowrap = 1;
}
if (tgt_box.N < y)
tgt_box.N = y;
if (tgt_box.S > y)
tgt_box.S = y;
}
G_debug(1, "Open new: location: %s mapset : %s", G_location_path(),
G_mapset());
if (Vect_open_new(&Out_Map, omap_name, Vect_is_3d(&Map)) < 0)
G_fatal_error(_("Unable to create vector map <%s>"), omap_name);
Vect_set_error_handler_io(NULL, &Out_Map); /* register standard i/o error handler */
Vect_copy_head_data(&Map, &Out_Map);
Vect_hist_copy(&Map, &Out_Map);
Vect_hist_command(&Out_Map);
out_zone = info_out.zone;
Vect_set_zone(&Out_Map, out_zone);
/* Read and write header info */
sprintf(date, "%s", G_date());
sscanf(date, "%*s%s%d%*s%d", mon, &day, &yr);
if (yr < 2000)
yr = yr - 1900;
else
yr = yr - 2000;
sprintf(date, "%s %d %d", mon, day, yr);
Vect_set_date(&Out_Map, date);
/* line densification works only with vector topology */
if (Map.format != GV_FORMAT_NATIVE)
lmax = 0;
/* Cycle through all lines */
Vect_rewind(&Map);
i = 0;
G_message(_("Reprojecting primitives ..."));
while (TRUE) {
++i;
G_progress(i, 1e3);
type = Vect_read_next_line(&Map, Points, Cats); /* read line */
if (type == 0)
continue; /* Dead */
if (type == -1)
G_fatal_error(_("Reading input vector map"));
if (type == -2)
break;
Vect_line_prune(Points);
if (lmax > 0 && (type & GV_LINES) && Points->n_points > 1) {
double x1, y1, z1, x2, y2, z2;
double dx, dy, dz;
double l;
int i, n;
Vect_reset_line(Points2);
for (i = 0; i < Points->n_points - 1; i++) {
x1 = Points->x[i];
y1 = Points->y[i];
z1 = Points->z[i];
n = i + 1;
x2 = Points->x[n];
y2 = Points->y[n];
z2 = Points->z[n];
dx = x2 - x1;
dy = y2 - y1;
dz = z2 - z1;
if (pj_do_transform(1, &x1, &y1,
flag.transformz->answer ? &z1 : NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Unable to re-project vector map <%s> from <%s>"),
Vect_get_full_name(&Map), ilocopt->answer);
}
if (pj_do_transform(1, &x2, &y2,
flag.transformz->answer ? &z2 : NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Unable to re-project vector map <%s> from <%s>"),
Vect_get_full_name(&Map), ilocopt->answer);
}
Vect_append_point(Points2, x1, y1, z1);
l = G_distance(x1, y1, x2, y2);
if (l > lmax) {
int j;
double x, y, z;
x1 = Points->x[i];
y1 = Points->y[i];
z1 = Points->z[i];
n = ceil(l / lmax);
for (j = 1; j < n; j++) {
x = x1 + dx * j / n;
y = y1 + dy * j / n;
z = z1 + dz * j / n;
if (pj_do_transform(1, &x, &y,
flag.transformz->answer ? &z : NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Unable to re-project vector map <%s> from <%s>"),
Vect_get_full_name(&Map), ilocopt->answer);
}
Vect_append_point(Points2, x, y, z);
}
}
}
Vect_append_point(Points2, x2, y2, z2);
Vect_write_line(&Out_Map, type, Points2, Cats); /* write line */
}
else {
if (pj_do_transform(Points->n_points, Points->x, Points->y,
flag.transformz->answer ? Points->z : NULL,
&info_in, &info_out) < 0) {
G_fatal_error(_("Unable to re-project vector map <%s> from <%s>"),
Vect_get_full_name(&Map), ilocopt->answer);
}
Vect_write_line(&Out_Map, type, Points, Cats); /* write line */
}
} /* end lines section */
G_progress(1, 1);
/* Copy tables */
if (Vect_copy_tables(&Map, &Out_Map, 0))
G_warning(_("Failed to copy attribute table to output map"));
Vect_close(&Map);
if (!flag.no_topol->answer)
Vect_build(&Out_Map);
Vect_close(&Out_Map);
if (recommend_nowrap)
G_important_message(_("Try to disable wrapping to -180,180 "
"if topological errors occurred"));
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
/* Variables' declarations */
int nsplx_adj, nsply_adj;
int nsubregion_col, nsubregion_row, subregion = 0, nsubregions = 0;
double N_extension, E_extension, edgeE, edgeN;
int dim_vect, nparameters, BW, npoints;
double lambda_B, lambda_F, grad_H, grad_L, alpha, mean;
const char *dvr, *db, *mapset;
char table_interpolation[GNAME_MAX], table_name[GNAME_MAX];
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
int last_row, last_column, flag_auxiliar = FALSE;
int *lineVect;
double *TN, *Q, *parVect_bilin, *parVect_bicub; /* Interpolating and least-square vectors */
double **N, **obsVect; /* Interpolation and least-square matrix */
/* Structs' declarations */
struct Map_info In, Out;
struct Option *in_opt, *out_opt, *stepE_opt, *stepN_opt,
*lambdaF_opt, *lambdaB_opt, *gradH_opt, *gradL_opt, *alfa_opt;
struct Flag *spline_step_flag;
struct GModule *module;
struct Cell_head elaboration_reg, original_reg;
struct Reg_dimens dims;
struct bound_box general_box, overlap_box;
struct Point *observ;
dbDriver *driver;
/*------------------------------------------------------------------------------------------*/
/* Options' declaration */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("LIDAR"));
G_add_keyword(_("edges"));
module->description =
_("Detects the object's edges from a LIDAR data set.");
spline_step_flag = G_define_flag();
spline_step_flag->key = 'e';
spline_step_flag->label = _("Estimate point density and distance");
spline_step_flag->description =
_("Estimate point density and distance for the input vector points within the current region extends and quit");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
stepE_opt = G_define_option();
stepE_opt->key = "see";
stepE_opt->type = TYPE_DOUBLE;
stepE_opt->required = NO;
stepE_opt->answer = "4";
stepE_opt->description =
_("Interpolation spline step value in east direction");
stepE_opt->guisection = _("Settings");
stepN_opt = G_define_option();
stepN_opt->key = "sen";
stepN_opt->type = TYPE_DOUBLE;
stepN_opt->required = NO;
stepN_opt->answer = "4";
stepN_opt->description =
_("Interpolation spline step value in north direction");
stepN_opt->guisection = _("Settings");
lambdaB_opt = G_define_option();
lambdaB_opt->key = "lambda_g";
lambdaB_opt->type = TYPE_DOUBLE;
lambdaB_opt->required = NO;
lambdaB_opt->description =
_("Regularization weight in gradient evaluation");
lambdaB_opt->answer = "0.01";
lambdaB_opt->guisection = _("Settings");
gradH_opt = G_define_option();
gradH_opt->key = "tgh";
gradH_opt->type = TYPE_DOUBLE;
gradH_opt->required = NO;
gradH_opt->description =
_("High gradient threshold for edge classification");
gradH_opt->answer = "6";
gradH_opt->guisection = _("Settings");
gradL_opt = G_define_option();
gradL_opt->key = "tgl";
gradL_opt->type = TYPE_DOUBLE;
gradL_opt->required = NO;
gradL_opt->description =
_("Low gradient threshold for edge classification");
gradL_opt->answer = "3";
gradL_opt->guisection = _("Settings");
alfa_opt = G_define_option();
alfa_opt->key = "theta_g";
alfa_opt->type = TYPE_DOUBLE;
alfa_opt->required = NO;
alfa_opt->description = _("Angle range for same direction detection");
alfa_opt->answer = "0.26";
alfa_opt->guisection = _("Settings");
lambdaF_opt = G_define_option();
lambdaF_opt->key = "lambda_r";
lambdaF_opt->type = TYPE_DOUBLE;
lambdaF_opt->required = NO;
lambdaF_opt->description =
_("Regularization weight in residual evaluation");
lambdaF_opt->answer = "2";
lambdaF_opt->guisection = _("Settings");
/* Parsing */
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
line_out_counter = 1;
stepN = atof(stepN_opt->answer);
stepE = atof(stepE_opt->answer);
lambda_F = atof(lambdaF_opt->answer);
lambda_B = atof(lambdaB_opt->answer);
grad_H = atof(gradH_opt->answer);
grad_L = atof(gradL_opt->answer);
alpha = atof(alfa_opt->answer);
grad_L = grad_L * grad_L;
grad_H = grad_H * grad_H;
if (!(db = G__getenv2("DB_DATABASE", G_VAR_MAPSET)))
G_fatal_error(_("Unable to read name of database"));
if (!(dvr = G__getenv2("DB_DRIVER", G_VAR_MAPSET)))
G_fatal_error(_("Unable to read name of driver"));
/* Setting auxiliar table's name */
if (G_name_is_fully_qualified(out_opt->answer, xname, xmapset)) {
sprintf(table_name, "%s_aux", xname);
sprintf(table_interpolation, "%s_edge_Interpolation", xname);
}
else {
sprintf(table_name, "%s_aux", out_opt->answer);
sprintf(table_interpolation, "%s_edge_Interpolation", out_opt->answer);
}
/* Something went wrong in a previous v.lidar.edgedetection execution */
if (db_table_exists(dvr, db, table_name)) {
/* Start driver and open db */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Old auxiliar table could not be dropped"));
db_close_database_shutdown_driver(driver);
}
/* Something went wrong in a previous v.lidar.edgedetection execution */
if (db_table_exists(dvr, db, table_interpolation)) {
/* Start driver and open db */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
if (P_Drop_Aux_Table(driver, table_interpolation) != DB_OK)
G_fatal_error(_("Old auxiliar table could not be dropped"));
db_close_database_shutdown_driver(driver);
}
/* Checking vector names */
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
G_FATAL_EXIT);
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL) {
G_fatal_error(_("Vector map <%s> not found"), in_opt->answer);
}
Vect_set_open_level(1);
/* Open input vector */
if (1 > Vect_open_old(&In, in_opt->answer, mapset))
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
/* Input vector must be 3D */
if (!Vect_is_3d(&In))
G_fatal_error(_("Input vector map <%s> is not 3D!"), in_opt->answer);
/* Estimate point density and mean distance for current region */
if (spline_step_flag->answer) {
double dens, dist;
if (P_estimate_splinestep(&In, &dens, &dist) == 0) {
G_message("Estimated point density: %.4g", dens);
G_message("Estimated mean distance between points: %.4g", dist);
}
else
G_warning(_("No points in current region!"));
Vect_close(&In);
exit(EXIT_SUCCESS);
}
/* Open output vector */
if (0 > Vect_open_new(&Out, out_opt->answer, WITH_Z))
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
/* Copy vector Head File */
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* Start driver and open db */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
db_set_error_handler_driver(driver);
/* Create auxiliar and interpolation table */
if ((flag_auxiliar = P_Create_Aux4_Table(driver, table_name)) == FALSE)
G_fatal_error(_("It was impossible to create <%s>."), table_name);
if (P_Create_Aux2_Table(driver, table_interpolation) == FALSE)
G_fatal_error(_("It was impossible to create <%s> interpolation table in database."),
out_opt->answer);
db_create_index2(driver, table_name, "ID");
db_create_index2(driver, table_interpolation, "ID");
/* sqlite likes that ??? */
db_close_database_shutdown_driver(driver);
driver = db_start_driver_open_database(dvr, db);
/* Setting regions and boxes */
G_get_set_window(&original_reg);
G_get_set_window(&elaboration_reg);
Vect_region_box(&elaboration_reg, &overlap_box);
Vect_region_box(&elaboration_reg, &general_box);
/*------------------------------------------------------------------
| Subdividing and working with tiles:
| Each original region will be divided into several subregions.
| Each one will be overlaped by its neighbouring subregions.
| The overlapping is calculated as a fixed OVERLAP_SIZE times
| the largest spline step plus 2 * edge
----------------------------------------------------------------*/
/* Fixing parameters of the elaboration region */
P_zero_dim(&dims);
nsplx_adj = NSPLX_MAX;
nsply_adj = NSPLY_MAX;
if (stepN > stepE)
dims.overlap = OVERLAP_SIZE * stepN;
else
dims.overlap = OVERLAP_SIZE * stepE;
P_get_edge(P_BICUBIC, &dims, stepE, stepN);
P_set_dim(&dims, stepE, stepN, &nsplx_adj, &nsply_adj);
G_verbose_message(_("adjusted EW splines %d"), nsplx_adj);
G_verbose_message(_("adjusted NS splines %d"), nsply_adj);
/* calculate number of subregions */
edgeE = dims.ew_size - dims.overlap - 2 * dims.edge_v;
edgeN = dims.sn_size - dims.overlap - 2 * dims.edge_h;
N_extension = original_reg.north - original_reg.south;
E_extension = original_reg.east - original_reg.west;
nsubregion_col = ceil(E_extension / edgeE) + 0.5;
nsubregion_row = ceil(N_extension / edgeN) + 0.5;
if (nsubregion_col < 0)
nsubregion_col = 0;
if (nsubregion_row < 0)
nsubregion_row = 0;
nsubregions = nsubregion_row * nsubregion_col;
elaboration_reg.south = original_reg.north;
last_row = FALSE;
while (last_row == FALSE) { /* For each row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_ROW);
if (elaboration_reg.north > original_reg.north) { /* First row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
FIRST_ROW);
}
if (elaboration_reg.south <= original_reg.south) { /* Last row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
LAST_ROW);
last_row = TRUE;
}
nsply =
ceil((elaboration_reg.north - elaboration_reg.south) / stepN) +
0.5;
/*
if (nsply > NSPLY_MAX) {
nsply = NSPLY_MAX;
}
*/
G_debug(1, "nsply = %d", nsply);
elaboration_reg.east = original_reg.west;
last_column = FALSE;
while (last_column == FALSE) { /* For each column */
subregion++;
if (nsubregions > 1)
G_message(_("subregion %d of %d"), subregion, nsubregions);
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_COLUMN);
if (elaboration_reg.west < original_reg.west) { /* First column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, FIRST_COLUMN);
}
if (elaboration_reg.east >= original_reg.east) { /* Last column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, LAST_COLUMN);
last_column = TRUE;
}
nsplx =
ceil((elaboration_reg.east - elaboration_reg.west) / stepE) +
0.5;
/*
if (nsplx > NSPLX_MAX) {
nsplx = NSPLX_MAX;
}
*/
G_debug(1, "nsplx = %d", nsplx);
/*Setting the active region */
dim_vect = nsplx * nsply;
G_debug(1, "read vector region map");
observ =
P_Read_Vector_Region_Map(&In, &elaboration_reg, &npoints,
dim_vect, 1);
if (npoints > 0) { /* If there is any point falling into elaboration_reg... */
int i, tn;
nparameters = nsplx * nsply;
/* Mean's calculation */
mean = P_Mean_Calc(&elaboration_reg, observ, npoints);
/* Least Squares system */
G_debug(1, _("Allocating memory for bilinear interpolation"));
BW = P_get_BandWidth(P_BILINEAR, nsply); /* Bilinear interpolation */
N = G_alloc_matrix(nparameters, BW); /* Normal matrix */
TN = G_alloc_vector(nparameters); /* vector */
parVect_bilin = G_alloc_vector(nparameters); /* Bilinear parameters vector */
obsVect = G_alloc_matrix(npoints + 1, 3); /* Observation vector */
Q = G_alloc_vector(npoints + 1); /* "a priori" var-cov matrix */
lineVect = G_alloc_ivector(npoints + 1);
/* Setting obsVect vector & Q matrix */
for (i = 0; i < npoints; i++) {
obsVect[i][0] = observ[i].coordX;
obsVect[i][1] = observ[i].coordY;
obsVect[i][2] = observ[i].coordZ - mean;
lineVect[i] = observ[i].lineID;
Q[i] = 1; /* Q=I */
}
G_free(observ);
G_verbose_message(_("Bilinear interpolation"));
normalDefBilin(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, npoints, nparameters,
BW);
nCorrectGrad(N, lambda_B, nsplx, nsply, stepE, stepN);
G_math_solver_cholesky_sband(N, parVect_bilin, TN, nparameters, BW);
G_free_matrix(N);
for (tn = 0; tn < nparameters; tn++)
TN[tn] = 0;
G_debug(1, _("Allocating memory for bicubic interpolation"));
BW = P_get_BandWidth(P_BICUBIC, nsply);
N = G_alloc_matrix(nparameters, BW); /* Normal matrix */
parVect_bicub = G_alloc_vector(nparameters); /* Bicubic parameters vector */
G_verbose_message(_("Bicubic interpolation"));
normalDefBicubic(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, npoints, nparameters,
BW);
nCorrectLapl(N, lambda_F, nsplx, nsply, stepE, stepN);
G_math_solver_cholesky_sband(N, parVect_bicub, TN, nparameters, BW);
G_free_matrix(N);
G_free_vector(TN);
G_free_vector(Q);
G_verbose_message(_("Point classification"));
classification(&Out, elaboration_reg, general_box,
overlap_box, obsVect, parVect_bilin,
parVect_bicub, mean, alpha, grad_H, grad_L,
dims.overlap, lineVect, npoints, driver,
table_interpolation, table_name);
G_free_vector(parVect_bilin);
G_free_vector(parVect_bicub);
G_free_matrix(obsVect);
G_free_ivector(lineVect);
} /* IF */
else {
G_free(observ);
G_warning(_("No data within this subregion. "
"Consider changing the spline step."));
}
} /*! END WHILE; last_column = TRUE */
} /*! END WHILE; last_row = TRUE */
/* Dropping auxiliar table */
if (npoints > 0) {
G_debug(1, _("Dropping <%s>"), table_name);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_warning(_("Auxiliar table could not be dropped"));
}
db_close_database_shutdown_driver(driver);
Vect_close(&In);
Vect_map_add_dblink(&Out, F_INTERPOLATION, NULL, table_interpolation,
"id", db, dvr);
Vect_close(&Out);
G_done_msg(" ");
exit(EXIT_SUCCESS);
} /*!END MAIN */
int main(int argc, char *argv[])
{
struct Map_info In, Out, Error;
struct line_pnts *Points;
struct line_cats *Cats;
int i, type, iter;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out, *error_out, *thresh_opt, *method_opt,
*look_ahead_opt;
struct Option *iterations_opt, *cat_opt, *alpha_opt, *beta_opt, *type_opt;
struct Option *field_opt, *where_opt, *reduction_opt, *slide_opt;
struct Option *angle_thresh_opt, *degree_thresh_opt,
*closeness_thresh_opt;
struct Option *betweeness_thresh_opt;
struct Flag *notab_flag, *loop_support_flag;
int with_z;
int total_input, total_output; /* Number of points in the input/output map respectively */
double thresh, alpha, beta, reduction, slide, angle_thresh;
double degree_thresh, closeness_thresh, betweeness_thresh;
int method;
int look_ahead, iterations;
int loop_support;
int layer;
int n_lines;
int simplification, mask_type;
struct cat_list *cat_list = NULL;
char *s, *descriptions;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("generalization"));
G_add_keyword(_("simplification"));
G_add_keyword(_("smoothing"));
G_add_keyword(_("displacement"));
G_add_keyword(_("network generalization"));
module->description = _("Performs vector based generalization.");
/* Define the different options as defined in gis.h */
map_in = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->options = "line,boundary,area";
type_opt->answer = "line,boundary,area";
type_opt->guisection = _("Selection");
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
error_out = G_define_standard_option(G_OPT_V_OUTPUT);
error_out->key = "error";
error_out->required = NO;
error_out->description =
_("Error map of all lines and boundaries not being generalized due to topology issues or over-simplification");
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = YES;
method_opt->multiple = NO;
method_opt->options =
"douglas,douglas_reduction,lang,reduction,reumann,boyle,sliding_averaging,distance_weighting,chaiken,hermite,snakes,network,displacement";
descriptions = NULL;
G_asprintf(&descriptions,
"douglas;%s;"
"douglas_reduction;%s;"
"lang;%s;"
"reduction;%s;"
"reumann;%s;"
"boyle;%s;"
"sliding_averaging;%s;"
"distance_weighting;%s;"
"chaiken;%s;"
"hermite;%s;"
"snakes;%s;"
"network;%s;"
"displacement;%s;",
_("Douglas-Peucker Algorithm"),
_("Douglas-Peucker Algorithm with reduction parameter"),
_("Lang Simplification Algorithm"),
_("Vertex Reduction Algorithm eliminates points close to each other"),
_("Reumann-Witkam Algorithm"),
_("Boyle's Forward-Looking Algorithm"),
_("McMaster's Sliding Averaging Algorithm"),
_("McMaster's Distance-Weighting Algorithm"),
_("Chaiken's Algorithm"),
_("Interpolation by Cubic Hermite Splines"),
_("Snakes method for line smoothing"),
_("Network generalization"),
_("Displacement of lines close to each other"));
method_opt->descriptions = G_store(descriptions);
method_opt->description = _("Generalization algorithm");
thresh_opt = G_define_option();
thresh_opt->key = "threshold";
thresh_opt->type = TYPE_DOUBLE;
thresh_opt->required = YES;
thresh_opt->options = "0-1000000000";
thresh_opt->description = _("Maximal tolerance value");
look_ahead_opt = G_define_option();
look_ahead_opt->key = "look_ahead";
look_ahead_opt->type = TYPE_INTEGER;
look_ahead_opt->required = NO;
look_ahead_opt->answer = "7";
look_ahead_opt->description = _("Look-ahead parameter");
reduction_opt = G_define_option();
reduction_opt->key = "reduction";
reduction_opt->type = TYPE_DOUBLE;
reduction_opt->required = NO;
reduction_opt->answer = "50";
reduction_opt->options = "0-100";
reduction_opt->description =
_("Percentage of the points in the output of 'douglas_reduction' algorithm");
slide_opt = G_define_option();
slide_opt->key = "slide";
slide_opt->type = TYPE_DOUBLE;
slide_opt->required = NO;
slide_opt->answer = "0.5";
slide_opt->options = "0-1";
slide_opt->description =
_("Slide of computed point toward the original point");
angle_thresh_opt = G_define_option();
angle_thresh_opt->key = "angle_thresh";
angle_thresh_opt->type = TYPE_DOUBLE;
angle_thresh_opt->required = NO;
angle_thresh_opt->answer = "3";
angle_thresh_opt->options = "0-180";
angle_thresh_opt->description =
_("Minimum angle between two consecutive segments in Hermite method");
degree_thresh_opt = G_define_option();
degree_thresh_opt->key = "degree_thresh";
degree_thresh_opt->type = TYPE_INTEGER;
degree_thresh_opt->required = NO;
degree_thresh_opt->answer = "0";
degree_thresh_opt->description =
_("Degree threshold in network generalization");
closeness_thresh_opt = G_define_option();
closeness_thresh_opt->key = "closeness_thresh";
closeness_thresh_opt->type = TYPE_DOUBLE;
closeness_thresh_opt->required = NO;
closeness_thresh_opt->answer = "0";
closeness_thresh_opt->options = "0-1";
closeness_thresh_opt->description =
_("Closeness threshold in network generalization");
betweeness_thresh_opt = G_define_option();
betweeness_thresh_opt->key = "betweeness_thresh";
betweeness_thresh_opt->type = TYPE_DOUBLE;
betweeness_thresh_opt->required = NO;
betweeness_thresh_opt->answer = "0";
betweeness_thresh_opt->description =
_("Betweeness threshold in network generalization");
alpha_opt = G_define_option();
alpha_opt->key = "alpha";
alpha_opt->type = TYPE_DOUBLE;
alpha_opt->required = NO;
alpha_opt->answer = "1.0";
alpha_opt->description = _("Snakes alpha parameter");
beta_opt = G_define_option();
beta_opt->key = "beta";
beta_opt->type = TYPE_DOUBLE;
beta_opt->required = NO;
beta_opt->answer = "1.0";
beta_opt->description = _("Snakes beta parameter");
iterations_opt = G_define_option();
iterations_opt->key = "iterations";
iterations_opt->type = TYPE_INTEGER;
iterations_opt->required = NO;
iterations_opt->answer = "1";
iterations_opt->description = _("Number of iterations");
cat_opt = G_define_standard_option(G_OPT_V_CATS);
cat_opt->guisection = _("Selection");
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
where_opt->guisection = _("Selection");
loop_support_flag = G_define_flag();
loop_support_flag->key = 'l';
loop_support_flag->label = _("Disable loop support");
loop_support_flag->description = _("Do not modify end points of lines forming a closed loop");
notab_flag = G_define_standard_flag(G_FLG_V_TABLE);
notab_flag->description = _("Do not copy attributes");
notab_flag->guisection = _("Attributes");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
thresh = atof(thresh_opt->answer);
look_ahead = atoi(look_ahead_opt->answer);
alpha = atof(alpha_opt->answer);
beta = atof(beta_opt->answer);
reduction = atof(reduction_opt->answer);
iterations = atoi(iterations_opt->answer);
slide = atof(slide_opt->answer);
angle_thresh = atof(angle_thresh_opt->answer);
degree_thresh = atof(degree_thresh_opt->answer);
closeness_thresh = atof(closeness_thresh_opt->answer);
betweeness_thresh = atof(betweeness_thresh_opt->answer);
mask_type = type_mask(type_opt);
G_debug(3, "Method: %s", method_opt->answer);
s = method_opt->answer;
if (strcmp(s, "douglas") == 0)
method = DOUGLAS;
else if (strcmp(s, "lang") == 0)
method = LANG;
else if (strcmp(s, "reduction") == 0)
method = VERTEX_REDUCTION;
else if (strcmp(s, "reumann") == 0)
method = REUMANN;
else if (strcmp(s, "boyle") == 0)
method = BOYLE;
else if (strcmp(s, "distance_weighting") == 0)
method = DISTANCE_WEIGHTING;
else if (strcmp(s, "chaiken") == 0)
method = CHAIKEN;
else if (strcmp(s, "hermite") == 0)
method = HERMITE;
else if (strcmp(s, "snakes") == 0)
method = SNAKES;
else if (strcmp(s, "douglas_reduction") == 0)
method = DOUGLAS_REDUCTION;
else if (strcmp(s, "sliding_averaging") == 0)
method = SLIDING_AVERAGING;
else if (strcmp(s, "network") == 0)
method = NETWORK;
else if (strcmp(s, "displacement") == 0) {
method = DISPLACEMENT;
/* we can displace only the lines */
mask_type = GV_LINE;
}
else {
G_fatal_error(_("Unknown method"));
exit(EXIT_FAILURE);
}
/* simplification or smoothing? */
switch (method) {
case DOUGLAS:
case DOUGLAS_REDUCTION:
case LANG:
case VERTEX_REDUCTION:
case REUMANN:
simplification = 1;
break;
default:
simplification = 0;
break;
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_check_input_output_name(map_in->answer, map_out->answer,
G_FATAL_EXIT);
Vect_set_open_level(2);
if (Vect_open_old2(&In, map_in->answer, "", field_opt->answer) < 1)
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
if (Vect_get_num_primitives(&In, mask_type) == 0) {
G_warning(_("No lines found in input map <%s>"), map_in->answer);
Vect_close(&In);
exit(EXIT_SUCCESS);
}
with_z = Vect_is_3d(&In);
if (0 > Vect_open_new(&Out, map_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), map_out->answer);
}
if (error_out->answer) {
if (0 > Vect_open_new(&Error, error_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create error vector map <%s>"), error_out->answer);
}
}
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
total_input = total_output = 0;
layer = Vect_get_field_number(&In, field_opt->answer);
/* parse filter options */
if (layer > 0)
cat_list = Vect_cats_set_constraint(&In, layer,
where_opt->answer, cat_opt->answer);
if (method == DISPLACEMENT) {
/* modifies only lines, all other features including boundaries are preserved */
/* options where, cats, and layer are respected */
G_message(_("Displacement..."));
snakes_displacement(&In, &Out, thresh, alpha, beta, 1.0, 10.0,
iterations, cat_list, layer);
}
/* TODO: rearrange code below. It's really messy */
if (method == NETWORK) {
/* extracts lines of selected type, all other features are discarded */
/* options where, cats, and layer are ignored */
G_message(_("Network generalization..."));
total_output =
graph_generalization(&In, &Out, mask_type, degree_thresh,
closeness_thresh, betweeness_thresh);
}
/* copy tables here because method == NETWORK is complete and
* tables for Out may be needed for parse_filter_options() below */
if (!notab_flag->answer) {
if (method == NETWORK)
copy_tables_by_cats(&In, &Out);
else
Vect_copy_tables(&In, &Out, -1);
}
else if (where_opt->answer && method < NETWORK) {
G_warning(_("Attributes are needed for 'where' option, copying table"));
Vect_copy_tables(&In, &Out, -1);
}
/* smoothing/simplification */
if (method < NETWORK) {
/* modifies only lines of selected type, all other features are preserved */
int not_modified_boundaries = 0, n_oversimplified = 0;
struct line_pnts *APoints; /* original Points */
set_topo_debug();
Vect_copy_map_lines(&In, &Out);
Vect_build_partial(&Out, GV_BUILD_CENTROIDS);
G_message("-----------------------------------------------------");
G_message(_("Generalization (%s)..."), method_opt->answer);
G_message(_("Using threshold: %g %s"), thresh, G_database_unit_name(1));
G_percent_reset();
APoints = Vect_new_line_struct();
n_lines = Vect_get_num_lines(&Out);
for (i = 1; i <= n_lines; i++) {
int after = 0;
G_percent(i, n_lines, 1);
type = Vect_read_line(&Out, APoints, Cats, i);
if (!(type & GV_LINES) || !(mask_type & type))
continue;
if (layer > 0) {
if ((type & GV_LINE) &&
!Vect_cats_in_constraint(Cats, layer, cat_list))
continue;
else if ((type & GV_BOUNDARY)) {
int do_line = 0;
int left, right;
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
if (!do_line) {
/* check if any of the centroids is selected */
Vect_get_line_areas(&Out, i, &left, &right);
if (left < 0)
left = Vect_get_isle_area(&Out, abs(left));
if (right < 0)
right = Vect_get_isle_area(&Out, abs(right));
if (left > 0) {
Vect_get_area_cats(&Out, left, Cats);
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
}
if (!do_line && right > 0) {
Vect_get_area_cats(&Out, right, Cats);
do_line = Vect_cats_in_constraint(Cats, layer, cat_list);
}
}
if (!do_line)
continue;
}
}
Vect_line_prune(APoints);
if (APoints->n_points < 2)
/* Line of length zero, delete if boundary ? */
continue;
total_input += APoints->n_points;
/* copy points */
Vect_reset_line(Points);
Vect_append_points(Points, APoints, GV_FORWARD);
loop_support = 0;
if (!loop_support_flag->answer) {
int n1, n2;
Vect_get_line_nodes(&Out, i, &n1, &n2);
if (n1 == n2) {
if (Vect_get_node_n_lines(&Out, n1) == 2) {
if (abs(Vect_get_node_line(&Out, n1, 0)) == i &&
abs(Vect_get_node_line(&Out, n1, 1)) == i)
loop_support = 1;
}
}
}
for (iter = 0; iter < iterations; iter++) {
switch (method) {
case DOUGLAS:
douglas_peucker(Points, thresh, with_z);
break;
case DOUGLAS_REDUCTION:
douglas_peucker_reduction(Points, thresh, reduction,
with_z);
break;
case LANG:
lang(Points, thresh, look_ahead, with_z);
break;
case VERTEX_REDUCTION:
vertex_reduction(Points, thresh, with_z);
break;
case REUMANN:
reumann_witkam(Points, thresh, with_z);
break;
case BOYLE:
boyle(Points, look_ahead, loop_support, with_z);
break;
case SLIDING_AVERAGING:
sliding_averaging(Points, slide, look_ahead, loop_support, with_z);
break;
case DISTANCE_WEIGHTING:
distance_weighting(Points, slide, look_ahead, loop_support, with_z);
break;
case CHAIKEN:
chaiken(Points, thresh, loop_support, with_z);
break;
case HERMITE:
hermite(Points, thresh, angle_thresh, loop_support, with_z);
break;
case SNAKES:
snakes(Points, alpha, beta, loop_support, with_z);
break;
}
}
if (loop_support == 0) {
/* safety check, BUG in method if not passed */
if (APoints->x[0] != Points->x[0] ||
APoints->y[0] != Points->y[0] ||
APoints->z[0] != Points->z[0])
G_fatal_error(_("Method '%s' did not preserve first point"), method_opt->answer);
if (APoints->x[APoints->n_points - 1] != Points->x[Points->n_points - 1] ||
APoints->y[APoints->n_points - 1] != Points->y[Points->n_points - 1] ||
APoints->z[APoints->n_points - 1] != Points->z[Points->n_points - 1])
G_fatal_error(_("Method '%s' did not preserve last point"), method_opt->answer);
}
else {
/* safety check, BUG in method if not passed */
if (Points->x[0] != Points->x[Points->n_points - 1] ||
Points->y[0] != Points->y[Points->n_points - 1] ||
Points->z[0] != Points->z[Points->n_points - 1])
G_fatal_error(_("Method '%s' did not preserve loop"), method_opt->answer);
}
Vect_line_prune(Points);
/* oversimplified line */
if (Points->n_points < 2) {
after = APoints->n_points;
n_oversimplified++;
if (error_out->answer)
Vect_write_line(&Error, type, APoints, Cats);
}
/* check for topology corruption */
else if (type == GV_BOUNDARY) {
if (!check_topo(&Out, i, APoints, Points, Cats)) {
after = APoints->n_points;
not_modified_boundaries++;
if (error_out->answer)
Vect_write_line(&Error, type, APoints, Cats);
}
else
after = Points->n_points;
}
else {
/* type == GV_LINE */
Vect_rewrite_line(&Out, i, type, Points, Cats);
after = Points->n_points;
}
total_output += after;
}
if (not_modified_boundaries > 0)
G_warning(_("%d boundaries were not modified because modification would damage topology"),
not_modified_boundaries);
if (n_oversimplified > 0)
G_warning(_("%d lines/boundaries were not modified due to over-simplification"),
n_oversimplified);
G_message("-----------------------------------------------------");
/* make sure that clean topo is built at the end */
Vect_build_partial(&Out, GV_BUILD_NONE);
if (error_out->answer)
Vect_build_partial(&Error, GV_BUILD_NONE);
}
Vect_build(&Out);
if (error_out->answer)
Vect_build(&Error);
Vect_close(&In);
Vect_close(&Out);
if (error_out->answer)
Vect_close(&Error);
G_message("-----------------------------------------------------");
if (total_input != 0 && total_input != total_output)
G_done_msg(_("Number of vertices for selected features %s from %d to %d (%d%% remaining)"),
simplification ? _("reduced") : _("changed"),
total_input, total_output,
(total_output * 100) / total_input);
else
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
/*----------------------------------------------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
/* Declarations */
int dim_vect, nparameters, BW, npoints;
int nsply, nsplx, nsplx_adj, nsply_adj;
int nsubregion_col, nsubregion_row;
int subregion = 0, nsubregions = 0;
const char *dvr, *db, *mapset;
char table_name[GNAME_MAX];
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
double lambda, mean, stepN, stepE, HighThresh,
LowThresh;
double N_extension, E_extension, edgeE, edgeN;
int i, nterrain, count_terrain;
int last_row, last_column, flag_auxiliar = FALSE;
int *lineVect;
double *TN, *Q, *parVect; /* Interpolating and least-square vectors */
double **N, **obsVect, **obsVect_all; /* Interpolation and least-square matrix */
struct Map_info In, Out, Terrain;
struct Option *in_opt, *out_opt, *out_terrain_opt, *stepE_opt,
*stepN_opt, *lambda_f_opt, *Thresh_A_opt, *Thresh_B_opt;
struct Flag *spline_step_flag;
struct GModule *module;
struct Cell_head elaboration_reg, original_reg;
struct Reg_dimens dims;
struct bound_box general_box, overlap_box;
struct Point *observ;
struct lidar_cat *lcat;
dbDriver *driver;
/*----------------------------------------------------------------------------------------------------------*/
/* Options' declaration */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("LIDAR"));
module->description =
_("Corrects the v.lidar.growing output. It is the last of the three algorithms for LIDAR filtering.");
spline_step_flag = G_define_flag();
spline_step_flag->key = 'e';
spline_step_flag->label = _("Estimate point density and distance");
spline_step_flag->description =
_("Estimate point density and distance for the input vector points within the current region extends and quit");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
in_opt->description =
_("Input observation vector map name (v.lidar.growing output)");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
out_opt->description = _("Output classified vector map name");
out_terrain_opt = G_define_option();
out_terrain_opt->key = "terrain";
out_terrain_opt->type = TYPE_STRING;
out_terrain_opt->key_desc = "name";
out_terrain_opt->required = YES;
out_terrain_opt->gisprompt = "new,vector,vector";
out_terrain_opt->description =
_("Only 'terrain' points output vector map");
stepE_opt = G_define_option();
stepE_opt->key = "ew_step";
stepE_opt->type = TYPE_DOUBLE;
stepE_opt->required = NO;
stepE_opt->answer = "25";
stepE_opt->description =
_("Length of each spline step in the east-west direction");
stepE_opt->guisection = _("Settings");
stepN_opt = G_define_option();
stepN_opt->key = "ns_step";
stepN_opt->type = TYPE_DOUBLE;
stepN_opt->required = NO;
stepN_opt->answer = "25";
stepN_opt->description =
_("Length of each spline step in the north-south direction");
stepN_opt->guisection = _("Settings");
lambda_f_opt = G_define_option();
lambda_f_opt->key = "lambda_c";
lambda_f_opt->type = TYPE_DOUBLE;
lambda_f_opt->required = NO;
lambda_f_opt->description =
_("Regularization weight in reclassification evaluation");
lambda_f_opt->answer = "1";
Thresh_A_opt = G_define_option();
Thresh_A_opt->key = "tch";
Thresh_A_opt->type = TYPE_DOUBLE;
Thresh_A_opt->required = NO;
Thresh_A_opt->description =
_("High threshold for object to terrain reclassification");
Thresh_A_opt->answer = "2";
Thresh_B_opt = G_define_option();
Thresh_B_opt->key = "tcl";
Thresh_B_opt->type = TYPE_DOUBLE;
Thresh_B_opt->required = NO;
Thresh_B_opt->description =
_("Low threshold for terrain to object reclassification");
Thresh_B_opt->answer = "1";
/* Parsing */
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
stepN = atof(stepN_opt->answer);
stepE = atof(stepE_opt->answer);
lambda = atof(lambda_f_opt->answer);
HighThresh = atof(Thresh_A_opt->answer);
LowThresh = atof(Thresh_B_opt->answer);
if (!(db = G_getenv_nofatal2("DB_DATABASE", G_VAR_MAPSET)))
G_fatal_error(_("Unable to read name of database"));
if (!(dvr = G_getenv_nofatal2("DB_DRIVER", G_VAR_MAPSET)))
G_fatal_error(_("Unable to read name of driver"));
/* Setting auxiliar table's name */
if (G_name_is_fully_qualified(out_opt->answer, xname, xmapset)) {
sprintf(table_name, "%s_aux", xname);
}
else
sprintf(table_name, "%s_aux", out_opt->answer);
/* Something went wrong in a previous v.lidar.correction execution */
if (db_table_exists(dvr, db, table_name)) {
/* Start driver and open db */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
db_set_error_handler_driver(driver);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Old auxiliar table could not be dropped"));
db_close_database_shutdown_driver(driver);
}
/* Checking vector names */
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
G_FATAL_EXIT);
/* Open input vector */
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), in_opt->answer);
Vect_set_open_level(1); /* without topology */
if (1 > Vect_open_old(&In, in_opt->answer, mapset))
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
/* Input vector must be 3D */
if (!Vect_is_3d(&In))
G_fatal_error(_("Input vector map <%s> is not 3D!"), in_opt->answer);
/* Estimate point density and mean distance for current region */
if (spline_step_flag->answer) {
double dens, dist;
if (P_estimate_splinestep(&In, &dens, &dist) == 0) {
G_message("Estimated point density: %.4g", dens);
G_message("Estimated mean distance between points: %.4g", dist);
}
else
G_warning(_("No points in current region!"));
Vect_close(&In);
exit(EXIT_SUCCESS);
}
/* Open output vector */
if (0 > Vect_open_new(&Out, out_opt->answer, WITH_Z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
}
if (0 > Vect_open_new(&Terrain, out_terrain_opt->answer, WITH_Z)) {
Vect_close(&In);
Vect_close(&Out);
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
}
/* Copy vector Head File */
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
Vect_copy_head_data(&In, &Terrain);
Vect_hist_copy(&In, &Terrain);
Vect_hist_command(&Terrain);
/* Start driver and open db */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
db_set_error_handler_driver(driver);
/* Create auxiliar table */
if ((flag_auxiliar =
P_Create_Aux2_Table(driver, table_name)) == FALSE) {
Vect_close(&In);
Vect_close(&Out);
Vect_close(&Terrain);
exit(EXIT_FAILURE);
}
db_create_index2(driver, table_name, "ID");
/* sqlite likes that ??? */
db_close_database_shutdown_driver(driver);
driver = db_start_driver_open_database(dvr, db);
/* Setting regions and boxes */
G_get_set_window(&original_reg);
G_get_set_window(&elaboration_reg);
Vect_region_box(&elaboration_reg, &overlap_box);
Vect_region_box(&elaboration_reg, &general_box);
/*------------------------------------------------------------------
| Subdividing and working with tiles:
| Each original region will be divided into several subregions.
| Each one will be overlaped by its neighbouring subregions.
| The overlapping is calculated as a fixed OVERLAP_SIZE times
| the largest spline step plus 2 * edge
----------------------------------------------------------------*/
/* Fixing parameters of the elaboration region */
P_zero_dim(&dims);
nsplx_adj = NSPLX_MAX;
nsply_adj = NSPLY_MAX;
if (stepN > stepE)
dims.overlap = OVERLAP_SIZE * stepN;
else
dims.overlap = OVERLAP_SIZE * stepE;
P_get_edge(P_BILINEAR, &dims, stepE, stepN);
P_set_dim(&dims, stepE, stepN, &nsplx_adj, &nsply_adj);
G_verbose_message(n_("adjusted EW spline %d",
"adjusted EW splines %d",
nsplx_adj), nsplx_adj);
G_verbose_message(n_("adjusted NS spline %d",
"adjusted NS splines %d",
nsply_adj), nsply_adj);
/* calculate number of subregions */
edgeE = dims.ew_size - dims.overlap - 2 * dims.edge_v;
edgeN = dims.sn_size - dims.overlap - 2 * dims.edge_h;
N_extension = original_reg.north - original_reg.south;
E_extension = original_reg.east - original_reg.west;
nsubregion_col = ceil(E_extension / edgeE) + 0.5;
nsubregion_row = ceil(N_extension / edgeN) + 0.5;
if (nsubregion_col < 0)
nsubregion_col = 0;
if (nsubregion_row < 0)
nsubregion_row = 0;
nsubregions = nsubregion_row * nsubregion_col;
elaboration_reg.south = original_reg.north;
last_row = FALSE;
while (last_row == FALSE) { /* For each row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_ROW);
if (elaboration_reg.north > original_reg.north) { /* First row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
FIRST_ROW);
}
if (elaboration_reg.south <= original_reg.south) { /* Last row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
LAST_ROW);
last_row = TRUE;
}
nsply =
ceil((elaboration_reg.north -
elaboration_reg.south) / stepN) + 0.5;
/*
if (nsply > NSPLY_MAX) {
nsply = NSPLY_MAX;
}
*/
G_debug(1, _("nsply = %d"), nsply);
elaboration_reg.east = original_reg.west;
last_column = FALSE;
while (last_column == FALSE) { /* For each column */
subregion++;
if (nsubregions > 1)
G_message(_("subregion %d of %d"), subregion, nsubregions);
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_COLUMN);
if (elaboration_reg.west < original_reg.west) { /* First column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, FIRST_COLUMN);
}
if (elaboration_reg.east >= original_reg.east) { /* Last column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, LAST_COLUMN);
last_column = TRUE;
}
nsplx =
ceil((elaboration_reg.east - elaboration_reg.west) / stepE) +
0.5;
/*
if (nsplx > NSPLX_MAX) {
nsplx = NSPLX_MAX;
}
*/
G_debug(1, _("nsplx = %d"), nsplx);
dim_vect = nsplx * nsply;
G_debug(1, _("read vector region map"));
observ =
P_Read_Vector_Correction(&In, &elaboration_reg, &npoints,
&nterrain, dim_vect, &lcat);
G_debug(5, _("npoints = %d, nterrain = %d"), npoints, nterrain);
if (npoints > 0) { /* If there is any point falling into elaboration_reg. */
count_terrain = 0;
nparameters = nsplx * nsply;
/* Mean calculation */
G_debug(3, _("Mean calculation"));
mean = P_Mean_Calc(&elaboration_reg, observ, npoints);
/*Least Squares system */
BW = P_get_BandWidth(P_BILINEAR, nsply); /* Bilinear interpolation */
N = G_alloc_matrix(nparameters, BW); /* Normal matrix */
TN = G_alloc_vector(nparameters); /* vector */
parVect = G_alloc_vector(nparameters); /* Bilinear parameters vector */
obsVect = G_alloc_matrix(nterrain + 1, 3); /* Observation vector with terrain points */
obsVect_all = G_alloc_matrix(npoints + 1, 3); /* Observation vector with all points */
Q = G_alloc_vector(nterrain + 1); /* "a priori" var-cov matrix */
lineVect = G_alloc_ivector(npoints + 1);
/* Setting obsVect vector & Q matrix */
G_debug(3, _("Only TERRAIN points"));
for (i = 0; i < npoints; i++) {
if (observ[i].cat == TERRAIN_SINGLE) {
obsVect[count_terrain][0] = observ[i].coordX;
obsVect[count_terrain][1] = observ[i].coordY;
obsVect[count_terrain][2] = observ[i].coordZ - mean;
Q[count_terrain] = 1; /* Q=I */
count_terrain++;
}
lineVect[i] = observ[i].lineID;
obsVect_all[i][0] = observ[i].coordX;
obsVect_all[i][1] = observ[i].coordY;
obsVect_all[i][2] = observ[i].coordZ - mean;
}
G_free(observ);
G_verbose_message(_("Bilinear interpolation"));
normalDefBilin(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, nterrain, nparameters,
BW);
nCorrectGrad(N, lambda, nsplx, nsply, stepE, stepN);
G_math_solver_cholesky_sband(N, parVect, TN, nparameters, BW);
G_free_matrix(N);
G_free_vector(TN);
G_free_vector(Q);
G_free_matrix(obsVect);
G_verbose_message( _("Correction and creation of terrain vector"));
P_Sparse_Correction(&In, &Out, &Terrain, &elaboration_reg,
general_box, overlap_box, obsVect_all, lcat,
parVect, lineVect, stepN, stepE,
dims.overlap, HighThresh, LowThresh,
nsplx, nsply, npoints, driver, mean, table_name);
G_free_vector(parVect);
G_free_matrix(obsVect_all);
G_free_ivector(lineVect);
}
else {
G_free(observ);
G_warning(_("No data within this subregion. "
"Consider changing the spline step."));
}
G_free(lcat);
} /*! END WHILE; last_column = TRUE */
} /*! END WHILE; last_row = TRUE */
/* Dropping auxiliar table */
if (npoints > 0) {
G_debug(1, _("Dropping <%s>"), table_name);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Auxiliar table could not be dropped"));
}
db_close_database_shutdown_driver(driver);
Vect_close(&In);
Vect_close(&Out);
Vect_close(&Terrain);
G_done_msg(" ");
exit(EXIT_SUCCESS);
} /*! END MAIN */
int main(int argc, char *argv[])
{
struct GModule *module;
struct {
struct Option *input, *output, *zshift, *height, *elevation, *hcolumn,
*type, *field, *cats, *where, *interp, *scale, *null;
} opt;
struct {
struct Flag *trace;
} flag;
struct Map_info In, Out;
struct line_pnts *Points;
struct line_cats *Cats;
struct bound_box map_box;
struct cat_list *cat_list;
struct Cell_head window;
int field;
int only_type, cat;
int fdrast, interp_method, trace;
double objheight, objheight_default, voffset;
double scale, null_val;
struct field_info *Fi;
dbDriver *driver = NULL;
char *comment;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("geometry"));
G_add_keyword(_("sampling"));
G_add_keyword(_("3D"));
module->label =
_("Extrudes flat vector features to 3D vector features with defined height.");
module->description =
_("Optionally the height can be derived from sampling of elevation raster map.");
flag.trace = G_define_flag();
flag.trace->key = 't';
flag.trace->description = _("Trace elevation");
flag.trace->guisection = _("Elevation");
opt.input = G_define_standard_option(G_OPT_V_INPUT);
opt.field = G_define_standard_option(G_OPT_V_FIELD_ALL);
opt.field->guisection = _("Selection");
opt.cats = G_define_standard_option(G_OPT_V_CATS);
opt.cats->guisection = _("Selection");
opt.where = G_define_standard_option(G_OPT_DB_WHERE);
opt.where->guisection = _("Selection");
opt.type = G_define_standard_option(G_OPT_V_TYPE);
opt.type->answer = "point,line,area";
opt.type->options = "point,line,area";
opt.type->guisection = _("Selection");
opt.output = G_define_standard_option(G_OPT_V_OUTPUT);
opt.zshift = G_define_option();
opt.zshift->key = "zshift";
opt.zshift->description = _("Shifting value for z coordinates");
opt.zshift->type = TYPE_DOUBLE;
opt.zshift->required = NO;
opt.zshift->answer = "0";
opt.zshift->guisection = _("Height");
opt.height = G_define_option();
opt.height->key = "height";
opt.height->type = TYPE_DOUBLE;
opt.height->required = NO;
opt.height->multiple = NO;
opt.height->description = _("Fixed height for 3D vector features");
opt.height->guisection = _("Height");
opt.hcolumn = G_define_standard_option(G_OPT_DB_COLUMN);
opt.hcolumn->key = "height_column";
opt.hcolumn->multiple = NO;
opt.hcolumn->description = _("Name of attribute column with feature height");
opt.hcolumn->guisection = _("Height");
/* raster sampling */
opt.elevation = G_define_standard_option(G_OPT_R_ELEV);
opt.elevation->required = NO;
opt.elevation->description = _("Elevation raster map for height extraction");
opt.elevation->guisection = _("Elevation");
opt.interp = G_define_standard_option(G_OPT_R_INTERP_TYPE);
opt.interp->answer = "nearest";
opt.interp->guisection = _("Elevation");
opt.scale = G_define_option();
opt.scale->key = "scale";
opt.scale->type = TYPE_DOUBLE;
opt.scale->description = _("Scale factor sampled raster values");
opt.scale->answer = "1.0";
opt.scale->guisection = _("Elevation");
opt.null = G_define_option();
opt.null->key = "null_value";
opt.null->type = TYPE_DOUBLE;
opt.null->description =
_("Height for sampled raster NULL values");
opt.null->guisection = _("Elevation");
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (!opt.height->answer && !opt.hcolumn->answer) {
G_fatal_error(_("One of '%s' or '%s' parameters must be set"),
opt.height->key, opt.hcolumn->key);
}
sscanf(opt.zshift->answer, "%lf", &voffset);
G_debug(1, "voffset = %f", voffset);
if (opt.height->answer)
sscanf(opt.height->answer, "%lf", &objheight);
else
objheight = 0.;
G_debug(1, "objheight = %f", objheight);
objheight_default = objheight;
only_type = Vect_option_to_types(opt.type);
/* sampling method */
interp_method = Rast_option_to_interp_type(opt.interp);
/* used to scale sampled raster values */
scale = atof(opt.scale->answer);
/* is null value defined */
if (opt.null->answer)
null_val = atof(opt.null->answer);
/* trace elevation */
trace = flag.trace->answer ? TRUE : FALSE;
/* set input vector map name and mapset */
Vect_check_input_output_name(opt.input->answer, opt.output->answer, G_FATAL_EXIT);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_set_open_level(2); /* topology required for input */
/* opening input vector map */
if (Vect_open_old2(&In, opt.input->answer, "", opt.field->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), opt.input->answer);
Vect_set_error_handler_io(&In, &Out);
/* creating output vector map */
if (Vect_open_new(&Out, opt.output->answer, WITH_Z) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
opt.output->answer);
field = Vect_get_field_number(&In, opt.field->answer);
if ((opt.hcolumn->answer || opt.cats->answer || opt.where->answer) && field == -1) {
G_warning(_("Invalid layer number (%d). "
"Parameter '%s', '%s' or '%s' specified, assuming layer '1'."),
field, opt.hcolumn->key, opt.cats->key, opt.where->key);
field = 1;
}
/* set constraint for cats or where */
cat_list = NULL;
if (field > 0)
cat_list = Vect_cats_set_constraint(&In, field, opt.where->answer,
opt.cats->answer);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* opening database connection, if required */
if (opt.hcolumn->answer) {
int ctype;
dbColumn *column;
if ((Fi = Vect_get_field(&In, field)) == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
field);
if ((driver =
db_start_driver_open_database(Fi->driver, Fi->database)) == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
db_set_error_handler_driver(driver);
if (db_get_column(driver, Fi->table, opt.hcolumn->answer, &column) != DB_OK)
G_fatal_error(_("Column <%s> does not exist"),
opt.hcolumn->answer);
else
db_free_column(column);
ctype = db_column_Ctype(driver, Fi->table, opt.hcolumn->answer);
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_STRING &&
ctype != DB_C_TYPE_DOUBLE) {
G_fatal_error(_("Column <%s>: invalid data type"),
opt.hcolumn->answer);
}
}
/* do we work with elevation raster? */
fdrast = -1;
if (opt.elevation->answer) {
/* raster setup */
G_get_window(&window);
/* open the elev raster, and check for error condition */
fdrast = Rast_open_old(opt.elevation->answer, "");
}
/* if area */
if (only_type & GV_AREA) {
int area, nareas, centroid;
nareas = Vect_get_num_areas(&In);
G_debug(2, "n_areas = %d", nareas);
if (nareas > 0)
G_message(_("Extruding areas..."));
for (area = 1; area <= nareas; area++) {
G_debug(3, "area = %d", area);
G_percent(area, nareas, 2);
if (!Vect_area_alive(&In, area))
continue;
centroid = Vect_get_area_centroid(&In, area);
if (!centroid) {
G_warning(_("Skipping area %d without centroid"), area);
continue;
}
Vect_read_line(&In, NULL, Cats, centroid);
if (field > 0 && !Vect_cats_in_constraint(Cats, field, cat_list))
continue;
/* height attribute */
if (opt.hcolumn->answer) {
cat = Vect_get_area_cat(&In, area, field);
if (cat == -1) {
G_warning(_("No category defined for area %d. Using default fixed height %f."),
area, objheight_default);
objheight = objheight_default;
}
if (get_height(Fi, opt.hcolumn->answer,
driver, cat, &objheight) != 0) {
G_warning(_("Unable to fetch height from DB for area %d. Using default fixed height %f."),
area, objheight_default);
objheight = objheight_default;
}
} /* if opt.hcolumn->answer */
Vect_get_area_points(&In, area, Points);
G_debug(3, "area: %d height: %f", area, objheight);
extrude(&In, &Out, Cats, Points,
fdrast, trace, interp_method, scale,
opt.null->answer ? TRUE : FALSE, null_val,
objheight, voffset, &window, GV_AREA,
centroid);
} /* foreach area */
}
if (only_type > 0) {
int line, nlines;
int type;
G_debug(1, "other than areas");
/* loop through each line in the dataset */
nlines = Vect_get_num_lines(&In);
G_message(_("Extruding features..."));
for (line = 1; line <= nlines; line++) {
/* progress feedback */
G_percent(line, nlines, 2);
if (!Vect_line_alive(&In, line))
continue;
/* read line */
type = Vect_read_line(&In, Points, Cats, line);
if (!(type & only_type))
continue;
if (field > 0 && !Vect_cats_in_constraint(Cats, field, cat_list))
continue;
/* height attribute */
if (opt.hcolumn->answer) {
cat = Vect_get_line_cat(&In, line, field);
if (cat == -1) {
G_warning(_("No category defined for feature %d. Using default fixed height %f."),
line, objheight_default);
objheight = objheight_default;
}
if (get_height(Fi, opt.hcolumn->answer,
driver, cat, &objheight) != 0) {
G_warning(_("Unable to fetch height from DB for line %d. Using default fixed height %f."),
line, objheight_default);
objheight = objheight_default;
}
} /* if opt.hcolumn->answer */
extrude(&In, &Out, Cats, Points,
fdrast, trace, interp_method, scale,
opt.null->answer ? TRUE : FALSE, null_val,
objheight, voffset, &window, type, -1);
} /* for each line */
} /* else if area */
if (driver) {
db_close_database(driver);
db_shutdown_driver(driver);
}
G_important_message(_("Copying attribute table..."));
if (field < 0)
Vect_copy_tables(&In, &Out, 0);
else
Vect_copy_table_by_cat_list(&In, &Out, field, field, NULL,
GV_1TABLE, cat_list);
Vect_build(&Out);
/* header */
G_asprintf(&comment, "Generated by %s from vector map <%s>",
G_program_name(), Vect_get_full_name(&In));
Vect_set_comment(&Out, comment);
G_free(comment);
Vect_get_map_box(&Out, &map_box);
Vect_close(&In);
Vect_close(&Out);
Vect_destroy_line_struct(Points);
Vect_destroy_cats_struct(Cats);
G_done_msg("T: %f B: %f.", map_box.T, map_box.B);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Map_info In, Out, Buf;
struct line_pnts *Points;
struct line_cats *Cats, *BCats;
char bufname[GNAME_MAX];
struct GModule *module;
struct Option *in_opt, *out_opt, *type_opt, *dista_opt, *distb_opt,
*angle_opt;
struct Flag *straight_flag, *nocaps_flag;
struct Option *tol_opt, *bufcol_opt, *scale_opt, *field_opt;
int verbose;
double da, db, dalpha, tolerance, unit_tolerance;
int type;
int i, ret, nareas, area, nlines, line;
char *Areas, *Lines;
int field;
struct buf_contours *arr_bc;
struct buf_contours_pts arr_bc_pts;
int buffers_count = 0, line_id;
struct spatial_index si;
struct bound_box bbox;
/* Attributes if sizecol is used */
int nrec, ctype;
struct field_info *Fi;
dbDriver *Driver;
dbCatValArray cvarr;
double size_val, scale;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("geometry"));
G_add_keyword(_("buffer"));
module->description =
_("Creates a buffer around vector features of given type.");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
field_opt->guisection = _("Selection");
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->options = "point,line,boundary,centroid,area";
type_opt->answer = "point,line,area";
type_opt->guisection = _("Selection");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
dista_opt = G_define_option();
dista_opt->key = "distance";
dista_opt->type = TYPE_DOUBLE;
dista_opt->required = NO;
dista_opt->description =
_("Buffer distance along major axis in map units");
dista_opt->guisection = _("Distance");
distb_opt = G_define_option();
distb_opt->key = "minordistance";
distb_opt->type = TYPE_DOUBLE;
distb_opt->required = NO;
distb_opt->description =
_("Buffer distance along minor axis in map units");
distb_opt->guisection = _("Distance");
angle_opt = G_define_option();
angle_opt->key = "angle";
angle_opt->type = TYPE_DOUBLE;
angle_opt->required = NO;
angle_opt->answer = "0";
angle_opt->description = _("Angle of major axis in degrees");
angle_opt->guisection = _("Distance");
bufcol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
bufcol_opt->key = "bufcolumn";
bufcol_opt->description =
_("Name of column to use for buffer distances");
bufcol_opt->guisection = _("Distance");
scale_opt = G_define_option();
scale_opt->key = "scale";
scale_opt->type = TYPE_DOUBLE;
scale_opt->required = NO;
scale_opt->answer = "1.0";
scale_opt->description = _("Scaling factor for attribute column values");
scale_opt->guisection = _("Distance");
tol_opt = G_define_option();
tol_opt->key = "tolerance";
tol_opt->type = TYPE_DOUBLE;
tol_opt->required = NO;
tol_opt->answer = "0.01";
tol_opt->description =
_("Maximum distance between theoretical arc and polygon segments as multiple of buffer");
tol_opt->guisection = _("Distance");
straight_flag = G_define_flag();
straight_flag->key = 's';
straight_flag->description = _("Make outside corners straight");
nocaps_flag = G_define_flag();
nocaps_flag->key = 'c';
nocaps_flag->description = _("Don't make caps at the ends of polylines");
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
type = Vect_option_to_types(type_opt);
if ((dista_opt->answer && bufcol_opt->answer) ||
(!(dista_opt->answer || bufcol_opt->answer)))
G_fatal_error(_("Select a buffer distance/minordistance/angle "
"or column, but not both."));
if (bufcol_opt->answer)
G_warning(_("The bufcol option may contain bugs during the cleaning "
"step. If you encounter problems, use the debug "
"option or clean manually with v.clean tool=break; "
"v.category step=0; v.extract -d type=area"));
if (field_opt->answer)
field = Vect_get_field_number(&In, field_opt->answer);
else
field = -1;
if (bufcol_opt->answer && field == -1)
G_fatal_error(_("The bufcol option requires a valid layer."));
tolerance = atof(tol_opt->answer);
if (tolerance <= 0)
G_fatal_error(_("The tolerance must be > 0."));
if (adjust_tolerance(&tolerance))
G_warning(_("The tolerance was reset to %g"), tolerance);
scale = atof(scale_opt->answer);
if (scale <= 0.0)
G_fatal_error("Illegal scale value");
da = db = dalpha = 0;
if (dista_opt->answer) {
da = atof(dista_opt->answer);
if (distb_opt->answer)
db = atof(distb_opt->answer);
else
db = da;
if (angle_opt->answer)
dalpha = atof(angle_opt->answer);
else
dalpha = 0;
unit_tolerance = tolerance * MIN(da, db);
G_verbose_message(_("The tolerance in map units = %g"), unit_tolerance);
}
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
GV_FATAL_EXIT);
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
BCats = Vect_new_cats_struct();
Vect_set_open_level(2); /* topology required */
if (1 > Vect_open_old2(&In, in_opt->answer, "", field_opt->answer))
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
if (0 > Vect_open_new(&Out, out_opt->answer, WITHOUT_Z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
}
/* open tmp vector for buffers, needed for cleaning */
sprintf(bufname, "%s_tmp_%d", out_opt->answer, getpid());
if (0 > Vect_open_new(&Buf, bufname, 0)) {
Vect_close(&In);
Vect_close(&Out);
Vect_delete(out_opt->answer);
exit(EXIT_FAILURE);
}
Vect_build_partial(&Buf, GV_BUILD_BASE);
/* check and load attribute column data */
if (bufcol_opt->answer) {
db_CatValArray_init(&cvarr);
Fi = Vect_get_field(&In, field);
if (Fi == NULL)
G_fatal_error(_("Database connection not defined for layer %d"),
field);
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);
/* Note do not check if the column exists in the table because it may be expression */
/* TODO: only select values we need instead of all in column */
nrec =
db_select_CatValArray(Driver, Fi->table, Fi->key,
bufcol_opt->answer, NULL, &cvarr);
if (nrec < 0)
G_fatal_error(_("Unable to select data from table <%s>"),
Fi->table);
G_debug(2, "%d records selected from table", nrec);
ctype = cvarr.ctype;
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("Column type not supported"));
db_close_database_shutdown_driver(Driver);
/* Output cats/values list */
for (i = 0; i < cvarr.n_values; i++) {
if (ctype == DB_C_TYPE_INT) {
G_debug(4, "cat = %d val = %d", cvarr.value[i].cat,
cvarr.value[i].val.i);
}
else if (ctype == DB_C_TYPE_DOUBLE) {
G_debug(4, "cat = %d val = %f", cvarr.value[i].cat,
cvarr.value[i].val.d);
}
}
}
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* Create buffers' boundaries */
nlines = nareas = 0;
if ((type & GV_POINTS) || (type & GV_LINES))
nlines += Vect_get_num_primitives(&In, type);
if (type & GV_AREA)
nareas = Vect_get_num_areas(&In);
if (nlines + nareas == 0) {
G_warning(_("No features available for buffering. "
"Check type option and features available in the input vector."));
exit(EXIT_SUCCESS);
}
buffers_count = 1;
arr_bc = G_malloc((nlines + nareas + 1) * sizeof(struct buf_contours));
Vect_spatial_index_init(&si, 0);
/* Lines (and Points) */
if ((type & GV_POINTS) || (type & GV_LINES)) {
int ltype;
if (nlines > 0)
G_message(_("Buffering lines..."));
for (line = 1; line <= nlines; line++) {
int cat;
G_debug(2, "line = %d", line);
G_percent(line, nlines, 2);
if (!Vect_line_alive(&In, line))
continue;
ltype = Vect_read_line(&In, Points, Cats, line);
if (!(ltype & type))
continue;
if (field > 0 && !Vect_cat_get(Cats, field, &cat))
continue;
if (bufcol_opt->answer) {
ret = db_CatValArray_get_value_di(&cvarr, cat, &size_val);
if (ret != DB_OK) {
G_warning(_("No record for category %d in table <%s>"),
cat, Fi->table);
continue;
}
if (size_val < 0.0) {
G_warning(_("Attribute is of invalid size (%.3f) for category %d"),
size_val, cat);
continue;
}
if (size_val == 0.0)
continue;
da = size_val * scale;
db = da;
dalpha = 0;
unit_tolerance = tolerance * MIN(da, db);
G_debug(2, " dynamic buffer size = %.2f", da);
G_debug(2, _("The tolerance in map units: %g"),
unit_tolerance);
}
Vect_line_prune(Points);
if (ltype & GV_POINTS || Points->n_points == 1) {
Vect_point_buffer2(Points->x[0], Points->y[0], da, db, dalpha,
!(straight_flag->answer), unit_tolerance,
&(arr_bc_pts.oPoints));
Vect_write_line(&Out, GV_BOUNDARY, arr_bc_pts.oPoints, BCats);
line_id = Vect_write_line(&Buf, GV_BOUNDARY, arr_bc_pts.oPoints, Cats);
Vect_destroy_line_struct(arr_bc_pts.oPoints);
/* add buffer to spatial index */
Vect_get_line_box(&Buf, line_id, &bbox);
Vect_spatial_index_add_item(&si, buffers_count, &bbox);
arr_bc[buffers_count].outer = line_id;
arr_bc[buffers_count].inner_count = 0;
arr_bc[buffers_count].inner = NULL;
buffers_count++;
}
else {
Vect_line_buffer2(Points, da, db, dalpha,
!(straight_flag->answer),
!(nocaps_flag->answer), unit_tolerance,
&(arr_bc_pts.oPoints),
&(arr_bc_pts.iPoints),
&(arr_bc_pts.inner_count));
Vect_write_line(&Out, GV_BOUNDARY, arr_bc_pts.oPoints, BCats);
line_id = Vect_write_line(&Buf, GV_BOUNDARY, arr_bc_pts.oPoints, Cats);
Vect_destroy_line_struct(arr_bc_pts.oPoints);
/* add buffer to spatial index */
Vect_get_line_box(&Buf, line_id, &bbox);
Vect_spatial_index_add_item(&si, buffers_count, &bbox);
arr_bc[buffers_count].outer = line_id;
arr_bc[buffers_count].inner_count = arr_bc_pts.inner_count;
if (arr_bc_pts.inner_count > 0) {
arr_bc[buffers_count].inner = G_malloc(arr_bc_pts.inner_count * sizeof(int));
for (i = 0; i < arr_bc_pts.inner_count; i++) {
Vect_write_line(&Out, GV_BOUNDARY, arr_bc_pts.iPoints[i], BCats);
line_id = Vect_write_line(&Buf, GV_BOUNDARY, arr_bc_pts.iPoints[i], Cats);
Vect_destroy_line_struct(arr_bc_pts.iPoints[i]);
/* add buffer to spatial index */
Vect_get_line_box(&Buf, line_id, &bbox);
Vect_spatial_index_add_item(&si, buffers_count, &bbox);
arr_bc[buffers_count].inner[i] = line_id;
}
G_free(arr_bc_pts.iPoints);
}
buffers_count++;
}
}
}
/* Areas */
if (type & GV_AREA) {
int centroid;
if (nareas > 0)
G_message(_("Buffering areas..."));
for (area = 1; area <= nareas; area++) {
int cat;
G_percent(area, nareas, 2);
if (!Vect_area_alive(&In, area))
continue;
centroid = Vect_get_area_centroid(&In, area);
if (centroid == 0)
continue;
Vect_read_line(&In, NULL, Cats, centroid);
if (field > 0 && !Vect_cat_get(Cats, field, &cat))
continue;
if (bufcol_opt->answer) {
ret = db_CatValArray_get_value_di(&cvarr, cat, &size_val);
if (ret != DB_OK) {
G_warning(_("No record for category %d in table <%s>"),
cat, Fi->table);
continue;
}
if (size_val < 0.0) {
G_warning(_("Attribute is of invalid size (%.3f) for category %d"),
size_val, cat);
continue;
}
if (size_val == 0.0)
continue;
da = size_val * scale;
db = da;
dalpha = 0;
unit_tolerance = tolerance * MIN(da, db);
G_debug(2, " dynamic buffer size = %.2f", da);
G_debug(2, _("The tolerance in map units: %g"),
unit_tolerance);
}
Vect_area_buffer2(&In, area, da, db, dalpha,
!(straight_flag->answer),
!(nocaps_flag->answer), unit_tolerance,
&(arr_bc_pts.oPoints),
&(arr_bc_pts.iPoints),
&(arr_bc_pts.inner_count));
Vect_write_line(&Out, GV_BOUNDARY, arr_bc_pts.oPoints, BCats);
line_id = Vect_write_line(&Buf, GV_BOUNDARY, arr_bc_pts.oPoints, Cats);
Vect_destroy_line_struct(arr_bc_pts.oPoints);
/* add buffer to spatial index */
Vect_get_line_box(&Buf, line_id, &bbox);
Vect_spatial_index_add_item(&si, buffers_count, &bbox);
arr_bc[buffers_count].outer = line_id;
arr_bc[buffers_count].inner_count = arr_bc_pts.inner_count;
if (arr_bc_pts.inner_count > 0) {
arr_bc[buffers_count].inner = G_malloc(arr_bc_pts.inner_count * sizeof(int));
for (i = 0; i < arr_bc_pts.inner_count; i++) {
Vect_write_line(&Out, GV_BOUNDARY, arr_bc_pts.iPoints[i], BCats);
line_id = Vect_write_line(&Buf, GV_BOUNDARY, arr_bc_pts.iPoints[i], Cats);
Vect_destroy_line_struct(arr_bc_pts.iPoints[i]);
/* add buffer to spatial index */
Vect_get_line_box(&Buf, line_id, &bbox);
Vect_spatial_index_add_item(&si, buffers_count, &bbox);
arr_bc[buffers_count].inner[i] = line_id;
}
G_free(arr_bc_pts.iPoints);
}
buffers_count++;
}
}
verbose = G_verbose();
G_message(_("Cleaning buffers..."));
/* Break lines */
G_message(_("Building parts of topology..."));
Vect_build_partial(&Out, GV_BUILD_BASE);
G_message(_("Snapping boundaries..."));
Vect_snap_lines(&Out, GV_BOUNDARY, 1e-7, NULL);
G_message(_("Breaking polygons..."));
Vect_break_polygons(&Out, GV_BOUNDARY, NULL);
G_message(_("Removing duplicates..."));
Vect_remove_duplicates(&Out, GV_BOUNDARY, NULL);
do {
G_message(_("Breaking boundaries..."));
Vect_break_lines(&Out, GV_BOUNDARY, NULL);
G_message(_("Removing duplicates..."));
Vect_remove_duplicates(&Out, GV_BOUNDARY, NULL);
G_message(_("Cleaning boundaries at nodes"));
} while (Vect_clean_small_angles_at_nodes(&Out, GV_BOUNDARY, NULL) > 0);
/* Dangles and bridges don't seem to be necessary if snapping is small enough. */
/* Still needed for larger buffer distances ? */
/*
G_message(_("Removing dangles..."));
Vect_remove_dangles(&Out, GV_BOUNDARY, -1, NULL);
G_message (_("Removing bridges..."));
Vect_remove_bridges(&Out, NULL);
*/
G_message(_("Attaching islands..."));
Vect_build_partial(&Out, GV_BUILD_ATTACH_ISLES);
/* Calculate new centroids for all areas */
nareas = Vect_get_num_areas(&Out);
Areas = (char *)G_calloc(nareas + 1, sizeof(char));
G_message(_("Calculating centroids for areas..."));
G_percent(0, nareas, 2);
for (area = 1; area <= nareas; area++) {
double x, y;
G_percent(area, nareas, 2);
G_debug(3, "area = %d", area);
if (!Vect_area_alive(&Out, area))
continue;
ret = Vect_get_point_in_area(&Out, area, &x, &y);
if (ret < 0) {
G_warning(_("Cannot calculate area centroid"));
continue;
}
ret = point_in_buffer(arr_bc, &si, &Buf, x, y);
if (ret) {
G_debug(3, " -> in buffer");
Areas[area] = 1;
}
}
/* Make a list of boundaries to be deleted (both sides inside) */
nlines = Vect_get_num_lines(&Out);
G_debug(3, "nlines = %d", nlines);
Lines = (char *)G_calloc(nlines + 1, sizeof(char));
G_message(_("Generating list of boundaries to be deleted..."));
for (line = 1; line <= nlines; line++) {
int j, side[2], areas[2];
G_percent(line, nlines, 2);
G_debug(3, "line = %d", line);
if (!Vect_line_alive(&Out, line))
continue;
Vect_get_line_areas(&Out, line, &side[0], &side[1]);
for (j = 0; j < 2; j++) {
if (side[j] == 0) { /* area/isle not build */
areas[j] = 0;
}
else if (side[j] > 0) { /* area */
areas[j] = side[j];
}
else { /* < 0 -> island */
areas[j] = Vect_get_isle_area(&Out, abs(side[j]));
}
}
G_debug(3, " areas = %d , %d -> Areas = %d, %d", areas[0], areas[1],
Areas[areas[0]], Areas[areas[1]]);
if (Areas[areas[0]] && Areas[areas[1]])
Lines[line] = 1;
}
G_free(Areas);
/* Delete boundaries */
G_message(_("Deleting boundaries..."));
for (line = 1; line <= nlines; line++) {
G_percent(line, nlines, 2);
if (!Vect_line_alive(&Out, line))
continue;
if (Lines[line]) {
G_debug(3, " delete line %d", line);
Vect_delete_line(&Out, line);
}
else {
/* delete incorrect boundaries */
int side[2];
Vect_get_line_areas(&Out, line, &side[0], &side[1]);
if (!side[0] && !side[1])
Vect_delete_line(&Out, line);
}
}
G_free(Lines);
/* Create new centroids */
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, 1);
nareas = Vect_get_num_areas(&Out);
G_message(_("Calculating centroids for areas..."));
for (area = 1; area <= nareas; area++) {
double x, y;
G_percent(area, nareas, 2);
G_debug(3, "area = %d", area);
if (!Vect_area_alive(&Out, area))
continue;
ret = Vect_get_point_in_area(&Out, area, &x, &y);
if (ret < 0) {
G_warning(_("Cannot calculate area centroid"));
continue;
}
ret = point_in_buffer(arr_bc, &si, &Buf, x, y);
if (ret) {
Vect_reset_line(Points);
Vect_append_point(Points, x, y, 0.);
Vect_write_line(&Out, GV_CENTROID, Points, Cats);
}
}
/* free arr_bc[] */
/* will only slow down the module
for (i = 0; i < buffers_count; i++) {
Vect_destroy_line_struct(arr_bc[i].oPoints);
for (j = 0; j < arr_bc[i].inner_count; j++)
Vect_destroy_line_struct(arr_bc[i].iPoints[j]);
G_free(arr_bc[i].iPoints);
} */
Vect_spatial_index_destroy(&si);
Vect_close(&Buf);
Vect_delete(bufname);
G_set_verbose(verbose);
Vect_close(&In);
Vect_build_partial(&Out, GV_BUILD_NONE);
Vect_build(&Out);
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int i;
int **cats, *ncats, nfields, *fields;
struct Flag *line_flag;
/* struct Flag *all_flag; */
struct Option *in_opt, *out_opt;
struct Flag *table_flag;
struct GModule *module;
struct line_pnts *Points;
struct line_cats *Cats;
int node, nnodes;
COOR *coor;
int ncoor, acoor;
int line, nlines, type, ctype, area, nareas;
int err_boundaries, err_centr_out, err_centr_dupl, err_nocentr;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("geometry"));
G_add_keyword(_("triangulation"));
module->description = _("Creates a Voronoi diagram from an input vector "
"map containing points or centroids.");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
/*
all_flag = G_define_flag ();
all_flag->key = 'a';
all_flag->description = _("Use all points (do not limit to current region)");
*/
line_flag = G_define_flag();
line_flag->key = 'l';
line_flag->description =
_("Output tessellation as a graph (lines), not areas");
table_flag = G_define_flag();
table_flag->key = 't';
table_flag->description = _("Do not create attribute table");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (line_flag->answer)
Type = GV_LINE;
else
Type = GV_BOUNDARY;
All = 0;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* open files */
Vect_set_open_level(2);
Vect_open_old(&In, in_opt->answer, "");
if (Vect_open_new(&Out, out_opt->answer, 0) < 0)
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* initialize working region */
G_get_window(&Window);
Vect_region_box(&Window, &Box);
Box.T = 0.5;
Box.B = -0.5;
freeinit(&sfl, sizeof(struct Site));
G_message(_("Reading sites..."));
readsites();
siteidx = 0;
geominit();
triangulate = 0;
plot = 0;
debug = 0;
G_message(_("Voronoi triangulation..."));
voronoi(triangulate, nextone);
/* Close free ends by current region */
Vect_build_partial(&Out, GV_BUILD_BASE);
ncoor = 0;
acoor = 100;
coor = (COOR *) G_malloc(sizeof(COOR) * acoor);
nnodes = Vect_get_num_nodes(&Out);
for (node = 1; node <= nnodes; node++) {
double x, y;
if (Vect_get_node_n_lines(&Out, node) < 2) { /* add coordinates */
Vect_get_node_coor(&Out, node, &x, &y, NULL);
if (ncoor == acoor - 5) { /* always space for 5 region corners */
acoor += 100;
coor = (COOR *) G_realloc(coor, sizeof(COOR) * acoor);
}
coor[ncoor].x = x;
coor[ncoor].y = y;
ncoor++;
}
}
/* Add region corners */
coor[ncoor].x = Box.W;
coor[ncoor].y = Box.S;
ncoor++;
coor[ncoor].x = Box.E;
coor[ncoor].y = Box.S;
ncoor++;
coor[ncoor].x = Box.E;
coor[ncoor].y = Box.N;
ncoor++;
coor[ncoor].x = Box.W;
coor[ncoor].y = Box.N;
ncoor++;
/* Sort */
qsort(coor, ncoor, sizeof(COOR), (void *)cmp);
/* add last (first corner) */
coor[ncoor].x = Box.W;
coor[ncoor].y = Box.S;
ncoor++;
for (i = 1; i < ncoor; i++) {
if (coor[i].x == coor[i - 1].x && coor[i].y == coor[i - 1].y)
continue; /* duplicate */
Vect_reset_line(Points);
Vect_append_point(Points, coor[i].x, coor[i].y, 0.0);
Vect_append_point(Points, coor[i - 1].x, coor[i - 1].y, 0.0);
Vect_write_line(&Out, Type, Points, Cats);
}
G_free(coor);
/* Copy input points as centroids */
nfields = Vect_cidx_get_num_fields(&In);
cats = (int **)G_malloc(nfields * sizeof(int *));
ncats = (int *)G_malloc(nfields * sizeof(int));
fields = (int *)G_malloc(nfields * sizeof(int));
for (i = 0; i < nfields; i++) {
ncats[i] = 0;
cats[i] =
(int *)G_malloc(Vect_cidx_get_num_cats_by_index(&In, i) *
sizeof(int));
fields[i] = Vect_cidx_get_field_number(&In, i);
}
if (line_flag->answer)
ctype = GV_POINT;
else
ctype = GV_CENTROID;
nlines = Vect_get_num_lines(&In);
G_message(_("Writing sites to output..."));
for (line = 1; line <= nlines; line++) {
G_percent(line, nlines, 2);
type = Vect_read_line(&In, Points, Cats, line);
if (!(type & GV_POINTS))
continue;
if (!Vect_point_in_box(Points->x[0], Points->y[0], 0.0, &Box))
continue;
Vect_write_line(&Out, ctype, Points, Cats);
for (i = 0; i < Cats->n_cats; i++) {
int f, j;
f = -1;
for (j = 0; j < nfields; j++) { /* find field */
if (fields[j] == Cats->field[i]) {
f = j;
break;
}
}
if (f > -1) {
cats[f][ncats[f]] = Cats->cat[i];
ncats[f]++;
}
}
}
/* Copy tables */
if (!(table_flag->answer)) {
int ttype, ntabs = 0;
struct field_info *IFi, *OFi;
/* Number of output tabs */
for (i = 0; i < Vect_get_num_dblinks(&In); i++) {
int f, j;
IFi = Vect_get_dblink(&In, i);
f = -1;
for (j = 0; j < nfields; j++) { /* find field */
if (fields[j] == IFi->number) {
f = j;
break;
}
}
if (f > -1) {
if (ncats[f] > 0)
ntabs++;
}
}
if (ntabs > 1)
ttype = GV_MTABLE;
else
ttype = GV_1TABLE;
for (i = 0; i < nfields; i++) {
int ret;
if (fields[i] == 0)
continue;
G_message(_("Layer %d"), fields[i]);
/* Make a list of categories */
IFi = Vect_get_field(&In, fields[i]);
if (!IFi) { /* no table */
G_message(_("No table"));
continue;
}
OFi =
Vect_default_field_info(&Out, IFi->number, IFi->name, ttype);
ret =
db_copy_table_by_ints(IFi->driver, IFi->database, IFi->table,
OFi->driver,
Vect_subst_var(OFi->database, &Out),
OFi->table, IFi->key, cats[i],
ncats[i]);
if (ret == DB_FAILED) {
G_warning(_("Cannot copy table"));
}
else {
Vect_map_add_dblink(&Out, OFi->number, OFi->name, OFi->table,
IFi->key, OFi->database, OFi->driver);
}
}
}
Vect_close(&In);
/* cleaning part 1: count errors */
Vect_build_partial(&Out, GV_BUILD_CENTROIDS);
err_boundaries = err_centr_out = err_centr_dupl = err_nocentr = 0;
nlines = Vect_get_num_lines(&Out);
for (line = 1; line <= nlines; line++) {
if (!Vect_line_alive(&Out, line))
continue;
type = Vect_get_line_type(&Out, line);
if (type == GV_BOUNDARY) {
int left, right;
Vect_get_line_areas(&Out, line, &left, &right);
if (left == 0 || right == 0) {
G_debug(3, "line = %d left = %d right = %d", line,
left, right);
err_boundaries++;
}
}
if (type == GV_CENTROID) {
area = Vect_get_centroid_area(&Out, line);
if (area == 0)
err_centr_out++;
else if (area < 0)
err_centr_dupl++;
}
}
err_nocentr = 0;
nareas = Vect_get_num_areas(&Out);
for (area = 1; area <= nareas; area++) {
if (!Vect_area_alive(&Out, area))
continue;
line = Vect_get_area_centroid(&Out, area);
if (line == 0)
err_nocentr++;
}
/* cleaning part 2: snap */
if (err_nocentr || err_centr_dupl || err_centr_out) {
int nmod;
G_important_message(_("Output needs topological cleaning"));
Vect_snap_lines(&Out, GV_BOUNDARY, 1e-7, NULL);
do {
Vect_break_lines(&Out, GV_BOUNDARY, NULL);
Vect_remove_duplicates(&Out, GV_BOUNDARY, NULL);
nmod =
Vect_clean_small_angles_at_nodes(&Out, GV_BOUNDARY, NULL);
} while (nmod > 0);
err_boundaries = 0;
nlines = Vect_get_num_lines(&Out);
for (line = 1; line <= nlines; line++) {
if (!Vect_line_alive(&Out, line))
continue;
type = Vect_get_line_type(&Out, line);
if (type == GV_BOUNDARY) {
int left, right;
Vect_get_line_areas(&Out, line, &left, &right);
if (left == 0 || right == 0) {
G_debug(3, "line = %d left = %d right = %d", line,
left, right);
err_boundaries++;
}
}
}
}
/* cleaning part 3: remove remaining incorrect boundaries */
if (err_boundaries) {
G_important_message(_("Removing incorrect boundaries from output"));
nlines = Vect_get_num_lines(&Out);
for (line = 1; line <= nlines; line++) {
if (!Vect_line_alive(&Out, line))
continue;
type = Vect_get_line_type(&Out, line);
if (type == GV_BOUNDARY) {
int left, right;
Vect_get_line_areas(&Out, line, &left, &right);
/* &&, not ||, no typo */
if (left == 0 && right == 0) {
G_debug(3, "line = %d left = %d right = %d", line,
left, right);
Vect_delete_line(&Out, line);
}
}
}
}
/* build clean topology */
Vect_build_partial(&Out, GV_BUILD_NONE);
Vect_build(&Out);
Vect_close(&Out);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Map_info in, out, vis;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *input, *output; /* The input map */
struct Option *coor, *ovis;
struct Point *points;
struct Line *lines;
int num_points, num_lines;
int n = 0;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("network"));
G_add_keyword(_("shortest path"));
G_add_keyword(_("visibility"));
module->description = _("Performs visibility graph construction.");
/* define the arguments needed */
input = G_define_standard_option(G_OPT_V_INPUT);
output = G_define_standard_option(G_OPT_V_OUTPUT);
coor = G_define_standard_option(G_OPT_M_COORDS);
ovis = G_define_standard_option(G_OPT_V_MAP);
ovis->key = "visibility";
ovis->required = NO;
ovis->label = _("Name of input vector map containing visible points");
ovis->description = _("Add points after computing the visibility graph");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
Vect_check_input_output_name(input->answer, output->answer,
G_FATAL_EXIT);
Vect_set_open_level(2);
if (Vect_open_old(&in, input->answer, "") < 1) /* opens the map */
G_fatal_error(_("Unable to open vector map <%s>"), input->answer);
if (Vect_open_new(&out, output->answer, WITHOUT_Z) < 0) {
Vect_close(&in);
G_fatal_error(_("Unable to create vector map <%s>"), output->answer);
}
if (ovis->answer != NULL) {
if (Vect_open_old(&vis, ovis->answer, "") < 1)
G_fatal_error(_("Unable to open vector map <%s>"), ovis->answer);
if (Vect_copy_map_lines(&vis, &out) > 0)
G_fatal_error(_("Unable to copy elements from vector map <%s>"),
ovis->answer);
}
if (G_projection() == PROJECTION_LL)
G_warning(_("Lat-long projection"));
/* counting how many points and lines we have to allocate */
count(&in, &num_points, &num_lines);
/* modify the number if we have new points to add */
if (coor->answers != NULL)
num_points += count_new(coor->answers);
/* and allocate */
points = G_malloc(num_points * sizeof(struct Point));
lines = G_malloc(num_lines * sizeof(struct Line));
/* and finally set the lines */
load_lines(&in, &points, &num_points, &lines, &num_lines);
if (coor->answers != NULL)
add_points(coor->answers, &points, &num_points);
if (ovis->answer == NULL)
construct_visibility(points, num_points, lines, num_lines, &out);
else
visibility_points(points, num_points, lines, num_lines, &out, n);
G_free(points);
G_free(lines);
Vect_copy_head_data(&in, &out);
Vect_hist_copy(&in, &out);
Vect_hist_command(&out);
Vect_build(&out);
Vect_close(&out);
Vect_close(&in);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Map_info In, Out, cut_map;
static struct line_pnts *Points;
struct line_cats *Cats;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out, *cut_out;
struct Option *afield_opt, *nfield_opt, *abcol, *afcol, *ncol;
struct Option *catsource_opt, *wheresource_opt;
struct Option *catsink_opt, *wheresink_opt;
int with_z;
int afield, nfield, mask_type;
struct varray *varray_source, *varray_sink;
dglGraph_s *graph;
int i, nlines, *flow, total_flow;
struct ilist *source_list, *sink_list, *cut;
int find_cut;
char buf[2000];
/* Attribute table */
dbString sql;
dbDriver *driver;
struct field_info *Fi;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("network"));
G_add_keyword(_("flow"));
module->description =
_("Computes the maximum flow between two sets of nodes in the network.");
/* Define the different options as defined in gis.h */
map_in = G_define_standard_option(G_OPT_V_INPUT);
afield_opt = G_define_standard_option(G_OPT_V_FIELD);
afield_opt->key = "arc_layer";
afield_opt->answer = "1";
afield_opt->label = _("Arc layer");
afield_opt->guisection = _("Cost");
nfield_opt = G_define_standard_option(G_OPT_V_FIELD);
nfield_opt->key = "node_layer";
nfield_opt->answer = "2";
nfield_opt->label = _("Node layer");
nfield_opt->guisection = _("Cost");
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
cut_out = G_define_standard_option(G_OPT_V_OUTPUT);
cut_out->key = "cut";
cut_out->description =
_("Name for output vector map containing a minimum cut");
afcol = G_define_standard_option(G_OPT_DB_COLUMN);
afcol->key = "arc_column";
afcol->required = NO;
afcol->description =
_("Arc forward/both direction(s) cost column (number)");
afcol->guisection = _("Cost");
abcol = G_define_standard_option(G_OPT_DB_COLUMN);
abcol->key = "arc_backward_column";
abcol->required = NO;
abcol->description = _("Arc backward direction cost column (number)");
abcol->guisection = _("Cost");
ncol = G_define_standard_option(G_OPT_DB_COLUMN);
ncol->key = "node_column";
ncol->required = NO;
ncol->description = _("Node cost column (number)");
ncol->guisection = _("Cost");
catsource_opt = G_define_standard_option(G_OPT_V_CATS);
catsource_opt->key = "source_cats";
catsource_opt->label = _("Source category values");
catsource_opt->guisection = _("Source");
wheresource_opt = G_define_standard_option(G_OPT_DB_WHERE);
wheresource_opt->key = "source_where";
wheresource_opt->label =
_("Source WHERE conditions of SQL statement without 'where' keyword");
wheresource_opt->guisection = _("Source");
catsink_opt = G_define_standard_option(G_OPT_V_CATS);
catsink_opt->key = "sink_cats";
catsink_opt->label = _("Sink category values");
catsink_opt->guisection = _("Sink");
wheresink_opt = G_define_standard_option(G_OPT_DB_WHERE);
wheresink_opt->key = "sink_where";
wheresink_opt->label =
_("Sink WHERE conditions of SQL statement without 'where' keyword");
wheresink_opt->guisection = _("Sink");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
find_cut = (cut_out->answer[0]);
/* TODO: make an option for this */
mask_type = GV_LINE | GV_BOUNDARY;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_check_input_output_name(map_in->answer, map_out->answer,
G_FATAL_EXIT);
Vect_set_open_level(2);
if (1 > Vect_open_old(&In, map_in->answer, ""))
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
with_z = Vect_is_3d(&In);
if (0 > Vect_open_new(&Out, map_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), map_out->answer);
}
if (find_cut && 0 > Vect_open_new(&cut_map, cut_out->answer, with_z)) {
Vect_close(&In);
Vect_close(&Out);
G_fatal_error(_("Unable to create vector map <%s>"), cut_out->answer);
}
/* parse filter option and select appropriate lines */
afield = Vect_get_field_number(&In, afield_opt->answer);
nfield = Vect_get_field_number(&In, nfield_opt->answer);
/* Create table */
Fi = Vect_default_field_info(&Out, 1, NULL, GV_1TABLE);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, GV_KEY_COLUMN, Fi->database,
Fi->driver);
db_init_string(&sql);
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);
db_set_error_handler_driver(driver);
sprintf(buf, "create table %s (cat integer, flow double precision)",
Fi->table);
db_set_string(&sql, buf);
G_debug(2, "%s", db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
db_close_database_shutdown_driver(driver);
G_fatal_error(_("Unable to create table: '%s'"), db_get_string(&sql));
}
if (db_create_index2(driver, Fi->table, GV_KEY_COLUMN) != DB_OK)
G_warning(_("Cannot create index"));
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT, DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Cannot grant privileges on table <%s>"), Fi->table);
db_begin_transaction(driver);
source_list = Vect_new_list();
sink_list = Vect_new_list();
if (NetA_initialise_varray
(&In, nfield, GV_POINT,
wheresource_opt->answer, catsource_opt->answer, &varray_source) <= 0) {
G_fatal_error(_("No source features selected. "
"Please check options '%s', '%s'."),
catsource_opt->key, wheresource_opt->key);
}
if (NetA_initialise_varray
(&In, nfield, GV_POINT, wheresink_opt->answer,
catsink_opt->answer, &varray_sink) <= 0) {
G_fatal_error(_("No sink features selected. "
"Please check options '%s', '%s'."),
catsink_opt->key, wheresink_opt->key);
}
NetA_varray_to_nodes(&In, varray_source, source_list, NULL);
NetA_varray_to_nodes(&In, varray_sink, sink_list, NULL);
if (source_list->n_values == 0)
G_fatal_error(_("No sources"));
if (sink_list->n_values == 0)
G_fatal_error(_("No sinks"));
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
if (0 != Vect_net_build_graph(&In, mask_type, afield, nfield, afcol->answer, abcol->answer,
ncol->answer, 0, 0))
G_fatal_error(_("Unable to build graph for vector map <%s>"), Vect_get_full_name(&In));
graph = Vect_net_get_graph(&In);
nlines = Vect_get_num_lines(&In);
flow = (int *)G_calloc(nlines + 1, sizeof(int));
if (!flow)
G_fatal_error(_("Out of memory"));
total_flow = NetA_flow(graph, source_list, sink_list, flow);
G_debug(3, "Max flow: %d", total_flow);
if (find_cut) {
cut = Vect_new_list();
total_flow = NetA_min_cut(graph, source_list, sink_list, flow, cut);
G_debug(3, "Min cut: %d", total_flow);
}
G_message(_("Writing the output..."));
G_percent_reset();
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 1);
int type = Vect_read_line(&In, Points, Cats, i);
Vect_write_line(&Out, type, Points, Cats);
if (type == GV_LINE) {
int cat;
Vect_cat_get(Cats, afield, &cat);
if (cat == -1)
continue; /*TODO: warning? */
sprintf(buf, "insert into %s values (%d, %f)", Fi->table, cat,
flow[i] / (double)In.dgraph.cost_multip);
db_set_string(&sql, buf);
G_debug(3, "%s", db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
db_close_database_shutdown_driver(driver);
G_fatal_error(_("Cannot insert new record: %s"),
db_get_string(&sql));
};
}
}
if (find_cut) {
for (i = 0; i < cut->n_values; i++) {
int type = Vect_read_line(&In, Points, Cats, cut->value[i]);
Vect_write_line(&cut_map, type, Points, Cats);
}
Vect_destroy_list(cut);
Vect_build(&cut_map);
Vect_close(&cut_map);
}
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
G_free(flow);
Vect_destroy_list(source_list);
Vect_destroy_list(sink_list);
Vect_build(&Out);
Vect_close(&In);
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Map_info In, Out;
static struct line_pnts *Points;
struct line_cats *Cats;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out;
struct Option *afield_opt, *nfield_opt, *abcol, *afcol, *ncol,
*method_opt;
int with_z;
int afield, nfield, mask_type;
dglGraph_s *graph;
int i, bridges, articulations;
struct ilist *bridge_list, *articulation_list;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("network"));
G_add_keyword(_("articulation points"));
module->description =
_("Computes bridges and articulation points in the network.");
/* Define the different options as defined in gis.h */
map_in = G_define_standard_option(G_OPT_V_INPUT);
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
afield_opt = G_define_standard_option(G_OPT_V_FIELD);
afield_opt->key = "alayer";
afield_opt->answer = "1";
afield_opt->description = _("Arc layer");
afield_opt->guisection = _("Cost");
nfield_opt = G_define_standard_option(G_OPT_V_FIELD);
nfield_opt->key = "nlayer";
nfield_opt->answer = "2";
nfield_opt->description = _("Node layer");
nfield_opt->guisection = _("Cost");
afcol = G_define_standard_option(G_OPT_DB_COLUMN);
afcol->key = "afcolumn";
afcol->required = NO;
afcol->description =
_("Arc forward/both direction(s) cost column (number)");
afcol->guisection = _("Cost");
abcol = G_define_standard_option(G_OPT_DB_COLUMN);
abcol->key = "abcolumn";
abcol->required = NO;
abcol->description = _("Arc backward direction cost column (number)");
abcol->guisection = _("Cost");
ncol = G_define_option();
ncol->key = "ncolumn";
ncol->type = TYPE_STRING;
ncol->required = NO;
ncol->description = _("Node cost column (number)");
ncol->guisection = _("Cost");
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = YES;
method_opt->multiple = NO;
method_opt->options = "bridge,articulation";
method_opt->descriptions = _("bridge;Finds bridges;"
"articulation;Finds articulation points;");
method_opt->description = _("Feature type");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* TODO: make an option for this */
mask_type = GV_LINE | GV_BOUNDARY;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_check_input_output_name(map_in->answer, map_out->answer,
GV_FATAL_EXIT);
Vect_set_open_level(2);
if (1 > Vect_open_old(&In, map_in->answer, ""))
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
with_z = Vect_is_3d(&In);
if (0 > Vect_open_new(&Out, map_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), map_out->answer);
}
/* parse filter option and select appropriate lines */
afield = Vect_get_field_number(&In, afield_opt->answer);
nfield = Vect_get_field_number(&In, nfield_opt->answer);
Vect_net_build_graph(&In, mask_type, afield, nfield, afcol->answer,
abcol->answer, ncol->answer, 0, 0);
graph = &(In.graph);
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
if (method_opt->answer[0] == 'b') {
bridge_list = Vect_new_list();
bridges = NetA_compute_bridges(graph, bridge_list);
G_debug(3, "Bridges: %d", bridges);
for (i = 0; i < bridges; i++) {
int type =
Vect_read_line(&In, Points, Cats, abs(bridge_list->value[i]));
Vect_write_line(&Out, type, Points, Cats);
}
Vect_destroy_list(bridge_list);
}
else {
articulation_list = Vect_new_list();
articulations = NetA_articulation_points(graph, articulation_list);
G_debug(3, "Articulation points: %d", articulations);
for (i = 0; i < articulations; i++) {
double x, y, z;
Vect_get_node_coor(&In, articulation_list->value[i], &x, &y, &z);
Vect_reset_line(Points);
Vect_append_point(Points, x, y, z);
Vect_write_line(&Out, GV_POINT, Points, Cats);
}
Vect_destroy_list(articulation_list);
}
Vect_build(&Out);
Vect_close(&In);
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int i, iopt;
int operator;
int aline, nalines, nskipped;
int ltype, itype[2], ifield[2];
int **cats, *ncats, nfields, *fields;
char *mapset[2], *pre[2];
struct GModule *module;
struct GParm parm;
struct GFlag flag;
struct Map_info In[2], Out;
struct field_info *IFi, *OFi;
struct line_pnts *APoints, *BPoints;
struct line_cats *ACats, *BCats;
int *ALines; /* List of lines: 0 do not output, 1 - write to output */
struct ilist *List, *TmpList, *BoundList;
G_gisinit(argv[0]);
pre[0] = "a";
pre[1] = "b";
module = G_define_module();
module->keywords = _("vector, spatial query");
module->description =
_("Selects features from vector map (A) by features from other vector map (B).");
parse_options(&parm, &flag);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (parm.operator->answer[0] == 'e')
operator = OP_EQUALS;
else if (parm.operator->answer[0] == 'd') {
/* operator = OP_DISJOINT; */
operator = OP_INTERSECTS;
flag.reverse->answer = YES;
}
else if (parm.operator->answer[0] == 'i')
operator = OP_INTERSECTS;
else if (parm.operator->answer[0] == 't')
operator = OP_TOUCHES;
else if (parm.operator->answer[0] == 'c' && parm.operator->answer[1] == 'r')
operator = OP_CROSSES;
else if (parm.operator->answer[0] == 'w')
operator = OP_WITHIN;
else if (parm.operator->answer[0] == 'c' && parm.operator->answer[1] == 'o')
operator = OP_CONTAINS;
else if (parm.operator->answer[0] == 'o') {
if (strcmp(parm.operator->answer, "overlaps") == 0)
operator = OP_OVERLAPS;
else
operator = OP_OVERLAP;
}
else if (parm.operator->answer[0] == 'r')
operator = OP_RELATE;
else
G_fatal_error(_("Unknown operator"));
if (operator == OP_RELATE && !parm.relate->answer) {
G_fatal_error(_("Required parameter <%s> not set"),
parm.relate->key);
}
for (iopt = 0; iopt < 2; iopt++) {
itype[iopt] = Vect_option_to_types(parm.type[iopt]);
ifield[iopt] = atoi(parm.field[iopt]->answer);
Vect_check_input_output_name(parm.input[iopt]->answer, parm.output->answer,
GV_FATAL_EXIT);
if ((mapset[iopt] =
G_find_vector2(parm.input[iopt]->answer, NULL)) == NULL) {
G_fatal_error(_("Vector map <%s> not found"),
parm.input[iopt]->answer);
}
Vect_set_open_level(2);
Vect_open_old(&(In[iopt]), parm.input[iopt]->answer, mapset[iopt]);
}
/* Read field info */
IFi = Vect_get_field(&(In[0]), ifield[0]);
APoints = Vect_new_line_struct();
BPoints = Vect_new_line_struct();
ACats = Vect_new_cats_struct();
BCats = Vect_new_cats_struct();
List = Vect_new_list();
TmpList = Vect_new_list();
BoundList = Vect_new_list();
/* Open output */
Vect_open_new(&Out, parm.output->answer, Vect_is_3d(&(In[0])));
Vect_set_map_name(&Out, _("Output from v.select"));
Vect_set_person(&Out, G_whoami());
Vect_copy_head_data(&(In[0]), &Out);
Vect_hist_copy(&(In[0]), &Out);
Vect_hist_command(&Out);
nskipped = 0;
nalines = Vect_get_num_lines(&(In[0]));
#ifdef HAVE_GEOS
initGEOS(G_message, G_fatal_error);
GEOSGeometry *AGeom = NULL;
#else
void *AGeom = NULL;
#endif
/* Alloc space for input lines array */
ALines = (int *)G_calloc(nalines + 1, sizeof(int));
G_message(_("Building spatial index..."));
Vect_build_spatial_index(&In[0]);
Vect_build_spatial_index(&In[1]);
/* Lines in A. Go through all lines and mark those that meets condition */
if (itype[0] & (GV_POINTS | GV_LINES)) {
G_message(_("Processing features..."));
for (aline = 1; aline <= nalines; aline++) {
BOUND_BOX abox;
G_debug(3, "aline = %d", aline);
G_percent(aline, nalines, 2); /* must be before any continue */
/* Check category */
if (!flag.cat->answer && Vect_get_line_cat(&(In[0]), aline, ifield[0]) < 0) {
nskipped++;
continue;
}
/* Read line and check type */
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
AGeom = Vect_read_line_geos(&(In[0]), aline, <ype);
#endif
if (!(ltype & (GV_POINT | GV_LINE)))
continue;
if (!AGeom)
G_fatal_error(_("Unable to read line id %d from vector map <%s>"),
aline, Vect_get_full_name(&(In[0])));
}
else {
ltype = Vect_read_line(&(In[0]), APoints, NULL, aline);
}
if (!(ltype & itype[0]))
continue;
Vect_get_line_box(&(In[0]), aline, &abox);
abox.T = PORT_DOUBLE_MAX;
abox.B = -PORT_DOUBLE_MAX;
/* Check if this line overlaps any feature in B */
/* x Lines in B */
if (itype[1] & (GV_POINTS | GV_LINES)) {
int i;
int found = 0;
/* Lines */
Vect_select_lines_by_box(&(In[1]), &abox, itype[1], List);
for (i = 0; i < List->n_values; i++) {
int bline;
bline = List->value[i];
G_debug(3, " bline = %d", bline);
/* Check category */
if (!flag.cat->answer && Vect_get_line_cat(&(In[1]), bline, ifield[1]) < 0) {
nskipped++;
continue;
}
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
if(line_relate_geos(&(In[1]), AGeom,
bline, operator, parm.relate->answer)) {
found = 1;
break;
}
#endif
}
else {
Vect_read_line(&(In[1]), BPoints, NULL, bline);
if (Vect_line_check_intersection(APoints, BPoints, 0)) {
found = 1;
break;
}
}
}
if (found) {
ALines[aline] = 1;
continue; /* Go to next A line */
}
}
/* x Areas in B. */
if (itype[1] & GV_AREA) {
int i;
Vect_select_areas_by_box(&(In[1]), &abox, List);
for (i = 0; i < List->n_values; i++) {
int barea;
barea = List->value[i];
G_debug(3, " barea = %d", barea);
if (Vect_get_area_cat(&(In[1]), barea, ifield[1]) < 0) {
nskipped++;
continue;
}
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
if(area_relate_geos(&(In[1]), AGeom,
barea, operator, parm.relate->answer)) {
ALines[aline] = 1;
break;
}
#endif
}
else {
if (line_overlap_area(&(In[0]), aline, &(In[1]), barea)) {
ALines[aline] = 1;
break;
}
}
}
}
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
GEOSGeom_destroy(AGeom);
#endif
AGeom = NULL;
}
}
}
/* Areas in A. */
if (itype[0] & GV_AREA) {
int aarea, naareas;
G_message(_("Processing areas..."));
naareas = Vect_get_num_areas(&(In[0]));
for (aarea = 1; aarea <= naareas; aarea++) {
BOUND_BOX abox;
G_percent(aarea, naareas, 2); /* must be before any continue */
if (Vect_get_area_cat(&(In[0]), aarea, ifield[0]) < 0) {
nskipped++;
continue;
}
Vect_get_area_box(&(In[0]), aarea, &abox);
abox.T = PORT_DOUBLE_MAX;
abox.B = -PORT_DOUBLE_MAX;
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
AGeom = Vect_read_area_geos(&(In[0]), aarea);
#endif
if (!AGeom)
G_fatal_error(_("Unable to read area id %d from vector map <%s>"),
aline, Vect_get_full_name(&(In[0])));
}
/* x Lines in B */
if (itype[1] & (GV_POINTS | GV_LINES)) {
Vect_select_lines_by_box(&(In[1]), &abox, itype[1], List);
for (i = 0; i < List->n_values; i++) {
int bline;
bline = List->value[i];
if (!flag.cat->answer && Vect_get_line_cat(&(In[1]), bline, ifield[1]) < 0) {
nskipped++;
continue;
}
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
if(line_relate_geos(&(In[1]), AGeom,
bline, operator, parm.relate->answer)) {
add_aarea(&(In[0]), aarea, ALines);
break;
}
#endif
}
else {
if (line_overlap_area(&(In[1]), bline, &(In[0]), aarea)) {
add_aarea(&(In[0]), aarea, ALines);
continue;
}
}
}
}
/* x Areas in B */
if (itype[1] & GV_AREA) {
int naisles;
int found = 0;
/* List of areas B */
/* Make a list of features forming area A */
Vect_reset_list(List);
Vect_get_area_boundaries(&(In[0]), aarea, BoundList);
for (i = 0; i < BoundList->n_values; i++) {
Vect_list_append(List, abs(BoundList->value[i]));
}
naisles = Vect_get_area_num_isles(&(In[0]), aarea);
for (i = 0; i < naisles; i++) {
int j, aisle;
aisle = Vect_get_area_isle(&(In[0]), aarea, i);
Vect_get_isle_boundaries(&(In[0]), aisle, BoundList);
for (j = 0; j < BoundList->n_values; j++) {
Vect_list_append(List, BoundList->value[j]);
}
}
Vect_select_areas_by_box(&(In[1]), &abox, TmpList);
for (i = 0; i < List->n_values; i++) {
int j, aline;
aline = abs(List->value[i]);
for (j = 0; j < TmpList->n_values; j++) {
int barea, bcentroid;
barea = TmpList->value[j];
G_debug(3, " barea = %d", barea);
if (Vect_get_area_cat(&(In[1]), barea, ifield[1]) < 0) {
nskipped++;
continue;
}
/* Check if any centroid of area B is in area A.
* This test is important in if area B is completely within area A */
bcentroid = Vect_get_area_centroid(&(In[1]), barea);
Vect_read_line(&(In[1]), BPoints, NULL, bcentroid);
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
if(area_relate_geos(&(In[1]), AGeom,
barea, operator, parm.relate->answer)) {
found = 1;
break;
}
#endif
}
else {
if (Vect_point_in_area(&(In[0]), aarea,
BPoints->x[0], BPoints->y[0])) {
found = 1;
break;
}
/* Check intersectin of lines from List with area B */
if (line_overlap_area(&(In[0]), aline,
&(In[1]), barea)) {
found = 1;
break;
}
}
}
if (found) {
add_aarea(&(In[0]), aarea, ALines);
break;
}
}
}
if (operator != OP_OVERLAP) {
#ifdef HAVE_GEOS
GEOSGeom_destroy(AGeom);
#endif
AGeom = NULL;
}
}
}
Vect_close(&(In[1]));
#ifdef HAVE_GEOS
finishGEOS();
#endif
/* Write lines */
nfields = Vect_cidx_get_num_fields(&(In[0]));
cats = (int **)G_malloc(nfields * sizeof(int *));
ncats = (int *)G_malloc(nfields * sizeof(int));
fields = (int *)G_malloc(nfields * sizeof(int));
for (i = 0; i < nfields; i++) {
ncats[i] = 0;
cats[i] =
(int *)G_malloc(Vect_cidx_get_num_cats_by_index(&(In[0]), i) *
sizeof(int));
fields[i] = Vect_cidx_get_field_number(&(In[0]), i);
}
G_message(_("Writing selected features..."));
for (aline = 1; aline <= nalines; aline++) {
int atype;
G_debug(4, "aline = %d ALines[aline] = %d", aline, ALines[aline]);
G_percent(aline, nalines, 2);
if ((!flag.reverse->answer && !(ALines[aline])) ||
(flag.reverse->answer && ALines[aline]))
continue;
atype = Vect_read_line(&(In[0]), APoints, ACats, aline);
Vect_write_line(&Out, atype, APoints, ACats);
if (!(flag.table->answer) && (IFi != NULL)) {
for (i = 0; i < ACats->n_cats; i++) {
int f, j;
for (j = 0; j < nfields; j++) { /* find field */
if (fields[j] == ACats->field[i]) {
f = j;
break;
}
}
cats[f][ncats[f]] = ACats->cat[i];
ncats[f]++;
}
}
}
/* Copy tables */
if (!(flag.table->answer)) {
int ttype, ntabs = 0;
G_message(_("Writing attributes..."));
/* Number of output tabs */
for (i = 0; i < Vect_get_num_dblinks(&(In[0])); i++) {
int f, j;
IFi = Vect_get_dblink(&(In[0]), i);
for (j = 0; j < nfields; j++) { /* find field */
if (fields[j] == IFi->number) {
f = j;
break;
}
}
if (ncats[f] > 0)
ntabs++;
}
if (ntabs > 1)
ttype = GV_MTABLE;
else
ttype = GV_1TABLE;
for (i = 0; i < nfields; i++) {
int ret;
if (fields[i] == 0)
continue;
/* Make a list of categories */
IFi = Vect_get_field(&(In[0]), fields[i]);
if (!IFi) { /* no table */
G_warning(_("Layer %d - no table"), fields[i]);
continue;
}
OFi =
Vect_default_field_info(&Out, IFi->number, IFi->name, ttype);
ret =
db_copy_table_by_ints(IFi->driver, IFi->database, IFi->table,
OFi->driver,
Vect_subst_var(OFi->database, &Out),
OFi->table, IFi->key, cats[i],
ncats[i]);
if (ret == DB_FAILED) {
G_warning(_("Layer %d - unable to copy table"), fields[i]);
}
else {
Vect_map_add_dblink(&Out, OFi->number, OFi->name, OFi->table,
IFi->key, OFi->database, OFi->driver);
}
}
}
Vect_close(&(In[0]));
Vect_build(&Out);
Vect_close(&Out);
if (nskipped > 0) {
G_warning(_("%d features without category skipped"), nskipped);
}
G_done_msg(_("%d features written to output."), Vect_get_num_lines(&Out));
exit(EXIT_SUCCESS);
}
/*--------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
/* Variables declarations */
int nsplx_adj, nsply_adj;
int nsubregion_col, nsubregion_row;
int subregion = 0, nsubregions = 0;
double N_extension, E_extension, edgeE, edgeN;
int dim_vect, nparameters, BW, npoints;
double mean, lambda;
const char *dvr, *db, *mapset;
char table_name[GNAME_MAX];
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
int last_row, last_column, flag_auxiliar = FALSE;
int filter_mode;
int *lineVect;
double *TN, *Q, *parVect; /* Interpolating and least-square vectors */
double **N, **obsVect; /* Interpolation and least-square matrix */
/* Structs declarations */
struct Map_info In, Out, Outlier, Qgis;
struct Option *in_opt, *out_opt, *outlier_opt, *qgis_opt, *stepE_opt,
*stepN_opt, *lambda_f_opt, *Thres_O_opt, *filter_opt;
struct Flag *spline_step_flag;
struct GModule *module;
struct Reg_dimens dims;
struct Cell_head elaboration_reg, original_reg;
struct bound_box general_box, overlap_box;
struct Point *observ;
dbDriver *driver;
/*----------------------------------------------------------------*/
/* Options declaration */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("statistics"));
G_add_keyword(_("extract"));
G_add_keyword(_("select"));
G_add_keyword(_("filter"));
module->description = _("Removes outliers from vector point data.");
spline_step_flag = G_define_flag();
spline_step_flag->key = 'e';
spline_step_flag->label = _("Estimate point density and distance");
spline_step_flag->description =
_("Estimate point density and distance for the input vector points within the current region extends and quit");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
outlier_opt = G_define_option();
outlier_opt->key = "outlier";
outlier_opt->type = TYPE_STRING;
outlier_opt->key_desc = "name";
outlier_opt->required = YES;
outlier_opt->gisprompt = "new,vector,vector";
outlier_opt->description = _("Name of output outlier vector map");
qgis_opt = G_define_option();
qgis_opt->key = "qgis";
qgis_opt->type = TYPE_STRING;
qgis_opt->key_desc = "name";
qgis_opt->required = NO;
qgis_opt->gisprompt = "new,vector,vector";
qgis_opt->description = _("Name of vector map for visualization in QGIS");
stepE_opt = G_define_option();
stepE_opt->key = "ew_step";
stepE_opt->type = TYPE_DOUBLE;
stepE_opt->required = NO;
stepE_opt->answer = "10";
stepE_opt->description =
_("Length of each spline step in the east-west direction");
stepE_opt->guisection = _("Settings");
stepN_opt = G_define_option();
stepN_opt->key = "ns_step";
stepN_opt->type = TYPE_DOUBLE;
stepN_opt->required = NO;
stepN_opt->answer = "10";
stepN_opt->description =
_("Length of each spline step in the north-south direction");
stepN_opt->guisection = _("Settings");
lambda_f_opt = G_define_option();
lambda_f_opt->key = "lambda";
lambda_f_opt->type = TYPE_DOUBLE;
lambda_f_opt->required = NO;
lambda_f_opt->description = _("Tykhonov regularization weight");
lambda_f_opt->answer = "0.1";
lambda_f_opt->guisection = _("Settings");
Thres_O_opt = G_define_option();
Thres_O_opt->key = "threshold";
Thres_O_opt->type = TYPE_DOUBLE;
Thres_O_opt->required = NO;
Thres_O_opt->description = _("Threshold for the outliers");
Thres_O_opt->answer = "50";
filter_opt = G_define_option();
filter_opt->key = "filter";
filter_opt->type = TYPE_STRING;
filter_opt->required = NO;
filter_opt->description = _("Filtering option");
filter_opt->options = "both,positive,negative";
filter_opt->answer = "both";
/* Parsing */
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (!(db = G_getenv_nofatal2("DB_DATABASE", G_VAR_MAPSET)))
G_fatal_error(_("Unable to read name of database"));
if (!(dvr = G_getenv_nofatal2("DB_DRIVER", G_VAR_MAPSET)))
G_fatal_error(_("Unable to read name of driver"));
stepN = atof(stepN_opt->answer);
stepE = atof(stepE_opt->answer);
lambda = atof(lambda_f_opt->answer);
Thres_Outlier = atof(Thres_O_opt->answer);
filter_mode = 0;
if (strcmp(filter_opt->answer, "positive") == 0)
filter_mode = 1;
else if (strcmp(filter_opt->answer, "negative") == 0)
filter_mode = -1;
P_set_outlier_fn(filter_mode);
flag_auxiliar = FALSE;
/* Checking vector names */
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
G_FATAL_EXIT);
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL) {
G_fatal_error(_("Vector map <%s> not found"), in_opt->answer);
}
/* Setting auxiliar table's name */
if (G_name_is_fully_qualified(out_opt->answer, xname, xmapset)) {
sprintf(table_name, "%s_aux", xname);
}
else
sprintf(table_name, "%s_aux", out_opt->answer);
/* Something went wrong in a previous v.outlier execution */
if (db_table_exists(dvr, db, table_name)) {
/* Start driver and open db */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
db_set_error_handler_driver(driver);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Old auxiliar table could not be dropped"));
db_close_database_shutdown_driver(driver);
}
/* Open input vector */
Vect_set_open_level(1); /* WITHOUT TOPOLOGY */
if (1 > Vect_open_old(&In, in_opt->answer, mapset))
G_fatal_error(_("Unable to open vector map <%s> at the topological level"),
in_opt->answer);
/* Input vector must be 3D */
if (!Vect_is_3d(&In))
G_fatal_error(_("Input vector map <%s> is not 3D!"), in_opt->answer);
/* Estimate point density and mean distance for current region */
if (spline_step_flag->answer) {
double dens, dist;
if (P_estimate_splinestep(&In, &dens, &dist) == 0) {
G_message("Estimated point density: %.4g", dens);
G_message("Estimated mean distance between points: %.4g", dist);
}
else
G_warning(_("No points in current region!"));
Vect_close(&In);
exit(EXIT_SUCCESS);
}
/* Open output vector */
if (qgis_opt->answer)
if (0 > Vect_open_new(&Qgis, qgis_opt->answer, WITHOUT_Z))
G_fatal_error(_("Unable to create vector map <%s>"),
qgis_opt->answer);
if (0 > Vect_open_new(&Out, out_opt->answer, WITH_Z)) {
Vect_close(&Qgis);
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
}
if (0 > Vect_open_new(&Outlier, outlier_opt->answer, WITH_Z)) {
Vect_close(&Out);
Vect_close(&Qgis);
G_fatal_error(_("Unable to create vector map <%s>"), out_opt->answer);
}
/* Copy vector Head File */
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
Vect_copy_head_data(&In, &Outlier);
Vect_hist_copy(&In, &Outlier);
Vect_hist_command(&Outlier);
if (qgis_opt->answer) {
Vect_copy_head_data(&In, &Qgis);
Vect_hist_copy(&In, &Qgis);
Vect_hist_command(&Qgis);
}
/* Open driver and database */
driver = db_start_driver_open_database(dvr, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
dvr);
db_set_error_handler_driver(driver);
/* Create auxiliar table */
if ((flag_auxiliar =
P_Create_Aux2_Table(driver, table_name)) == FALSE)
G_fatal_error(_("It was impossible to create <%s> table."), table_name);
db_create_index2(driver, table_name, "ID");
/* sqlite likes that ??? */
db_close_database_shutdown_driver(driver);
driver = db_start_driver_open_database(dvr, db);
/* Setting regions and boxes */
G_get_set_window(&original_reg);
G_get_set_window(&elaboration_reg);
Vect_region_box(&elaboration_reg, &overlap_box);
Vect_region_box(&elaboration_reg, &general_box);
/*------------------------------------------------------------------
| Subdividing and working with tiles:
| Each original region will be divided into several subregions.
| Each one will be overlaped by its neighbouring subregions.
| The overlapping is calculated as a fixed OVERLAP_SIZE times
| the largest spline step plus 2 * edge
----------------------------------------------------------------*/
/* Fixing parameters of the elaboration region */
P_zero_dim(&dims); /* Set dim struct to zero */
nsplx_adj = NSPLX_MAX;
nsply_adj = NSPLY_MAX;
if (stepN > stepE)
dims.overlap = OVERLAP_SIZE * stepN;
else
dims.overlap = OVERLAP_SIZE * stepE;
P_get_edge(P_BILINEAR, &dims, stepE, stepN);
P_set_dim(&dims, stepE, stepN, &nsplx_adj, &nsply_adj);
G_verbose_message(_("Adjusted EW splines %d"), nsplx_adj);
G_verbose_message(_("Adjusted NS splines %d"), nsply_adj);
/* calculate number of subregions */
edgeE = dims.ew_size - dims.overlap - 2 * dims.edge_v;
edgeN = dims.sn_size - dims.overlap - 2 * dims.edge_h;
N_extension = original_reg.north - original_reg.south;
E_extension = original_reg.east - original_reg.west;
nsubregion_col = ceil(E_extension / edgeE) + 0.5;
nsubregion_row = ceil(N_extension / edgeN) + 0.5;
if (nsubregion_col < 0)
nsubregion_col = 0;
if (nsubregion_row < 0)
nsubregion_row = 0;
nsubregions = nsubregion_row * nsubregion_col;
elaboration_reg.south = original_reg.north;
last_row = FALSE;
while (last_row == FALSE) { /* For each row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_ROW);
if (elaboration_reg.north > original_reg.north) { /* First row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
FIRST_ROW);
}
if (elaboration_reg.south <= original_reg.south) { /* Last row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
LAST_ROW);
last_row = TRUE;
}
nsply =
ceil((elaboration_reg.north -
elaboration_reg.south) / stepN) + 0.5;
/*
if (nsply > NSPLY_MAX)
nsply = NSPLY_MAX;
*/
G_debug(1, "nsply = %d", nsply);
elaboration_reg.east = original_reg.west;
last_column = FALSE;
while (last_column == FALSE) { /* For each column */
subregion++;
if (nsubregions > 1)
G_message(_("Processing subregion %d of %d..."), subregion, nsubregions);
else /* v.outlier -e will report mean point distance: */
G_warning(_("No subregions found! Check values for 'ew_step' and 'ns_step' parameters"));
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_COLUMN);
if (elaboration_reg.west < original_reg.west) { /* First column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, FIRST_COLUMN);
}
if (elaboration_reg.east >= original_reg.east) { /* Last column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, LAST_COLUMN);
last_column = TRUE;
}
nsplx =
ceil((elaboration_reg.east -
elaboration_reg.west) / stepE) + 0.5;
/*
if (nsplx > NSPLX_MAX)
nsplx = NSPLX_MAX;
*/
G_debug(1, "nsplx = %d", nsplx);
/*Setting the active region */
dim_vect = nsplx * nsply;
observ =
P_Read_Vector_Region_Map(&In, &elaboration_reg, &npoints,
dim_vect, 1);
if (npoints > 0) { /* If there is any point falling into elaboration_reg... */
int i;
nparameters = nsplx * nsply;
/* Mean calculation */
mean = P_Mean_Calc(&elaboration_reg, observ, npoints);
/* Least Squares system */
G_debug(1, "Allocation memory for bilinear interpolation");
BW = P_get_BandWidth(P_BILINEAR, nsply); /* Bilinear interpolation */
N = G_alloc_matrix(nparameters, BW); /* Normal matrix */
TN = G_alloc_vector(nparameters); /* vector */
parVect = G_alloc_vector(nparameters); /* Bicubic parameters vector */
obsVect = G_alloc_matrix(npoints, 3); /* Observation vector */
Q = G_alloc_vector(npoints); /* "a priori" var-cov matrix */
lineVect = G_alloc_ivector(npoints);
/* Setting obsVect vector & Q matrix */
for (i = 0; i < npoints; i++) {
obsVect[i][0] = observ[i].coordX;
obsVect[i][1] = observ[i].coordY;
obsVect[i][2] = observ[i].coordZ - mean;
lineVect[i] = observ[i].lineID;
Q[i] = 1; /* Q=I */
}
G_free(observ);
G_verbose_message(_("Bilinear interpolation"));
normalDefBilin(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, npoints, nparameters,
BW);
nCorrectGrad(N, lambda, nsplx, nsply, stepE, stepN);
G_math_solver_cholesky_sband(N, parVect, TN, nparameters, BW);
G_free_matrix(N);
G_free_vector(TN);
G_free_vector(Q);
G_verbose_message(_("Outlier detection"));
if (qgis_opt->answer)
P_Outlier(&Out, &Outlier, &Qgis, elaboration_reg,
general_box, overlap_box, obsVect, parVect,
mean, dims.overlap, lineVect, npoints,
driver, table_name);
else
P_Outlier(&Out, &Outlier, NULL, elaboration_reg,
general_box, overlap_box, obsVect, parVect,
mean, dims.overlap, lineVect, npoints,
driver, table_name);
G_free_vector(parVect);
G_free_matrix(obsVect);
G_free_ivector(lineVect);
} /*! END IF; npoints > 0 */
else {
G_free(observ);
G_warning(_("No data within this subregion. "
"Consider increasing spline step values."));
}
} /*! END WHILE; last_column = TRUE */
} /*! END WHILE; last_row = TRUE */
/* Drop auxiliar table */
if (npoints > 0) {
G_debug(1, "%s: Dropping <%s>", argv[0], table_name);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Auxiliary table could not be dropped"));
}
db_close_database_shutdown_driver(driver);
Vect_close(&In);
Vect_close(&Out);
Vect_close(&Outlier);
if (qgis_opt->answer) {
Vect_build(&Qgis);
Vect_close(&Qgis);
}
G_done_msg(" ");
exit(EXIT_SUCCESS);
} /*END MAIN */
int main(int argc, char *argv[])
{
struct Map_info In, Out;
static struct line_pnts *Points, *PPoints;
struct line_cats *Cats, *TCats;
struct ilist *slist;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out;
struct Option *catf_opt, *fieldf_opt, *wheref_opt;
struct Option *catt_opt, *fieldt_opt, *wheret_opt, *typet_opt;
struct Option *afield_opt, *nfield_opt, *abcol, *afcol, *ncol, *atype_opt;
struct Flag *geo_f, *segments_f;
int with_z, geo, segments;
int atype, ttype;
struct varray *varrayf, *varrayt;
int flayer, tlayer;
int afield, nfield;
dglGraph_s *graph;
struct ilist *nodest;
int i, j, nnodes, nlines;
int *dst, *nodes_to_features;
int from_nr; /* 'from' features not reachable */
dglInt32_t **nxt;
struct line_cats **on_path;
char *segdir;
char buf[2000];
/* Attribute table */
dbString sql;
dbDriver *driver;
struct field_info *Fi;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("network"));
G_add_keyword(_("shortest path"));
module->label = _("Computes shortest distance via the network between "
"the given sets of features.");
module->description =
_("Finds the shortest paths from each 'from' point to the nearest 'to' feature "
"and various information about this relation are uploaded to the attribute table.");
/* Define the different options as defined in gis.h */
map_in = G_define_standard_option(G_OPT_V_INPUT);
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
afield_opt = G_define_standard_option(G_OPT_V_FIELD);
afield_opt->key = "arc_layer";
afield_opt->answer = "1";
afield_opt->label = _("Arc layer");
afield_opt->guisection = _("Cost");
atype_opt = G_define_standard_option(G_OPT_V_TYPE);
atype_opt->key = "arc_type";
atype_opt->options = "line,boundary";
atype_opt->answer = "line,boundary";
atype_opt->label = _("Arc type");
atype_opt->guisection = _("Cost");
nfield_opt = G_define_standard_option(G_OPT_V_FIELD);
nfield_opt->key = "node_layer";
nfield_opt->answer = "2";
nfield_opt->label = _("Node layer");
nfield_opt->guisection = _("Cost");
fieldf_opt = G_define_standard_option(G_OPT_V_FIELD);
fieldf_opt->key = "from_layer";
fieldf_opt->label = _("From layer number or name");
fieldf_opt->guisection = _("From");
catf_opt = G_define_standard_option(G_OPT_V_CATS);
catf_opt->key = "from_cats";
catf_opt->label = _("From category values");
catf_opt->guisection = _("From");
wheref_opt = G_define_standard_option(G_OPT_DB_WHERE);
wheref_opt->key = "from_where";
wheref_opt->label =
_("From WHERE conditions of SQL statement without 'where' keyword");
wheref_opt->guisection = _("From");
fieldt_opt = G_define_standard_option(G_OPT_V_FIELD);
fieldt_opt->key = "to_layer";
fieldt_opt->description = _("To layer number or name");
fieldt_opt->guisection = _("To");
typet_opt = G_define_standard_option(G_OPT_V_TYPE);
typet_opt->key = "to_type";
typet_opt->options = "point,line,boundary";
typet_opt->answer = "point";
typet_opt->description = _("To feature type");
typet_opt->guisection = _("To");
catt_opt = G_define_standard_option(G_OPT_V_CATS);
catt_opt->key = "to_cats";
catt_opt->label = _("To category values");
catt_opt->guisection = _("To");
wheret_opt = G_define_standard_option(G_OPT_DB_WHERE);
wheret_opt->key = "to_where";
wheret_opt->label =
_("To WHERE conditions of SQL statement without 'where' keyword");
wheret_opt->guisection = _("To");
afcol = G_define_standard_option(G_OPT_DB_COLUMN);
afcol->key = "arc_column";
afcol->required = NO;
afcol->description =
_("Arc forward/both direction(s) cost column (number)");
afcol->guisection = _("Cost");
abcol = G_define_standard_option(G_OPT_DB_COLUMN);
abcol->key = "arc_backward_column";
abcol->required = NO;
abcol->description = _("Arc backward direction cost column (number)");
abcol->guisection = _("Cost");
ncol = G_define_standard_option(G_OPT_DB_COLUMN);
ncol->key = "node_column";
ncol->required = NO;
ncol->description = _("Node cost column (number)");
ncol->guisection = _("Cost");
geo_f = G_define_flag();
geo_f->key = 'g';
geo_f->description =
_("Use geodesic calculation for longitude-latitude locations");
segments_f = G_define_flag();
#if 0
/* use this to sync with v.net.path */
segments_f->key = 's';
segments_f->description = _("Write output as original input segments, "
"not each path as one line.");
#else
segments_f->key = 'l';
segments_f->description = _("Write each output path as one line, "
"not as original input segments.");
#endif
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
atype = Vect_option_to_types(atype_opt);
ttype = Vect_option_to_types(typet_opt);
Points = Vect_new_line_struct();
PPoints = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
TCats = Vect_new_cats_struct();
slist = G_new_ilist();
Vect_check_input_output_name(map_in->answer, map_out->answer,
G_FATAL_EXIT);
Vect_set_open_level(2);
if (1 > Vect_open_old(&In, map_in->answer, ""))
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
with_z = Vect_is_3d(&In);
if (0 > Vect_open_new(&Out, map_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), map_out->answer);
}
if (geo_f->answer) {
geo = 1;
if (G_projection() != PROJECTION_LL)
G_warning(_("The current projection is not longitude-latitude"));
}
else
geo = 0;
#if 0
/* use this to sync with v.net.path */
segments = segments_f->answer;
#else
segments = !segments_f->answer;
#endif
nnodes = Vect_get_num_nodes(&In);
nlines = Vect_get_num_lines(&In);
dst = (int *)G_calloc(nnodes + 1, sizeof(int));
nxt = (dglInt32_t **) G_calloc(nnodes + 1, sizeof(dglInt32_t *));
nodes_to_features = (int *)G_calloc(nnodes + 1, sizeof(int));
on_path =
(struct line_cats **)G_calloc(nlines + 1, sizeof(struct line_cats *));
segdir = (char *)G_calloc(nlines + 1, sizeof(char));
if (!dst || !nxt || !nodes_to_features || !on_path || !segdir)
G_fatal_error(_("Out of memory"));
for (i = 1; i <= nlines; i++) {
on_path[i] = Vect_new_cats_struct();
segdir[i] = 0;
}
/*initialise varrays and nodes list appropriatelly */
afield = Vect_get_field_number(&In, afield_opt->answer);
nfield = Vect_get_field_number(&In, nfield_opt->answer);
flayer = atoi(fieldf_opt->answer);
tlayer = atoi(fieldt_opt->answer);
if (NetA_initialise_varray(&In, flayer, GV_POINT, wheref_opt->answer,
catf_opt->answer, &varrayf) <= 0) {
G_fatal_error(_("No 'from' features selected. "
"Please check options '%s', '%s', '%s'."),
fieldf_opt->key, wheref_opt->key, catf_opt->key);
}
if (NetA_initialise_varray(&In, tlayer, ttype, wheret_opt->answer,
catt_opt->answer, &varrayt) <= 0) {
G_fatal_error(_("No 'to' features selected. "
"Please check options '%s', '%s', '%s'."),
fieldt_opt->key, wheret_opt->key, catt_opt->key);
}
nodest = Vect_new_list();
NetA_varray_to_nodes(&In, varrayt, nodest, nodes_to_features);
if (nodest->n_values == 0)
G_fatal_error(_("No 'to' features"));
if (0 != Vect_net_build_graph(&In, atype, afield, nfield, afcol->answer, abcol->answer,
ncol->answer, geo, 2))
G_fatal_error(_("Unable to build graph for vector map <%s>"), Vect_get_full_name(&In));
graph = Vect_net_get_graph(&In);
G_message(_("Distances to 'to' features ..."));
NetA_distance_to_points(graph, nodest, dst, nxt);
/* Create table */
Fi = Vect_default_field_info(&Out, 1, NULL, GV_1TABLE);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, GV_KEY_COLUMN, Fi->database,
Fi->driver);
db_init_string(&sql);
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);
db_set_error_handler_driver(driver);
sprintf(buf,
"create table %s ( cat integer, tcat integer, dist double precision)",
Fi->table);
db_set_string(&sql, buf);
G_debug(2, "%s", db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Unable to create table: '%s'"), db_get_string(&sql));
}
if (db_create_index2(driver, Fi->table, GV_KEY_COLUMN) != DB_OK)
G_warning(_("Cannot create index"));
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT, DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Cannot grant privileges on table <%s>"), Fi->table);
db_begin_transaction(driver);
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
G_message(_("Tracing paths from 'from' features ..."));
from_nr = 0;
for (i = 1; i <= nlines; i++) {
if (varrayf->c[i]) {
int type = Vect_read_line(&In, Points, Cats, i);
int node, tcat, cat;
double cost;
dglInt32_t *vertex, vertex_id;
if (!Vect_cat_get(Cats, flayer, &cat))
continue;
if (type & GV_POINTS) {
node = Vect_find_node(&In, Points->x[0], Points->y[0], Points->z[0], 0, 0);
}
else {
Vect_get_line_nodes(&In, i, &node, NULL);
}
if (node < 1)
continue;
if (dst[node] < 0) {
/* unreachable */
from_nr++;
continue;
}
cost = dst[node] / (double)In.dgraph.cost_multip;
vertex = dglGetNode(graph, node);
vertex_id = node;
slist->n_values = 0;
while (nxt[vertex_id] != NULL) {
int edge_id;
edge_id = (int) dglEdgeGet_Id(graph, nxt[vertex_id]);
if (segments) {
Vect_cat_set(on_path[abs(edge_id)], 1, cat);
if (edge_id < 0) {
segdir[abs(edge_id)] = 1;
}
}
else
G_ilist_add(slist, edge_id);
vertex = dglEdgeGet_Tail(graph, nxt[vertex_id]);
vertex_id = dglNodeGet_Id(graph, vertex);
}
G_debug(3, "read line %d, vertex id %d", nodes_to_features[vertex_id], (int)vertex_id);
Vect_read_line(&In, NULL, TCats, nodes_to_features[vertex_id]);
if (!Vect_cat_get(TCats, tlayer, &tcat))
continue;
Vect_write_line(&Out, type, Points, Cats);
sprintf(buf, "insert into %s values (%d, %d, %f)", Fi->table, cat,
tcat, cost);
db_set_string(&sql, buf);
G_debug(3, "%s", db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Cannot insert new record: %s"),
db_get_string(&sql));
};
if (!segments) {
Vect_reset_line(PPoints);
for (j = 0; j < slist->n_values; j++) {
Vect_read_line(&In, Points, NULL, abs(slist->value[j]));
if (slist->value[j] > 0)
Vect_append_points(PPoints, Points,
GV_FORWARD);
else
Vect_append_points(PPoints, Points,
GV_BACKWARD);
PPoints->n_points--;
}
PPoints->n_points++;
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, cat);
Vect_write_line(&Out, GV_LINE, PPoints, Cats);
}
}
}
if (segments) {
for (i = 1; i <= nlines; i++) {
if (on_path[i]->n_cats > 0) {
int type;
if (segdir[i]) {
type = Vect_read_line(&In, PPoints, NULL, i);
Vect_reset_line(Points);
Vect_append_points(Points, PPoints, GV_BACKWARD);
}
else
type = Vect_read_line(&In, Points, NULL, i);
Vect_write_line(&Out, type, Points, on_path[i]);
}
}
}
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
Vect_build(&Out);
Vect_close(&In);
Vect_close(&Out);
for (i = 1; i <= nlines; i++)
Vect_destroy_cats_struct(on_path[i]);
G_free(on_path);
G_free(nodes_to_features);
G_free(dst);
G_free(nxt);
G_free(segdir);
if (from_nr)
G_warning(n_("%d 'from' feature was not reachable",
"%d 'from' features were not reachable",
from_nr), from_nr);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct file_info Current, Trans, Coord;
struct GModule *module;
struct Option *vold, *vnew, *pointsfile, *xshift, *yshift, *zshift,
*xscale, *yscale, *zscale, *zrot, *columns, *table, *field;
struct Flag *quiet_flag, *tozero_flag, *shift_flag, *print_mat_flag;
char *mapset, mon[4], date[40], buf[1000];
struct Map_info Old, New;
int ifield;
int day, yr;
BOUND_BOX box;
double ztozero;
double trans_params[7]; /* xshift, ..., xscale, ..., zrot */
/* columns */
unsigned int i;
int idx, out3d;
char **tokens;
char *columns_name[7]; /* xshift, yshift, zshift, xscale, yscale, zscale, zrot */
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("vector, transformation");
module->description =
_("Performs an affine transformation (shift, scale and rotate, "
"or GPCs) on vector map.");
/* remove in GRASS7 */
quiet_flag = G_define_flag();
quiet_flag->key = 'q';
quiet_flag->description =
_("Suppress display of residuals or other information");
tozero_flag = G_define_flag();
tozero_flag->key = 't';
tozero_flag->description = _("Shift all z values to bottom=0");
tozero_flag->guisection = _("Custom");
print_mat_flag = G_define_flag();
print_mat_flag->key = 'm';
print_mat_flag->description =
_("Print the transformation matrix to stdout");
shift_flag = G_define_flag();
shift_flag->key = 's';
shift_flag->description =
_("Instead of points use transformation parameters "
"(xshift, yshift, zshift, xscale, yscale, zscale, zrot)");
shift_flag->guisection = _("Custom");
vold = G_define_standard_option(G_OPT_V_INPUT);
field = G_define_standard_option(G_OPT_V_FIELD);
field->answer = "-1";
vnew = G_define_standard_option(G_OPT_V_OUTPUT);
pointsfile = G_define_standard_option(G_OPT_F_INPUT);
pointsfile->key = "pointsfile";
pointsfile->required = NO;
pointsfile->label = _("ASCII file holding transform coordinates");
pointsfile->description = _("If not given, transformation parameters "
"(xshift, yshift, zshift, xscale, yscale, zscale, zrot) are used instead");
pointsfile->gisprompt = "old_file,file,points";
pointsfile->guisection = _("Points");
xshift = G_define_option();
xshift->key = "xshift";
xshift->type = TYPE_DOUBLE;
xshift->required = NO;
xshift->multiple = NO;
xshift->description = _("Shifting value for x coordinates");
xshift->answer = "0.0";
xshift->guisection = _("Custom");
yshift = G_define_option();
yshift->key = "yshift";
yshift->type = TYPE_DOUBLE;
yshift->required = NO;
yshift->multiple = NO;
yshift->description = _("Shifting value for y coordinates");
yshift->answer = "0.0";
yshift->guisection = _("Custom");
zshift = G_define_option();
zshift->key = "zshift";
zshift->type = TYPE_DOUBLE;
zshift->required = NO;
zshift->multiple = NO;
zshift->description = _("Shifting value for z coordinates");
zshift->answer = "0.0";
zshift->guisection = _("Custom");
xscale = G_define_option();
xscale->key = "xscale";
xscale->type = TYPE_DOUBLE;
xscale->required = NO;
xscale->multiple = NO;
xscale->description = _("Scaling factor for x coordinates");
xscale->answer = "1.0";
xscale->guisection = _("Custom");
yscale = G_define_option();
yscale->key = "yscale";
yscale->type = TYPE_DOUBLE;
yscale->required = NO;
yscale->multiple = NO;
yscale->description = _("Scaling factor for y coordinates");
yscale->answer = "1.0";
yscale->guisection = _("Custom");
zscale = G_define_option();
zscale->key = "zscale";
zscale->type = TYPE_DOUBLE;
zscale->required = NO;
zscale->multiple = NO;
zscale->description = _("Scaling factor for z coordinates");
zscale->answer = "1.0";
zscale->guisection = _("Custom");
zrot = G_define_option();
zrot->key = "zrot";
zrot->type = TYPE_DOUBLE;
zrot->required = NO;
zrot->multiple = NO;
zrot->description =
_("Rotation around z axis in degrees counterclockwise");
zrot->answer = "0.0";
zrot->guisection = _("Custom");
table = G_define_standard_option(G_OPT_TABLE);
table->description =
_("Name of table containing transformation parameters");
table->guisection = _("Attributes");
columns = G_define_option();
columns->key = "columns";
columns->type = TYPE_STRING;
columns->required = NO;
columns->multiple = NO;
columns->label =
_("Name of attribute column(s) used as transformation parameters");
columns->description =
_("Format: parameter:column, e.g. xshift:xs,yshift:ys,zrot:zr");
columns->guisection = _("Attributes");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_strcpy(Current.name, vold->answer);
G_strcpy(Trans.name, vnew->answer);
Vect_check_input_output_name(vold->answer, vnew->answer, GV_FATAL_EXIT);
out3d = WITHOUT_Z;
ifield = atoi(field->answer);
if (shift_flag->answer)
G_warning(_("The '%c' flag is deprecated and will be removed in future. "
"Transformation parameters are used automatically when no pointsfile is given."),
shift_flag->key);
/* please remove in GRASS7 */
if (quiet_flag->answer) {
G_warning(_("The '%c' flag is deprecated and will be removed in future. "
"Please use '--quiet' instead."), quiet_flag->key);
G_putenv("GRASS_VERBOSE", "0");
}
/* if a table is specified, require columns and layer */
/* if columns are specified, but no table, require layer > 0 and use
* the table attached to that layer */
if (table->answer && !columns->answer) {
G_fatal_error(_("Column names are not defined. Please use '%s' parameter."),
columns->key);
}
if ((columns->answer || table->answer) && ifield < 1) {
G_fatal_error(_("Please specify a valid layer with '%s' parameter."),
field->key);
}
if (table->answer && strcmp(vnew->answer, table->answer) == 0) {
G_fatal_error(_("Name of table and name for output vector map must be different. "
"Otherwise the table is overwritten."));
}
if (!columns->answer && !table->answer)
ifield = -1;
if (pointsfile->answer != NULL && !shift_flag->answer) {
G_strcpy(Coord.name, pointsfile->answer);
}
else {
Coord.name[0] = '\0';
}
/* open coord file */
if (Coord.name[0] != '\0') {
if ((Coord.fp = fopen(Coord.name, "r")) == NULL)
G_fatal_error(_("Unable to open file with coordinates <%s>"),
Coord.name);
}
/* tokenize columns names */
for (i = 0; i <= IDX_ZROT; i++) {
columns_name[i] = NULL;
}
i = 0;
if (columns->answer) {
while (columns->answers[i]) {
tokens = G_tokenize(columns->answers[i], ":");
if (G_number_of_tokens(tokens) == 2) {
if (strcmp(tokens[0], xshift->key) == 0)
idx = IDX_XSHIFT;
else if (strcmp(tokens[0], yshift->key) == 0)
idx = IDX_YSHIFT;
else if (strcmp(tokens[0], zshift->key) == 0)
idx = IDX_ZSHIFT;
else if (strcmp(tokens[0], xscale->key) == 0)
idx = IDX_XSCALE;
else if (strcmp(tokens[0], yscale->key) == 0)
idx = IDX_YSCALE;
else if (strcmp(tokens[0], zscale->key) == 0)
idx = IDX_ZSCALE;
else if (strcmp(tokens[0], zrot->key) == 0)
idx = IDX_ZROT;
else
idx = -1;
if (idx != -1)
columns_name[idx] = G_store(tokens[1]);
G_free_tokens(tokens);
}
else {
G_fatal_error(_("Unable to tokenize column string: [%s]"),
columns->answers[i]);
}
i++;
}
}
/* determine transformation parameters */
trans_params[IDX_XSHIFT] = atof(xshift->answer);
trans_params[IDX_YSHIFT] = atof(yshift->answer);
trans_params[IDX_ZSHIFT] = atof(zshift->answer);
trans_params[IDX_XSCALE] = atof(xscale->answer);
trans_params[IDX_YSCALE] = atof(yscale->answer);
trans_params[IDX_ZSCALE] = atof(zscale->answer);
trans_params[IDX_ZROT] = atof(zrot->answer);
/* open vector maps */
if ((mapset = G_find_vector2(vold->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), vold->answer);
Vect_open_old(&Old, vold->answer, mapset);
/* should output be 3D ?
* note that z-scale and ztozero have no effect with input 2D */
if (Vect_is_3d(&Old) || trans_params[IDX_ZSHIFT] != 0. ||
columns_name[IDX_ZSHIFT])
out3d = WITH_Z;
Vect_open_new(&New, vnew->answer, out3d);
/* copy and set header */
Vect_copy_head_data(&Old, &New);
Vect_hist_copy(&Old, &New);
Vect_hist_command(&New);
sprintf(date, "%s", G_date());
sscanf(date, "%*s%s%d%*s%d", mon, &day, &yr);
sprintf(date, "%s %d %d", mon, day, yr);
Vect_set_date(&New, date);
Vect_set_person(&New, G_whoami());
sprintf(buf, "transformed from %s", vold->answer);
Vect_set_map_name(&New, buf);
Vect_set_scale(&New, 1);
Vect_set_zone(&New, 0);
Vect_set_thresh(&New, 0.0);
/* points file */
if (Coord.name[0]) {
create_transform_from_file(&Coord, quiet_flag->answer);
if (Coord.name[0] != '\0')
fclose(Coord.fp);
}
Vect_get_map_box(&Old, &box);
/* z to zero */
if (tozero_flag->answer)
ztozero = 0 - box.B;
else
ztozero = 0;
/* do the transformation */
transform_digit_file(&Old, &New, Coord.name[0] ? 1 : 0,
ztozero, trans_params,
table->answer, columns_name, ifield);
if (Vect_copy_tables(&Old, &New, 0))
G_warning(_("Failed to copy attribute table to output map"));
Vect_close(&Old);
Vect_build(&New);
if (!quiet_flag->answer) {
Vect_get_map_box(&New, &box);
G_message(_("\nNew vector map <%s> boundary coordinates:"),
vnew->answer);
G_message(_(" N: %-10.3f S: %-10.3f"), box.N, box.S);
G_message(_(" E: %-10.3f W: %-10.3f"), box.E, box.W);
G_message(_(" B: %6.3f T: %6.3f"), box.B, box.T);
/* print the transformation matrix if requested */
if (print_mat_flag->answer)
print_transform_matrix();
}
Vect_close(&New);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int field, type, vertex_type;
double dmax;
struct Option *in_opt, *out_opt, *type_opt, *dmax_opt, *lfield_opt;
struct Flag *inter_flag, *vertex_flag, *table_flag, *node_flag;
struct GModule *module;
char *mapset;
struct Map_info In, Out;
struct line_cats *LCats;
struct line_pnts *LPoints;
char buf[2000];
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("vector, geometry");
module->description =
_("Create points along input lines in new vector with 2 layers.");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
in_opt->description = _("Input vector map containing lines");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
out_opt->description =
_("Output vector map where points will be written");
type_opt = G_define_standard_option(G_OPT_V_TYPE);
type_opt->answer = "point,line,boundary,centroid";
lfield_opt = G_define_standard_option(G_OPT_V_FIELD);
lfield_opt->key = "llayer";
lfield_opt->answer = "1";
lfield_opt->description = "Line layer";
node_flag = G_define_flag();
node_flag->key = 'n';
node_flag->description = _("Write line nodes");
vertex_flag = G_define_flag();
vertex_flag->key = 'v';
vertex_flag->description = _("Write line vertices");
inter_flag = G_define_flag();
inter_flag->key = 'i';
inter_flag->description = _("Interpolate points between line vertices");
dmax_opt = G_define_option();
dmax_opt->key = "dmax";
dmax_opt->type = TYPE_DOUBLE;
dmax_opt->required = NO;
dmax_opt->answer = "100";
dmax_opt->description = _("Maximum distance between points in map units");
table_flag = G_define_flag();
table_flag->key = 't';
table_flag->description = _("Do not create attribute table");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
LCats = Vect_new_cats_struct();
PCats = Vect_new_cats_struct();
LPoints = Vect_new_line_struct();
PPoints = Vect_new_line_struct();
db_init_string(&stmt);
field = atoi(lfield_opt->answer);
type = Vect_option_to_types(type_opt);
dmax = atof(dmax_opt->answer);
if (node_flag->answer && vertex_flag->answer)
G_fatal_error(_("Use either -n or -v flag, not both"));
if (node_flag->answer)
vertex_type = GV_NODE;
else if (vertex_flag->answer)
vertex_type = GV_VERTEX;
else
vertex_type = 0;
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
GV_FATAL_EXIT);
/* Open input lines */
mapset = G_find_vector2(in_opt->answer, NULL);
if (mapset == NULL)
G_fatal_error(_("Vector map <%s> not found"), in_opt->answer);
Vect_set_open_level(2);
Vect_open_old(&In, in_opt->answer, mapset);
/* Open output segments */
Vect_open_new(&Out, out_opt->answer, Vect_is_3d(&In));
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* Table */
if (!table_flag->answer) {
struct field_info *Fin;
/* copy input table */
Fin = Vect_get_field(&In, field);
if (Fin) { /* table defined */
int ret;
Fi = Vect_default_field_info(&Out, 1, NULL, GV_MTABLE);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, Fin->key,
Fi->database, Fi->driver);
ret = db_copy_table(Fin->driver, Fin->database, Fin->table,
Fi->driver, Vect_subst_var(Fi->database,
&Out), Fi->table);
if (ret == DB_FAILED) {
G_fatal_error(_("Unable to copy table <%s>"),
Fin->table);
}
}
Fi = Vect_default_field_info(&Out, 2, NULL, GV_MTABLE);
Vect_map_add_dblink(&Out, 2, NULL, Fi->table, "cat", Fi->database,
Fi->driver);
/* Open driver */
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);
sprintf(buf,
"create table %s ( cat int, lcat int, along double precision )",
Fi->table);
db_append_string(&stmt, buf);
if (db_execute_immediate(driver, &stmt) != DB_OK) {
db_close_database_shutdown_driver(driver);
G_fatal_error(_("Unable to create table: '%s'"),
db_get_string(&stmt));
}
if (db_create_index2(driver, Fi->table, "cat") != DB_OK)
G_warning(_("Unable to create index for table <%s>, key <%s>"),
Fi->table, "cat");
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Unable to grant privileges on table <%s>"),
Fi->table);
db_begin_transaction(driver);
}
point_cat = 1;
if (type & (GV_POINTS | GV_LINES)) {
int line, nlines;
nlines = Vect_get_num_lines(&In);
for (line = 1; line <= nlines; line++) {
int ltype, cat;
G_debug(3, "line = %d", line);
ltype = Vect_read_line(&In, LPoints, LCats, line);
if (!(ltype & type))
continue;
Vect_cat_get(LCats, field, &cat);
if (LPoints->n_points <= 1) {
write_point(&Out, LPoints->x[0], LPoints->y[0], LPoints->z[0],
cat, 0.0, table_flag->answer);
}
else { /* lines */
write_line(&Out, LPoints, cat, vertex_type,
inter_flag->answer, dmax, table_flag->answer);
}
G_percent(line, nlines, 2);
}
}
if (type == GV_AREA) {
int area, nareas, centroid, cat;
nareas = Vect_get_num_areas(&In);
for (area = 1; area <= nareas; area++) {
int i, isle, nisles;
centroid = Vect_get_area_centroid(&In, area);
cat = -1;
if (centroid > 0) {
Vect_read_line(&In, NULL, LCats, centroid);
Vect_cat_get(LCats, field, &cat);
}
Vect_get_area_points(&In, area, LPoints);
write_line(&Out, LPoints, cat, vertex_type, inter_flag->answer,
dmax, table_flag->answer);
nisles = Vect_get_area_num_isles(&In, area);
for (i = 0; i < nisles; i++) {
isle = Vect_get_area_isle(&In, area, i);
Vect_get_isle_points(&In, isle, LPoints);
write_line(&Out, LPoints, cat, vertex_type,
inter_flag->answer, dmax, table_flag->answer);
}
G_percent(area, nareas, 2);
}
}
if (!table_flag->answer) {
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
}
Vect_build(&Out);
/* Free, close ... */
Vect_close(&In);
Vect_close(&Out);
G_done_msg(_("%d points written to output vector map"), point_cat - 1);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Map_info In, Out;
static struct line_pnts *Points;
struct line_cats *Cats;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out;
struct Option *method_opt, *afield_opt, *nfield_opt, *abcol,
*afcol, *ncol;
struct Flag *add_f;
int with_z;
int afield, nfield, mask_type;
dglGraph_s *graph;
int *component, nnodes, type, i, nlines, components, max_cat;
char buf[2000], *covered;
char *desc;
/* Attribute table */
dbString sql;
dbDriver *driver;
struct field_info *Fi;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("network"));
G_add_keyword(_("components"));
module->description =
_("Computes strongly and weakly connected components in the network.");
/* Define the different options as defined in gis.h */
map_in = G_define_standard_option(G_OPT_V_INPUT);
afield_opt = G_define_standard_option(G_OPT_V_FIELD);
afield_opt->key = "arc_layer";
afield_opt->answer = "1";
afield_opt->label = _("Arc layer");
afield_opt->guisection = _("Cost");
nfield_opt = G_define_standard_option(G_OPT_V_FIELD);
nfield_opt->key = "node_layer";
nfield_opt->answer = "2";
nfield_opt->label = _("Node layer");
nfield_opt->guisection = _("Cost");
afcol = G_define_standard_option(G_OPT_DB_COLUMN);
afcol->key = "arc_column";
afcol->required = NO;
afcol->description =
_("Arc forward/both direction(s) cost column (number)");
afcol->guisection = _("Cost");
abcol = G_define_standard_option(G_OPT_DB_COLUMN);
abcol->key = "arc_backward_column";
abcol->required = NO;
abcol->description = _("Arc backward direction cost column (number)");
abcol->guisection = _("Cost");
ncol = G_define_option();
ncol->key = "node_column";
ncol->type = TYPE_STRING;
ncol->required = NO;
ncol->description = _("Node cost column (number)");
ncol->guisection = _("Cost");
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
method_opt = G_define_option();
method_opt->key = "method";
method_opt->type = TYPE_STRING;
method_opt->required = YES;
method_opt->multiple = NO;
method_opt->options = "weak,strong";
desc = NULL;
G_asprintf(&desc,
"weak;%s;strong;%s",
_("Weakly connected components"),
_("Strongly connected components"));
method_opt->descriptions = desc;
method_opt->description = _("Type of components");
add_f = G_define_flag();
add_f->key = 'a';
add_f->description = _("Add points on nodes");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* TODO: make an option for this */
mask_type = GV_LINE | GV_BOUNDARY;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_check_input_output_name(map_in->answer, map_out->answer,
G_FATAL_EXIT);
Vect_set_open_level(2);
if (1 > Vect_open_old(&In, map_in->answer, ""))
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
with_z = Vect_is_3d(&In);
if (0 > Vect_open_new(&Out, map_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), map_out->answer);
}
/* parse filter option and select appropriate lines */
afield = Vect_get_field_number(&In, afield_opt->answer);
nfield = Vect_get_field_number(&In, nfield_opt->answer);
if (0 != Vect_net_build_graph(&In, mask_type, afield, nfield, afcol->answer,
abcol->answer, ncol->answer, 0, 2))
G_fatal_error(_("Unable to build graph for vector map <%s>"), Vect_get_full_name(&In));
graph = Vect_net_get_graph(&In);
nnodes = Vect_get_num_nodes(&In);
component = (int *)G_calloc(nnodes + 1, sizeof(int));
covered = (char *)G_calloc(nnodes + 1, sizeof(char));
if (!component || !covered) {
G_fatal_error(_("Out of memory"));
exit(EXIT_FAILURE);
}
/* Create table */
Fi = Vect_default_field_info(&Out, 1, NULL, GV_1TABLE);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, GV_KEY_COLUMN, Fi->database,
Fi->driver);
db_init_string(&sql);
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);
sprintf(buf, "create table %s ( cat integer, comp integer)", Fi->table);
db_set_string(&sql, buf);
G_debug(2, "%s", db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
db_close_database_shutdown_driver(driver);
G_fatal_error(_("Unable to create table: '%s'"), db_get_string(&sql));
}
if (db_create_index2(driver, Fi->table, GV_KEY_COLUMN) != DB_OK)
G_warning(_("Cannot create index"));
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT, DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Cannot grant privileges on table <%s>"), Fi->table);
db_begin_transaction(driver);
if (method_opt->answer[0] == 'w') {
G_message(_("Computing weakly connected components..."));
components = NetA_weakly_connected_components(graph, component);
}
else {
G_message(_("Computing strongly connected components..."));
components = NetA_strongly_connected_components(graph, component);
}
G_debug(3, "Components: %d", components);
G_message(_("Writing output..."));
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
nlines = Vect_get_num_lines(&In);
max_cat = 1;
G_percent(0, nlines, 4);
for (i = 1; i <= nlines; i++) {
int comp, cat;
G_percent(i, nlines, 4);
type = Vect_read_line(&In, Points, Cats, i);
if (!Vect_cat_get(Cats, afield, &cat))
continue;
if (type == GV_LINE || type == GV_BOUNDARY) {
int node1, node2;
Vect_get_line_nodes(&In, i, &node1, &node2);
if (component[node1] == component[node2]) {
comp = component[node1];
}
else {
continue;
}
}
else if (type == GV_POINT) {
int node;
/* Vect_get_line_nodes(&In, i, &node, NULL); */
node = Vect_find_node(&In, Points->x[0], Points->y[0], Points->z[0], 0, 0);
if (!node)
continue;
comp = component[node];
covered[node] = 1;
}
else
continue;
cat = max_cat++;
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, cat);
Vect_write_line(&Out, type, Points, Cats);
insert_new_record(driver, Fi, &sql, cat, comp);
}
/*add points on nodes not covered by any point in the network */
if (add_f->answer) {
for (i = 1; i <= nnodes; i++)
if (!covered[i]) {
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, max_cat);
NetA_add_point_on_node(&In, &Out, i, Cats);
insert_new_record(driver, Fi, &sql, max_cat++, component[i]);
}
}
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
Vect_close(&In);
Vect_build(&Out);
Vect_close(&Out);
G_done_msg(_("Found %d components."), components);
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
int field, type, vertex_type;
double dmax;
char buf[DB_SQL_MAX];
struct {
struct Option *input, *output, *type, *dmax, *lfield, *use;
} opt;
struct {
struct Flag *table, *inter;
} flag;
struct GModule *module;
struct Map_info In, Out;
struct line_cats *LCats;
struct line_pnts *LPoints;
dbDriver *driver;
struct field_info *Fi;
dbString stmt;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("geometry"));
G_add_keyword("3D");
G_add_keyword(_("node"));
G_add_keyword(_("vertex"));
module->description =
_("Creates points along input lines in new vector map with 2 layers.");
opt.input = G_define_standard_option(G_OPT_V_INPUT);
opt.lfield = G_define_standard_option(G_OPT_V_FIELD);
opt.lfield->key = "llayer";
opt.lfield->answer = "1";
opt.lfield->label = "Line layer number or name";
opt.lfield->guisection = _("Selection");
opt.type = G_define_standard_option(G_OPT_V3_TYPE);
opt.type->answer = "point,line,boundary,centroid,face";
opt.type->guisection = _("Selection");
opt.output = G_define_standard_option(G_OPT_V_OUTPUT);
opt.use = G_define_option();
opt.use->key = "use";
opt.use->type = TYPE_STRING;
opt.use->required = NO;
opt.use->description = _("Use line nodes or vertices only");
opt.use->options = "node,vertex";
opt.dmax = G_define_option();
opt.dmax->key = "dmax";
opt.dmax->type = TYPE_DOUBLE;
opt.dmax->required = NO;
opt.dmax->answer = "100";
opt.dmax->description = _("Maximum distance between points in map units");
flag.inter = G_define_flag();
flag.inter->key = 'i';
flag.inter->description = _("Interpolate points between line vertices (only for use=vertex)");
flag.table = G_define_standard_flag(G_FLG_V_TABLE);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
LCats = Vect_new_cats_struct();
LPoints = Vect_new_line_struct();
db_init_string(&stmt);
type = Vect_option_to_types(opt.type);
dmax = atof(opt.dmax->answer);
vertex_type = 0;
if (opt.use->answer) {
if (opt.use->answer[0] == 'n')
vertex_type = GV_NODE;
else
vertex_type = GV_VERTEX;
}
Vect_check_input_output_name(opt.input->answer, opt.output->answer,
G_FATAL_EXIT);
/* Open input lines */
Vect_set_open_level(2);
if (Vect_open_old2(&In, opt.input->answer, "", opt.lfield->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), opt.input->answer);
Vect_set_error_handler_io(&In, &Out);
field = Vect_get_field_number(&In, opt.lfield->answer);
/* Open output segments */
if (Vect_open_new(&Out, opt.output->answer, Vect_is_3d(&In)) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
opt.output->answer);
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* Table */
Fi = NULL;
if (!flag.table->answer) {
struct field_info *Fin;
/* copy input table */
Fin = Vect_get_field(&In, field);
if (Fin) { /* table defined */
int ret;
Fi = Vect_default_field_info(&Out, 1, NULL, GV_MTABLE);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, Fin->key,
Fi->database, Fi->driver);
ret = db_copy_table(Fin->driver, Fin->database, Fin->table,
Fi->driver, Vect_subst_var(Fi->database,
&Out), Fi->table);
if (ret == DB_FAILED) {
G_fatal_error(_("Unable to copy table <%s>"),
Fin->table);
}
}
Fi = Vect_default_field_info(&Out, 2, NULL, GV_MTABLE);
Vect_map_add_dblink(&Out, 2, NULL, Fi->table, GV_KEY_COLUMN, Fi->database,
Fi->driver);
/* Open driver */
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);
db_set_error_handler_driver(driver);
if (field == -1)
sprintf(buf,
"create table %s ( cat int, along double precision )",
Fi->table);
else
sprintf(buf,
"create table %s ( cat int, lcat int, along double precision )",
Fi->table);
db_append_string(&stmt, buf);
if (db_execute_immediate(driver, &stmt) != DB_OK) {
G_fatal_error(_("Unable to create table: '%s'"),
db_get_string(&stmt));
}
if (db_create_index2(driver, Fi->table, GV_KEY_COLUMN) != DB_OK)
G_warning(_("Unable to create index for table <%s>, key <%s>"),
Fi->table, GV_KEY_COLUMN);
if (db_grant_on_table (driver, Fi->table, DB_PRIV_SELECT,
DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Unable to grant privileges on table <%s>"),
Fi->table);
db_begin_transaction(driver);
}
if (type & (GV_POINTS | GV_LINES | GV_FACE)) {
int line, nlines, nskipped;
nskipped = 0;
nlines = Vect_get_num_lines(&In);
for (line = 1; line <= nlines; line++) {
int ltype, cat;
G_debug(3, "line = %d", line);
G_percent(line, nlines, 2);
ltype = Vect_read_line(&In, LPoints, LCats, line);
if (!(ltype & type))
continue;
if (!Vect_cat_get(LCats, field, &cat) && field != -1) {
nskipped++;
continue;
}
/* Assign CAT for layer 0 objects (i.e. boundaries) */
if (field == -1)
cat = -1;
if (LPoints->n_points <= 1) {
write_point(&Out, LPoints->x[0], LPoints->y[0], LPoints->z[0],
cat, 0.0, driver, Fi);
}
else { /* lines */
write_line(&Out, LPoints, cat, vertex_type,
flag.inter->answer, dmax, driver, Fi);
}
}
if (nskipped > 0)
G_warning(_("%d features without category in layer <%d> skipped. "
"Note that features without category (usually boundaries) are not "
"skipped when '%s=-1' is given."),
nskipped, field, opt.lfield->key);
}
if (type == GV_AREA) {
int area, nareas, centroid, cat;
nareas = Vect_get_num_areas(&In);
for (area = 1; area <= nareas; area++) {
int i, isle, nisles;
G_percent(area, nareas, 2);
centroid = Vect_get_area_centroid(&In, area);
cat = -1;
if (centroid > 0) {
Vect_read_line(&In, NULL, LCats, centroid);
if (!Vect_cat_get(LCats, field, &cat))
continue;
}
Vect_get_area_points(&In, area, LPoints);
write_line(&Out, LPoints, cat, vertex_type, flag.inter->answer,
dmax, driver, Fi);
nisles = Vect_get_area_num_isles(&In, area);
for (i = 0; i < nisles; i++) {
isle = Vect_get_area_isle(&In, area, i);
Vect_get_isle_points(&In, isle, LPoints);
write_line(&Out, LPoints, cat, vertex_type,
flag.inter->answer, dmax, driver, Fi);
}
}
}
if (!flag.table->answer) {
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
}
Vect_build(&Out);
/* Free, close ... */
Vect_close(&In);
G_done_msg(_("%d points written to output vector map."),
Vect_get_num_primitives(&Out, GV_POINT));
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
/*--------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
/* Variable declarations */
int nsply, nsplx, nrows, ncols, nsplx_adj, nsply_adj;
int nsubregion_col, nsubregion_row, subregion_row, subregion_col;
int subregion = 0, nsubregions = 0;
int last_row, last_column, grid, bilin, ext, flag_auxiliar, cross; /* booleans */
double stepN, stepE, lambda, mean;
double N_extension, E_extension, edgeE, edgeN;
const char *mapset, *drv, *db, *vector, *map;
char table_name[GNAME_MAX], title[64];
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
int dim_vect, nparameters, BW;
int *lineVect; /* Vector restoring primitive's ID */
double *TN, *Q, *parVect; /* Interpolating and least-square vectors */
double **N, **obsVect; /* Interpolation and least-square matrix */
SEGMENT out_seg, mask_seg;
const char *out_file, *mask_file;
int out_fd, mask_fd;
double seg_size;
int seg_mb, segments_in_memory;
int have_mask;
/* Structs declarations */
int raster;
struct Map_info In, In_ext, Out;
struct History history;
struct GModule *module;
struct Option *in_opt, *in_ext_opt, *out_opt, *out_map_opt, *stepE_opt,
*stepN_opt, *lambda_f_opt, *type_opt, *dfield_opt, *col_opt, *mask_opt,
*memory_opt, *solver, *error, *iter;
struct Flag *cross_corr_flag, *spline_step_flag;
struct Reg_dimens dims;
struct Cell_head elaboration_reg, original_reg;
struct bound_box general_box, overlap_box, original_box;
struct Point *observ;
struct line_cats *Cats;
dbCatValArray cvarr;
int with_z;
int nrec, ctype = 0;
struct field_info *Fi;
dbDriver *driver, *driver_cats;
/*----------------------------------------------------------------*/
/* Options declarations */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("surface"));
G_add_keyword(_("interpolation"));
G_add_keyword(_("LIDAR"));
module->description =
_("Performs bicubic or bilinear spline interpolation with Tykhonov regularization.");
cross_corr_flag = G_define_flag();
cross_corr_flag->key = 'c';
cross_corr_flag->description =
_("Find the best Tykhonov regularizing parameter using a \"leave-one-out\" cross validation method");
spline_step_flag = G_define_flag();
spline_step_flag->key = 'e';
spline_step_flag->label = _("Estimate point density and distance");
spline_step_flag->description =
_("Estimate point density and distance for the input vector points within the current region extends and quit");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
in_opt->label = _("Name of input vector point map");
dfield_opt = G_define_standard_option(G_OPT_V_FIELD);
dfield_opt->guisection = _("Settings");
col_opt = G_define_standard_option(G_OPT_DB_COLUMN);
col_opt->required = NO;
col_opt->label =
_("Name of the attribute column with values to be used for approximation");
col_opt->description = _("If not given and input is 3D vector map then z-coordinates are used.");
col_opt->guisection = _("Settings");
in_ext_opt = G_define_standard_option(G_OPT_V_INPUT);
in_ext_opt->key = "sparse_input";
in_ext_opt->required = NO;
in_ext_opt->label =
_("Name of input vector map with sparse points");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
out_opt->required = NO;
out_opt->guisection = _("Outputs");
out_map_opt = G_define_standard_option(G_OPT_R_OUTPUT);
out_map_opt->key = "raster_output";
out_map_opt->required = NO;
out_map_opt->guisection = _("Outputs");
mask_opt = G_define_standard_option(G_OPT_R_INPUT);
mask_opt->key = "mask";
mask_opt->label = _("Raster map to use for masking (applies to raster output only)");
mask_opt->description = _("Only cells that are not NULL and not zero are interpolated");
mask_opt->required = NO;
stepE_opt = G_define_option();
stepE_opt->key = "ew_step";
stepE_opt->type = TYPE_DOUBLE;
stepE_opt->required = NO;
stepE_opt->answer = "4";
stepE_opt->description =
_("Length of each spline step in the east-west direction");
stepE_opt->guisection = _("Settings");
stepN_opt = G_define_option();
stepN_opt->key = "ns_step";
stepN_opt->type = TYPE_DOUBLE;
stepN_opt->required = NO;
stepN_opt->answer = "4";
stepN_opt->description =
_("Length of each spline step in the north-south direction");
stepN_opt->guisection = _("Settings");
type_opt = G_define_option();
type_opt->key = "method";
type_opt->description = _("Spline interpolation algorithm");
type_opt->type = TYPE_STRING;
type_opt->options = "bilinear,bicubic";
type_opt->answer = "bilinear";
type_opt->guisection = _("Settings");
G_asprintf((char **) &(type_opt->descriptions),
"bilinear;%s;bicubic;%s",
_("Bilinear interpolation"),
_("Bicubic interpolation"));
lambda_f_opt = G_define_option();
lambda_f_opt->key = "lambda_i";
lambda_f_opt->type = TYPE_DOUBLE;
lambda_f_opt->required = NO;
lambda_f_opt->description = _("Tykhonov regularization parameter (affects smoothing)");
lambda_f_opt->answer = "0.01";
lambda_f_opt->guisection = _("Settings");
solver = N_define_standard_option(N_OPT_SOLVER_SYMM);
solver->options = "cholesky,cg";
solver->answer = "cholesky";
iter = N_define_standard_option(N_OPT_MAX_ITERATIONS);
error = N_define_standard_option(N_OPT_ITERATION_ERROR);
memory_opt = G_define_option();
memory_opt->key = "memory";
memory_opt->type = TYPE_INTEGER;
memory_opt->required = NO;
memory_opt->answer = "300";
memory_opt->label = _("Maximum memory to be used (in MB)");
memory_opt->description = _("Cache size for raster rows");
/*----------------------------------------------------------------*/
/* Parsing */
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
vector = out_opt->answer;
map = out_map_opt->answer;
if (vector && map)
G_fatal_error(_("Choose either vector or raster output, not both"));
if (!vector && !map && !cross_corr_flag->answer)
G_fatal_error(_("No raster or vector or cross-validation output"));
if (!strcmp(type_opt->answer, "linear"))
bilin = P_BILINEAR;
else
bilin = P_BICUBIC;
stepN = atof(stepN_opt->answer);
stepE = atof(stepE_opt->answer);
lambda = atof(lambda_f_opt->answer);
flag_auxiliar = FALSE;
drv = db_get_default_driver_name();
if (!drv) {
if (db_set_default_connection() != DB_OK)
G_fatal_error(_("Unable to set default DB connection"));
drv = db_get_default_driver_name();
}
db = db_get_default_database_name();
if (!db)
G_fatal_error(_("No default DB defined"));
/* Set auxiliary table's name */
if (vector) {
if (G_name_is_fully_qualified(out_opt->answer, xname, xmapset)) {
sprintf(table_name, "%s_aux", xname);
}
else
sprintf(table_name, "%s_aux", out_opt->answer);
}
/* Something went wrong in a previous v.surf.bspline execution */
if (db_table_exists(drv, db, table_name)) {
/* Start driver and open db */
driver = db_start_driver_open_database(drv, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
drv);
db_set_error_handler_driver(driver);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Old auxiliary table could not be dropped"));
db_close_database_shutdown_driver(driver);
}
/* Open input vector */
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), in_opt->answer);
Vect_set_open_level(1); /* WITHOUT TOPOLOGY */
if (1 > Vect_open_old(&In, in_opt->answer, mapset))
G_fatal_error(_("Unable to open vector map <%s> at the topological level"),
in_opt->answer);
bspline_field = 0; /* assume 3D input */
bspline_column = col_opt->answer;
with_z = !bspline_column && Vect_is_3d(&In);
if (Vect_is_3d(&In)) {
if (!with_z)
G_verbose_message(_("Input is 3D: using attribute values instead of z-coordinates for approximation"));
else
G_verbose_message(_("Input is 3D: using z-coordinates for approximation"));
}
else { /* 2D */
if (!bspline_column)
G_fatal_error(_("Input vector map is 2D. Parameter <%s> required."), col_opt->key);
}
if (!with_z) {
bspline_field = Vect_get_field_number(&In, dfield_opt->answer);
}
/* Estimate point density and mean distance for current region */
if (spline_step_flag->answer) {
double dens, dist;
if (P_estimate_splinestep(&In, &dens, &dist) == 0) {
fprintf(stdout, _("Estimated point density: %.4g"), dens);
fprintf(stdout, _("Estimated mean distance between points: %.4g"), dist);
}
else {
fprintf(stdout, _("No points in current region"));
}
Vect_close(&In);
exit(EXIT_SUCCESS);
}
/*----------------------------------------------------------------*/
/* Cross-correlation begins */
if (cross_corr_flag->answer) {
G_debug(1, "CrossCorrelation()");
cross = cross_correlation(&In, stepE, stepN);
if (cross != TRUE)
G_fatal_error(_("Cross validation didn't finish correctly"));
else {
G_debug(1, "Cross validation finished correctly");
Vect_close(&In);
G_done_msg(_("Cross validation finished for ew_step = %f and ns_step = %f"), stepE, stepN);
exit(EXIT_SUCCESS);
}
}
/* Open input ext vector */
ext = FALSE;
if (in_ext_opt->answer) {
ext = TRUE;
G_message(_("Vector map <%s> of sparse points will be interpolated"),
in_ext_opt->answer);
if ((mapset = G_find_vector2(in_ext_opt->answer, "")) == NULL)
G_fatal_error(_("Vector map <%s> not found"), in_ext_opt->answer);
Vect_set_open_level(1); /* WITHOUT TOPOLOGY */
if (1 > Vect_open_old(&In_ext, in_ext_opt->answer, mapset))
G_fatal_error(_("Unable to open vector map <%s> at the topological level"),
in_opt->answer);
}
/* Open output map */
/* vector output */
if (vector && !map) {
if (strcmp(drv, "dbf") == 0)
G_fatal_error(_("Sorry, the <%s> driver is not compatible with "
"the vector output of this module. "
"Try with raster output or another driver."), drv);
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
G_FATAL_EXIT);
grid = FALSE;
if (0 > Vect_open_new(&Out, out_opt->answer, WITH_Z))
G_fatal_error(_("Unable to create vector map <%s>"),
out_opt->answer);
/* Copy vector Head File */
if (ext == FALSE) {
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
}
else {
Vect_copy_head_data(&In_ext, &Out);
Vect_hist_copy(&In_ext, &Out);
}
Vect_hist_command(&Out);
G_verbose_message(_("Points in input vector map <%s> will be interpolated"),
vector);
}
/* read z values from attribute table */
if (bspline_field > 0) {
G_message(_("Reading values from attribute table..."));
db_CatValArray_init(&cvarr);
Fi = Vect_get_field(&In, bspline_field);
if (Fi == NULL)
G_fatal_error(_("Cannot read layer info"));
driver_cats = db_start_driver_open_database(Fi->driver, Fi->database);
/*G_debug (0, _("driver=%s db=%s"), Fi->driver, Fi->database); */
if (driver_cats == NULL)
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Fi->database, Fi->driver);
db_set_error_handler_driver(driver_cats);
nrec =
db_select_CatValArray(driver_cats, Fi->table, Fi->key,
col_opt->answer, 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(_("%d records selected from table"), nrec);
db_close_database_shutdown_driver(driver_cats);
}
/*----------------------------------------------------------------*/
/* Interpolation begins */
G_debug(1, "Interpolation()");
/* Open driver and database */
driver = db_start_driver_open_database(drv, db);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. "
"Run db.connect."), drv);
db_set_error_handler_driver(driver);
/* Create auxiliary table */
if (vector) {
if ((flag_auxiliar = P_Create_Aux4_Table(driver, table_name)) == FALSE) {
P_Drop_Aux_Table(driver, table_name);
G_fatal_error(_("Interpolation: Creating table: "
"It was impossible to create table <%s>."),
table_name);
}
/* db_create_index2(driver, table_name, "ID"); */
/* sqlite likes that ??? */
db_close_database_shutdown_driver(driver);
driver = db_start_driver_open_database(drv, db);
}
/* raster output */
raster = -1;
Rast_set_fp_type(DCELL_TYPE);
if (!vector && map) {
grid = TRUE;
raster = Rast_open_fp_new(out_map_opt->answer);
G_verbose_message(_("Cells for raster map <%s> will be interpolated"),
map);
}
/* Setting regions and boxes */
G_debug(1, "Interpolation: Setting regions and boxes");
G_get_window(&original_reg);
G_get_window(&elaboration_reg);
Vect_region_box(&original_reg, &original_box);
Vect_region_box(&elaboration_reg, &overlap_box);
Vect_region_box(&elaboration_reg, &general_box);
nrows = Rast_window_rows();
ncols = Rast_window_cols();
/* Alloc raster matrix */
have_mask = 0;
out_file = mask_file = NULL;
out_fd = mask_fd = -1;
if (grid == TRUE) {
int row;
DCELL *drastbuf;
seg_mb = atoi(memory_opt->answer);
if (seg_mb < 3)
G_fatal_error(_("Memory in MB must be >= 3"));
if (mask_opt->answer)
seg_size = sizeof(double) + sizeof(char);
else
seg_size = sizeof(double);
seg_size = (seg_size * SEGSIZE * SEGSIZE) / (1 << 20);
segments_in_memory = seg_mb / seg_size + 0.5;
G_debug(1, "%d %dx%d segments held in memory", segments_in_memory, SEGSIZE, SEGSIZE);
out_file = G_tempfile();
out_fd = creat(out_file, 0666);
if (Segment_format(out_fd, nrows, ncols, SEGSIZE, SEGSIZE, sizeof(double)) != 1)
G_fatal_error(_("Can not create temporary file"));
close(out_fd);
out_fd = open(out_file, 2);
if (Segment_init(&out_seg, out_fd, segments_in_memory) != 1)
G_fatal_error(_("Can not initialize temporary file"));
/* initialize output */
G_message(_("Initializing output..."));
drastbuf = Rast_allocate_buf(DCELL_TYPE);
Rast_set_d_null_value(drastbuf, ncols);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
Segment_put_row(&out_seg, drastbuf, row);
}
G_percent(row, nrows, 2);
if (mask_opt->answer) {
int row, col, maskfd;
DCELL dval, *drastbuf;
char mask_val;
G_message(_("Load masking map"));
mask_file = G_tempfile();
mask_fd = creat(mask_file, 0666);
if (Segment_format(mask_fd, nrows, ncols, SEGSIZE, SEGSIZE, sizeof(char)) != 1)
G_fatal_error(_("Can not create temporary file"));
close(mask_fd);
mask_fd = open(mask_file, 2);
if (Segment_init(&mask_seg, mask_fd, segments_in_memory) != 1)
G_fatal_error(_("Can not initialize temporary file"));
maskfd = Rast_open_old(mask_opt->answer, "");
drastbuf = Rast_allocate_buf(DCELL_TYPE);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
Rast_get_d_row(maskfd, drastbuf, row);
for (col = 0; col < ncols; col++) {
dval = drastbuf[col];
if (Rast_is_d_null_value(&dval) || dval == 0)
mask_val = 0;
else
mask_val = 1;
Segment_put(&mask_seg, &mask_val, row, col);
}
}
G_percent(row, nrows, 2);
G_free(drastbuf);
Rast_close(maskfd);
have_mask = 1;
}
}
/*------------------------------------------------------------------
| Subdividing and working with tiles:
| Each original region will be divided into several subregions.
| Each one will be overlaped by its neighbouring subregions.
| The overlapping is calculated as a fixed OVERLAP_SIZE times
| the largest spline step plus 2 * edge
----------------------------------------------------------------*/
/* Fixing parameters of the elaboration region */
P_zero_dim(&dims); /* Set dim struct to zero */
nsplx_adj = NSPLX_MAX;
nsply_adj = NSPLY_MAX;
if (stepN > stepE)
dims.overlap = OVERLAP_SIZE * stepN;
else
dims.overlap = OVERLAP_SIZE * stepE;
P_get_edge(bilin, &dims, stepE, stepN);
P_set_dim(&dims, stepE, stepN, &nsplx_adj, &nsply_adj);
G_verbose_message(_("Adjusted EW splines %d"), nsplx_adj);
G_verbose_message(_("Adjusted NS splines %d"), nsply_adj);
/* calculate number of subregions */
edgeE = dims.ew_size - dims.overlap - 2 * dims.edge_v;
edgeN = dims.sn_size - dims.overlap - 2 * dims.edge_h;
N_extension = original_reg.north - original_reg.south;
E_extension = original_reg.east - original_reg.west;
nsubregion_col = ceil(E_extension / edgeE) + 0.5;
nsubregion_row = ceil(N_extension / edgeN) + 0.5;
if (nsubregion_col < 0)
nsubregion_col = 0;
if (nsubregion_row < 0)
nsubregion_row = 0;
nsubregions = nsubregion_row * nsubregion_col;
/* Creating line and categories structs */
Cats = Vect_new_cats_struct();
Vect_cat_set(Cats, 1, 0);
subregion_row = 0;
elaboration_reg.south = original_reg.north;
last_row = FALSE;
while (last_row == FALSE) { /* For each subregion row */
subregion_row++;
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_ROW);
if (elaboration_reg.north > original_reg.north) { /* First row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
FIRST_ROW);
}
if (elaboration_reg.south <= original_reg.south) { /* Last row */
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
LAST_ROW);
last_row = TRUE;
}
nsply =
ceil((elaboration_reg.north -
elaboration_reg.south) / stepN) + 0.5;
G_debug(1, "Interpolation: nsply = %d", nsply);
/*
if (nsply > NSPLY_MAX)
nsply = NSPLY_MAX;
*/
elaboration_reg.east = original_reg.west;
last_column = FALSE;
subregion_col = 0;
/* TODO: process each subregion using its own thread (via OpenMP or pthreads) */
/* I'm not sure about pthreads, but you can tell OpenMP to start all at the
same time and it will keep num_workers supplied with the next job as free
cpus become available */
while (last_column == FALSE) { /* For each subregion column */
int npoints = 0;
/* needed for sparse points interpolation */
int npoints_ext, *lineVect_ext = NULL;
double **obsVect_ext; /*, mean_ext = .0; */
struct Point *observ_ext;
subregion_col++;
subregion++;
if (nsubregions > 1)
G_message(_("Processing subregion %d of %d..."), subregion, nsubregions);
P_set_regions(&elaboration_reg, &general_box, &overlap_box, dims,
GENERAL_COLUMN);
if (elaboration_reg.west < original_reg.west) { /* First column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, FIRST_COLUMN);
}
if (elaboration_reg.east >= original_reg.east) { /* Last column */
P_set_regions(&elaboration_reg, &general_box, &overlap_box,
dims, LAST_COLUMN);
last_column = TRUE;
}
nsplx =
ceil((elaboration_reg.east -
elaboration_reg.west) / stepE) + 0.5;
G_debug(1, "Interpolation: nsplx = %d", nsplx);
/*
if (nsplx > NSPLX_MAX)
nsplx = NSPLX_MAX;
*/
G_debug(1, "Interpolation: (%d,%d): subregion bounds",
subregion_row, subregion_col);
G_debug(1, "Interpolation: \t\tNORTH:%.2f\t",
elaboration_reg.north);
G_debug(1, "Interpolation: WEST:%.2f\t\tEAST:%.2f",
elaboration_reg.west, elaboration_reg.east);
G_debug(1, "Interpolation: \t\tSOUTH:%.2f",
elaboration_reg.south);
#ifdef DEBUG_SUBREGIONS
fprintf(stdout, "B 5\n");
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.east, elaboration_reg.north);
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.west, elaboration_reg.north);
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.west, elaboration_reg.south);
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.east, elaboration_reg.south);
fprintf(stdout, " %.11g %.11g\n", elaboration_reg.east, elaboration_reg.north);
fprintf(stdout, "C 1 1\n");
fprintf(stdout, " %.11g %.11g\n", (elaboration_reg.west + elaboration_reg.east) / 2,
(elaboration_reg.south + elaboration_reg.north) / 2);
fprintf(stdout, " 1 %d\n", subregion);
#endif
/* reading points in interpolation region */
dim_vect = nsplx * nsply;
observ_ext = NULL;
if (grid == FALSE && ext == TRUE) {
observ_ext =
P_Read_Vector_Region_Map(&In_ext,
&elaboration_reg,
&npoints_ext, dim_vect,
1);
}
else
npoints_ext = 1;
if (grid == TRUE && have_mask) {
/* any unmasked cells in general region ? */
mean = 0;
observ_ext =
P_Read_Raster_Region_masked(&mask_seg, &original_reg,
original_box, general_box,
&npoints_ext, dim_vect, mean);
}
observ = NULL;
if (npoints_ext > 0) {
observ =
P_Read_Vector_Region_Map(&In, &elaboration_reg, &npoints,
dim_vect, bspline_field);
}
else
npoints = 1;
G_debug(1,
"Interpolation: (%d,%d): Number of points in <elaboration_box> is %d",
subregion_row, subregion_col, npoints);
if (npoints > 0)
G_verbose_message(_("%d points found in this subregion"), npoints);
/* only interpolate if there are any points in current subregion */
if (npoints > 0 && npoints_ext > 0) {
int i;
nparameters = nsplx * nsply;
BW = P_get_BandWidth(bilin, nsply);
/* Least Squares system */
N = G_alloc_matrix(nparameters, BW); /* Normal matrix */
TN = G_alloc_vector(nparameters); /* vector */
parVect = G_alloc_vector(nparameters); /* Parameters vector */
obsVect = G_alloc_matrix(npoints, 3); /* Observation vector */
Q = G_alloc_vector(npoints); /* "a priori" var-cov matrix */
lineVect = G_alloc_ivector(npoints); /* */
for (i = 0; i < npoints; i++) { /* Setting obsVect vector & Q matrix */
double dval;
Q[i] = 1; /* Q=I */
lineVect[i] = observ[i].lineID;
obsVect[i][0] = observ[i].coordX;
obsVect[i][1] = observ[i].coordY;
/* read z coordinates from attribute table */
if (bspline_field > 0) {
int cat, ival, ret;
cat = observ[i].cat;
if (cat < 0)
continue;
if (ctype == DB_C_TYPE_INT) {
ret =
db_CatValArray_get_value_int(&cvarr, cat,
&ival);
obsVect[i][2] = ival;
observ[i].coordZ = ival;
}
else { /* DB_C_TYPE_DOUBLE */
ret =
db_CatValArray_get_value_double(&cvarr, cat,
&dval);
obsVect[i][2] = dval;
observ[i].coordZ = dval;
}
if (ret != DB_OK) {
G_warning(_("Interpolation: (%d,%d): No record for point (cat = %d)"),
subregion_row, subregion_col, cat);
continue;
}
}
/* use z coordinates of 3D vector */
else {
obsVect[i][2] = observ[i].coordZ;
}
}
/* Mean calculation for every point */
mean = P_Mean_Calc(&elaboration_reg, observ, npoints);
G_debug(1, "Interpolation: (%d,%d): mean=%lf",
subregion_row, subregion_col, mean);
G_free(observ);
for (i = 0; i < npoints; i++)
obsVect[i][2] -= mean;
/* Bilinear interpolation */
if (bilin) {
G_debug(1,
"Interpolation: (%d,%d): Bilinear interpolation...",
subregion_row, subregion_col);
normalDefBilin(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, npoints,
nparameters, BW);
nCorrectGrad(N, lambda, nsplx, nsply, stepE, stepN);
}
/* Bicubic interpolation */
else {
G_debug(1,
"Interpolation: (%d,%d): Bicubic interpolation...",
subregion_row, subregion_col);
normalDefBicubic(N, TN, Q, obsVect, stepE, stepN, nsplx,
nsply, elaboration_reg.west,
elaboration_reg.south, npoints,
nparameters, BW);
nCorrectGrad(N, lambda, nsplx, nsply, stepE, stepN);
}
if(G_strncasecmp(solver->answer, "cg", 2) == 0)
G_math_solver_cg_sband(N, parVect, TN, nparameters, BW, atoi(iter->answer), atof(error->answer));
else
G_math_solver_cholesky_sband(N, parVect, TN, nparameters, BW);
G_free_matrix(N);
G_free_vector(TN);
G_free_vector(Q);
if (grid == TRUE) { /* GRID INTERPOLATION ==> INTERPOLATION INTO A RASTER */
G_debug(1, "Interpolation: (%d,%d): Regular_Points...",
subregion_row, subregion_col);
if (!have_mask) {
P_Regular_Points(&elaboration_reg, &original_reg, general_box,
overlap_box, &out_seg, parVect,
stepN, stepE, dims.overlap, mean,
nsplx, nsply, nrows, ncols, bilin);
}
else {
P_Sparse_Raster_Points(&out_seg,
&elaboration_reg, &original_reg,
general_box, overlap_box,
observ_ext, parVect,
stepE, stepN,
dims.overlap, nsplx, nsply,
npoints_ext, bilin, mean);
}
}
else { /* OBSERVATION POINTS INTERPOLATION */
if (ext == FALSE) {
G_debug(1, "Interpolation: (%d,%d): Sparse_Points...",
subregion_row, subregion_col);
P_Sparse_Points(&Out, &elaboration_reg, general_box,
overlap_box, obsVect, parVect,
lineVect, stepE, stepN,
dims.overlap, nsplx, nsply, npoints,
bilin, Cats, driver, mean,
table_name);
}
else { /* FLAG_EXT == TRUE */
/* done that earlier */
/*
int npoints_ext, *lineVect_ext = NULL;
double **obsVect_ext;
struct Point *observ_ext;
observ_ext =
P_Read_Vector_Region_Map(&In_ext,
&elaboration_reg,
&npoints_ext, dim_vect,
1);
*/
obsVect_ext = G_alloc_matrix(npoints_ext, 3); /* Observation vector_ext */
lineVect_ext = G_alloc_ivector(npoints_ext);
for (i = 0; i < npoints_ext; i++) { /* Setting obsVect_ext vector & Q matrix */
obsVect_ext[i][0] = observ_ext[i].coordX;
obsVect_ext[i][1] = observ_ext[i].coordY;
obsVect_ext[i][2] = observ_ext[i].coordZ - mean;
lineVect_ext[i] = observ_ext[i].lineID;
}
G_free(observ_ext);
G_debug(1, "Interpolation: (%d,%d): Sparse_Points...",
subregion_row, subregion_col);
P_Sparse_Points(&Out, &elaboration_reg, general_box,
overlap_box, obsVect_ext, parVect,
lineVect_ext, stepE, stepN,
dims.overlap, nsplx, nsply,
npoints_ext, bilin, Cats, driver,
mean, table_name);
G_free_matrix(obsVect_ext);
G_free_ivector(lineVect_ext);
} /* END FLAG_EXT == TRUE */
} /* END GRID == FALSE */
G_free_vector(parVect);
G_free_matrix(obsVect);
G_free_ivector(lineVect);
}
else {
if (observ)
G_free(observ);
if (observ_ext)
G_free(observ_ext);
if (npoints == 0)
G_warning(_("No data within this subregion. "
"Consider increasing spline step values."));
}
} /*! END WHILE; last_column = TRUE */
} /*! END WHILE; last_row = TRUE */
G_verbose_message(_("Writing output..."));
/* Writing the output raster map */
if (grid == TRUE) {
int row, col;
DCELL *drastbuf, dval;
if (have_mask) {
Segment_release(&mask_seg); /* release memory */
close(mask_fd);
unlink(mask_file);
}
drastbuf = Rast_allocate_buf(DCELL_TYPE);
for (row = 0; row < nrows; row++) {
G_percent(row, nrows, 2);
for (col = 0; col < ncols; col++) {
Segment_get(&out_seg, &dval, row, col);
drastbuf[col] = dval;
}
Rast_put_d_row(raster, drastbuf);
}
Rast_close(raster);
Segment_release(&out_seg); /* release memory */
close(out_fd);
unlink(out_file);
/* set map title */
sprintf(title, "%s interpolation with Tykhonov regularization",
type_opt->answer);
Rast_put_cell_title(out_map_opt->answer, title);
/* write map history */
Rast_short_history(out_map_opt->answer, "raster", &history);
Rast_command_history(&history);
Rast_write_history(out_map_opt->answer, &history);
}
/* Writing to the output vector map the points from the overlapping zones */
else if (flag_auxiliar == TRUE) {
if (ext == FALSE)
P_Aux_to_Vector(&In, &Out, driver, table_name);
else
P_Aux_to_Vector(&In_ext, &Out, driver, table_name);
/* Drop auxiliary table */
G_debug(1, "%s: Dropping <%s>", argv[0], table_name);
if (P_Drop_Aux_Table(driver, table_name) != DB_OK)
G_fatal_error(_("Auxiliary table could not be dropped"));
}
db_close_database_shutdown_driver(driver);
Vect_close(&In);
if (ext != FALSE)
Vect_close(&In_ext);
if (vector)
Vect_close(&Out);
G_done_msg(" ");
exit(EXIT_SUCCESS);
} /*END MAIN */
int main(int argc, char *argv[])
{
struct Map_info In, Out;
static struct line_pnts *Points;
struct line_cats *Cats;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out;
struct Option *afield_opt, *nfield_opt, *afcol, *ncol;
struct Flag *geo_f;
int with_z;
int afield, nfield, mask_type;
dglGraph_s *graph;
int i, edges, geo;
struct ilist *tree_list;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("network"));
G_add_keyword(_("spanning tree"));
module->description =
_("Computes minimum spanning tree for the network.");
/* Define the different options as defined in gis.h */
map_in = G_define_standard_option(G_OPT_V_INPUT);
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
afield_opt = G_define_standard_option(G_OPT_V_FIELD);
afield_opt->key = "alayer";
afield_opt->answer = "1";
afield_opt->label = _("Arc layer");
afield_opt->guisection = _("Cost");
nfield_opt = G_define_standard_option(G_OPT_V_FIELD);
nfield_opt->key = "nlayer";
nfield_opt->answer = "2";
nfield_opt->label = _("Node layer");
nfield_opt->guisection = _("Cost");
afcol = G_define_standard_option(G_OPT_DB_COLUMN);
afcol->key = "afcolumn";
afcol->required = NO;
afcol->description =
_("Arc forward/both direction(s) cost column (number)");
afcol->guisection = _("Cost");
ncol = G_define_standard_option(G_OPT_DB_COLUMN);
ncol->key = "ncolumn";
ncol->required = NO;
ncol->description = _("Node cost column (number)");
ncol->guisection = _("Cost");
geo_f = G_define_flag();
geo_f->key = 'g';
geo_f->description =
_("Use geodesic calculation for longitude-latitude locations");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* TODO: make an option for this */
mask_type = GV_LINE | GV_BOUNDARY;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_check_input_output_name(map_in->answer, map_out->answer,
G_FATAL_EXIT);
Vect_set_open_level(2);
if (1 > Vect_open_old(&In, map_in->answer, ""))
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
with_z = Vect_is_3d(&In);
if (0 > Vect_open_new(&Out, map_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), map_out->answer);
}
if (geo_f->answer) {
geo = 1;
if (G_projection() != PROJECTION_LL)
G_warning(_("The current projection is not longitude-latitude"));
}
else
geo = 0;
/* parse filter option and select appropriate lines */
afield = Vect_get_field_number(&In, afield_opt->answer);
nfield = Vect_get_field_number(&In, nfield_opt->answer);
if (0 != Vect_net_build_graph(&In, mask_type, afield, nfield, afcol->answer, NULL,
ncol->answer, geo, 0))
G_fatal_error(_("Unable to build graph for vector map <%s>"), Vect_get_full_name(&In));
graph = Vect_net_get_graph(&In);
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
tree_list = Vect_new_list();
edges = NetA_spanning_tree(graph, tree_list);
G_debug(3, "Edges: %d", edges);
for (i = 0; i < edges; i++) {
int type =
Vect_read_line(&In, Points, Cats, abs(tree_list->value[i]));
Vect_write_line(&Out, type, Points, Cats);
}
Vect_destroy_list(tree_list);
Vect_build(&Out);
Vect_close(&In);
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Map_info In, Out;
static struct line_pnts *Points;
struct line_cats *Cats;
struct GModule *module; /* GRASS module for parsing arguments */
struct Option *map_in, *map_out;
struct Option *cat_opt, *field_opt, *where_opt, *abcol, *afcol;
struct Option *iter_opt, *error_opt;
struct Flag *geo_f, *add_f;
int chcat, with_z;
int layer, mask_type;
struct varray *varray;
dglGraph_s *graph;
int i, geo, nnodes, nlines, j, max_cat;
char buf[2000], *covered;
/* initialize GIS environment */
G_gisinit(argv[0]); /* reads grass env, stores program name to G_program_name() */
/* initialize module */
module = G_define_module();
module->keywords = _("vector, network, centrality measures");
module->description =
_("Computes degree, centrality, betweeness, closeness and eigenvector "
"centrality measures in the network.");
/* Define the different options as defined in gis.h */
map_in = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD);
map_out = G_define_standard_option(G_OPT_V_OUTPUT);
cat_opt = G_define_standard_option(G_OPT_V_CATS);
cat_opt->guisection = _("Selection");
where_opt = G_define_standard_option(G_OPT_WHERE);
where_opt->guisection = _("Selection");
afcol = G_define_standard_option(G_OPT_COLUMN);
afcol->key = "afcolumn";
afcol->required = NO;
afcol->description =
_("Name of arc forward/both direction(s) cost column");
afcol->guisection = _("Cost");
abcol = G_define_standard_option(G_OPT_COLUMN);
abcol->key = "abcolumn";
abcol->required = NO;
abcol->description = _("Name of arc backward direction cost column");
abcol->guisection = _("Cost");
deg_opt = G_define_standard_option(G_OPT_COLUMN);
deg_opt->key = "degree";
deg_opt->required = NO;
deg_opt->description = _("Name of degree centrality column");
deg_opt->guisection = _("Columns");
close_opt = G_define_standard_option(G_OPT_COLUMN);
close_opt->key = "closeness";
close_opt->required = NO;
close_opt->description = _("Name of closeness centrality column");
close_opt->guisection = _("Columns");
betw_opt = G_define_standard_option(G_OPT_COLUMN);
betw_opt->key = "betweenness";
betw_opt->required = NO;
betw_opt->description = _("Name of betweenness centrality column");
betw_opt->guisection = _("Columns");
eigen_opt = G_define_standard_option(G_OPT_COLUMN);
eigen_opt->key = "eigenvector";
eigen_opt->required = NO;
eigen_opt->description = _("Name of eigenvector centrality column");
eigen_opt->guisection = _("Columns");
iter_opt = G_define_option();
iter_opt->key = "iterations";
iter_opt->answer = "1000";
iter_opt->type = TYPE_INTEGER;
iter_opt->required = NO;
iter_opt->description =
_("Maximum number of iterations to compute eigenvector centrality");
error_opt = G_define_option();
error_opt->key = "error";
error_opt->answer = "0.1";
error_opt->type = TYPE_DOUBLE;
error_opt->required = NO;
error_opt->description =
_("Cummulative error tolerance for eigenvector centrality");
geo_f = G_define_flag();
geo_f->key = 'g';
geo_f->description =
_("Use geodesic calculation for longitude-latitude locations");
add_f = G_define_flag();
add_f->key = 'a';
add_f->description = _("Add points on nodes");
/* options and flags parser */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* TODO: make an option for this */
mask_type = GV_LINE | GV_BOUNDARY;
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_check_input_output_name(map_in->answer, map_out->answer,
GV_FATAL_EXIT);
Vect_set_open_level(2);
if (1 > Vect_open_old(&In, map_in->answer, ""))
G_fatal_error(_("Unable to open vector map <%s>"), map_in->answer);
with_z = Vect_is_3d(&In);
if (0 > Vect_open_new(&Out, map_out->answer, with_z)) {
Vect_close(&In);
G_fatal_error(_("Unable to create vector map <%s>"), map_out->answer);
}
if (geo_f->answer) {
geo = 1;
if (G_projection() != PROJECTION_LL)
G_warning(_("The current projection is not longitude-latitude"));
}
else
geo = 0;
/* parse filter option and select appropriate lines */
layer = atoi(field_opt->answer);
chcat =
(NetA_initialise_varray
(&In, layer, mask_type, where_opt->answer, cat_opt->answer,
&varray) == 1);
/* Create table */
Fi = Vect_default_field_info(&Out, 1, NULL, GV_1TABLE);
Vect_map_add_dblink(&Out, 1, NULL, Fi->table, "cat", Fi->database,
Fi->driver);
db_init_string(&sql);
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);
db_init_string(&tmp);
if (deg_opt->answer)
append_string(&tmp, deg_opt->answer);
if (close_opt->answer)
append_string(&tmp, close_opt->answer);
if (betw_opt->answer)
append_string(&tmp, betw_opt->answer);
if (eigen_opt->answer)
append_string(&tmp, eigen_opt->answer);
sprintf(buf,
"create table %s(cat integer%s)", Fi->table, db_get_string(&tmp));
db_set_string(&sql, buf);
G_debug(2, db_get_string(&sql));
if (db_execute_immediate(driver, &sql) != DB_OK) {
db_close_database_shutdown_driver(driver);
G_fatal_error(_("Unable to create table: '%s'"), db_get_string(&sql));
}
if (db_create_index2(driver, Fi->table, "cat") != DB_OK)
G_warning(_("Cannot create index"));
if (db_grant_on_table
(driver, Fi->table, DB_PRIV_SELECT, DB_GROUP | DB_PUBLIC) != DB_OK)
G_fatal_error(_("Cannot grant privileges on table <%s>"), Fi->table);
db_begin_transaction(driver);
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
Vect_net_build_graph(&In, mask_type, atoi(field_opt->answer), 0,
afcol->answer, abcol->answer, NULL, geo, 0);
graph = &(In.graph);
nnodes = dglGet_NodeCount(graph);
deg = closeness = betw = eigen = NULL;
covered = (char *)G_calloc(nnodes + 1, sizeof(char));
if (!covered)
G_fatal_error(_("Out of memory"));
if (deg_opt->answer) {
deg = (double *)G_calloc(nnodes + 1, sizeof(double));
if (!deg)
G_fatal_error(_("Out of memory"));
}
if (close_opt->answer) {
closeness = (double *)G_calloc(nnodes + 1, sizeof(double));
if (!closeness)
G_fatal_error(_("Out of memory"));
}
if (betw_opt->answer) {
betw = (double *)G_calloc(nnodes + 1, sizeof(double));
if (!betw)
G_fatal_error(_("Out of memory"));
}
if (eigen_opt->answer) {
eigen = (double *)G_calloc(nnodes + 1, sizeof(double));
if (!eigen)
G_fatal_error(_("Out of memory"));
}
if (deg_opt->answer) {
G_message(_("Computing degree centrality measure"));
NetA_degree_centrality(graph, deg);
}
if (betw_opt->answer || close_opt->answer) {
G_message(_("Computing betweenness and/or closeness centrality measure"));
NetA_betweenness_closeness(graph, betw, closeness);
if (closeness)
for (i = 1; i <= nnodes; i++)
closeness[i] /= (double)In.cost_multip;
}
if (eigen_opt->answer) {
G_message(_("Computing eigenvector centrality measure"));
NetA_eigenvector_centrality(graph, atoi(iter_opt->answer),
atof(error_opt->answer), eigen);
}
nlines = Vect_get_num_lines(&In);
G_message(_("Writing data into the table..."));
G_percent_reset();
for (i = 1; i <= nlines; i++) {
G_percent(i, nlines, 1);
int type = Vect_read_line(&In, Points, Cats, i);
if (type == GV_POINT && (!chcat || varray->c[i])) {
int cat, node;
if (!Vect_cat_get(Cats, layer, &cat))
continue;
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, cat);
Vect_write_line(&Out, type, Points, Cats);
Vect_get_line_nodes(&In, i, &node, NULL);
process_node(node, cat);
covered[node] = 1;
}
}
if (add_f->answer && !chcat) {
max_cat = 0;
for (i = 1; i <= nlines; i++) {
Vect_read_line(&In, NULL, Cats, i);
for (j = 0; j < Cats->n_cats; j++)
if (Cats->cat[j] > max_cat)
max_cat = Cats->cat[j];
}
max_cat++;
for (i = 1; i <= nnodes; i++)
if (!covered[i]) {
Vect_reset_cats(Cats);
Vect_cat_set(Cats, 1, max_cat);
NetA_add_point_on_node(&In, &Out, i, Cats);
process_node(i, max_cat);
max_cat++;
}
}
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
G_free(covered);
if (deg)
G_free(deg);
if (closeness)
G_free(closeness);
if (betw)
G_free(betw);
if (eigen)
G_free(eigen);
Vect_build(&Out);
Vect_close(&In);
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Map_info In, Out;
static struct line_pnts *Points;
struct line_cats *Cats;
struct field_info *Fi;
struct cat_list *Clist;
int i, j, ret, option, otype, type, with_z, step, id;
int n_areas, centr, new_centr, nmodified;
int open_level;
double x, y;
int cat, ocat, scat, *fields, nfields, field;
struct GModule *module;
struct Option *in_opt, *out_opt, *option_opt, *type_opt;
struct Option *cat_opt, *field_opt, *step_opt, *id_opt;
struct Flag *shell, *notab;
FREPORT **freps;
int nfreps, rtype, fld;
char *desc;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("category"));
G_add_keyword(_("layer"));
module->description =
_("Attaches, deletes or reports vector categories to map geometry.");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
field_opt = G_define_standard_option(G_OPT_V_FIELD);
field_opt->multiple = YES;
field_opt->guisection = _("Selection");
type_opt = G_define_standard_option(G_OPT_V3_TYPE);
type_opt->answer = "point,line,centroid,face";
type_opt->guisection = _("Selection");
id_opt = G_define_standard_option(G_OPT_V_IDS);
id_opt->label = _("Feature ids (by default all features are processed)");
id_opt->guisection = _("Selection");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
out_opt->required = NO;
option_opt = G_define_option();
option_opt->key = "option";
option_opt->type = TYPE_STRING;
option_opt->required = YES;
option_opt->multiple = NO;
option_opt->options = "add,del,chlayer,sum,report,print,layers,transfer";
option_opt->description = _("Action to be done");
desc = NULL;
G_asprintf(&desc,
"add;%s;"
"del;%s;"
"chlayer;%s;"
"sum;%s;"
"transfer;%s;"
"report;%s;"
"print;%s;"
"layers;%s",
_("add a category to features without category in the given layer"),
_("delete category (cat=-1 to delete all categories of given layer)"),
_("change layer number (e.g. layer=3,1 changes layer 3 to layer 1)"),
_("add the value specified by cat option to the current category value"),
_("copy values from one layer to another (e.g. layer=1,2,3 copies values from layer 1 to layer 2 and 3)"),
_("print report (statistics), in shell style: layer type count min max"),
_("print category values, layers are separated by '|', more cats in the same layer are separated by '/'"),
_("print only layer numbers"));
option_opt->descriptions = desc;
cat_opt = G_define_standard_option(G_OPT_V_CAT);
cat_opt->answer = "1";
step_opt = G_define_option();
step_opt->key = "step";
step_opt->type = TYPE_INTEGER;
step_opt->required = NO;
step_opt->multiple = NO;
step_opt->answer = "1";
step_opt->description = _("Category increment");
shell = G_define_flag();
shell->key = 'g';
shell->label = _("Shell script style, currently only for report");
shell->description = _("Format: layer type count min max");
notab = G_define_standard_flag(G_FLG_V_TABLE);
notab->description = _("Do not copy attribute table(s)");
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* read options */
option = 0;
switch (option_opt->answer[0]) {
case ('a'):
option = O_ADD;
break;
case ('d'):
option = O_DEL;
break;
case ('c'):
option = O_CHFIELD;
G_warning(_("Database connection and attribute tables for concerned layers are not changed"));
break;
case ('s'):
option = O_SUM;
break;
case ('t'):
option = O_TRANS;
break;
case ('r'):
option = O_REP;
break;
case ('p'):
option = O_PRN;
break;
case ('l'):
option = O_LYR;
break;
}
if (option == O_LYR) {
/* print vector layer numbers */
/* open vector on level 2 head only, this is why this option
* is processed here, all other options need (?) to fully open
* the input vector */
Vect_set_open_level(2);
if (Vect_open_old_head2(&In, in_opt->answer, "", field_opt->answer) < 2) {
G_fatal_error(_("Unable to open vector map <%s> at topological level %d"),
Vect_get_full_name(&In), 2);
}
if (In.format == GV_FORMAT_NATIVE) {
nfields = Vect_cidx_get_num_fields(&In);
for (i = 0; i < nfields; i++) {
if ((field = Vect_cidx_get_field_number(&In, i)) > 0)
fprintf(stdout, "%d\n", field);
}
}
else
fprintf(stdout, "%s\n", field_opt->answer);
Vect_close(&In);
exit(EXIT_SUCCESS);
}
cat = atoi(cat_opt->answer);
step = atoi(step_opt->answer);
otype = Vect_option_to_types(type_opt);
if (cat < 0 && option == O_ADD)
G_fatal_error(_("Invalid category number (must be equal to or greater than 0). "
"Normally category number starts at 1."));
/* collect ids */
if (id_opt->answer) {
Clist = Vect_new_cat_list();
Clist->field = atoi(field_opt->answer);
ret = Vect_str_to_cat_list(id_opt->answer, Clist);
if (ret > 0) {
G_warning(n_("%d error in id option",
"%d errors in id option",
ret), ret);
}
}
else {
Clist = NULL;
}
if ((option != O_REP) && (option != O_PRN) && (option != O_LYR)) {
if (out_opt->answer == NULL)
G_fatal_error(_("Output vector wasn't entered"));
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
G_FATAL_EXIT);
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
/* do we need topology ? */
if ((option == O_ADD && (otype & GV_AREA)) ||
(option == O_REP && (otype & GV_AREA)) ||
(option == O_TRANS) || /* topo for cidx check */
(option == O_LYR)) /* topo for cidx check */
open_level = 2;
else
open_level = 1;
/* open input vector */
if (open_level > 1) {
Vect_set_open_level(open_level);
if (Vect_open_old2(&In, in_opt->answer, "", field_opt->answer) < open_level) {
G_warning(_("Unable to open vector map <%s> at topological level %d"),
Vect_get_full_name(&In), open_level);
open_level = 1;
}
}
if (open_level == 1) {
Vect_set_open_level(open_level);
if (Vect_open_old2(&In, in_opt->answer, "", field_opt->answer) < open_level) {
G_fatal_error(_("Unable to open vector map <%s> at topological level %d"),
Vect_get_full_name(&In), open_level);
}
}
/* read fields */
i = nfields = 0;
while (field_opt->answers[i++])
nfields++;
fields = (int *)G_malloc(nfields * sizeof(int));
i = 0;
while (field_opt->answers[i]) {
fields[i] = Vect_get_field_number(&In, field_opt->answers[i]);
i++;
}
if (nfields > 1 && option != O_PRN && option != O_CHFIELD && option != O_TRANS)
G_fatal_error(_("Too many layers for this operation"));
if (nfields != 2 && option == O_CHFIELD)
G_fatal_error(_("2 layers must be specified"));
if (option == O_TRANS && open_level == 1 && nfields < 2) {
G_fatal_error(_("2 layers must be specified"));
}
if (option == O_TRANS && open_level > 1) {
/* check if field[>0] already exists */
if (nfields > 1) {
for(i = 1; i < nfields; i++) {
if (Vect_cidx_get_field_index(&In, fields[i]) != -1)
G_warning(_("Categories already exist in layer %d"), fields[i]);
}
}
/* find next free layer number */
else if (nfields == 1) {
int max = -1;
for (i = 0; i < Vect_cidx_get_num_fields(&In); i++) {
if (max < Vect_cidx_get_field_number(&In, i))
max = Vect_cidx_get_field_number(&In, i);
}
max++;
nfields++;
fields = (int *)G_realloc(fields, nfields * sizeof(int));
fields[nfields - 1] = max;
}
}
if (otype & GV_AREA && option == O_TRANS && !(otype & GV_CENTROID))
otype |= GV_CENTROID;
/* open output vector if needed */
if (option == O_ADD || option == O_DEL || option == O_CHFIELD ||
option == O_SUM || option == O_TRANS) {
with_z = Vect_is_3d(&In);
if (0 > Vect_open_new(&Out, out_opt->answer, with_z)) {
Vect_close(&In);
exit(EXIT_FAILURE);
}
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
}
id = 0;
nmodified = 0;
if (option == O_ADD || option == O_DEL || option == O_CHFIELD ||
option == O_SUM || option == O_TRANS) {
G_message(_("Processing features..."));
}
switch (option) {
case (O_ADD):
/* Lines */
while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) {
id++;
if (type & otype && (!Clist ||
(Clist &&
Vect_cat_in_cat_list(id, Clist) == TRUE))) {
if ((Vect_cat_get(Cats, fields[0], &ocat)) == 0) {
if (ocat < 0) {
if (Vect_cat_set(Cats, fields[0], cat) > 0) {
nmodified++;
}
cat += step;
}
}
}
Vect_write_line(&Out, type, Points, Cats);
}
/* Areas */
if ((otype & GV_AREA) && open_level > 1) {
n_areas = Vect_get_num_areas(&In);
new_centr = 0;
for (i = 1; i <= n_areas; i++) {
centr = Vect_get_area_centroid(&In, i);
if (centr > 0)
continue; /* Centroid exists and may be processed as line */
ret = Vect_get_point_in_area(&In, i, &x, &y);
if (ret < 0) {
G_warning(_("Unable to calculate area centroid"));
continue;
}
Vect_reset_line(Points);
Vect_reset_cats(Cats);
Vect_append_point(Points, x, y, 0.0);
if (Vect_cat_set(Cats, fields[0], cat) > 0) {
nmodified++;
}
cat += step;
Vect_write_line(&Out, GV_CENTROID, Points, Cats);
new_centr++;
}
if (new_centr > 0)
G_message(n_("%d new centroid placed in output map",
"%d new centroids placed in output map",
new_centr), new_centr);
}
break;
case (O_TRANS):
/* Lines */
while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) {
id++;
if (type & otype && (!Clist ||
(Clist &&
Vect_cat_in_cat_list(id, Clist) == TRUE))) {
int n = Cats->n_cats;
scat = -1;
for (i = 0; i < n; i++) {
if (Cats->field[i] == fields[0]) {
scat = Cats->cat[i];
for (j = 1; j < nfields; j++) {
if (Vect_cat_set(Cats, fields[j], scat) > 0) {
G_debug(4, "Copy cat %i of field %i to field %i", scat, fields[0], fields[j]);
}
}
}
}
if (scat != -1)
nmodified++;
}
Vect_write_line(&Out, type, Points, Cats);
}
break;
case (O_DEL):
while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) {
id++;
if (type & otype && (!Clist ||
(Clist &&
Vect_cat_in_cat_list(id, Clist) == TRUE))) {
ret = Vect_field_cat_del(Cats, fields[0], cat);
if (ret > 0) {
nmodified++;
}
}
Vect_write_line(&Out, type, Points, Cats);
}
break;
case (O_CHFIELD):
while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) {
id++;
if (type & otype && (!Clist ||
(Clist &&
Vect_cat_in_cat_list(id, Clist) == TRUE))) {
i = 0;
while (i < Cats->n_cats) {
if (Cats->field[i] == fields[0]) {
int found = -1;
/* check if cat already exists in layer fields[1] */
for (j = 0; j < Cats->n_cats; j++) {
if (Cats->field[j] == fields[1] &&
Cats->cat[j] == Cats->cat[i]) {
found = j;
break;
}
}
/* does not exist, change layer */
if (found < 0) {
Cats->field[i] = fields[1];
i++;
}
/* exists already in fields[1], delete from fields[0] */
else
Vect_field_cat_del(Cats, fields[0], Cats->cat[found]);
nmodified++;
}
}
}
Vect_write_line(&Out, type, Points, Cats);
}
break;
case (O_SUM):
while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) {
id++;
if (type & otype && (!Clist ||
(Clist &&
Vect_cat_in_cat_list(id, Clist) == TRUE))) {
for (i = 0; i < Cats->n_cats; i++) {
if (Cats->field[i] == fields[0]) {
Cats->cat[i] += cat;
}
}
nmodified++;
}
Vect_write_line(&Out, type, Points, Cats);
}
break;
case (O_REP):
nfreps = 0;
freps = NULL;
while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) {
id++;
if (Clist && Vect_cat_in_cat_list(id, Clist) == FALSE)
continue;
switch (type) {
case (GV_POINT):
rtype = FR_POINT;
break;
case (GV_LINE):
rtype = FR_LINE;
break;
case (GV_BOUNDARY):
rtype = FR_BOUNDARY;
break;
case (GV_CENTROID):
rtype = FR_CENTROID;
break;
case (GV_FACE):
rtype = FR_FACE;
break;
case (GV_KERNEL):
rtype = FR_KERNEL;
break;
default:
rtype = FR_UNKNOWN;
}
for (i = 0; i < Cats->n_cats; i++) {
field = Cats->field[i];
cat = Cats->cat[i];
ret = FALSE;
for (j = 0; j < nfreps; j++) {
if (freps[j]->field == field) {
fld = j;
ret = TRUE;
break;
}
}
if (!ret) { /* field report doesn't exist */
nfreps++;
freps =
(FREPORT **) G_realloc(freps,
nfreps * sizeof(FREPORT *));
fld = nfreps - 1;
freps[fld] = (FREPORT *) G_calloc(1, sizeof(FREPORT));
freps[fld]->field = field;
for (j = 0; j < FRTYPES; j++) {
/* cat '0' is valid category number */
freps[fld]->min[j] = -1;
}
if ((Fi = Vect_get_field(&In, field)) != NULL) {
freps[fld]->table = G_store(Fi->table);
}
else {
freps[fld]->table = '\0';
}
}
freps[fld]->count[rtype]++;
freps[fld]->count[FR_ALL]++;
if (freps[fld]->min[rtype] == -1 ||
freps[fld]->min[rtype] > cat)
freps[fld]->min[rtype] = cat;
if ((freps[fld]->max[rtype] == 0) ||
freps[fld]->max[rtype] < cat)
freps[fld]->max[rtype] = cat;
if (freps[fld]->min[FR_ALL] == -1 ||
freps[fld]->min[FR_ALL] > cat)
freps[fld]->min[FR_ALL] = cat;
if ((freps[fld]->max[FR_ALL] == 0) ||
freps[fld]->max[FR_ALL] < cat)
freps[fld]->max[FR_ALL] = cat;
}
}
/* Areas */
if ((otype & GV_AREA) && open_level > 1 && !Clist) {
n_areas = Vect_get_num_areas(&In);
for (i = 1; i <= n_areas; i++) {
int k;
centr = Vect_get_area_centroid(&In, i);
if (centr <= 0)
continue; /* Area without centroid */
Vect_read_line(&In, NULL, Cats, centr);
for (j = 0; j < Cats->n_cats; j++) {
field = Cats->field[j];
cat = Cats->cat[j];
ret = FALSE;
for (k = 0; k < nfreps; k++) {
if (freps[k]->field == field) {
fld = k;
ret = TRUE;
break;
}
}
if (!ret) { /* field report doesn't exist */
nfreps++;
freps =
(FREPORT **) G_realloc(freps,
nfreps * sizeof(FREPORT *));
fld = nfreps - 1;
freps[fld] = (FREPORT *) G_calloc(1, sizeof(FREPORT));
freps[fld]->field = field;
for (j = 0; j < FRTYPES; j++) {
/* cat '0' is valid category number */
freps[fld]->min[k] = -1;
}
if ((Fi = Vect_get_field(&In, field)) != NULL) {
freps[fld]->table = G_store(Fi->table);
}
else {
freps[fld]->table = '\0';
}
}
freps[fld]->count[FR_AREA]++;
if (freps[fld]->min[FR_AREA] == -1 ||
freps[fld]->min[FR_AREA] > cat)
freps[fld]->min[FR_AREA] = cat;
if ((freps[fld]->max[FR_AREA] == 0) ||
freps[fld]->max[FR_AREA] < cat)
freps[fld]->max[FR_AREA] = cat;
}
}
}
for (i = 0; i < nfreps; i++) {
if (shell->answer) {
if (freps[i]->count[FR_POINT] > 0)
fprintf(stdout, "%d point %d %d %d\n", freps[i]->field,
freps[i]->count[FR_POINT],
(freps[i]->min[FR_POINT] < 0 ? 0 : freps[i]->min[FR_POINT]),
freps[i]->max[FR_POINT]);
if (freps[i]->count[FR_LINE] > 0)
fprintf(stdout, "%d line %d %d %d\n", freps[i]->field,
freps[i]->count[FR_LINE],
(freps[i]->min[FR_LINE] < 0 ? 0 : freps[i]->min[FR_LINE]),
freps[i]->max[FR_LINE]);
if (freps[i]->count[FR_BOUNDARY] > 0)
fprintf(stdout, "%d boundary %d %d %d\n", freps[i]->field,
freps[i]->count[FR_BOUNDARY],
(freps[i]->min[FR_BOUNDARY] < 0 ? 0 : freps[i]->min[FR_BOUNDARY]),
freps[i]->max[FR_BOUNDARY]);
if (freps[i]->count[FR_CENTROID] > 0)
fprintf(stdout, "%d centroid %d %d %d\n", freps[i]->field,
freps[i]->count[FR_CENTROID],
(freps[i]->min[FR_BOUNDARY] < 0 ? 0 : freps[i]->min[FR_BOUNDARY]),
freps[i]->max[FR_CENTROID]);
if (freps[i]->count[FR_AREA] > 0)
fprintf(stdout, "%d area %d %d %d\n", freps[i]->field,
freps[i]->count[FR_AREA],
(freps[i]->min[FR_AREA] < 0 ? 0 : freps[i]->min[FR_AREA]),
freps[i]->max[FR_AREA]);
if (freps[i]->count[FR_FACE] > 0)
fprintf(stdout, "%d face %d %d %d\n", freps[i]->field,
freps[i]->count[FR_FACE],
(freps[i]->min[FR_FACE] < 0 ? 0 : freps[i]->min[FR_FACE]),
freps[i]->max[FR_FACE]);
if (freps[i]->count[FR_KERNEL] > 0)
fprintf(stdout, "%d kernel %d %d %d\n", freps[i]->field,
freps[i]->count[FR_KERNEL],
(freps[i]->min[FR_KERNEL] < 0 ? 0 : freps[i]->min[FR_KERNEL]),
freps[i]->max[FR_KERNEL]);
if (freps[i]->count[FR_ALL] > 0)
fprintf(stdout, "%d all %d %d %d\n", freps[i]->field,
freps[i]->count[FR_ALL],
(freps[i]->min[FR_ALL] < 0 ? 0 : freps[i]->min[FR_ALL]),
freps[i]->max[FR_ALL]);
}
else {
if (freps[i]->table != '\0') {
fprintf(stdout, "%s: %d/%s\n", _("Layer/table"),
freps[i]->field, freps[i]->table);
}
else {
fprintf(stdout, "%s: %d\n", _("Layer"), freps[i]->field);
}
fprintf(stdout, _("type count min max\n"));
fprintf(stdout, "%s %7d %10d %10d\n", _("point"),
freps[i]->count[FR_POINT],
(freps[i]->min[FR_POINT] < 0) ? 0 : freps[i]->min[FR_POINT],
freps[i]->max[FR_POINT]);
fprintf(stdout, "%s %7d %10d %10d\n", _("line"),
freps[i]->count[FR_LINE],
(freps[i]->min[FR_LINE] < 0) ? 0 : freps[i]->min[FR_LINE],
freps[i]->max[FR_LINE]);
fprintf(stdout, "%s %7d %10d %10d\n", _("boundary"),
freps[i]->count[FR_BOUNDARY],
(freps[i]->min[FR_BOUNDARY] < 0) ? 0 : freps[i]->min[FR_BOUNDARY],
freps[i]->max[FR_BOUNDARY]);
fprintf(stdout, "%s %7d %10d %10d\n", _("centroid"),
freps[i]->count[FR_CENTROID],
(freps[i]->min[FR_CENTROID] < 0) ? 0 : freps[i]->min[FR_CENTROID],
freps[i]->max[FR_CENTROID]);
fprintf(stdout, "%s %7d %10d %10d\n", _("area"),
freps[i]->count[FR_AREA],
(freps[i]->min[FR_AREA] < 0) ? 0 : freps[i]->min[FR_AREA],
freps[i]->max[FR_AREA]);
fprintf(stdout, "%s %7d %10d %10d\n", _("face"),
freps[i]->count[FR_FACE],
(freps[i]->min[FR_FACE] < 0) ? 0 : freps[i]->min[FR_FACE],
freps[i]->max[FR_FACE]);
fprintf(stdout, "%s %7d %10d %10d\n", _("kernel"),
freps[i]->count[FR_KERNEL],
(freps[i]->min[FR_KERNEL] < 0) ? 0 : freps[i]->min[FR_KERNEL],
freps[i]->max[FR_KERNEL]);
fprintf(stdout, "%s %7d %10d %10d\n", _("all"),
freps[i]->count[FR_ALL],
(freps[i]->min[FR_ALL] < 0) ? 0 : freps[i]->min[FR_ALL],
freps[i]->max[FR_ALL]);
}
}
break;
case (O_PRN):
while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) {
id++;
int has = 0;
if (!(type & otype))
continue;
if (Clist && Vect_cat_in_cat_list(id, Clist) == FALSE)
continue;
/* Check if the line has at least one cat */
for (i = 0; i < nfields; i++) {
for (j = 0; j < Cats->n_cats; j++) {
if (Cats->field[j] == fields[i]) {
has = 1;
break;
}
}
}
if (!has)
continue;
for (i = 0; i < nfields; i++) {
int first = 1;
if (i > 0)
fprintf(stdout, "|");
for (j = 0; j < Cats->n_cats; j++) {
if (Cats->field[j] == fields[i]) {
if (!first)
fprintf(stdout, "/");
fprintf(stdout, "%d", Cats->cat[j]);
first = 0;
}
}
}
fprintf(stdout, "\n");
}
break;
}
if (option == O_ADD || option == O_DEL || option == O_CHFIELD ||
option == O_SUM || option == O_TRANS){
if (!notab->answer){
G_message(_("Copying attribute table(s)..."));
if (Vect_copy_tables(&In, &Out, 0))
G_warning(_("Failed to copy attribute table to output map"));
}
Vect_build(&Out);
Vect_close(&Out);
}
if (option == O_TRANS && nmodified > 0)
for(i = 1; i < nfields; i++)
G_important_message(_("Categories copied from layer %d to layer %d"),
fields[0], fields[i]);
if (option != O_REP && option != O_PRN)
G_done_msg(n_("%d feature modified.",
"%d features modified.",
nmodified), nmodified);
Vect_close(&In);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *in_opt, *layer_opt, *out_opt, *length_opt, *units_opt, *vertices_opt;
struct Map_info In, Out;
struct line_pnts *Points, *Points2;
struct line_cats *Cats;
int line, nlines, layer;
double length = -1;
int vertices = 0;
double (*line_length) ();
int latlon = 0;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("geometry"));
module->description = _("Splits vector lines to shorter segments.");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
layer_opt = G_define_standard_option(G_OPT_V_FIELD_ALL);
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
length_opt = G_define_option();
length_opt->key = "length";
length_opt->type = TYPE_DOUBLE;
length_opt->required = NO;
length_opt->multiple = NO;
length_opt->description = _("Maximum segment length");
units_opt = G_define_option();
units_opt->key = "units";
units_opt->type = TYPE_STRING;
units_opt->required = NO;
units_opt->multiple = NO;
units_opt->options = "meters,kilometers,feet,miles,nautmiles";
units_opt->answer = "meters";
units_opt->description = _("Length units");
vertices_opt = G_define_option();
vertices_opt->key = "vertices";
vertices_opt->type = TYPE_INTEGER;
vertices_opt->required = NO;
vertices_opt->multiple = NO;
vertices_opt->description = _("Maximum number of vertices in segment");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if ((length_opt->answer && vertices_opt->answer) ||
!(length_opt->answer || vertices_opt->answer))
G_fatal_error(_("Use either length or vertices"));
line_length = NULL;
if (length_opt->answer) {
length = atof(length_opt->answer);
if (length <= 0)
G_fatal_error(_("Length must be positive but is %g"), length);
/* convert length to meters */
if (strcmp(units_opt->answer, "meters") == 0)
/* do nothing */ ;
else if (strcmp(units_opt->answer, "kilometers") == 0)
length *= FROM_KILOMETERS;
else if (strcmp(units_opt->answer, "feet") == 0)
length *= FROM_FEET;
else if (strcmp(units_opt->answer, "miles") == 0)
length *= FROM_MILES;
else if (strcmp(units_opt->answer, "nautmiles") == 0)
length *= FROM_NAUTMILES;
else
G_fatal_error(_("Unknown unit %s"), units_opt->answer);
/* set line length function */
if ((latlon = (G_projection() == PROJECTION_LL)) == 1)
line_length = Vect_line_geodesic_length;
else {
double factor;
line_length = Vect_line_length;
/* convert length to map units */
if ((factor = G_database_units_to_meters_factor()) == 0)
G_fatal_error(_("Can not get projection units"));
else {
/* meters to units */
length = length / factor;
}
}
G_verbose_message(_("length in %s: %g"), (latlon ? "meters" : "map units"), length);
}
if (vertices_opt->answer) {
vertices = atoi(vertices_opt->answer);
if (vertices < 2)
G_fatal_error(_("Number of vertices must be at least 2"));
}
Vect_set_open_level(2);
Vect_open_old2(&In, in_opt->answer, "", layer_opt->answer);
layer = Vect_get_field_number(&In, layer_opt->answer);
Vect_open_new(&Out, out_opt->answer, Vect_is_3d(&In));
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
Vect_copy_tables(&In, &Out, layer);
Points = Vect_new_line_struct();
Points2 = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
nlines = Vect_get_num_lines(&In);
for (line = 1; line <= nlines; line++) {
int ltype;
G_percent(line, nlines, 1);
if (!Vect_line_alive(&In, line))
continue;
ltype = Vect_read_line(&In, Points, Cats, line);
if (layer != -1 && !Vect_cat_get(Cats, layer, NULL))
continue;
if (ltype & GV_LINES) {
if (length > 0) {
double l, from, to, step;
l = line_length(Points);
if (l <= length) {
Vect_write_line(&Out, ltype, Points, Cats);
}
else {
int n, i;
n = ceil(l / length);
if (latlon)
l = Vect_line_length(Points);
step = l / n;
from = 0.;
for (i = 0; i < n; i++) {
int ret;
double x, y, z;
if (i == n - 1) {
to = l; /* to be sure that it goes to end */
}
else {
to = from + step;
}
ret = Vect_line_segment(Points, from, to, Points2);
if (ret == 0) {
G_warning(_("Unable to make line segment: %f - %f (line length = %f)"),
from, to, l);
continue;
}
/* To be sure that the coordinates are identical */
if (i > 0) {
Points2->x[0] = x;
Points2->y[0] = y;
Points2->z[0] = z;
}
if (i == n - 1) {
Points2->x[Points2->n_points - 1] =
Points->x[Points->n_points - 1];
Points2->y[Points2->n_points - 1] =
Points->y[Points->n_points - 1];
Points2->z[Points2->n_points - 1] =
Points->z[Points->n_points - 1];
}
Vect_write_line(&Out, ltype, Points2, Cats);
/* last point */
x = Points2->x[Points2->n_points - 1];
y = Points2->y[Points2->n_points - 1];
z = Points2->z[Points2->n_points - 1];
from += step;
}
}
}
else {
int start = 0; /* number of coordinates written */
while (start < Points->n_points - 1) {
int i, v;
Vect_reset_line(Points2);
for (i = 0; i < vertices; i++) {
v = start + i;
if (v == Points->n_points)
break;
Vect_append_point(Points2, Points->x[v], Points->y[v],
Points->z[v]);
}
Vect_write_line(&Out, ltype, Points2, Cats);
start = v;
}
}
}
else {
Vect_write_line(&Out, ltype, Points, Cats);
}
}
Vect_close(&In);
Vect_build(&Out);
Vect_close(&Out);
exit(EXIT_SUCCESS);
}
/*--------------------------------------------------------------------------------*/
int main(int argc, char *argv[])
{
/* Variables' declarations */
int row, nrows, col, ncols, MaxPoints;
int nsubregion_col, nsubregion_row;
int subregion = 0, nsubregions = 0;
int last_row, last_column;
int nlines, nlines_first, line_num;
int more;
int clas, region = TRUE;
double Z_interp;
double Thres_j, Thres_d, ew_resol, ns_resol;
double minNS, minEW, maxNS, maxEW;
const char *mapset;
char buf[1024], table_name[GNAME_MAX];
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
int colorBordo, ripieno, conta, lungPunti, lungHull, xi, c1, c2;
double altPiano;
extern double **P, **cvxHull, **punti_bordo;
/* Struct declarations */
struct Cell_head elaboration_reg, original_reg;
struct element_grow **raster_matrix;
struct Map_info In, Out, First;
struct Option *in_opt, *out_opt, *first_opt, *Thres_j_opt, *Thres_d_opt;
struct GModule *module;
struct line_pnts *points, *points_first;
struct line_cats *Cats, *Cats_first;
struct field_info *field;
dbDriver *driver;
dbString sql;
dbTable *table;
dbCursor cursor;
/*------------------------------------------------------------------------------------------*/
/* Options' declaration */ ;
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("LIDAR"));
module->description =
_("Building contour determination and Region Growing "
"algorithm for determining the building inside");
in_opt = G_define_standard_option(G_OPT_V_INPUT);
in_opt->description =
_("Input vector (v.lidar.edgedetection output");
out_opt = G_define_standard_option(G_OPT_V_OUTPUT);
first_opt = G_define_option();
first_opt->key = "first";
first_opt->type = TYPE_STRING;
first_opt->key_desc = "name";
first_opt->required = YES;
first_opt->gisprompt = "old,vector,vector";
first_opt->description = _("Name of the first pulse vector map");
Thres_j_opt = G_define_option();
Thres_j_opt->key = "tj";
Thres_j_opt->type = TYPE_DOUBLE;
Thres_j_opt->required = NO;
Thres_j_opt->description =
_("Threshold for cell object frequency in region growing");
Thres_j_opt->answer = "0.2";
Thres_d_opt = G_define_option();
Thres_d_opt->key = "td";
Thres_d_opt->type = TYPE_DOUBLE;
Thres_d_opt->required = NO;
Thres_d_opt->description =
_("Threshold for double pulse in region growing");
Thres_d_opt->answer = "0.6";
/* Parsing */
G_gisinit(argv[0]);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
Thres_j = atof(Thres_j_opt->answer);
Thres_d = atof(Thres_d_opt->answer);
Thres_j += 1;
/* Open input vector */
Vect_check_input_output_name(in_opt->answer, out_opt->answer,
GV_FATAL_EXIT);
if ((mapset = G_find_vector2(in_opt->answer, "")) == NULL) {
G_fatal_error(_("Vector map <%s> not found"), in_opt->answer);
}
/* Setting auxiliar table's name */
if (G_name_is_fully_qualified(in_opt->answer, xname, xmapset)) {
sprintf(table_name, "%s_edge_Interpolation", xname);
}
else
sprintf(table_name, "%s_edge_Interpolation", in_opt->answer);
Vect_set_open_level(1); /* WITHOUT TOPOLOGY */
if (Vect_open_old(&In, in_opt->answer, mapset) < 1)
G_fatal_error(_("Unable to open vector map <%s>"), in_opt->answer);
Vect_set_open_level(1); /* WITHOUT TOPOLOGY */
if (Vect_open_old(&First, first_opt->answer, mapset) < 1)
G_fatal_error(_("Unable to open vector map <%s>"), first_opt->answer);
/* Open output vector */
if (0 > Vect_open_new(&Out, out_opt->answer, WITH_Z)) {
Vect_close(&In);
Vect_close(&First);
exit(EXIT_FAILURE);
}
/* Copy vector Head File */
Vect_copy_head_data(&In, &Out);
Vect_hist_copy(&In, &Out);
Vect_hist_command(&Out);
/* Starting driver and open db for edgedetection interpolation table */
field = Vect_get_field(&In, F_INTERPOLATION);
/*if (field == NULL)
G_fatal_error (_("Cannot read field info")); */
driver = db_start_driver_open_database(field->driver, field->database);
if (driver == NULL)
G_fatal_error(_("No database connection for driver <%s> is defined. Run db.connect."),
field->driver);
/* is this the right place to open the cursor ??? */
db_init_string(&sql);
db_zero_string(&sql);
sprintf(buf, "SELECT Interp,ID FROM %s", table_name);
G_debug(1, "buf: %s", buf);
db_append_string(&sql, buf);
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK)
G_fatal_error(_("Unable to open table <%s>"), table_name);
count_obj = 1;
/* no topology, get number of lines in input vector */
nlines = 0;
points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
Vect_rewind(&In);
while (Vect_read_next_line(&In, points, Cats) > 0) {
nlines++;
}
Vect_rewind(&In);
/* no topology, get number of lines in first pulse input vector */
nlines_first = 0;
points_first = Vect_new_line_struct();
Cats_first = Vect_new_cats_struct();
Vect_rewind(&First);
while (Vect_read_next_line(&First, points_first, Cats_first) > 0) {
nlines_first++;
}
Vect_rewind(&First);
/* Setting regions and boxes */
G_debug(1, _("Setting regions and boxes"));
G_get_set_window(&original_reg);
G_get_set_window(&elaboration_reg);
/* Fixing parameters of the elaboration region */
/*! The original_region will be divided into subregions */
ew_resol = original_reg.ew_res;
ns_resol = original_reg.ns_res;
/* calculate number of subregions */
nsubregion_col = ceil((original_reg.east - original_reg.west) / (LATO * ew_resol)) + 0.5;
nsubregion_row = ceil((original_reg.north - original_reg.south) / (LATO * ns_resol)) + 0.5;
if (nsubregion_col < 0)
nsubregion_col = 0;
if (nsubregion_row < 0)
nsubregion_row = 0;
nsubregions = nsubregion_row * nsubregion_col;
/* Subdividing and working with tiles */
elaboration_reg.south = original_reg.north;
last_row = FALSE;
while (last_row == FALSE) { /* For each strip of LATO rows */
elaboration_reg.north = elaboration_reg.south;
if (elaboration_reg.north > original_reg.north) /* First row */
elaboration_reg.north = original_reg.north;
elaboration_reg.south = elaboration_reg.north - LATO * ns_resol;
if (elaboration_reg.south <= original_reg.south) { /* Last row */
elaboration_reg.south = original_reg.south;
last_row = TRUE;
}
elaboration_reg.east = original_reg.west;
last_column = FALSE;
while (last_column == FALSE) { /* For each strip of LATO columns */
struct bound_box elaboration_box;
subregion++;
if (nsubregions > 1)
G_message(_("subregion %d of %d"), subregion, nsubregions);
elaboration_reg.west = elaboration_reg.east;
if (elaboration_reg.west < original_reg.west) /* First column */
elaboration_reg.west = original_reg.west;
elaboration_reg.east = elaboration_reg.west + LATO * ew_resol;
if (elaboration_reg.east >= original_reg.east) { /* Last column */
elaboration_reg.east = original_reg.east;
last_column = TRUE;
}
/* Setting the active region */
elaboration_reg.ns_res = ns_resol;
elaboration_reg.ew_res = ew_resol;
nrows = (elaboration_reg.north - elaboration_reg.south) / ns_resol + 0.1;
ncols = (elaboration_reg.east - elaboration_reg.west) / ew_resol + 0.1;
elaboration_reg.rows = nrows;
elaboration_reg.cols = ncols;
G_debug(1, _("Rows = %d"), nrows);
G_debug(1, _("Columns = %d"), ncols);
raster_matrix = structMatrix(0, nrows, 0, ncols);
MaxPoints = nrows * ncols;
/* Initializing matrix */
for (row = 0; row <= nrows; row++) {
for (col = 0; col <= ncols; col++) {
raster_matrix[row][col].interp = 0;
raster_matrix[row][col].fi = 0;
raster_matrix[row][col].bordo = 0;
raster_matrix[row][col].dueImp = SINGLE_PULSE;
raster_matrix[row][col].orig = 0;
raster_matrix[row][col].fo = 0;
raster_matrix[row][col].clas = PRE_TERRAIN;
raster_matrix[row][col].fc = 0;
raster_matrix[row][col].obj = 0;
}
}
G_verbose_message(_("read points in input vector"));
Vect_region_box(&elaboration_reg, &elaboration_box);
line_num = 0;
Vect_rewind(&In);
while (Vect_read_next_line(&In, points, Cats) > 0) {
line_num++;
if ((Vect_point_in_box
(points->x[0], points->y[0], points->z[0],
&elaboration_box)) &&
((points->x[0] != elaboration_reg.west) ||
(points->x[0] == original_reg.west)) &&
((points->y[0] != elaboration_reg.north) ||
(points->y[0] == original_reg.north))) {
row =
(int)(Rast_northing_to_row
(points->y[0], &elaboration_reg));
col =
(int)(Rast_easting_to_col
(points->x[0], &elaboration_reg));
Z_interp = 0;
/* TODO: make sure the current db_fetch() usage works */
/* why not: */
/*
db_init_string(&sql);
sprintf(buf, "SELECT Interp,ID FROM %s WHERE ID=%d", table_name, line_num);
db_append_string(&sql, buf);
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK)
G_fatal_error(_("Unable to open table <%s>"), table_name);
while (db_fetch(&cursor, DB_NEXT, &more) == DB_OK && more) {
dbColumn *Z_Interp_col;
dbValue *Z_Interp_value;
table = db_get_cursor_table(&cursor);
Z_Interp_col = db_get_table_column(table, 1);
if (db_sqltype_to_Ctype(db_get_column_sqltype(Z_Interp_col)) ==
DB_C_TYPE_DOUBLE)
Z_Interp_value = db_get_column_value(Z_Interp_col);
else
continue;
Z_interp = db_get_value_double(Z_Interp_value);
break;
}
db_close_cursor(&cursor);
db_free_string(&sql);
*/
/* instead of */
while (1) {
if (db_fetch(&cursor, DB_NEXT, &more) != DB_OK ||
!more)
break;
dbColumn *Z_Interp_col, *ID_col;
dbValue *Z_Interp_value, *ID_value;
table = db_get_cursor_table(&cursor);
ID_col = db_get_table_column(table, 1);
if (db_sqltype_to_Ctype(db_get_column_sqltype(ID_col))
== DB_C_TYPE_INT)
ID_value = db_get_column_value(ID_col);
else
continue;
if (db_get_value_int(ID_value) == line_num) {
Z_Interp_col = db_get_table_column(table, 0);
if (db_sqltype_to_Ctype
(db_get_column_sqltype(Z_Interp_col)) ==
DB_C_TYPE_DOUBLE)
Z_Interp_value =
db_get_column_value(Z_Interp_col);
else
continue;
Z_interp = db_get_value_double(Z_Interp_value);
break;
}
}
raster_matrix[row][col].interp += Z_interp;
raster_matrix[row][col].fi++;
/*if (( clas = Vect_get_line_cat (&In, line_num, F_EDGE_DETECTION_CLASS) ) != UNKNOWN_EDGE) { */
if (Vect_cat_get(Cats, F_EDGE_DETECTION_CLASS, &clas)) {
raster_matrix[row][col].clas += clas;
raster_matrix[row][col].fc++;
}
raster_matrix[row][col].orig += points->z[0];
raster_matrix[row][col].fo++;
}
Vect_reset_cats(Cats);
Vect_reset_line(points);
}
for (row = 0; row <= nrows; row++) {
for (col = 0; col <= ncols; col++) {
if (raster_matrix[row][col].fc != 0) {
raster_matrix[row][col].clas--;
raster_matrix[row][col].
clas /= raster_matrix[row][col].fc;
}
if (raster_matrix[row][col].fi != 0)
raster_matrix[row][col].
interp /= raster_matrix[row][col].fi;
if (raster_matrix[row][col].fo != 0)
raster_matrix[row][col].
orig /= raster_matrix[row][col].fo;
}
}
/* DOUBLE IMPULSE */
Vect_rewind(&First);
while (Vect_read_next_line(&First, points_first, Cats_first) > 0) {
if ((Vect_point_in_box
(points_first->x[0], points_first->y[0],
points_first->z[0], &elaboration_box)) &&
((points->x[0] != elaboration_reg.west) ||
(points->x[0] == original_reg.west)) &&
((points->y[0] != elaboration_reg.north) ||
(points->y[0] == original_reg.north))) {
row =
(int)(Rast_northing_to_row
(points_first->y[0], &elaboration_reg));
col =
(int)(Rast_easting_to_col
(points_first->x[0], &elaboration_reg));
if (fabs
(points_first->z[0] - raster_matrix[row][col].orig) >=
Thres_d)
raster_matrix[row][col].dueImp = DOUBLE_PULSE;
}
Vect_reset_cats(Cats_first);
Vect_reset_line(points_first);
}
/* REGION GROWING */
if (region == TRUE) {
G_verbose_message(_("Region Growing"));
punti_bordo = G_alloc_matrix(MaxPoints, 3);
P = Pvector(0, MaxPoints);
colorBordo = 5;
ripieno = 6;
for (row = 0; row <= nrows; row++) {
G_percent(row, nrows, 2);
for (col = 0; col <= ncols; col++) {
if ((raster_matrix[row][col].clas >= Thres_j) &&
(raster_matrix[row][col].clas < colorBordo)
&& (raster_matrix[row][col].fi != 0) &&
(raster_matrix[row][col].dueImp ==
SINGLE_PULSE)) {
/* Selecting a connected Object zone */
ripieno++;
if (ripieno > 10)
ripieno = 6;
/* Selecting points on a connected edge */
for (conta = 0; conta < MaxPoints; conta++) {
punti_bordo[conta][0] = 0;
punti_bordo[conta][1] = 0;
punti_bordo[conta][2] = 0;
P[conta] = punti_bordo[conta]; /* It only makes indexes to be equal, not coord values!! */
}
lungPunti = 0;
lungHull = 0;
regGrow8(elaboration_reg, raster_matrix,
punti_bordo, &lungPunti, row, col,
colorBordo, Thres_j, MaxPoints);
/* CONVEX-HULL COMPUTATION */
lungHull = ch2d(P, lungPunti);
cvxHull = G_alloc_matrix(lungHull, 3);
for (xi = 0; xi < lungHull; xi++) {
cvxHull[xi][0] = P[xi][0];
cvxHull[xi][1] = P[xi][1];
cvxHull[xi][2] = P[xi][2];
}
/* Computes the interpoling plane based only on Object points */
altPiano =
pianOriz(punti_bordo, lungPunti, &minNS,
&minEW, &maxNS, &maxEW,
raster_matrix, colorBordo);
for (c1 = minNS; c1 <= maxNS; c1++) {
for (c2 = minEW; c2 <= maxEW; c2++) {
if (checkHull(c1, c2, cvxHull, lungHull)
== 1) {
raster_matrix[c1][c2].obj = count_obj;
if ((raster_matrix[c1][c2].clas ==
PRE_TERRAIN)
&& (raster_matrix[c1][c2].orig >=
altPiano) && (lungHull > 3))
raster_matrix[c1][c2].clas =
ripieno;
}
}
}
G_free_matrix(cvxHull);
count_obj++;
}
}
}
G_free_matrix(punti_bordo);
free_Pvector(P, 0, MaxPoints);
}
/* WRITING THE OUTPUT VECTOR CATEGORIES */
Vect_rewind(&In);
while (Vect_read_next_line(&In, points, Cats) > 0) { /* Read every line for buffering points */
if ((Vect_point_in_box
(points->x[0], points->y[0], points->z[0],
&elaboration_box)) &&
((points->x[0] != elaboration_reg.west) ||
(points->x[0] == original_reg.west)) &&
((points->y[0] != elaboration_reg.north) ||
(points->y[0] == original_reg.north))) {
row =
(int)(Rast_northing_to_row
(points->y[0], &elaboration_reg));
col =
(int)(Rast_easting_to_col
(points->x[0], &elaboration_reg));
if (raster_matrix[row][col].clas == PRE_TERRAIN) {
if (raster_matrix[row][col].dueImp == SINGLE_PULSE)
Vect_cat_set(Cats, F_CLASSIFICATION,
TERRAIN_SINGLE);
else
Vect_cat_set(Cats, F_CLASSIFICATION,
TERRAIN_DOUBLE);
}
else {
if (raster_matrix[row][col].dueImp == SINGLE_PULSE)
Vect_cat_set(Cats, F_CLASSIFICATION,
OBJECT_SINGLE);
else
Vect_cat_set(Cats, F_CLASSIFICATION,
OBJECT_DOUBLE);
}
Vect_cat_set(Cats, F_COUNTER_OBJ,
raster_matrix[row][col].obj);
Vect_write_line(&Out, GV_POINT, points, Cats);
}
Vect_reset_cats(Cats);
Vect_reset_line(points);
}
free_structmatrix(raster_matrix, 0, nrows - 1, 0, ncols - 1);
} /*! END WHILE; last_column = TRUE */
} /*! END WHILE; last_row = TRUE */
Vect_close(&In);
Vect_close(&First);
Vect_close(&Out);
db_close_database_shutdown_driver(driver);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}