/*!
\brief Read header of GRASS ASCII vector format
\param dascii pointer to the ASCII file
\param Map pointer to Map_info structure
\return 0 on success
\return -1 on error
*/
int Vect_read_ascii_head(FILE *dascii, struct Map_info *Map)
{
char buff[1024];
char *ptr;
for (;;) {
if (0 == G_getl2(buff, sizeof(buff) - 1, dascii))
return (0);
/* Last line of header */
if (strncmp(buff, "VERTI:", 6) == 0)
return (0);
if (!(ptr = strchr(buff, ':'))) {
G_warning(_("Unexpected data in vector header:\n[%s]"), buff);
return -1;
}
ptr++; /* Search for the start of text */
while (*ptr == ' ')
ptr++;
if (strncmp(buff, "ORGANIZATION:", 12) == 0)
Vect_set_organization(Map, ptr);
else if (strncmp(buff, "DIGIT DATE:", 11) == 0)
Vect_set_date(Map, ptr);
else if (strncmp(buff, "DIGIT NAME:", 11) == 0)
Vect_set_person(Map, ptr);
else if (strncmp(buff, "MAP NAME:", 9) == 0)
Vect_set_map_name(Map, ptr);
else if (strncmp(buff, "MAP DATE:", 9) == 0)
Vect_set_map_date(Map, ptr);
else if (strncmp(buff, "MAP SCALE:", 10) == 0)
Vect_set_scale(Map, atoi(ptr));
else if (strncmp(buff, "OTHER INFO:", 11) == 0)
Vect_set_comment(Map, ptr);
else if (strncmp(buff, "ZONE:", 5) == 0 ||
strncmp(buff, "UTM ZONE:", 9) == 0)
Vect_set_zone(Map, atoi(ptr));
else if (strncmp(buff, "WEST EDGE:", 10) == 0) {
}
else if (strncmp(buff, "EAST EDGE:", 10) == 0) {
}
else if (strncmp(buff, "SOUTH EDGE:", 11) == 0) {
}
else if (strncmp(buff, "NORTH EDGE:", 11) == 0) {
}
else if (strncmp(buff, "MAP THRESH:", 11) == 0)
Vect_set_thresh(Map, atof(ptr));
else {
G_warning(_("Unknown keyword <%s> in vector head"), buff);
}
}
/* NOTREACHED */
}
/*!
\brief Copy header data from one to another map
\param from target vector map
\param[out] to destination vector map
\return 0
*/
int Vect_copy_head_data(const struct Map_info *from, struct Map_info *to)
{
Vect_set_organization(to, Vect_get_organization(from));
Vect_set_date(to, Vect_get_date(from));
Vect_set_person(to, Vect_get_person(from));
Vect_set_map_name(to, Vect_get_map_name(from));
Vect_set_map_date(to, Vect_get_map_date(from));
Vect_set_comment(to, Vect_get_comment(from));
Vect_set_scale(to, Vect_get_scale(from));
Vect_set_zone(to, Vect_get_zone(from));
Vect_set_thresh(to, Vect_get_thresh(from));
return 0;
}
/*!
\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;
}
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[])
{
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);
}
/*!
\brief Reads head information from text file (GV_HEAD_ELEMENT) - for internal use only
\param Map pointer to Map_info structure
\return 0 on success
\return -1 on error
*/
int Vect__read_head(struct Map_info *Map)
{
FILE *head_fp;
char buff[2000];
char *path, *ptr;
/* Reset / init */
Vect__init_head(Map);
G_debug(1, "Vect__read_head(): vector = %s@%s", Map->name, Map->mapset);
path = Vect__get_path(Map);
head_fp = G_fopen_old(path, GV_HEAD_ELEMENT, Map->mapset);
G_free(path);
if (head_fp == NULL) {
G_warning(_("Unable to open header file of vector <%s>"),
Vect_get_full_name(Map));
return -1;
}
while (G_getl2(buff, 2000, head_fp)) {
if (!(ptr = strchr(buff, ':'))) {
G_warning(_("Corrupted row in head: %s"), buff);
continue;
}
ptr++; /* Search for the start of text */
while (*ptr == ' ')
ptr++;
if (strncmp(buff, "ORGANIZATION:", sizeof(char) * 12) == 0)
Vect_set_organization(Map, ptr);
else if (strncmp(buff, "DIGIT DATE:", sizeof(char) * 11) == 0)
Vect_set_date(Map, ptr);
else if (strncmp(buff, "DIGIT NAME:", sizeof(char) * 11) == 0)
Vect_set_person(Map, ptr);
else if (strncmp(buff, "MAP NAME:", sizeof(char) * 9) == 0)
Vect_set_map_name(Map, ptr);
else if (strncmp(buff, "MAP DATE:", sizeof(char) * 9) == 0)
Vect_set_map_date(Map, ptr);
else if (strncmp(buff, "MAP SCALE:", sizeof(char) * 10) == 0)
Vect_set_scale(Map, atoi(ptr));
else if (strncmp(buff, "OTHER INFO:", sizeof(char) * 11) == 0)
Vect_set_comment(Map, ptr);
else if (strncmp(buff, "PROJ:", sizeof(char) * 5) == 0)
Vect_set_proj(Map, atoi(ptr));
else if (strncmp(buff, "ZONE:", sizeof(char) * 5) == 0 ||
strncmp(buff, "UTM ZONE:", sizeof(char) * 9) == 0)
Vect_set_zone(Map, atoi(ptr));
else if (strncmp(buff, "WEST EDGE:", sizeof(char) * 10) == 0) {
}
else if (strncmp(buff, "EAST EDGE:", sizeof(char) * 10) == 0) {
}
else if (strncmp(buff, "SOUTH EDGE:", sizeof(char) * 11) == 0) {
}
else if (strncmp(buff, "NORTH EDGE:", sizeof(char) * 11) == 0) {
}
else if (strncmp(buff, "MAP THRESH:", sizeof(char) * 11) == 0)
Vect_set_thresh(Map, atof(ptr));
else
G_warning(_("Unknown keyword '%s' in vector head"), buff);
}
fclose(head_fp);
return 0;
}
/* read old 3.0 or 4.0 dig file into array
returns number of elements read into array
or -1 on error */
int read_dig(FILE * Digin, struct Map_info *Mapout,
struct Line **plines, int endian, int att)
{
char buf[100];
struct dig_head In_head;
int lalloc, line = 0, type, portable = 1;
int npoints = 0, nlines = 0, nbounds = 0;
int ndpoints = 0, ndlines = 0, ndbounds = 0, nunknown = 0;
struct Line *lines;
struct line_pnts *nline;
struct line_cats *cat_out;
double dbuf;
int ibuf;
long lbuf;
struct gvfile gvf;
dig_file_init(&gvf);
gvf.file = Digin;
Vect__init_head(Mapout);
/* set conversion matrices */
dig_init_portable(&(In_head.port), endian);
/* Version 3 dig files were not portable and some version 4
* files may be also non portable */
G_message(_("Reading dig file..."));
/* read and copy head */
dig_fseek(&gvf, 0L, SEEK_SET); /* set to beginning */
if (0 >= dig__fread_port_C(buf, DIG4_ORGAN_LEN, &gvf))
return -1;
buf[DIG4_ORGAN_LEN - 1] = '\0';
Vect_set_organization(Mapout, buf);
if (0 >= dig__fread_port_C(buf, DIG4_DATE_LEN, &gvf))
return -1;
buf[DIG4_DATE_LEN - 1] = '\0';
Vect_set_date(Mapout, buf);
if (0 >= dig__fread_port_C(buf, DIG4_YOUR_NAME_LEN, &gvf))
return -1;
buf[DIG4_YOUR_NAME_LEN - 1] = '\0';
Vect_set_person(Mapout, buf);
if (0 >= dig__fread_port_C(buf, DIG4_MAP_NAME_LEN, &gvf))
return -1;
buf[DIG4_MAP_NAME_LEN - 1] = '\0';
Vect_set_map_name(Mapout, buf);
if (0 >= dig__fread_port_C(buf, DIG4_SOURCE_DATE_LEN, &gvf))
return -1;
buf[DIG4_SOURCE_DATE_LEN - 1] = '\0';
Vect_set_map_date(Mapout, buf);
if (0 >= dig__fread_port_C(buf, DIG4_LINE_3_LEN, &gvf))
return -1;
buf[DIG4_LINE_3_LEN - 1] = '\0';
Vect_set_comment(Mapout, buf);
if (0 >= dig__fread_port_C(buf, VERS_4_DATA_SIZE, &gvf))
return -1;
if (buf[0] != '%' || buf[1] != '%') { /* Version3.0 */
In_head.Version_Major = 3;
portable = 0; /* input vector is not portable format */
G_message(_("Input file is version 3."));
}
else {
In_head.Version_Major = 4;
G_message(_("Input file is version 4."));
/* determine if in portable format or not */
if (buf[6] == 1 && (~buf[6] & 0xff) == (buf[7] & 0xff)) { /* portable ? */
portable = 1; /* input vector is portable format */
}
else {
portable = 0; /* input vector is not portable format */
}
}
if (portable == 1) {
G_message(_("Input file is portable."));
}
else {
G_warning(_("Input file is not portable. "
"We will attempt to convert anyway but conversion may fail. "
"Please read manual for detail information."));
}
/* set Cur_Head because it is used by dig__*_convert()
called by dig__fread_port_*() */
dig_set_cur_port(&(In_head.port));
if (0 >= dig__fread_port_L(&lbuf, 1, &gvf))
return -1;
Vect_set_scale(Mapout, (int)lbuf);
if (0 >= dig__fread_port_I(&ibuf, 1, &gvf))
return -1;
Vect_set_zone(Mapout, ibuf);
if (0 >= dig__fread_port_D(&dbuf, 1, &gvf))
return -1; /* W */
if (0 >= dig__fread_port_D(&dbuf, 1, &gvf))
return -1; /* E */
if (0 >= dig__fread_port_D(&dbuf, 1, &gvf))
return -1; /* S */
if (0 >= dig__fread_port_D(&dbuf, 1, &gvf))
return -1; /* N */
if (0 >= dig__fread_port_D(&dbuf, 1, &gvf))
return -1;
Vect_set_thresh(Mapout, dbuf);
/* reading dig file body (elements) */
nline = Vect_new_line_struct();
cat_out = Vect_new_cats_struct();
lalloc = 0;
lines = NULL;
line = 0;
while (1) {
type = read_line(&gvf, nline);
G_debug(3, "read line = %d, type = %d", line, type);
if (type == -2)
break; /* EOF */
switch (type) {
case GV_POINT:
npoints++;
break;
case GV_LINE:
nlines++;
break;
case GV_BOUNDARY:
nbounds++;
break;
case 0: /* dead */
break;
default:
nunknown++;
break;
}
if (!(type & (GV_POINT | GV_LINE | GV_BOUNDARY)))
continue;
if ((type & GV_BOUNDARY) || !att) {
Vect_write_line(Mapout, type, nline, cat_out);
/* reset In_head */
dig_set_cur_port(&(In_head.port));
}
else { /* GV_POINT or GV_LINE */
if (line >= lalloc) {
lalloc += 10000;
lines =
(struct Line *)G_realloc(lines,
lalloc * sizeof(struct Line));
}
lines[line].type = type;
lines[line].n_points = nline->n_points;
lines[line].cat = -1;
lines[line].x =
(double *)G_malloc(nline->n_points * sizeof(double));
lines[line].y =
(double *)G_malloc(nline->n_points * sizeof(double));
memcpy((void *)lines[line].x, (void *)nline->x,
nline->n_points * sizeof(double));
memcpy((void *)lines[line].y, (void *)nline->y,
nline->n_points * sizeof(double));
line++;
}
}
if (att) {
G_message(_("[%d] points read to memory"), npoints);
G_message(_("[%d] lines read to memory"), nlines);
}
else {
G_message(_("[%d] points read and written to output"), npoints);
G_message(_("[%d] lines read and written to output"), nlines);
}
G_message(_("[%d] area boundaries read and written to output"), nbounds);
G_message(_("[%d] dead points skipped"), ndpoints);
G_message(_("[%d] dead lines skipped"), ndlines);
G_message(_("[%d] dead area boundaries skipped"), ndbounds);
G_message(_("[%d] elements of unknown type skipped"), nunknown);
G_message(_("[%d] elements read to memory"), line);
*plines = lines;
return (line);
}