/*!
\brief Initialize Map_info head structure (dig_head)
\param[in,out] Map pointer to Map_info structure
*/
void Vect__init_head(struct Map_info *Map)
{
char buf[64];
/* organization */
Map->head.organization = NULL;
Vect_set_organization(Map, "");
/* date */
Map->head.date = NULL;
Vect_set_date(Map, "");
/* user name */
Map->head.user_name = NULL;
sprintf(buf, "%s", G_whoami());
Vect_set_person(Map, buf);
/* map name */
Map->head.map_name = NULL;
Vect_set_map_name(Map, "");
/* source date */
Map->head.source_date = NULL;
sprintf(buf, "%s", G_date());
Vect_set_map_date(Map, buf);
/* comments */
Map->head.comment = NULL;
Vect_set_comment(Map, "");
/* scale, threshold */
Vect_set_scale(Map, 1);
Vect_set_thresh(Map, 0.0);
/* proj, zone */
Vect_set_proj(Map, -1);
Vect_set_zone(Map, -1);
/* support variables */
Map->plus.Spidx_built = 0;
Map->plus.release_support = 0;
Map->plus.update_cidx = 0;
}
static char *_get_make_sock_path(void)
{
char *path, *user, *lock;
const char *prefix = "/tmp/grass6";
int len, status;
struct stat theStat;
user = G_whoami(); /* Don't G_free () return value ever! */
if (user == NULL)
return NULL;
else if (user[0] == '?') { /* why's it do that? */
return NULL;
}
if ((lock = getenv("GIS_LOCK")) == NULL)
G_fatal_error(_("Unable to get GIS_LOCK environment variable value"));
len = strlen(prefix) + strlen(user) + strlen(lock) + 3;
path = G_malloc(len);
sprintf(path, "%s-%s-%s", prefix, user, lock);
if ((status = G_lstat(path, &theStat)) != 0) {
status = G_mkdir(path);
}
else {
if (!S_ISDIR(theStat.st_mode)) {
status = -1; /* not a directory ?? */
}
else {
status = chmod(path, S_IRWXU); /* fails if we don't own it */
}
}
if (status) { /* something's wrong if non-zero */
G_free(path);
path = NULL;
}
return path;
}
static int output(char *line, char *date)
{
char text[1024];
char fmt[30];
char *buf;
buf = line;
*text = 0;
while (*buf) {
if (*buf == '%') {
buf++;
if (*buf == '%')
strcat(text, "%");
else if (*buf == 'n') {
if (*text)
show_text(x, y, text);
y -= dy;
return 0;
}
else if (*buf == '_') {
fprintf(PS.fp, "BW ");
draw_line(x, y + 0.2 * fontsize,
72.0 * (PS.page_width - PS.right_marg),
y + 0.2 * fontsize);
y -= dy;
set_ps_color(&hdr.color);
return 0;
}
else {
buf = get_format(buf, fmt);
append('s', fmt);
switch (*buf) {
case 'd':
apply(date, fmt, text);
break;
case 'l':
apply(G_location(), fmt, text);
break;
case 'L':
apply(G_myname(), fmt, text);
break;
case 'c':
if (PS.cell_fd >= 0) {
char name[100];
sprintf(name, "<%s> in mapset <%s>",
PS.cell_name, PS.cell_mapset);
apply(name, fmt, text);
}
else
apply("none", fmt, text);
break;
case 'm':
apply(G_mapset(), fmt, text);
break;
case 'u':
apply(G_whoami(), fmt, text);
break;
case 'x':
apply(G_mask_info(), fmt, text);
break;
case 0:
continue;
}
}
}
else
append(*buf, text);
buf++;
}
if (*text)
show_text(x, y, text);
y -= dy;
return 0;
}
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);
}
/*
Create GRASS vector output map.
Create attribute table.
Calculate geometries and write them into the output map.
Calculate attributes and write them into the output map's attribute table.
*/
void writeMap()
{
int i, j;
double xlength, ylength, zlength;
double length, flatLength, bailLength;
double xoffset, yoffset, zoffset;
double xys[12];
int ratio;
double zRatio;
/* attributes to be written to output map */
int boneID;
int skelID;
int unitID;
int oldID;
int cat;
char *organization;
char buf[MAXSTR];
if ( numPoints < 2 ) {
G_fatal_error ("Less than two valid measurement points in input file");
}
G_message (_("Constructing geometries for %i valid points:"), numPoints );
/* CREATE OUTPUT VECTOR MAP */
if (Vect_legal_filename(output->answer) < 0) {
G_fatal_error(_("Use '%s' option to change vector map name"), output->key);
}
Map = (struct Map_info *) G_malloc (sizeof ( struct Map_info ) );
if (Vect_open_new(Map, output->answer, WITH_Z) < 0) {
G_fatal_error(_("Unable to create vector map <%s>"), output->answer);
}
Vect_set_map_name(Map, output->answer);
Vect_hist_command(Map);
if ((organization = getenv("GRASS_ORGANIZATION"))) {
Vect_set_organization(Map, organization);
} else {
Vect_set_organization(Map, "UNKNOWN ORGANIZATION");
}
Vect_set_date(Map, G_date());
Vect_set_person(Map, G_whoami());
Vect_set_map_date(Map, "");
Vect_set_scale(Map, 2400);
Vect_set_comment(Map, "");
Vect_set_zone(Map, 0);
Vect_set_thresh(Map, 0.0);
/* START DBMS INTERFACE */
/* prepare strings for use in db_* calls */
db_init_string(&sql);
/* start default database driver */
Fi = Vect_default_field_info(Map, 1, NULL, GV_1TABLE);
driver = db_start_driver_open_database(Fi->driver,Vect_subst_var(Fi->database, Map));
if (driver == NULL) {
Vect_delete(output->answer);
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
Vect_subst_var(Fi->database, Map), Fi->driver);
}
/* create attribute table */
db_begin_transaction ( driver );
sprintf(buf, "create table %s (cat integer, skel_id integer, bone_id integer, unit_id integer, GRASSRGB varchar(11),BONERGB varchar(11));",
Fi->table);
if ( DEBUG ) {
fprintf ( stderr, "Creating attribute table: %s\n", buf );
}
db_set_string(&sql, buf);
if (db_execute_immediate(driver, &sql) != DB_OK) {
Vect_delete(output->answer);
G_fatal_error(_("Unable to create attribute table: %s"), db_get_string(&sql));
}
if (db_grant_on_table
(driver, output->answer, DB_PRIV_SELECT, DB_GROUP | DB_PUBLIC) != DB_OK) {
Vect_delete(output->answer);
G_fatal_error(_("Unable to grant privileges on table <%s>"), output->answer);
}
if (db_create_index2(driver, output->answer, "cat") != DB_OK) {
G_warning(_("Unable to create index for table <%s>, key <%s>"), output->answer, "cat");
}
/* link vector map to attribute table */
if (Vect_map_add_dblink(Map, 1, NULL, Fi->table, "cat", Fi->database, Fi->driver) ) {
Vect_delete(output->answer);
G_fatal_error(_("Unable to add database link for vector map <%s>"), Vect_get_full_name(Map));
}
/* PROCESS POINTS AND WRITE GEOMETRIES */
/* Now process point measurements and write geometries into output vector map. */
/* At this stage, the global points array has an even number of valid points. */
oldID = pointTable[0].SKEL_ID;
unitID = 1;
cat = 0;
for ( i = 0; i < numPoints; i = i + 2 ) {
/* This boneID is a generalized ID that does not differentiate
between start and end measurement. */
boneID = (int) pointTable[i+1].BONE_ID / 2;
skelID = pointTable[i+1].SKEL_ID;
/* get coordinates for top and bottom of bone */
ax = pointTable[i].X;
ay = pointTable[i].Y;
az = pointTable[i].Z;
bx = pointTable[i+1].X;
by = pointTable[i+1].Y;
bz = pointTable[i+1].Z;
/* get vector lengths */
xlength = fabs (ax - bx);
ylength = fabs (ay - by);
zlength = fabs (az - bz);
/* get real length */
length = sqrt ( (xlength*xlength) + (ylength*ylength) + (zlength*zlength) );
/* get length in x/y plane */
flatLength = sqrt ( (xlength*xlength) + (ylength*ylength) );
/* determine ratio for triangles, depending on bone type */
ratio = 12; /* default */
for ( j = 0; j < NUM_RATIOS; j ++ ) {
if ( boneID == RATIO_ID[j] ) {
ratio = RATIO_VAL[j];
}
}
/* get bail length */
bailLength = (double) ( length / (double) ratio);
/* calculate bail offsets from top point (one bail is mirror of the other) */
xoffset = (bailLength * ylength) / flatLength;
yoffset = ( (bailLength * xlength) / flatLength ) * (-1);
zoffset = 0;
xys[0]= ax + xoffset;
xys[1]= ay + yoffset;
xys[2]= az + zoffset;
xys[6]= ax - xoffset;
xys[7]= ay - yoffset;
xys[8]= az - zoffset;
/* get 3rd axis offsets */
zRatio = (zlength/ratio) / flatLength;
xoffset = xlength * zRatio;
yoffset = ylength * zRatio;
zoffset = (flatLength/ratio) * (-1);
xys[3]= ax + xoffset;
xys[4]= ay + yoffset;
xys[5]= az + zoffset;
xys[9]= ax - xoffset;
xys[10]= ay - yoffset;
xys[11]= az - zoffset;
/* Increase unit ID by "1", if we have another skeleton ID */
if ( oldID != pointTable[i+1].SKEL_ID ) {
unitID ++;
oldID = pointTable[i+1].SKEL_ID;
/* switch to next colour for next geometry */
RGBNUM ++;
if ( RGBNUM == RGBMAX ) {
RGBNUM = 0;
}
}
/* write geometries */
if ( MODE == MODE_DARTS ) {
writeTriangle ( cat, skelID, boneID, unitID, xys, 0, 6 );
cat ++;
writeTriangle ( cat, skelID, boneID, unitID, xys, 3, 9 );
cat ++;
}
if ( MODE == MODE_LINES ) {
writeLine ( cat, skelID, boneID, unitID );
cat ++;
}
if ( MODE == MODE_PLANES_H ) {
writeTriangle ( cat, skelID, boneID, unitID, xys, 0, 6 );
cat ++;
}
if ( MODE == MODE_PLANES_V ) {
writeTriangle ( cat, skelID, boneID, unitID, xys, 3, 9 );
cat ++;
}
if ( MODE == MODE_POINTS ) {
writePoints ( cat, skelID, boneID, unitID );
cat = cat + 2;
}
if ( MODE == MODE_PYRAMIDS ) {
writeTriangle ( cat, skelID, boneID, unitID, xys, 0, 3 );
cat ++;
writeTriangle ( cat, skelID, boneID, unitID, xys, 3, 6 );
cat ++;
writeTriangle ( cat, skelID, boneID, unitID, xys, 6, 9 );
cat ++;
writeTriangle ( cat, skelID, boneID, unitID, xys, 9, 0 );
cat ++;
writeSquare ( cat, skelID, boneID, unitID, xys );
cat ++;
}
/* switch to next colour for bone colouring */
RGBNUM_BONE ++;
if ( RGBNUM_BONE == RGBMAX ) {
RGBNUM_BONE = 0;
}
G_percent ( i, numPoints - 2, 1 );
}
fprintf ( stdout, "\n" );
/* commit DBMS actions */
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
if (!Vect_build(Map)) {
G_warning("Building topology failed");
}
Vect_close(Map);
db_free_string(&sql);
}
int make_new_cell_layer(void)
{
struct History hist;
void *rast;
int cellfd;
int tmpfd;
int row;
/* open the new raster map to contain the edited version of
the original cell layer. open our temporary file for read
and copy its contents to the layer */
G_set_window(&real_window);
cellfd = G_open_raster_new(new_name, map_type);
tmpfd = open(tempfile, 0);
lseek(tmpfd, 0L, 0);
rast = G_allocate_raster_buf(map_type);
fprintf(stderr, "\n +-------------------------------------------+\n");
fprintf(stderr, " | Saving new cell layer |\n");
fprintf(stderr, " +---------------------------------------");
for (row = 0; row < real_nrows; row++) {
if (read(tmpfd, rast, real_ncols * cellsize) !=
(real_ncols * cellsize))
error(1, "error writing raster map during copy");
G_put_raster_row(cellfd, rast, map_type);
G_percent(row, real_nrows, 5);
}
G_percent(100, 100, 5);
fprintf(stderr, "\n");
close(tmpfd);
G_close_cell(cellfd);
unlink(tempfile);
/* create and write cat, colr, quant, and hist support files
for the newly created layer */
if (colr_ok) {
G_write_colors(new_name, user_mapset, &colr);
G_free_colors(&colr);
colr_ok = 0;
}
if (cats_ok) {
cats.num = G_number_of_cats(new_name, user_mapset);
G_write_cats(new_name, &cats);
G_free_cats(&cats);
cats_ok = 0;
}
if (quant_ok) {
G_write_quant(new_name, G_mapset(), &quant);
G_quant_free(&quant);
cats_ok = 0;
}
/* construct some history information */
sprintf(hist.mapid, "%s", G_date());
sprintf(hist.title, "%s", new_name);
sprintf(hist.mapset, "%s", user_mapset);
sprintf(hist.creator, "%s", G_whoami());
sprintf(hist.maptype, "cell");
sprintf(hist.edhist[0],
"Generated by d.rast.edit from original raster map");
sprintf(hist.edhist[1], " %s in mapset %s ", orig_name, orig_mapset);
hist.edlinecnt = 2;
/* write history */
if (G_write_history(new_name, &hist) == -1)
error(0, "could not write history");
return 0;
}
/*!
\brief Generate script-like output
*/
void G__script(void)
{
FILE *fp = stdout;
char *type;
fprintf(fp,
"############################################################################\n");
fprintf(fp, "#\n");
fprintf(fp, "# MODULE: %s_wrapper\n", G_program_name());
fprintf(fp, "# AUTHOR(S): %s\n", G_whoami());
fprintf(fp, "# PURPOSE: \n");
fprintf(fp, "# COPYRIGHT: (C) %s by %s, and The GRASS Development Team\n",
GRASS_VERSION_DATE, G_whoami());
fprintf(fp, "#\n");
fprintf(fp,
"# This program is free software; you can redistribute it and/or modify\n");
fprintf(fp,
"# it under the terms of the GNU General Public License as published by\n");
fprintf(fp,
"# the Free Software Foundation; either version 2 of the License, or\n");
fprintf(fp, "# (at your option) any later version.\n");
fprintf(fp, "#\n");
fprintf(fp,
"# This program is distributed in the hope that it will be useful,\n");
fprintf(fp,
"# but WITHOUT ANY WARRANTY; without even the implied warranty of\n");
fprintf(fp,
"# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n");
fprintf(fp, "# GNU General Public License for more details.\n");
fprintf(fp, "#\n");
fprintf(fp,
"############################################################################\n\n");
fprintf(fp, "#%%module\n");
if (st->module_info.label)
fprintf(fp, "#%% label: %s\n", st->module_info.label);
if (st->module_info.description)
fprintf(fp, "#%% description: %s\n", st->module_info.description);
if (st->module_info.keywords) {
fprintf(fp, "#%% keywords: ");
G__print_keywords(fp, NULL);
fprintf(fp, "\n");
}
fprintf(fp, "#%%end\n");
if (st->n_flags) {
struct Flag *flag;
for (flag = &st->first_flag; flag; flag = flag->next_flag) {
fprintf(fp, "#%%flag\n");
fprintf(fp, "#%% key: %c\n", flag->key);
if (flag->suppress_required)
fprintf(fp, "#%% suppress_required: yes\n");
if (flag->label)
fprintf(fp, "#%% label: %s\n", flag->label);
if (flag->description)
fprintf(fp, "#%% description: %s\n", flag->description);
if (flag->guisection)
fprintf(fp, "#%% guisection: %s\n", flag->guisection);
fprintf(fp, "#%%end\n");
}
}
if (st->n_opts) {
struct Option *opt;
for (opt = &st->first_option; opt; opt = opt->next_opt) {
switch (opt->type) {
case TYPE_INTEGER:
type = "integer";
break;
case TYPE_DOUBLE:
type = "double";
break;
case TYPE_STRING:
type = "string";
break;
default:
type = "string";
break;
}
fprintf(fp, "#%%option\n");
fprintf(fp, "#%% key: %s\n", opt->key);
fprintf(fp, "#%% type: %s\n", type);
fprintf(fp, "#%% required: %s\n", opt->required ? "yes" : "no");
fprintf(fp, "#%% multiple: %s\n", opt->multiple ? "yes" : "no");
if (opt->options)
fprintf(fp, "#%% options: %s\n", opt->options);
if (opt->key_desc)
fprintf(fp, "#%% key_desc: %s\n", opt->key_desc);
if (opt->label)
fprintf(fp, "#%% label: %s\n", opt->label);
if (opt->description)
fprintf(fp, "#%% description: %s\n", opt->description);
if (opt->descriptions)
fprintf(fp, "#%% descriptions: %s\n", opt->descriptions);
if (opt->answer)
fprintf(fp, "#%% answer: %s\n", opt->answer);
if (opt->gisprompt)
fprintf(fp, "#%% gisprompt: %s\n", opt->gisprompt);
if (opt->guisection)
fprintf(fp, "#%% guisection: %s\n", opt->guisection);
if (opt->guidependency)
fprintf(fp, "#%% guidependency: %s\n", opt->guidependency);
fprintf(fp, "#%%end\n");
}
}
}
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[])
{
int ret;
struct GModule *module;
struct Option *gisdbase_opt, *location_opt, *mapset_opt;
struct Flag *f_add, *f_list;
char *gisdbase_old, *location_old, *mapset_old;
char *gisdbase_new, *location_new, *mapset_new;
char *gis_lock;
char *mapset_old_path, *mapset_new_path;
char *lock_prog;
char path[GPATH_MAX];
char *shell, *monitor;
struct MON_CAP *cap;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("general, settings");
module->label = _("Changes current mapset.");
module->description = _("Optionally create new mapset or list available mapsets in given location.");
mapset_opt = G_define_option();
mapset_opt->key = "mapset";
mapset_opt->type = TYPE_STRING;
mapset_opt->required = NO;
mapset_opt->multiple = NO;
mapset_opt->description = _("Name of mapset where to switch");
mapset_opt->guisection = _("Settings");
location_opt = G_define_option();
location_opt->key = "location";
location_opt->type = TYPE_STRING;
location_opt->required = NO;
location_opt->multiple = NO;
location_opt->description = _("Location name (not location path)");
location_opt->guisection = _("Settings");
gisdbase_opt = G_define_option();
gisdbase_opt->key = "gisdbase";
gisdbase_opt->type = TYPE_STRING;
gisdbase_opt->required = NO;
gisdbase_opt->multiple = NO;
gisdbase_opt->key_desc = "path";
gisdbase_opt->description =
_("GIS data directory (full path to the directory where the new location is)");
gisdbase_opt->guisection = _("Settings");
f_add = G_define_flag();
f_add->key = 'c';
f_add->description = _("Create mapset if it doesn't exist");
f_add->answer = FALSE;
f_add->guisection = _("Create");
f_list = G_define_flag();
f_list->key = 'l';
f_list->description = _("List available mapsets");
f_list->guisection = _("Print");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (!mapset_opt->answer && !f_list->answer)
G_fatal_error(_("Either mapset= or -l must be used"));
/* Store original values */
gisdbase_old = G__getenv("GISDBASE");
location_old = G__getenv("LOCATION_NAME");
mapset_old = G__getenv("MAPSET");
G_asprintf(&mapset_old_path, "%s/%s/%s", gisdbase_old, location_old,
mapset_old);
monitor = G__getenv("MONITOR");
/* New values */
if (gisdbase_opt->answer)
gisdbase_new = gisdbase_opt->answer;
else
gisdbase_new = gisdbase_old;
if (location_opt->answer)
location_new = location_opt->answer;
else
location_new = location_old;
if (f_list->answer) {
char **ms;
int nmapsets;
G__setenv("LOCATION_NAME", location_new);
G__setenv("GISDBASE", gisdbase_new);
ms = G_available_mapsets();
for (nmapsets = 0; ms[nmapsets]; nmapsets++) {
if (G__mapset_permissions(ms[nmapsets]) > 0) {
fprintf(stdout, "%s ", ms[nmapsets]);
}
}
fprintf(stdout, "\n");
exit(EXIT_SUCCESS);
}
mapset_new = mapset_opt->answer;
G_asprintf(&mapset_new_path, "%s/%s/%s", gisdbase_new, location_new,
mapset_new);
/* TODO: this should be checked better (repeated '/' etc.) */
if (strcmp(mapset_old_path, mapset_new_path) == 0)
G_fatal_error(_("<%s> is already the current mapset"), mapset_new);
/* Check if the mapset exists and user is owner */
G_debug(2, "check : %s", mapset_new_path);
ret = G__mapset_permissions2(gisdbase_new, location_new, mapset_new);
switch (ret) {
case 0:
G_fatal_error(_("You don't have permission to use this mapset"));
break;
case -1:
if (f_add->answer == TRUE) {
G_debug(2, "Mapset %s doesn't exist, attempting to create it",
mapset_new);
G_make_mapset(gisdbase_new, location_new, mapset_new);
}
else
G_fatal_error(_("The mapset does not exist. Use -c flag to create it."));
break;
default:
break;
}
/* Check if the mapset is in use */
gis_lock = getenv("GIS_LOCK");
if (!gis_lock)
G_fatal_error(_("Unable to read GIS_LOCK environment variable"));
G_asprintf(&lock_prog, "%s/etc/lock", G_gisbase());
sprintf(path, "%s/.gislock", mapset_new_path);
G_debug(2, path);
ret = G_spawn(lock_prog, lock_prog, path, gis_lock, NULL);
G_debug(2, "lock result = %d", ret);
G_free(lock_prog);
/* Warning: the value returned by system() is not that returned by exit() in executed program
* e.g. exit(1) -> 256 (multiplied by 256) */
if (ret != 0)
G_fatal_error(_("%s is currently running GRASS in selected mapset or lock file cannot be checked"),
G_whoami());
/* Erase monitors */
G_message(_("Erasing monitors..."));
while ((cap = R_parse_monitorcap(MON_NEXT, "")) != NULL) {
G__setenv("MONITOR", cap->name);
R__open_quiet();
if (R_open_driver() == 0) {
D_erase(DEFAULT_BG_COLOR);
D_add_to_list("d.erase");
R_close_driver();
R_release_driver();
}
}
if (monitor)
G_setenv("MONITOR", monitor);
/* Clean temporary directory */
sprintf(path, "%s/etc/clean_temp", G_gisbase());
G_verbose_message(_("Cleaning up temporary files..."));
G_spawn(path, "clean_temp", NULL);
/* Reset variables */
G_setenv("GISDBASE", gisdbase_new);
G_setenv("LOCATION_NAME", location_new);
G_setenv("MAPSET", mapset_new);
/* Remove old lock */
sprintf(path, "%s/.gislock", mapset_old_path);
remove(path);
G_free(mapset_old_path);
G_important_message(_("Your shell continues to use the history for the old mapset"));
if ((shell = getenv("SHELL"))) {
if (strstr(shell, "bash")) {
G_important_message(_("You can switch the history by commands:\n"
"history -w; history -r %s/.bash_history; HISTFILE=%s/.bash_history"),
mapset_new_path, mapset_new_path);
}
else if (strstr(shell, "tcsh")) {
G_important_message(_("You can switch the history by commands:\n"
"history -S; history -L %s/.history; setenv histfile=%s/.history"),
mapset_new_path, mapset_new_path);
}
}
G_message(_("Your current mapset is <%s>"), mapset_new);
G_free(mapset_new_path);
return (EXIT_SUCCESS);
}
