void print_shell(const struct Map_info *Map)
{
if (Vect_maptype(Map) & (GV_FORMAT_OGR | GV_FORMAT_OGR_DIRECT)) {
fprintf(stdout, "ogr_layer=%s\n",
Vect_get_ogr_layer_name(Map));
fprintf(stdout, "ogr_dsn=%s\n",
Vect_get_ogr_dsn_name(Map));
}
else {
fprintf(stdout, "name=%s\n",
Vect_get_name(Map));
fprintf(stdout, "mapset=%s\n",
Vect_get_mapset(Map));
}
fprintf(stdout, "location=%s\n",
G_location());
fprintf(stdout, "database=%s\n",
G_gisdbase());
fprintf(stdout, "title=%s\n",
Vect_get_map_name(Map));
fprintf(stdout, "scale=1:%d\n",
Vect_get_scale(Map));
if (Vect_maptype(Map) & (GV_FORMAT_OGR | GV_FORMAT_OGR_DIRECT)) {
fprintf(stdout, "format=%s,%s\n",
Vect_maptype_info(Map), Vect_get_ogr_format_info(Map));
}
else {
fprintf(stdout, "format=%s\n",
Vect_maptype_info(Map));
}
fprintf(stdout, "creator=%s\n",
Vect_get_person(Map));
fprintf(stdout, "organization=%s\n",
Vect_get_organization(Map));
fprintf(stdout, "source_date=%s\n",
Vect_get_map_date(Map));
fprintf(stdout, "level=%d\n",
Vect_level(Map));
if (Vect_level(Map) > 0) {
fprintf(stdout, "num_dblinks=%d\n",
Vect_get_num_dblinks(Map));
}
fprintf(stdout, "projection=%s\n",
Vect_get_proj_name(Map));
if (G_projection() == PROJECTION_UTM) {
fprintf(stdout, "zone=%d\n",
Vect_get_zone(Map));
}
fprintf(stdout, "digitization_threshold=%f\n",
Vect_get_thresh(Map));
fprintf(stdout, "comment=%s\n",
Vect_get_comment(Map));
}
/*!
* \brief Get current location path
*
* \param
* \return char* to location path
*/
char *G__location_path(void)
{
const char *name = G_location();
const char *base = G_gisdbase();
char *location = G_malloc(strlen(base) + strlen(name) + 2);
sprintf(location, "%s/%s", base, name);
return location;
}
int G__make_location(const char *location_name,
struct Cell_head *wind,
struct Key_Value *proj_info,
struct Key_Value *proj_units, FILE * report_file)
{
char path[GPATH_MAX];
int out_stat;
/* Try to create the location directory, under the gisdbase. */
sprintf(path, "%s/%s", G_gisdbase(), location_name);
if (G_mkdir(path) != 0)
return -1;
/* Make the PERMANENT mapset. */
sprintf(path, "%s/%s/%s", G_gisdbase(), location_name, "PERMANENT");
if (G_mkdir(path) != 0)
return -1;
/* make these the new current location and mapset */
G__setenv("LOCATION_NAME", location_name);
G__setenv("MAPSET", "PERMANENT");
/* Create the default, and current window files */
G__put_window(wind, "", "DEFAULT_WIND");
G__put_window(wind, "", "WIND");
/* Write out the PROJ_INFO, and PROJ_UNITS if available. */
if (proj_info != NULL) {
G__file_name(path, "", "PROJ_INFO", "PERMANENT");
G_write_key_value_file(path, proj_info, &out_stat);
if (out_stat != 0)
return -2;
}
if (proj_units != NULL) {
G__file_name(path, "", "PROJ_UNITS", "PERMANENT");
G_write_key_value_file(path, proj_units, &out_stat);
if (out_stat != 0)
return -2;
}
return 0;
}
/*!
\brief Get current mapset UNIX-like path (internal use only)
Allocated buffer should be freed by G_free(). See also
G_mapset_path().
\todo Support also Windows-like path (?)
\return buffer with mapset path
*/
char *G__mapset_path(void)
{
const char *mapset = G__mapset();
const char *location = G_location();
const char *base = G_gisdbase();
char *mapset_path = G_malloc(strlen(base) + strlen(location) +
strlen(mapset) + 3);
sprintf(mapset_path, "%s/%s/%s", base, location, mapset);
return mapset_path;
}
char *
G__location_path()
{
char *location = 0;
char *base;
char *name;
name = G_location();
base = G_gisdbase();
location = G_malloc (strlen (base) + strlen (name) + 2);
sprintf (location, "%s/%s", base, name);
return location;
}
int G__make_mapset(const char *gisdbase_name, const char *location_name,
const char *mapset_name)
{
char path[GPATH_MAX];
struct Cell_head default_window;
/* Get location */
if (location_name == NULL)
location_name = G_location();
/* Get GISDBASE */
if (gisdbase_name == NULL)
gisdbase_name = G_gisdbase();
/* TODO: Should probably check that user specified location and gisdbase are valid */
/* Make the mapset. */
sprintf(path, "%s/%s/%s", gisdbase_name, location_name, mapset_name);
if (G_mkdir(path) != 0)
return -1;
G__create_alt_env();
/* Get PERMANENT default window */
G__setenv("GISDBASE", gisdbase_name);
G__setenv("LOCATION", location_name);
G__setenv("MAPSET", "PERMANENT");
G_get_default_window(&default_window);
/* Change to the new mapset */
G__setenv("MAPSET", mapset_name);
/* Copy default window/regions to new mapset */
G__put_window(&default_window, "", "WIND");
/* And switch back to original environment */
G__switch_env();
return 0;
}
int get_target(void)
{
char location[GNAME_MAX];
char mapset[GMAPSET_MAX];
char buf[1024];
int stat;
if (!I_get_target(group.name, location, mapset)) {
sprintf(buf, "Target information for group [%s] missing\n",
group.name);
goto error;
}
sprintf(buf, "%s/%s", G_gisdbase(), location);
if (access(buf, 0) != 0) {
sprintf(buf, "Target location [%s] not found\n", location);
goto error;
}
G_create_alt_env();
G__setenv("LOCATION_NAME", location);
stat = G__mapset_permissions(mapset);
if (stat > 0) {
G__setenv("MAPSET", mapset);
G_create_alt_search_path();
G_switch_env();
G_switch_search_path();
which_env = 0;
return 1;
}
sprintf(buf, "Mapset [%s] in target location [%s] - ", mapset, location);
strcat(buf, stat == 0 ? "permission denied\n" : "not found\n");
error:
strcat(buf, "Please run i.target for group ");
strcat(buf, group.name);
G_fatal_error(buf);
return -1;
}
int main(int argc, char **argv)
{
char *mapname, /* ptr to name of output layer */
*setname, /* ptr to name of input mapset */
*ipolname; /* name of interpolation method */
int fdi, /* input map file descriptor */
fdo, /* output map file descriptor */
method, /* position of method in table */
permissions, /* mapset permissions */
cell_type, /* output celltype */
cell_size, /* size of a cell in bytes */
row, col, /* counters */
irows, icols, /* original rows, cols */
orows, ocols, have_colors, /* Input map has a colour table */
overwrite, /* Overwrite */
curr_proj; /* output projection (see gis.h) */
void *obuffer, /* buffer that holds one output row */
*obufptr; /* column ptr in output buffer */
struct cache *ibuffer; /* buffer that holds the input map */
func interpolate; /* interpolation routine */
double xcoord1, xcoord2, /* temporary x coordinates */
ycoord1, ycoord2, /* temporary y coordinates */
col_idx, /* column index in input matrix */
row_idx, /* row index in input matrix */
onorth, osouth, /* save original border coords */
oeast, owest, inorth, isouth, ieast, iwest;
char north_str[30], south_str[30], east_str[30], west_str[30];
struct Colors colr; /* Input map colour table */
struct History history;
struct pj_info iproj, /* input map proj parameters */
oproj; /* output map proj parameters */
struct Key_Value *in_proj_info, /* projection information of */
*in_unit_info, /* input and output mapsets */
*out_proj_info, *out_unit_info;
struct GModule *module;
struct Flag *list, /* list files in source location */
*nocrop, /* don't crop output map */
*print_bounds, /* print output bounds and exit */
*gprint_bounds; /* same but print shell style */
struct Option *imapset, /* name of input mapset */
*inmap, /* name of input layer */
*inlocation, /* name of input location */
*outmap, /* name of output layer */
*indbase, /* name of input database */
*interpol, /* interpolation method:
nearest neighbor, bilinear, cubic */
*memory, /* amount of memory for cache */
*res; /* resolution of target map */
struct Cell_head incellhd, /* cell header of input map */
outcellhd; /* and output map */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("projection"));
G_add_keyword(_("transformation"));
module->description =
_("Re-projects a raster map from given location to the current location.");
inmap = G_define_standard_option(G_OPT_R_INPUT);
inmap->description = _("Name of input raster map to re-project");
inmap->required = NO;
inmap->guisection = _("Source");
inlocation = G_define_option();
inlocation->key = "location";
inlocation->type = TYPE_STRING;
inlocation->required = YES;
inlocation->description = _("Location containing input raster map");
inlocation->gisprompt = "old,location,location";
inlocation->key_desc = "name";
imapset = G_define_standard_option(G_OPT_M_MAPSET);
imapset->label = _("Mapset containing input raster map");
imapset->description = _("default: name of current mapset");
imapset->guisection = _("Source");
indbase = G_define_option();
indbase->key = "dbase";
indbase->type = TYPE_STRING;
indbase->required = NO;
indbase->description = _("Path to GRASS database of input location");
indbase->gisprompt = "old,dbase,dbase";
indbase->key_desc = "path";
indbase->guisection = _("Source");
outmap = G_define_standard_option(G_OPT_R_OUTPUT);
outmap->required = NO;
outmap->description = _("Name for output raster map (default: same as 'input')");
outmap->guisection = _("Target");
ipolname = make_ipol_list();
interpol = G_define_option();
interpol->key = "method";
interpol->type = TYPE_STRING;
interpol->required = NO;
interpol->answer = "nearest";
interpol->options = ipolname;
interpol->description = _("Interpolation method to use");
interpol->guisection = _("Target");
interpol->descriptions = make_ipol_desc();
memory = G_define_option();
memory->key = "memory";
memory->type = TYPE_INTEGER;
memory->required = NO;
memory->description = _("Cache size (MiB)");
res = G_define_option();
res->key = "resolution";
res->type = TYPE_DOUBLE;
res->required = NO;
res->description = _("Resolution of output raster map");
res->guisection = _("Target");
list = G_define_flag();
list->key = 'l';
list->description = _("List raster maps in input location and exit");
nocrop = G_define_flag();
nocrop->key = 'n';
nocrop->description = _("Do not perform region cropping optimization");
print_bounds = G_define_flag();
print_bounds->key = 'p';
print_bounds->description =
_("Print input map's bounds in the current projection and exit");
print_bounds->guisection = _("Target");
gprint_bounds = G_define_flag();
gprint_bounds->key = 'g';
gprint_bounds->description =
_("Print input map's bounds in the current projection and exit (shell style)");
gprint_bounds->guisection = _("Target");
/* 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);
/* get the method */
for (method = 0; (ipolname = menu[method].name); method++)
if (strcmp(ipolname, interpol->answer) == 0)
break;
if (!ipolname)
G_fatal_error(_("<%s=%s> unknown %s"),
interpol->key, interpol->answer, interpol->key);
interpolate = menu[method].method;
mapname = outmap->answer ? outmap->answer : inmap->answer;
if (mapname && !list->answer && !overwrite &&
G_find_raster(mapname, G_mapset()))
G_fatal_error(_("option <%s>: <%s> exists."), "output", mapname);
setname = imapset->answer ? imapset->answer : G_store(G_mapset());
if (strcmp(inlocation->answer, G_location()) == 0 &&
(!indbase->answer || strcmp(indbase->answer, G_gisdbase()) == 0))
#if 0
G_fatal_error(_("Input and output locations can not be the same"));
#else
G_warning(_("Input and output locations are the same"));
#endif
G_get_window(&outcellhd);
if(gprint_bounds->answer && !print_bounds->answer)
print_bounds->answer = gprint_bounds->answer;
curr_proj = G_projection();
/* Get projection info for output mapset */
if ((out_proj_info = G_get_projinfo()) == NULL)
G_fatal_error(_("Unable to get projection info of output raster map"));
if ((out_unit_info = G_get_projunits()) == NULL)
G_fatal_error(_("Unable to get projection units of output raster map"));
if (pj_get_kv(&oproj, out_proj_info, out_unit_info) < 0)
G_fatal_error(_("Unable to get projection key values of output raster map"));
/* Change the location */
G__create_alt_env();
G__setenv("GISDBASE", indbase->answer ? indbase->answer : G_gisdbase());
G__setenv("LOCATION_NAME", inlocation->answer);
permissions = G__mapset_permissions(setname);
if (permissions < 0) /* can't access mapset */
G_fatal_error(_("Mapset <%s> in input location <%s> - %s"),
setname, inlocation->answer,
permissions == 0 ? _("permission denied")
: _("not found"));
/* if requested, list the raster maps in source location - MN 5/2001 */
if (list->answer) {
int i;
char **list;
G_verbose_message(_("Checking location <%s> mapset <%s>"),
inlocation->answer, setname);
list = G_list(G_ELEMENT_RASTER, G__getenv("GISDBASE"),
G__getenv("LOCATION_NAME"), setname);
for (i = 0; list[i]; i++) {
fprintf(stdout, "%s\n", list[i]);
}
fflush(stdout);
exit(EXIT_SUCCESS); /* leave r.proj after listing */
}
if (!inmap->answer)
G_fatal_error(_("Required parameter <%s> not set"), inmap->key);
if (!G_find_raster(inmap->answer, setname))
G_fatal_error(_("Raster map <%s> in location <%s> in mapset <%s> not found"),
inmap->answer, inlocation->answer, setname);
/* Read input map colour table */
have_colors = Rast_read_colors(inmap->answer, setname, &colr);
/* Get projection info for input mapset */
if ((in_proj_info = G_get_projinfo()) == NULL)
G_fatal_error(_("Unable to get projection info of input map"));
if ((in_unit_info = G_get_projunits()) == NULL)
G_fatal_error(_("Unable to get projection units of input map"));
if (pj_get_kv(&iproj, in_proj_info, in_unit_info) < 0)
G_fatal_error(_("Unable to get projection key values of input map"));
G_free_key_value(in_proj_info);
G_free_key_value(in_unit_info);
G_free_key_value(out_proj_info);
G_free_key_value(out_unit_info);
if (G_verbose() > G_verbose_std())
pj_print_proj_params(&iproj, &oproj);
/* this call causes r.proj to read the entire map into memeory */
Rast_get_cellhd(inmap->answer, setname, &incellhd);
Rast_set_input_window(&incellhd);
if (G_projection() == PROJECTION_XY)
G_fatal_error(_("Unable to work with unprojected data (xy location)"));
/* Save default borders so we can show them later */
inorth = incellhd.north;
isouth = incellhd.south;
ieast = incellhd.east;
iwest = incellhd.west;
irows = incellhd.rows;
icols = incellhd.cols;
onorth = outcellhd.north;
osouth = outcellhd.south;
oeast = outcellhd.east;
owest = outcellhd.west;
orows = outcellhd.rows;
ocols = outcellhd.cols;
if (print_bounds->answer) {
G_message(_("Input map <%s@%s> in location <%s>:"),
inmap->answer, setname, inlocation->answer);
if (pj_do_proj(&iwest, &isouth, &iproj, &oproj) < 0)
G_fatal_error(_("Error in pj_do_proj (projection of input coordinate pair)"));
if (pj_do_proj(&ieast, &inorth, &iproj, &oproj) < 0)
G_fatal_error(_("Error in pj_do_proj (projection of input coordinate pair)"));
G_format_northing(inorth, north_str, curr_proj);
G_format_northing(isouth, south_str, curr_proj);
G_format_easting(ieast, east_str, curr_proj);
G_format_easting(iwest, west_str, curr_proj);
if(gprint_bounds->answer) {
fprintf(stdout, "n=%s s=%s w=%s e=%s rows=%d cols=%d\n",
north_str, south_str, west_str, east_str, irows, icols);
}
else {
fprintf(stdout, "Source cols: %d\n", icols);
fprintf(stdout, "Source rows: %d\n", irows);
fprintf(stdout, "Local north: %s\n", north_str);
fprintf(stdout, "Local south: %s\n", south_str);
fprintf(stdout, "Local west: %s\n", west_str);
fprintf(stdout, "Local east: %s\n", east_str);
}
/* somehow approximate local ewres, nsres ?? (use 'g.region -m' on lat/lon side) */
exit(EXIT_SUCCESS);
}
/* Cut non-overlapping parts of input map */
if (!nocrop->answer)
bordwalk(&outcellhd, &incellhd, &oproj, &iproj);
/* Add 2 cells on each side for bilinear/cubic & future interpolation methods */
/* (should probably be a factor based on input and output resolution) */
incellhd.north += 2 * incellhd.ns_res;
incellhd.east += 2 * incellhd.ew_res;
incellhd.south -= 2 * incellhd.ns_res;
incellhd.west -= 2 * incellhd.ew_res;
if (incellhd.north > inorth)
incellhd.north = inorth;
if (incellhd.east > ieast)
incellhd.east = ieast;
if (incellhd.south < isouth)
incellhd.south = isouth;
if (incellhd.west < iwest)
incellhd.west = iwest;
Rast_set_input_window(&incellhd);
/* And switch back to original location */
G__switch_env();
/* Adjust borders of output map */
if (!nocrop->answer)
bordwalk(&incellhd, &outcellhd, &iproj, &oproj);
#if 0
outcellhd.west = outcellhd.south = HUGE_VAL;
outcellhd.east = outcellhd.north = -HUGE_VAL;
for (row = 0; row < incellhd.rows; row++) {
ycoord1 = Rast_row_to_northing((double)(row + 0.5), &incellhd);
for (col = 0; col < incellhd.cols; col++) {
xcoord1 = Rast_col_to_easting((double)(col + 0.5), &incellhd);
pj_do_proj(&xcoord1, &ycoord1, &iproj, &oproj);
if (xcoord1 > outcellhd.east)
outcellhd.east = xcoord1;
if (ycoord1 > outcellhd.north)
outcellhd.north = ycoord1;
if (xcoord1 < outcellhd.west)
outcellhd.west = xcoord1;
if (ycoord1 < outcellhd.south)
outcellhd.south = ycoord1;
}
}
#endif
if (res->answer != NULL) /* set user defined resolution */
outcellhd.ns_res = outcellhd.ew_res = atof(res->answer);
G_adjust_Cell_head(&outcellhd, 0, 0);
Rast_set_output_window(&outcellhd);
G_message(" ");
G_message(_("Input:"));
G_message(_("Cols: %d (%d)"), incellhd.cols, icols);
G_message(_("Rows: %d (%d)"), incellhd.rows, irows);
G_message(_("North: %f (%f)"), incellhd.north, inorth);
G_message(_("South: %f (%f)"), incellhd.south, isouth);
G_message(_("West: %f (%f)"), incellhd.west, iwest);
G_message(_("East: %f (%f)"), incellhd.east, ieast);
G_message(_("EW-res: %f"), incellhd.ew_res);
G_message(_("NS-res: %f"), incellhd.ns_res);
G_message(" ");
G_message(_("Output:"));
G_message(_("Cols: %d (%d)"), outcellhd.cols, ocols);
G_message(_("Rows: %d (%d)"), outcellhd.rows, orows);
G_message(_("North: %f (%f)"), outcellhd.north, onorth);
G_message(_("South: %f (%f)"), outcellhd.south, osouth);
G_message(_("West: %f (%f)"), outcellhd.west, owest);
G_message(_("East: %f (%f)"), outcellhd.east, oeast);
G_message(_("EW-res: %f"), outcellhd.ew_res);
G_message(_("NS-res: %f"), outcellhd.ns_res);
G_message(" ");
/* open and read the relevant parts of the input map and close it */
G__switch_env();
Rast_set_input_window(&incellhd);
fdi = Rast_open_old(inmap->answer, setname);
cell_type = Rast_get_map_type(fdi);
ibuffer = readcell(fdi, memory->answer);
Rast_close(fdi);
G__switch_env();
Rast_set_output_window(&outcellhd);
if (strcmp(interpol->answer, "nearest") == 0) {
fdo = Rast_open_new(mapname, cell_type);
obuffer = (CELL *) Rast_allocate_output_buf(cell_type);
}
else {
fdo = Rast_open_fp_new(mapname);
cell_type = FCELL_TYPE;
obuffer = (FCELL *) Rast_allocate_output_buf(cell_type);
}
cell_size = Rast_cell_size(cell_type);
xcoord1 = xcoord2 = outcellhd.west + (outcellhd.ew_res / 2);
/**/ ycoord1 = ycoord2 = outcellhd.north - (outcellhd.ns_res / 2);
/**/ G_important_message(_("Projecting..."));
G_percent(0, outcellhd.rows, 2);
for (row = 0; row < outcellhd.rows; row++) {
obufptr = obuffer;
for (col = 0; col < outcellhd.cols; col++) {
/* project coordinates in output matrix to */
/* coordinates in input matrix */
if (pj_do_proj(&xcoord1, &ycoord1, &oproj, &iproj) < 0)
Rast_set_null_value(obufptr, 1, cell_type);
else {
/* convert to row/column indices of input matrix */
col_idx = (xcoord1 - incellhd.west) / incellhd.ew_res;
row_idx = (incellhd.north - ycoord1) / incellhd.ns_res;
/* and resample data point */
interpolate(ibuffer, obufptr, cell_type,
&col_idx, &row_idx, &incellhd);
}
obufptr = G_incr_void_ptr(obufptr, cell_size);
xcoord2 += outcellhd.ew_res;
xcoord1 = xcoord2;
ycoord1 = ycoord2;
}
Rast_put_row(fdo, obuffer, cell_type);
xcoord1 = xcoord2 = outcellhd.west + (outcellhd.ew_res / 2);
ycoord2 -= outcellhd.ns_res;
ycoord1 = ycoord2;
G_percent(row, outcellhd.rows - 1, 2);
}
Rast_close(fdo);
if (have_colors > 0) {
Rast_write_colors(mapname, G_mapset(), &colr);
Rast_free_colors(&colr);
}
Rast_short_history(mapname, "raster", &history);
Rast_command_history(&history);
Rast_write_history(mapname, &history);
G_done_msg(NULL);
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);
}
void GRASS_EXPORT QgsGrass::init( void )
{
// Warning!!!
// G_set_error_routine() once called from plugin
// is not valid in provider -> call it always
// Set error function
G_set_error_routine( &error_routine );
if ( initialized )
return;
QSettings settings;
// Is it active mode ?
if ( getenv( "GISRC" ) )
{
active = true;
// Store default values
defaultGisdbase = G_gisdbase();
defaultLocation = G_location();
defaultMapset = G_mapset();
}
else
{
active = false;
}
// Don't use GISRC file and read/write GRASS variables (from location G_VAR_GISRC) to memory only.
G_set_gisrc_mode( G_GISRC_MODE_MEMORY );
// Init GRASS libraries (required)
G_no_gisinit(); // Doesn't check write permissions for mapset compare to G_gisinit("libgrass++");
// I think that mask should not be used in QGIS as it can only confuses people,
// anyway, I don't think anybody is using MASK
G_suppress_masking();
// Set program name
G_set_program_name( "QGIS" );
// Require GISBASE to be set. This should point to the location of
// the GRASS installation. The GRASS libraries use it to know
// where to look for things.
// Look first to see if GISBASE env var is already set.
// This is set when QGIS is run from within GRASS
// or when set explicitly by the user.
// This value should always take precedence.
#if WIN32
QString gisBase = getenv( "WINGISBASE" ) ? getenv( "WINGISBASE" ) : getenv( "GISBASE" );
gisBase = shortPath( gisBase );
#else
QString gisBase = getenv( "GISBASE" );
#endif
QgsDebugMsg( QString( "GRASS gisBase from GISBASE env var is: %1" ).arg( gisBase ) );
if ( !isValidGrassBaseDir( gisBase ) )
{
// Look for gisbase in QSettings
gisBase = settings.value( "/GRASS/gisbase", "" ).toString();
QgsDebugMsg( QString( "GRASS gisBase from QSettings is: %1" ).arg( gisBase ) );
}
if ( !isValidGrassBaseDir( gisBase ) )
{
// Erase gisbase from settings because it does not exists
settings.setValue( "/GRASS/gisbase", "" );
#ifdef WIN32
// Use the applicationDirPath()/grass
gisBase = shortPath( QCoreApplication::applicationDirPath() + "/grass" );
QgsDebugMsg( QString( "GRASS gisBase = %1" ).arg( gisBase ) );
#else
// Use the location specified --with-grass during configure
gisBase = GRASS_BASE;
QgsDebugMsg( QString( "GRASS gisBase from configure is: %1" ).arg( gisBase ) );
#endif
}
bool userGisbase = false;
bool valid = false;
while ( !( valid = isValidGrassBaseDir( gisBase ) ) )
{
// ask user if he wants to specify GISBASE
QMessageBox::StandardButton res = QMessageBox::warning( 0, QObject::tr( "GRASS plugin" ),
QObject::tr( "QGIS couldn't find your GRASS installation.\n"
"Would you like to specify path (GISBASE) to your GRASS installation?" ),
QMessageBox::Ok | QMessageBox::Cancel );
if ( res != QMessageBox::Ok )
{
userGisbase = false;
break;
}
// XXX Need to subclass this and add explantory message above to left side
userGisbase = true;
// For Mac, GISBASE folder may be inside GRASS bundle. Use Qt file dialog
// since Mac native dialog doesn't allow user to browse inside bundles.
gisBase = QFileDialog::getExistingDirectory(
0, QObject::tr( "Choose GRASS installation path (GISBASE)" ), gisBase,
QFileDialog::DontUseNativeDialog );
if ( gisBase == QString::null )
{
// User pressed cancel. No GRASS for you!
userGisbase = false;
break;
}
#if defined(WIN32)
gisBase = shortPath( gisBase );
#endif
}
if ( !valid )
{
// warn user
QMessageBox::information( 0, QObject::tr( "GRASS plugin" ),
QObject::tr( "GRASS data won't be available if GISBASE is not specified." ) );
}
if ( userGisbase )
{
settings.setValue( "/GRASS/gisbase", gisBase );
}
QgsDebugMsg( QString( "Valid GRASS gisBase is: %1" ).arg( gisBase ) );
putEnv( "GISBASE", gisBase );
// Add path to GRASS modules
#ifdef WIN32
QString sep = ";";
#else
QString sep = ":";
#endif
QString path = gisBase + "/bin";
path.append( sep + gisBase + "/scripts" );
path.append( sep + QgsApplication::pkgDataPath() + "/grass/scripts/" );
// On windows the GRASS libraries are in
// QgsApplication::prefixPath(), we have to add them
// to PATH to enable running of GRASS modules
// and database drivers
#ifdef WIN32
// It seems that QgsApplication::prefixPath()
// is not initialized at this point
path.append( sep + shortPath( QCoreApplication::applicationDirPath() ) );
// Add path to MSYS bin
// Warning: MSYS sh.exe will translate this path to '/bin'
if ( QFileInfo( QCoreApplication::applicationDirPath() + "/msys/bin/" ).isDir() )
path.append( sep + shortPath( QCoreApplication::applicationDirPath() + "/msys/bin/" ) );
#endif
QString p = getenv( "PATH" );
path.append( sep + p );
QgsDebugMsg( QString( "set PATH: %1" ).arg( path ) );
putEnv( "PATH", path );
// Set PYTHONPATH
QString pythonpath = gisBase + "/etc/python";
QString pp = getenv( "PYTHONPATH" );
pythonpath.append( sep + pp );
QgsDebugMsg( QString( "set PYTHONPATH: %1" ).arg( pythonpath ) );
putEnv( "PYTHONPATH", pythonpath );
// Set GRASS_PAGER if not set, it is necessary for some
// modules printing to terminal, e.g. g.list
// We use 'cat' because 'more' is not present in MSYS (Win)
// and it doesn't work well in built in shell (Unix/Mac)
// and 'less' is not user friendly (for example user must press
// 'q' to quit which is definitely difficult for normal user)
// Also scroling can be don in scrollable window in both
// MSYS terminal and built in shell.
if ( !getenv( "GRASS_PAGER" ) )
{
QString pager;
QStringList pagers;
//pagers << "more" << "less" << "cat"; // se notes above
pagers << "cat";
for ( int i = 0; i < pagers.size(); i++ )
{
int state;
QProcess p;
p.start( pagers.at( i ) );
p.waitForStarted();
state = p.state();
p.write( "\004" ); // Ctrl-D
p.closeWriteChannel();
p.waitForFinished( 1000 );
p.kill();
if ( state == QProcess::Running )
{
pager = pagers.at( i );
break;
}
}
if ( pager.length() > 0 )
{
putEnv( "GRASS_PAGER", pager );
}
}
initialized = 1;
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *group_opt;
char location[GMAPSET_MAX];
char mapset[GMAPSET_MAX];
char group[GNAME_MAX];
char buf[100];
int stat;
/* must run in a term window */
G_putenv("GRASS_UI_TERM", "1");
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("imagery, orthorectify");
module->description =
_("Interactively select or modify the target elevation model.");
group_opt = G_define_standard_option(G_OPT_I_GROUP);
group_opt->description =
_("Name of imagery group for ortho-rectification");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
elev_layer = (char *)G_malloc(GNAME_MAX * sizeof(char));
mapset_elev = (char *)G_malloc(GMAPSET_MAX * sizeof(char));
tl = (char *)G_malloc(80 * sizeof(char));
math_exp = (char *)G_malloc(80 * sizeof(char));
units = (char *)G_malloc(80 * sizeof(char));
nd = (char *)G_malloc(80 * sizeof(char));
*elev_layer = 0;
*mapset_elev = 0;
*tl = 0;
*math_exp = 0;
*units = 0;
*nd = 0;
strcpy(group, group_opt->answer);
G_suppress_warnings(1);
if (!I_get_target(group, location, mapset)) {
sprintf(buf, _("Target information for group [%s] missing\n"), group);
goto error;
}
G_suppress_warnings(0);
sprintf(buf, "%s/%s", G_gisdbase(), location);
if (access(buf, 0) != 0) {
sprintf(buf, _("Target location [%s] not found\n"), location);
goto error;
}
I_get_group_elev(group, elev_layer, mapset_elev, tl, math_exp, units, nd);
G__create_alt_env();
G__setenv("LOCATION_NAME", location);
stat = G__mapset_permissions(mapset);
if (stat > 0) {
G__setenv("MAPSET", mapset);
G__create_alt_search_path();
G__switch_env();
G__switch_search_path();
which_env = 0;
/* get elevation layer raster map in target location */
select_target_env();
ask_elev(group, location, mapset);
/* select current location */
select_current_env();
I_put_group_elev(group, elev_layer, mapset_elev, tl,
math_exp, units, nd);
exit(EXIT_SUCCESS);
}
sprintf(buf, _("Mapset [%s] in target location [%s] - "), mapset, location);
strcat(buf, stat == 0 ? _("permission denied\n") : _("not found\n"));
error:
strcat(buf, _("Please select a target for group"));
strcat(buf, group);
G_suppress_warnings(0);
G_fatal_error(buf);
}
void print_info(const struct Map_info *Map)
{
int i;
char line[100];
char tmp1[100], tmp2[100];
struct bound_box box;
divider('+');
if (Vect_maptype(Map) & (GV_FORMAT_OGR | GV_FORMAT_OGR_DIRECT)) {
/* for OGR format print also datasource and layer */
sprintf(line, "%-17s%s", _("OGR layer:"),
Vect_get_ogr_layer_name(Map));
printline(line);
sprintf(line, "%-17s%s", _("OGR datasource:"),
Vect_get_ogr_dsn_name(Map));
printline(line);
}
else {
sprintf(line, "%-17s%s", _("Name:"),
Vect_get_name(Map));
printline(line);
sprintf(line, "%-17s%s", _("Mapset:"),
Vect_get_mapset(Map));
printline(line);
}
sprintf(line, "%-17s%s", _("Location:"),
G_location());
printline(line);
sprintf(line, "%-17s%s", _("Database:"),
G_gisdbase());
printline(line);
sprintf(line, "%-17s%s", _("Title:"),
Vect_get_map_name(Map));
printline(line);
sprintf(line, "%-17s1:%d", _("Map scale:"),
Vect_get_scale(Map));
printline(line);
if (Vect_maptype(Map) & (GV_FORMAT_OGR | GV_FORMAT_OGR_DIRECT)) {
sprintf(line, "%-17s%s (%s)", _("Map format:"),
Vect_maptype_info(Map), Vect_get_ogr_format_info(Map));
}
else {
sprintf(line, "%-17s%s", _("Map format:"),
Vect_maptype_info(Map));
}
printline(line);
sprintf(line, "%-17s%s", _("Name of creator:"),
Vect_get_person(Map));
printline(line);
sprintf(line, "%-17s%s", _("Organization:"),
Vect_get_organization(Map));
printline(line);
sprintf(line, "%-17s%s", _("Source date:"),
Vect_get_map_date(Map));
printline(line);
divider('|');
sprintf(line, " %s: %s (%s: %i)",
_("Type of map"), _("vector"), _("level"), Vect_level(Map));
printline(line);
if (Vect_level(Map) > 0) {
printline("");
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of points:"),
Vect_get_num_primitives(Map, GV_POINT),
_("Number of centroids:"),
Vect_get_num_primitives(Map, GV_CENTROID));
printline(line);
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of lines:"),
Vect_get_num_primitives(Map, GV_LINE),
_("Number of boundaries:"),
Vect_get_num_primitives(Map, GV_BOUNDARY));
printline(line);
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of areas:"),
Vect_get_num_areas(Map),
_("Number of islands:"),
Vect_get_num_islands(Map));
printline(line);
if (Vect_is_3d(Map)) {
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of faces:"),
Vect_get_num_primitives(Map, GV_FACE),
_("Number of kernels:"),
Vect_get_num_primitives(Map, GV_KERNEL));
printline(line);
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of volumes:"),
Vect_get_num_volumes(Map),
_("Number of holes:"),
Vect_get_num_holes(Map));
printline(line);
}
printline("");
sprintf(line, " %-24s%s",
_("Map is 3D:"),
Vect_is_3d(Map) ? _("Yes") : _("No"));
printline(line);
sprintf(line, " %-24s%-9d",
_("Number of dblinks:"),
Vect_get_num_dblinks(Map));
printline(line);
}
printline("");
/* this differs from r.info in that proj info IS taken from the map here, not the location settings */
/* Vect_get_proj_name() and _zone() are typically unset?! */
if (G_projection() == PROJECTION_UTM)
sprintf(line, " %s: %s (%s %d)",
_("Projection:"),
Vect_get_proj_name(Map),
_("zone"), Vect_get_zone(Map));
else
sprintf(line, " %s: %s",
_("Projection"),
Vect_get_proj_name(Map));
printline(line);
printline("");
Vect_get_map_box(Map, &box);
G_format_northing(box.N, tmp1, G_projection());
G_format_northing(box.S, tmp2, G_projection());
sprintf(line, " %c: %17s %c: %17s",
'N', tmp1, 'S', tmp2);
printline(line);
G_format_easting(box.E, tmp1, G_projection());
G_format_easting(box.W, tmp2, G_projection());
sprintf(line, " %c: %17s %c: %17s",
'E', tmp1, 'W', tmp2);
printline(line);
if (Vect_is_3d(Map)) {
format_double(box.B, tmp1);
format_double(box.T, tmp2);
sprintf(line, " %c: %17s %c: %17s",
'B', tmp1, 'T', tmp2);
printline(line);
}
printline("");
format_double(Vect_get_thresh(Map), tmp1);
sprintf(line, " %s: %s", _("Digitization threshold"), tmp1);
printline(line);
sprintf(line, " %s:", _("Comment"));
printline(line);
sprintf(line, " %s", Vect_get_comment(Map));
printline(line);
divider('+');
fprintf(stdout, "\n");
}
void print_info(const struct Map_info *Map)
{
int i, map_type;
char line[1024];
char timebuff[256];
struct TimeStamp ts;
int time_ok, first_time_ok, second_time_ok;
struct bound_box box;
char tmp1[1024], tmp2[1024];
time_ok = first_time_ok = second_time_ok = FALSE;
map_type = Vect_maptype(Map);
/* Check the Timestamp */
time_ok = G_read_vector_timestamp(Vect_get_name(Map), NULL, "", &ts);
/* Check for valid entries, show none if no timestamp available */
if (time_ok == TRUE) {
if (ts.count > 0)
first_time_ok = TRUE;
if (ts.count > 1)
second_time_ok = TRUE;
}
divider('+');
sprintf(line, "%-17s%s", _("Name:"),
Vect_get_name(Map));
printline(line);
sprintf(line, "%-17s%s", _("Mapset:"),
Vect_get_mapset(Map));
printline(line);
sprintf(line, "%-17s%s", _("Location:"),
G_location());
printline(line);
sprintf(line, "%-17s%s", _("Database:"),
G_gisdbase());
printline(line);
sprintf(line, "%-17s%s", _("Title:"),
Vect_get_map_name(Map));
printline(line);
sprintf(line, "%-17s1:%d", _("Map scale:"),
Vect_get_scale(Map));
printline(line);
sprintf(line, "%-17s%s", _("Name of creator:"),
Vect_get_person(Map));
printline(line);
sprintf(line, "%-17s%s", _("Organization:"),
Vect_get_organization(Map));
printline(line);
sprintf(line, "%-17s%s", _("Source date:"),
Vect_get_map_date(Map));
printline(line);
/* This shows the TimeStamp (if present) */
if (time_ok == TRUE && (first_time_ok || second_time_ok)) {
G_format_timestamp(&ts, timebuff);
sprintf(line, "%-17s%s", _("Timestamp (first layer): "), timebuff);
printline(line);
}
else {
strcpy(line, _("Timestamp (first layer): none"));
printline(line);
}
divider('|');
if (map_type == GV_FORMAT_OGR ||
map_type == GV_FORMAT_OGR_DIRECT) {
sprintf(line, "%-17s%s (%s)", _("Map format:"),
Vect_maptype_info(Map), Vect_get_finfo_format_info(Map));
printline(line);
/* for OGR format print also datasource and layer */
sprintf(line, "%-17s%s", _("OGR layer:"),
Vect_get_finfo_layer_name(Map));
printline(line);
sprintf(line, "%-17s%s", _("OGR datasource:"),
Vect_get_finfo_dsn_name(Map));
printline(line);
sprintf(line, "%-17s%s", _("Feature type:"),
Vect_get_finfo_geometry_type(Map));
printline(line);
}
else if (map_type == GV_FORMAT_POSTGIS) {
int topo_format;
char *toposchema_name, *topogeom_column;
int topo_geo_only;
const struct Format_info *finfo;
finfo = Vect_get_finfo(Map);
sprintf(line, "%-17s%s (%s)", _("Map format:"),
Vect_maptype_info(Map), Vect_get_finfo_format_info(Map));
printline(line);
/* for PostGIS format print also datasource and layer */
sprintf(line, "%-17s%s", _("DB table:"),
Vect_get_finfo_layer_name(Map));
printline(line);
sprintf(line, "%-17s%s", _("DB name:"),
Vect_get_finfo_dsn_name(Map));
printline(line);
sprintf(line, "%-17s%s", _("Geometry column:"),
finfo->pg.geom_column);
printline(line);
sprintf(line, "%-17s%s", _("Feature type:"),
Vect_get_finfo_geometry_type(Map));
printline(line);
topo_format = Vect_get_finfo_topology_info(Map,
&toposchema_name, &topogeom_column,
&topo_geo_only);
if (topo_format == GV_TOPO_POSTGIS) {
sprintf(line, "%-17s%s (%s %s%s)", _("Topology:"), "PostGIS",
_("schema:"), toposchema_name,
topo_geo_only ? ", topo-geo-only: yes" : "");
printline(line);
sprintf(line, "%-17s%s", _("Topology column:"),
topogeom_column);
}
else
sprintf(line, "%-17s%s", _("Topology:"), "pseudo (simple features)");
printline(line);
}
else {
sprintf(line, "%-17s%s", _("Map format:"),
Vect_maptype_info(Map));
printline(line);
}
divider('|');
sprintf(line, " %s: %s (%s: %i)",
_("Type of map"), _("vector"), _("level"), Vect_level(Map));
printline(line);
if (Vect_level(Map) > 0) {
printline("");
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of points:"),
Vect_get_num_primitives(Map, GV_POINT),
_("Number of centroids:"),
Vect_get_num_primitives(Map, GV_CENTROID));
printline(line);
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of lines:"),
Vect_get_num_primitives(Map, GV_LINE),
_("Number of boundaries:"),
Vect_get_num_primitives(Map, GV_BOUNDARY));
printline(line);
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of areas:"),
Vect_get_num_areas(Map),
_("Number of islands:"),
Vect_get_num_islands(Map));
printline(line);
if (Vect_is_3d(Map)) {
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of faces:"),
Vect_get_num_primitives(Map, GV_FACE),
_("Number of kernels:"),
Vect_get_num_primitives(Map, GV_KERNEL));
printline(line);
sprintf(line,
" %-24s%-9d %-22s%-9d",
_("Number of volumes:"),
Vect_get_num_volumes(Map),
_("Number of holes:"),
Vect_get_num_holes(Map));
printline(line);
}
printline("");
sprintf(line, " %-24s%s",
_("Map is 3D:"),
Vect_is_3d(Map) ? _("Yes") : _("No"));
printline(line);
sprintf(line, " %-24s%-9d",
_("Number of dblinks:"),
Vect_get_num_dblinks(Map));
printline(line);
}
printline("");
/* this differs from r.info in that proj info IS taken from the map here, not the location settings */
/* Vect_get_proj_name() and _zone() are typically unset?! */
if (G_projection() == PROJECTION_UTM) {
int utm_zone;
utm_zone = Vect_get_zone(Map);
if (utm_zone < 0 || utm_zone > 60)
strcpy(tmp1, _("invalid"));
else if (utm_zone == 0)
strcpy(tmp1, _("unspecified"));
else
sprintf(tmp1, "%d", utm_zone);
sprintf(line, " %s: %s (%s %s)",
_("Projection"), Vect_get_proj_name(Map),
_("zone"), tmp1);
}
else
sprintf(line, " %s: %s",
_("Projection"), Vect_get_proj_name(Map));
printline(line);
printline("");
Vect_get_map_box(Map, &box);
G_format_northing(box.N, tmp1, G_projection());
G_format_northing(box.S, tmp2, G_projection());
sprintf(line, " %c: %17s %c: %17s",
'N', tmp1, 'S', tmp2);
printline(line);
G_format_easting(box.E, tmp1, G_projection());
G_format_easting(box.W, tmp2, G_projection());
sprintf(line, " %c: %17s %c: %17s",
'E', tmp1, 'W', tmp2);
printline(line);
if (Vect_is_3d(Map)) {
format_double(box.B, tmp1);
format_double(box.T, tmp2);
sprintf(line, " %c: %17s %c: %17s",
'B', tmp1, 'T', tmp2);
printline(line);
}
printline("");
format_double(Vect_get_thresh(Map), tmp1);
sprintf(line, " %s: %s", _("Digitization threshold"), tmp1);
printline(line);
sprintf(line, " %s:", _("Comment"));
printline(line);
sprintf(line, " %s", Vect_get_comment(Map));
printline(line);
divider('+');
fprintf(stdout, "\n");
}
void print_shell(const struct Map_info *Map, const char *field_opt)
{
int map_type;
int time_ok, first_time_ok, second_time_ok;
char timebuff[256];
struct field_info *fi;
struct TimeStamp ts;
time_ok = first_time_ok = second_time_ok = FALSE;
/* Check the Timestamp */
time_ok = G_read_vector_timestamp(Vect_get_name(Map), NULL, "", &ts);
/* Check for valid entries, show none if no timestamp available */
if (time_ok == TRUE) {
if (ts.count > 0)
first_time_ok = TRUE;
if (ts.count > 1)
second_time_ok = TRUE;
}
map_type = Vect_maptype(Map);
fprintf(stdout, "name=%s\n",
Vect_get_name(Map));
fprintf(stdout, "mapset=%s\n",
Vect_get_mapset(Map));
fprintf(stdout, "location=%s\n",
G_location());
fprintf(stdout, "database=%s\n",
G_gisdbase());
fprintf(stdout, "title=%s\n",
Vect_get_map_name(Map));
fprintf(stdout, "scale=1:%d\n",
Vect_get_scale(Map));
fprintf(stdout, "creator=%s\n",
Vect_get_person(Map));
fprintf(stdout, "organization=%s\n",
Vect_get_organization(Map));
fprintf(stdout, "source_date=%s\n",
Vect_get_map_date(Map));
/* This shows the TimeStamp (if present) */
if (time_ok == TRUE && (first_time_ok || second_time_ok)) {
G_format_timestamp(&ts, timebuff);
fprintf(stdout, "timestamp=%s\n", timebuff);
}
else {
fprintf(stdout, "timestamp=none\n");
}
if (map_type == GV_FORMAT_OGR ||
map_type == GV_FORMAT_OGR_DIRECT) {
fprintf(stdout, "format=%s,%s\n",
Vect_maptype_info(Map), Vect_get_finfo_format_info(Map));
fprintf(stdout, "ogr_layer=%s\n",
Vect_get_finfo_layer_name(Map));
fprintf(stdout, "ogr_dsn=%s\n",
Vect_get_finfo_dsn_name(Map));
fprintf(stdout, "feature_type=%s\n",
Vect_get_finfo_geometry_type(Map));
}
else if (map_type == GV_FORMAT_POSTGIS) {
int topo_format;
char *toposchema_name, *topogeom_column;
const struct Format_info *finfo;
finfo = Vect_get_finfo(Map);
fprintf(stdout, "format=%s,%s\n",
Vect_maptype_info(Map), Vect_get_finfo_format_info(Map));
fprintf(stdout, "pg_table=%s\n",
Vect_get_finfo_layer_name(Map));
fprintf(stdout, "pg_dbname=%s\n",
Vect_get_finfo_dsn_name(Map));
fprintf(stdout, "geometry_column=%s\n",
finfo->pg.geom_column);
fprintf(stdout, "feature_type=%s\n",
Vect_get_finfo_geometry_type(Map));
topo_format = Vect_get_finfo_topology_info(Map, &toposchema_name, &topogeom_column, NULL);
if (topo_format == GV_TOPO_POSTGIS) {
fprintf(stdout, "pg_topo_schema=%s\n",
toposchema_name);
fprintf(stdout, "pg_topo_column=%s\n",
topogeom_column);
}
}
else {
fprintf(stdout, "format=%s\n",
Vect_maptype_info(Map));
}
fprintf(stdout, "level=%d\n",
Vect_level(Map));
if (Vect_level(Map) > 0) {
fprintf(stdout, "num_dblinks=%d\n",
Vect_get_num_dblinks(Map));
if (Vect_get_num_dblinks(Map) > 0) {
fi = Vect_get_field2(Map, field_opt);
if(fi != NULL) {
fprintf(stdout, "attribute_layer_number=%i\n",fi->number);
fprintf(stdout, "attribute_layer_name=%s\n",fi->name);
fprintf(stdout, "attribute_database=%s\n",fi->database);
fprintf(stdout, "attribute_database_driver=%s\n",fi->driver);
fprintf(stdout, "attribute_table=%s\n",fi->table);
fprintf(stdout, "attribute_primary_key=%s\n",fi->key);
}
}
}
fprintf(stdout, "projection=%s\n",
Vect_get_proj_name(Map));
if (G_projection() == PROJECTION_UTM) {
fprintf(stdout, "zone=%d\n",
Vect_get_zone(Map));
}
fprintf(stdout, "digitization_threshold=%f\n",
Vect_get_thresh(Map));
fprintf(stdout, "comment=%s\n",
Vect_get_comment(Map));
}
/*!
\brief Delete vector map including attribute tables
\param map vector map name
\return -1 error
\return 0 success
*/
int Vect_delete(const char *map)
{
int i, n, ret;
struct Map_info Map;
struct field_info *Fi;
char buf[GPATH_MAX];
DIR *dir;
struct dirent *ent;
const char *tmp;
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
G_debug(3, "Delete vector '%s'", map);
/* remove mapset from fully qualified name */
if (G_name_is_fully_qualified(map, xname, xmapset)) {
map = xname;
}
if (map == NULL || strlen(map) == 0) {
G_warning(_("Invalid vector map name <%s>"), map ? map : "null");
return -1;
}
sprintf(buf, "%s/%s/%s/%s/%s/%s", G_gisdbase(), G_location(),
G_mapset(), GV_DIRECTORY, map, GV_DBLN_ELEMENT);
G_debug(1, "dbln file: %s", buf);
if (access(buf, F_OK) == 0) {
/* Open input */
Vect_set_open_level(1); /* Topo not needed */
ret = Vect_open_old_head(&Map, map, G_mapset());
if (ret < 1) {
G_warning(_("Unable to open header file for vector map <%s>"),
map);
return -1;
}
/* Delete all tables, NOT external (OGR) */
if (Map.format == GV_FORMAT_NATIVE) {
n = Vect_get_num_dblinks(&Map);
for (i = 0; i < n; i++) {
Fi = Vect_get_dblink(&Map, i);
if (Fi == NULL) {
G_warning(_("Database connection not defined for layer %d"),
Map.dblnk->field[i].number);
Vect_close(&Map);
return -1;
}
G_debug(3, "Delete drv:db:table '%s:%s:%s'", Fi->driver,
Fi->database, Fi->table);
ret = db_table_exists(Fi->driver, Fi->database, Fi->table);
if (ret == -1) {
G_warning(_("Unable to find table <%s> linked to vector map <%s>"),
Fi->table, map);
Vect_close(&Map);
return -1;
}
if (ret == 1) {
ret =
db_delete_table(Fi->driver, Fi->database, Fi->table);
if (ret == DB_FAILED) {
G_warning(_("Unable to delete table <%s>"),
Fi->table);
Vect_close(&Map);
return -1;
}
}
else {
G_warning(_("Table <%s> linked to vector map <%s> does not exist"),
Fi->table, map);
}
}
}
Vect_close(&Map);
}
/* Delete all files from vector/name directory */
sprintf(buf, "%s/%s/vector/%s", G_location_path(), G_mapset(), map);
G_debug(3, "opendir '%s'", buf);
dir = opendir(buf);
if (dir == NULL) {
G_warning(_("Unable to open directory '%s'"), buf);
return -1;
}
while ((ent = readdir(dir))) {
G_debug(3, "file = '%s'", ent->d_name);
if ((strcmp(ent->d_name, ".") == 0) ||
(strcmp(ent->d_name, "..") == 0))
continue;
sprintf(buf, "%s/%s/vector/%s/%s", G_location_path(), G_mapset(), map,
ent->d_name);
G_debug(3, "delete file '%s'", buf);
ret = unlink(buf);
if (ret == -1) {
G_warning(_("Unable to delete file '%s'"), buf);
closedir(dir);
return -1;
}
}
closedir(dir);
/* NFS can create .nfsxxxxxxxx files for those deleted
* -> we have to move the directory to ./tmp before it is deleted */
sprintf(buf, "%s/%s/vector/%s", G_location_path(), G_mapset(), map);
tmp = G_tempfile();
G_debug(3, "rename '%s' to '%s'", buf, tmp);
ret = rename(buf, tmp);
if (ret == -1) {
G_warning(_("Unable to rename directory '%s' to '%s'"), buf, tmp);
return -1;
}
G_debug(3, "remove directory '%s'", tmp);
/* Warning: remove() fails on Windows */
ret = rmdir(tmp);
if (ret == -1) {
G_warning(_("Unable to remove directory '%s'"), tmp);
return -1;
}
return 0;
}
