int main(int argc, char *argv[])
{
struct Option *raster, *conf, *output;
struct GModule *module;
G_gisinit(argv[0]);
module = G_define_module();
module->description =
_("Calculates coefficient of variation of patch area on a raster map");
module->keywords = _("raster, landscape structure analysis, patch index");
/* define options */
raster = G_define_standard_option(G_OPT_R_MAP);
conf = G_define_option();
conf->key = "conf";
conf->description = _("Configuration file");
conf->gisprompt = "old_file,file,input";
conf->type = TYPE_STRING;
conf->required = YES;
output = G_define_standard_option(G_OPT_R_OUTPUT);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
return calculateIndex(conf->answer, patchAreaDistributionCV, NULL,
raster->answer, output->answer);
}
static void parse_command_line(int argc, char **argv)
{
struct Option *driver, *database;
struct GModule *module;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
driver = G_define_standard_option(G_OPT_DB_DRIVER);
driver->options = db_list_drivers();
driver->required = YES;
driver->answer = (char *) db_get_default_driver_name();
database = G_define_standard_option(G_OPT_DB_DATABASE);
database->required = YES;
/* Set description */
module = G_define_module();
G_add_keyword(_("database"));
G_add_keyword(_("attribute table"));
G_add_keyword(_("SQL"));
module->description = _("Removes an existing database.");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
parms.driver = driver->answer;
parms.database = database->answer;
}
int main(int argc, char *argv[])
{
char name[200];
char *fpath;
struct GModule *module;
struct Option *opt1;
module = G_define_module();
G_add_keyword(_("general"));
G_add_keyword(_("map management"));
G_add_keyword(_("scripts"));
module->description = "Searches for GRASS support files.";
G_gisinit(argv[0]);
/* Define the different options */
opt1 = G_define_option();
opt1->key = "file";
opt1->type = TYPE_STRING;
opt1->required = YES;
opt1->description = "Name of an file or directory";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
strcpy(name, opt1->answer);
fpath = G_find_etc(name);
if (fpath)
fprintf(stdout, "%s\n", fpath);
exit(fpath ? EXIT_SUCCESS : EXIT_FAILURE);
}
int main(int argc, char *argv[])
{
struct Option *raster, *conf, *output;
struct GModule *module;
G_gisinit(argv[0]);
module = G_define_module();
module->description =
_("Calculates range of patch area size on a raster map");
G_add_keyword(_("raster"));
G_add_keyword(_("landscape structure analysis"));
G_add_keyword(_("patch index"));
/* define options */
raster = G_define_standard_option(G_OPT_R_INPUT);
conf = G_define_standard_option(G_OPT_F_INPUT);
conf->key = "config";
conf->description = _("Configuration file");
conf->required = YES;
output = G_define_standard_option(G_OPT_R_OUTPUT);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
return calculateIndex(conf->answer, patchAreaDistributionRANGE, NULL,
raster->answer, output->answer);
}
/* Define our module so that Grass can print it if the user wants to know more. */
static void define_module(void)
{
struct GModule *module;
module = G_define_module();
module->label =
_("Performs atmospheric correction using the 6S algorithm.");
module->description =
_("6S - Second Simulation of Satellite Signal in the Solar Spectrum.");
G_add_keyword(_("imagery"));
G_add_keyword(_("atmospheric correction"));
G_add_keyword(_("radiometric conversion"));
G_add_keyword(_("radiance"));
G_add_keyword(_("reflectance"));
G_add_keyword(_("satellite"));
/*
" Incorporated into Grass by Christo A. Zietsman, January 2003.\n"
" Converted from Fortran to C by Christo A. Zietsman, November 2002.\n\n"
" Adapted by Mauro A. Homem Antunes for atmopheric corrections of\n"
" remotely sensed images in raw format (.RAW) of 8 bits.\n"
" April 4, 2001.\n\n"
" Please refer to the following paper and acknowledge the authors of\n"
" the model:\n"
" Vermote, E.F., Tanre, D., Deuze, J.L., Herman, M., and Morcrette,\n"
" J.J., (1997), Second simulation of the satellite signal in\n"
" the solar spectrum, 6S: An overview., IEEE Trans. Geosc.\n"
" and Remote Sens. 35(3):675-686.\n"
" The code is provided as is and is not to be sold. See notes on\n"
" http://loasys.univ-lille1.fr/informatique/sixs_gb.html\n"
" http://www.ltid.inpe.br/dsr/mauro/6s/index.html\n"
" and on http://www.cs.sun.ac.za/~caz/index.html\n"; */
}
int main(int argc, char *argv[])
{
struct parms parms; /* command line parms */
struct files files; /* file descriptors, io, buffers */
struct Signature S;
struct GModule *module;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("imagery"));
G_add_keyword(_("classification"));
G_add_keyword(_("supervised"));
G_add_keyword(_("MLC"));
module->description =
_("Generates statistics for i.maxlik from raster map.");
parse(argc, argv, &parms);
openfiles(&parms, &files);
read_training_labels(&parms, &files);
get_training_classes(&files, &S);
compute_means(&files, &S);
compute_covariances(&files, &S);
check_signatures(&S);
write_sigfile(&parms, &S);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
static void parse_command_line(int argc, char **argv)
{
struct Option *driver, *database;
struct GModule *module;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
driver = G_define_standard_option(G_OPT_DRIVER);
driver->options = db_list_drivers();
driver->required = YES;
database = G_define_standard_option(G_OPT_DATABASE);
database->required = YES;
/* Set description */
module = G_define_module();
module->keywords = _("database, SQL");
module->description = _("Creates an empty database.");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
parms.driver = driver->answer;
parms.database = database->answer;
}
int main(int argc, char *argv[])
{
struct Option *raster, *conf, *output;
struct GModule *module;
G_gisinit(argv[0]);
module = G_define_module();
module->description = _("Calculates shape index on a raster map");
G_add_keyword(_("raster"));
G_add_keyword(_("landscape structure analysis"));
G_add_keyword(_("patch index"));
/* define options */
raster = G_define_standard_option(G_OPT_R_INPUT);
conf = G_define_option();
conf->key = "config";
conf->description = _("Configuration file");
conf->gisprompt = "old_file,file,input";
conf->type = TYPE_STRING;
conf->required = YES;
output = G_define_standard_option(G_OPT_R_OUTPUT);
/** add other options for index parameters here */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
return calculateIndex(conf->answer, shape_index, NULL, raster->answer,
output->answer);
}
int main( int argc, char **argv )
{
char *mapset;
char *name;
int fp;
struct GModule *module;
struct Option *map;
struct Option *win;
struct Cell_head window;
/* Initialize the GIS calls */
G_gisinit( argv[0] );
module = G_define_module();
module->keywords = ( "display, raster" );
module->description = ( "Output raster map layers in a format suitable for display in QGIS" );
map = G_define_standard_option( G_OPT_R_MAP );
map->description = ( "Raster map to be displayed" );
win = G_define_option();
win->key = "window";
win->type = TYPE_DOUBLE;
win->multiple = YES;
win->description = "xmin,ymin,xmax,ymax,ncols,nrows";
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
name = map->answer;
/* Make sure map is available */
mapset = G_find_cell2( name, "" );
if ( mapset == NULL )
G_fatal_error(( "Raster map <%s> not found" ), name );
/* It can happen that GRASS data set is 'corrupted' and zone differs in WIND and
* cellhd, and G_open_cell_old fails, so it is better to read window from map */
/* G_get_window( &window ); */
G_get_cellhd( name, mapset, &window );
window.west = atof( win->answers[0] );
window.south = atof( win->answers[1] );
window.east = atof( win->answers[2] );
window.north = atof( win->answers[3] );
window.cols = atoi( win->answers[4] );
window.rows = atoi( win->answers[5] );
G_adjust_Cell_head( &window, 1, 1 );
G_set_window( &window );
fp = G_raster_map_is_fp( name, mapset );
/* use DCELL even if the map is FCELL */
if ( fp )
display( name, mapset, DCELL_TYPE );
else
display( name, mapset, CELL_TYPE );
exit( EXIT_SUCCESS );
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *map, *date;
struct TimeStamp ts;
char *name;
int modify;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("metadata"));
G_add_keyword(_("timestamp"));
module->label = _("Modifies a timestamp for a raster map.");
module->description = _("Print/add/remove a timestamp for a raster map.");
map = G_define_standard_option(G_OPT_R_MAP);
date = G_define_option();
date->key = "date";
date->key_desc = "timestamp";
date->required = NO;
date->type = TYPE_STRING;
date->label = _("Datetime, datetime1/datetime2, or 'none' to remove");
date->description = _("Format: '15 jan 1994' (absolute) or '2 years' (relative)");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
name = map->answer;
modify = date->answer != NULL;
if (!modify) {
if (G_read_raster_timestamp(name, "", &ts) == 1) {
G__write_timestamp(stdout, &ts);
exit(EXIT_SUCCESS);
}
else
exit(EXIT_FAILURE);
}
if (strcmp(date->answer, "none") == 0) {
G_remove_raster_timestamp(name);
exit(EXIT_SUCCESS);
}
if (1 == G_scan_timestamp(&ts, date->answer)) {
G_write_raster_timestamp(name, &ts);
exit(EXIT_SUCCESS);
}
else
G_fatal_error(_("Invalid timestamp"));
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int nlines;
double textsize;
char *dxf_file;
struct Map_info In;
struct GModule *module;
struct Option *input, *output, *field;
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("export"));
G_add_keyword(_("DXF"));
module->description =
_("Exports vector map to DXF file format.");
input = G_define_standard_option(G_OPT_V_INPUT);
field = G_define_standard_option(G_OPT_V_FIELD_ALL);
output = G_define_standard_option(G_OPT_F_OUTPUT);
output->required = YES;
output->description = _("Name for DXF output file");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
overwrite = module->overwrite;
/* open input vector */
dxf_file = G_store(output->answer);
Vect_set_open_level(2);
if (Vect_open_old2(&In, input->answer, "", field->answer) < 0)
G_fatal_error(_("Unable to open vector map <%s>"), input->answer);
dxf_open(dxf_file); /* open output */
textsize = do_limits(&In); /* does header in dxf_fp */
make_layername();
dxf_entities();
nlines = add_plines(&In, Vect_get_field_number(&In, field->answer),
textsize); /* puts plines in dxf_fp */
dxf_endsec();
dxf_eof(); /* puts final stuff in dxf_fp, closes file */
G_done_msg(_("%d features written to '%s'."), nlines, dxf_file);
G_free(dxf_file);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct Option *raster, *conf, *output, *alpha;
struct GModule *module;
char **par = NULL;
G_gisinit(argv[0]);
module = G_define_module();
module->description =
_("Calculates Renyi's diversity index on a raster map");
G_add_keyword(_("raster"));
G_add_keyword(_("landscape structure analysis"));
G_add_keyword(_("diversity index"));
/* define options */
raster = G_define_standard_option(G_OPT_R_INPUT);
conf = G_define_option();
conf->key = "config";
conf->description = _("Configuration file");
conf->gisprompt = "old_file,file,input";
conf->type = TYPE_STRING;
conf->required = YES;
alpha = G_define_option();
alpha->key = "alpha";
alpha->description =
_("Alpha value is the order of the generalized entropy");
alpha->type = TYPE_STRING;
alpha->required = YES;
output = G_define_standard_option(G_OPT_R_OUTPUT);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (atoi(alpha->answer) == 1) {
G_fatal_error
("If alpha = 1 Renyi index is not defined. (Ricotta et al., 2003, Environ. Model. Softw.)");
exit(RLI_ERRORE);
}
else if (atof(alpha->answer) < 0.) {
G_fatal_error
("Alpha must be > 0 otherwise Renyi index is not defined. (Ricotta et al., 2003, Environ. Model. Softw.)");
exit(RLI_ERRORE);
}
else {
par = &alpha->answer;
}
return calculateIndex(conf->answer, renyi, par, raster->answer,
output->answer);
}
static void parse_command_line(int argc, char **argv)
{
struct Option *driver, *database, *schema, *input;
struct Flag *i;
struct GModule *module;
const char *drv, *db, *schema_name;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("database"));
G_add_keyword(_("attribute table"));
G_add_keyword(_("SQL"));
module->label = _("Executes any SQL statement.");
module->description = _("For SELECT statements use 'db.select'.");
input = G_define_standard_option(G_OPT_F_INPUT);
input->label = _("Name of file containing SQL statements");
input->description = _("'-' to read from standard input");
driver = G_define_standard_option(G_OPT_DB_DRIVER);
driver->options = db_list_drivers();
driver->guisection = _("Connection");
if ((drv = db_get_default_driver_name()))
driver->answer = (char *) drv;
database = G_define_standard_option(G_OPT_DB_DATABASE);
database->guisection = _("Connection");
if ((db = db_get_default_database_name()))
database->answer = (char *) db;
schema = G_define_standard_option(G_OPT_DB_SCHEMA);
schema->guisection = _("Connection");
if ((schema_name = db_get_default_schema_name()))
schema->answer = (char *) schema_name;
i = G_define_flag();
i->key = 'i';
i->description = _("Ignore SQL errors and continue");
i->guisection = _("Errors");
if (G_parser(argc, argv))
exit(EXIT_SUCCESS);
parms.driver = driver->answer;
parms.database = database->answer;
parms.schema = schema->answer;
parms.input = input->answer;
parms.i = i->answer;
}
int main(int argc, char *argv[])
{
struct Option *driver, *database, *user, *password;
struct GModule *module;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("database"));
G_add_keyword(_("connection settings"));
module->description = _("Sets user/password for driver/database.");
driver = G_define_standard_option(G_OPT_DB_DRIVER);
driver->options = db_list_drivers();
driver->required = YES;
driver->answer = (char *) db_get_default_driver_name();
database = G_define_standard_option(G_OPT_DB_DATABASE);
database->required = YES;
database->answer = (char *) db_get_default_database_name();
user = G_define_option();
user->key = "user";
user->type = TYPE_STRING;
user->required = NO;
user->multiple = NO;
user->description = _("Username");
password = G_define_option();
password->key = "password";
password->type = TYPE_STRING;
password->required = NO;
password->multiple = NO;
password->description = _("Password");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (db_set_login(driver->answer, database->answer, user->answer,
password->answer) == DB_FAILED) {
G_fatal_error(_("Unable to set user/password"));
}
if (password->answer)
G_important_message(_("The password was stored in file (%s/dblogin)"), CONFIG_DIR);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct
{
struct Option *map;
struct Option *line;
struct Option *null_str;
} parms;
struct Flag *coord;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("transect"));
module->description =
_("Outputs raster map layer values lying along "
"user defined transect line(s).");
parms.map = G_define_standard_option(G_OPT_R_MAP);
parms.map->description = _("Raster map to be queried");
parms.line = G_define_option();
parms.line->key = "line";
parms.line->key_desc = "east,north,azimuth,distance";
parms.line->type = TYPE_STRING;
parms.line->description = _("Transect definition");
parms.line->required = YES;
parms.line->multiple = YES;
parms.null_str = G_define_standard_option(G_OPT_M_NULL_VALUE);
parms.null_str->answer = "*";
coord = G_define_flag();
coord->key = 'g';
coord->description =
_("Output easting and northing in first two columns of four column output");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
return profile(coord->answer,
parms.map->answer,
parms.null_str->answer,
parms.line->answers) != 0;
}
int main(int argc, char *argv[])
{
/****** INITIALISE ******/
double gauss_mean, gauss_sigma;
struct GModule *module;
struct Option *out;
struct Option *mean;
struct Option *sigma;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("surface"));
G_add_keyword(_("random"));
module->label =
_("Generates a raster map using gaussian "
"random number generator.");
module->description = _("Mean and standard deviation of gaussian deviates "
"can be expressed by the user.");
out = G_define_standard_option(G_OPT_R_OUTPUT);
mean = G_define_option();
mean->key = "mean";
mean->description = _("Distribution mean");
mean->type = TYPE_DOUBLE;
mean->answer = "0.0";
sigma = G_define_option();
sigma->key = "sigma";
sigma->description = _("Standard deviation");
sigma->type = TYPE_DOUBLE;
sigma->answer = "1.0";
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
sscanf(mean->answer, "%lf", &gauss_mean);
sscanf(sigma->answer, "%lf", &gauss_sigma);
gaussurf(out->answer, gauss_mean, gauss_sigma);
exit(EXIT_SUCCESS);
}
void parse_toplevel(struct context *ctx, const char *cmd)
{
char **tokens;
if (G_strcasecmp(cmd, "module") == 0) {
ctx->state = S_MODULE;
ctx->module = G_define_module();
return;
}
if (G_strcasecmp(cmd, "flag") == 0) {
ctx->state = S_FLAG;
ctx->flag = G_define_flag();
if (!ctx->first_flag)
ctx->first_flag = ctx->flag;
return;
}
if (G_strncasecmp(cmd, "option", strlen("option")) == 0) {
ctx->state = S_OPTION;
tokens = G_tokenize(cmd, " ");
if (G_number_of_tokens(tokens) > 1) {
/* standard option */
ctx->option = define_standard_option(tokens[1]);
}
else {
ctx->option = G_define_option();
}
if (!ctx->first_option)
ctx->first_option = ctx->option;
G_free_tokens(tokens);
return;
}
if (G_strcasecmp(cmd, "rules") == 0) {
ctx->state = S_RULES;
return;
}
fprintf(stderr, _("Unknown command \"%s\" at line %d\n"), cmd, ctx->line);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct _options options;
struct _flags flags;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("export"));
G_add_keyword(_("output"));
G_add_keyword(_("external"));
module->description =
_("Defines vector output format utilizing OGR library.");
OGRRegisterAll();
parse_args(argc, argv, &options, &flags);
if (flags.f->answer) {
list_formats();
exit(EXIT_SUCCESS);
}
if (flags.r->answer) {
G_remove("", "OGR");
exit(EXIT_SUCCESS);
}
if (options.format->answer)
check_format(options.format->answer);
if (options.dsn->answer)
make_link(options.dsn->answer,
options.format->answer, options.opts->answers);
if (flags.p->answer || flags.g->answer) {
print_status(flags.g->answer ? 1 : 0);
}
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct GModule *module;
struct
{
struct Option *input;
struct Option *output;
} params;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("hydrology"));
module->description =
_("Creates a topographic index raster map from an elevation raster map.");
params.input = G_define_standard_option(G_OPT_R_ELEV);
params.input->key = "input";
params.output = G_define_standard_option(G_OPT_R_OUTPUT);
params.output->description = _("Name for output topographic index raster map");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* Make sure that the current projection is not lat/long */
if ((G_projection() == PROJECTION_LL))
G_fatal_error(_("Lat/Long location is not supported by %s. Please reproject map first."),
G_program_name());
input = params.input->answer;
output = params.output->answer;
G_get_window(&window);
read_cells();
initialize();
calculate_atanb();
write_cells();
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
char *name;
d_Mask *maskRules;
struct GModule *module;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("mask"));
G_add_keyword(_("voxel"));
module->description =
_("Establishes the current working 3D raster mask.");
params.map = G_define_option();
params.map->key = "map";
params.map->type = TYPE_STRING;
params.map->required = YES;
params.map->multiple = NO;
params.map->gisprompt = "old,grid3,3d-raster";
params.map->description = _("3D raster map with reference values");
params.maskVals = G_define_option();
params.maskVals->key = "maskvalues";
params.maskVals->key_desc = "val[-val]";
params.maskVals->type = TYPE_STRING;
params.maskVals->required = NO;
params.maskVals->multiple = YES;
params.maskVals->description = _("List of cell values to be masked out");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (Rast3d_mask_file_exists())
G_fatal_error(_("Cannot create mask file: RASTER3D_MASK already exists"));
getParams(&name, &maskRules);
makeMask(name, maskRules);
exit(EXIT_SUCCESS);
}
static void parse_command_line(int argc, char **argv)
{
struct Option *driver, *database;
struct Flag *p, *s;
struct GModule *module;
const char *drv, *db;
/* Initialize the GIS calls */
G_gisinit(argv[0]);
driver = G_define_standard_option(G_OPT_DB_DRIVER);
driver->options = db_list_drivers();
if ((drv = db_get_default_driver_name()))
driver->answer = (char *) drv;
database = G_define_standard_option(G_OPT_DB_DATABASE);
if ((db = db_get_default_database_name()))
database->answer = (char *) db;
p = G_define_flag();
p->key = 'p';
p->description = _("Print tables and exit");
s = G_define_flag();
s->key = 's';
s->description = _("System tables instead of user tables");
/* Set description */
module = G_define_module();
G_add_keyword(_("database"));
G_add_keyword(_("attribute table"));
module->description = _("Lists all tables for a given database.");
if (G_parser(argc, argv))
exit(EXIT_SUCCESS);
parms.driver = driver->answer;
parms.database = database->answer;
parms.s = s->answer;
}
int main(int argc, char *argv[])
{
struct parms parms; /* command line parms */
struct files files; /* file descriptors, io, buffers */
struct SigSet S;
int i;
int junk;
struct GModule *module;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("imagery"));
G_add_keyword(_("classification"));
G_add_keyword(_("supervised classification"));
G_add_keyword(_("SMAP"));
G_add_keyword(_("signatures"));
module->description =
_("Generates statistics for i.smap from raster map.");
parse(argc, argv, &parms);
openfiles(&parms, &files);
read_training_labels(&parms, &files);
get_training_classes(&parms, &files, &S);
read_data(&files, &S);
for (i = 0; i < S.nclasses; i++) {
G_message(_("Clustering class %d (%d pixels)..."),
i + 1, S.ClassSig[i].ClassData.npixels);
subcluster(&S, i, &junk, parms.maxsubclasses);
G_message(_("Number of subclasses is %d"),
S.ClassSig[i].nsubclasses);
}
write_sigfile(&parms, &S);
G_done_msg(" ");
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
char *name;
d_Mask *maskRules;
int changeNull;
double newNullVal;
struct GModule *module;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("raster3d, voxel");
module->description =
_("Explicitly create the 3D NULL-value bitmap file.");
setParams();
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
getParams(&name, &maskRules, &changeNull, &newNullVal);
modifyNull(name, maskRules, changeNull, newNullVal);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
struct GModule *module;
struct Option *pid;
char *tempfile, *G__tempfile();
int p;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("general, map management");
module->description =
"Creates a temporary file and prints the file name.";
pid = G_define_option();
pid->key = "pid";
pid->type = TYPE_INTEGER;
pid->required = YES;
pid->description = "Process id to use when naming the tempfile";
G_disable_interactive();
if (G_parser(argc, argv))
exit(1);
if (sscanf(pid->answer, "%d", &p) != 1) {
G_usage();
exit(EXIT_FAILURE);
}
tempfile = G__tempfile(p);
/* create tempfile so next run of this program will create a unique name */
close(creat(tempfile, 0666));
fprintf(stdout, "%s\n", tempfile);
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct GModule *module;
struct Option *viewopts[MAXVIEWS], *out, *qual;
struct Flag *conv;
int i;
int *sdimp, longdim, r_out;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("export"));
G_add_keyword(_("animation"));
module->description =
_("Converts raster map series to MPEG movie.");
for (i = 0; i < MAXVIEWS; i++) {
char *buf = NULL;
viewopts[i] = G_define_standard_option(G_OPT_R_INPUTS);
G_asprintf(&buf, "view%d", i + 1);
viewopts[i]->key = G_store(buf);
viewopts[i]->required = (i ? NO : YES);
G_asprintf(&buf, _("Name of input raster map(s) for view no.%d"), i + 1);
viewopts[i]->description = G_store(buf);
viewopts[i]->guisection = _("Views");
G_free(buf);
}
out = G_define_standard_option(G_OPT_R_OUTPUT);
out->description = _("Name for output file");
qual = G_define_option();
qual->key = "qual";
qual->type = TYPE_INTEGER;
qual->required = NO;
qual->multiple = NO;
qual->answer = "3";
qual->options = "1-5";
qual->description =
_("Quality factor (1 = highest quality, lowest compression)");
qual->guisection = _("Settings");
conv = G_define_flag();
conv->key = 'c';
conv->label = _("Convert on the fly, uses less disk space");
conv->description = _("Requires r.out.ppm with stdout option");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
parse_command(viewopts, vfiles, &numviews, &frames);
r_out = 0;
if (conv->answer)
r_out = 1;
quality = 3;
if (qual->answer != NULL)
sscanf(qual->answer, "%d", &quality);
if (quality > 5 || quality < 1)
quality = 3;
/* find a working encoder */
if (check_encoder("ppmtompeg"))
encoder = "ppmtompeg";
else if (check_encoder("mpeg_encode"))
encoder = "mpeg_encode";
else
G_fatal_error(_("Either mpeg_encode or ppmtompeg must be installed"));
G_debug(1, "encoder = [%s]", encoder);
vrows = Rast_window_rows();
vcols = Rast_window_cols();
nrows = vrows;
ncols = vcols;
/* short dimension */
sdimp = nrows > ncols ? &ncols : &nrows;
/* these proportions should work fine for 1 or 4 views, but for
2 views, want to double the narrow dim & for 3 views triple it */
if (numviews == 2)
*sdimp *= 2;
else if (numviews == 3)
*sdimp *= 3;
longdim = nrows > ncols ? nrows : ncols;
scale = 1.0;
{ /* find animation image size */
int max, min;
char *p;
max = DEF_MAX;
min = DEF_MIN;
if ((p = getenv("GMPEG_SIZE")))
max = min = atoi(p);
if (longdim > max) /* scale down */
scale = (float)max / longdim;
else if (longdim < min) /* scale up */
scale = (float)min / longdim;
}
/* TODO: align image size to 16 pixel width & height */
vscale = scale;
if (numviews == 4)
vscale = scale / 2.;
nrows *= scale;
ncols *= scale;
/* now nrows & ncols are the size of the combined - views image */
vrows *= vscale;
vcols *= vscale;
/* now vrows & vcols are the size for each sub-image */
/* add to nrows & ncols for borders */
/* irows, icols used for vert/horizontal determination in loop below */
irows = nrows;
icols = ncols;
nrows += (1 + (nrows / vrows)) * BORDER_W;
ncols += (1 + (ncols / vcols)) * BORDER_W;
if (numviews == 1 && r_out)
use_r_out();
else
load_files();
return (EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
struct GModule *module;
struct
{
struct Option *text;
struct Option *size;
struct Option *fgcolor;
struct Option *bgcolor;
struct Option *line;
struct Option *at;
struct Option *rotation;
struct Option *align;
struct Option *linespacing;
struct Option *font;
struct Option *path;
struct Option *charset;
struct Option *input;
} opt;
struct
{
struct Flag *p;
struct Flag *g;
struct Flag *b;
struct Flag *r;
struct Flag *s;
} flag;
/* options and flags */
char *text;
double size;
double x, y;
int line;
double rotation;
char align[3];
double linespacing;
char bold;
/* window info */
struct rectinfo win;
/* command file */
FILE *cmd_fp;
char buf[512];
int first_text;
int linefeed;
int set_l;
double orig_x, orig_y;
double prev_x, prev_y;
double set_x, set_y;
double east, north;
int do_background, fg_color, bg_color;
/* initialize the GIS calls */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("display"));
G_add_keyword(_("cartography"));
module->description =
_("Draws text in the active display frame on the graphics monitor using the current font.");
opt.text = G_define_option();
opt.text->key = "text";
opt.text->type = TYPE_STRING;
opt.text->required = NO;
opt.text->description = _("Text to display");
opt.text->guisection = _("Input");
opt.input = G_define_standard_option(G_OPT_F_INPUT);
opt.input->required = NO;
opt.input->description = _("Input file");
opt.input->guisection = _("Input");
opt.fgcolor = G_define_option();
opt.fgcolor->key = "color";
opt.fgcolor->type = TYPE_STRING;
opt.fgcolor->answer = DEFAULT_COLOR;
opt.fgcolor->required = NO;
opt.fgcolor->description =
_("Text color, either a standard GRASS color or R:G:B triplet");
opt.fgcolor->gisprompt = "old_color,color,color";
opt.fgcolor->guisection = _("Text");
opt.bgcolor = G_define_option();
opt.bgcolor->key = "bgcolor";
opt.bgcolor->type = TYPE_STRING;
opt.bgcolor->required = NO;
opt.bgcolor->description =
_("Text background color, either a standard GRASS color or R:G:B triplet");
opt.bgcolor->gisprompt = "old_color,color,color";
opt.bgcolor->guisection = _("Text");
opt.rotation = G_define_option();
opt.rotation->key = "rotation";
opt.rotation->type = TYPE_DOUBLE;
opt.rotation->required = NO;
opt.rotation->answer = "0";
opt.rotation->description =
_("Rotation angle in degrees (counter-clockwise)");
opt.rotation->guisection = _("Text");
opt.linespacing = G_define_option();
opt.linespacing->key = "linespacing";
opt.linespacing->type = TYPE_DOUBLE;
opt.linespacing->required = NO;
opt.linespacing->answer = "1.25";
opt.linespacing->description = _("Line spacing");
opt.linespacing->guisection = _("Text");
opt.at = G_define_option();
opt.at->key = "at";
opt.at->key_desc = "x,y";
opt.at->type = TYPE_DOUBLE;
opt.at->required = NO;
opt.at->description =
_("Screen position at which text will begin to be drawn (percentage, [0,0] is lower left)");
opt.at->guisection = _("Position");
opt.line = G_define_option();
opt.line->key = "line";
opt.line->required = NO;
opt.line->type = TYPE_INTEGER;
opt.line->options = "1-1000";
opt.line->description =
_("The screen line number on which text will begin to be drawn");
opt.line->guisection = _("Position");
opt.align = G_define_option();
opt.align->key = "align";
opt.align->type = TYPE_STRING;
opt.align->required = NO;
opt.align->answer = "ll";
opt.align->options = "ll,lc,lr,cl,cc,cr,ul,uc,ur";
opt.align->description = _("Text alignment");
opt.align->guisection = _("Position");
opt.font = G_define_option();
opt.font->key = "font";
opt.font->type = TYPE_STRING;
opt.font->required = NO;
opt.font->description = _("Font name");
opt.font->guisection = _("Font settings");
opt.size = G_define_option();
opt.size->key = "size";
opt.size->type = TYPE_DOUBLE;
opt.size->required = NO;
opt.size->answer = "5";
opt.size->options = "0-100";
opt.size->description =
_("Height of letters in percentage of available frame height");
opt.size->guisection = _("Font settings");
opt.path = G_define_standard_option(G_OPT_F_INPUT);
opt.path->key = "path";
opt.path->required = NO;
opt.path->description = _("Path to font file");
opt.path->gisprompt = "old,font,file";
opt.path->guisection = _("Font settings");
opt.charset = G_define_option();
opt.charset->key = "charset";
opt.charset->type = TYPE_STRING;
opt.charset->required = NO;
opt.charset->description =
_("Text encoding (only applicable to TrueType fonts)");
opt.charset->guisection = _("Font settings");
flag.p = G_define_flag();
flag.p->key = 'p';
flag.p->description = _("Screen position in pixels ([0,0] is top left)");
flag.p->guisection = _("Position");
flag.g = G_define_flag();
flag.g->key = 'g';
flag.g->description = _("Screen position in geographic coordinates");
flag.g->guisection = _("Position");
flag.b = G_define_flag();
flag.b->key = 'b';
flag.b->description = _("Use bold text");
flag.b->guisection = _("Text");
flag.r = G_define_flag();
flag.r->key = 'r';
flag.r->description = _("Use radians instead of degrees for rotation");
flag.r->guisection = _("Text");
flag.s = G_define_flag();
flag.s->key = 's';
flag.s->description = _("Font size is height in pixels");
flag.s->guisection = _("Font settings");
/* check command line */
if (G_parser(argc, argv))
exit(1);
/* parse and check options and flags */
if ((opt.line->answer && opt.at->answer) ||
(flag.p->answer && flag.g->answer))
G_fatal_error(_("Please choose only one placement method"));
text = opt.text->answer;
line = (opt.line->answer ? atoi(opt.line->answer) : 1);
/* calculate rotation angle in radian */
rotation = atof(opt.rotation->answer);
if (!flag.r->answer)
rotation *= M_PI / 180.0;
rotation = fmod(rotation, 2.0 * M_PI);
if (rotation < 0.0)
rotation += 2.0 * M_PI;
strncpy(align, opt.align->answer, 2);
linespacing = atof(opt.linespacing->answer);
bold = flag.b->answer;
D_open_driver();
if (opt.font->answer)
D_font(opt.font->answer);
else if (opt.path->answer)
D_font(opt.path->answer);
if (opt.charset->answer)
D_encoding(opt.charset->answer);
D_setup_unity(0);
/* figure out where to put text */
D_get_src(&win.t, &win.b, &win.l, &win.r);
if (flag.s->answer)
size = atof(opt.size->answer);
else
#ifdef BACKWARD_COMPATIBILITY
size = atof(opt.size->answer) / 100.0 * (win.b - win.t) / linespacing;
#else
size = atof(opt.size->answer) / 100.0 * (win.b - win.t);
#endif
fg_color = D_parse_color(opt.fgcolor->answer, TRUE);
if (opt.bgcolor->answer) {
do_background = 1;
bg_color = D_parse_color(opt.bgcolor->answer, TRUE);
if (bg_color == 0) /* ie color="none" */
do_background = 0;
} else
do_background = 0;
set_color(opt.fgcolor->answer);
orig_x = orig_y = 0;
if (opt.at->answer) {
if (get_coordinates(&x, &y, &east, &north,
win, opt.at->answers,
flag.p->answer, flag.g->answer))
G_fatal_error(_("Invalid coordinates"));
orig_x = x;
orig_y = y;
}
else {
x = win.l + (size * linespacing + 0.5) - size; /* d.text: +5 */
y = win.t + line * (size * linespacing + 0.5);
}
prev_x = x;
prev_y = y;
D_text_size(size, size);
D_text_rotation(rotation * 180.0 / M_PI);
if (text) {
double x2, y2;
x2 = x;
y2 = y;
if (text[0])
draw_text(text, &x2, &y2, size, align, rotation, bold, do_background, fg_color, bg_color);
/* reset */
D_text_size(5, 5);
D_text_rotation(0.0);
D_save_command(G_recreate_command());
D_close_driver();
exit(EXIT_SUCCESS);
}
if (!opt.input->answer || strcmp(opt.input->answer, "-") == 0)
cmd_fp = stdin;
else {
cmd_fp = fopen(opt.input->answer, "r");
if (!cmd_fp)
G_fatal_error(_("Unable to open input file <%s>"), opt.input->answer);
}
if (isatty(fileno(cmd_fp)))
fprintf(stderr,
_("\nPlease enter text instructions. Enter EOF (ctrl-d) on last line to quit\n"));
set_x = set_y = set_l = 0;
first_text = 1;
linefeed = 1;
/* do the plotting */
while (fgets(buf, sizeof(buf), cmd_fp)) {
int buf_len;
char *buf_ptr, *ptr;
buf_len = strlen(buf) - 1;
for (; buf[buf_len] == '\r' || buf[buf_len] == '\n'; buf_len--) ;
buf[buf_len + 1] = 0;
if (buf[0] == '.' && buf[1] != '.') {
int i;
double d;
G_squeeze(buf); /* added 6/91 DBS @ CWU */
for (buf_ptr = buf + 2; *buf_ptr == ' '; buf_ptr++) ;
buf_len = strlen(buf_ptr);
switch (buf[1] & 0x7f) {
case 'F':
/* font */
if ((ptr = strchr(buf_ptr, ':')))
*ptr = 0;
D_font(buf_ptr);
if (ptr)
D_encoding(ptr + 1);
break;
case 'C':
/* color */
set_color(buf_ptr);
fg_color = D_parse_color(buf_ptr, 1);
break;
case 'G':
/* background color */
bg_color = D_parse_color(buf_ptr, 1);
do_background = 1;
break;
case 'S':
/* size */
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] != 'p')
#ifdef BACKWARD_COMPATIBILITY
d *= (win.b - win.t) / 100.0 / linespacing;
#else
d *= (win.b - win.t) / 100.0;
#endif
size = d + (i ? size : 0);
D_text_size(size, size);
break;
case 'B':
/* bold */
bold = (atoi(buf_ptr) ? 1 : 0);
break;
case 'A':
/* align */
strncpy(align, buf_ptr, 2);
break;
case 'R':
/* rotation */
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] != 'r')
d *= M_PI / 180.0;
d += (i ? rotation : 0.0);
rotation = fmod(d, 2.0 * M_PI);
if (rotation < 0.0)
rotation += 2.0 * M_PI;
D_text_rotation(rotation * 180.0 / M_PI);
break;
case 'I':
/* linespacing */
linespacing = atof(buf_ptr);
break;
case 'X':
/* x */
set_l = 0;
set_x = 1;
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] == '%')
/* percentage */
d *= (win.r - win.l) / 100.0;
else if (buf_ptr[buf_len - 1] != 'p')
/* column */
d = (d - 1) * size * linespacing + 0.5;
x = prev_x = d + (i ? x : orig_x);
break;
case 'Y':
/* y */
set_l = 0;
set_y = 1;
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] == '%')
/* percentage */
d = win.b - d * (win.b - win.t) / 100.0;
else if (buf_ptr[buf_len - 1] != 'p')
/* row */
d *= size * linespacing + 0.5;
y = prev_y = d + (i ? y : orig_y);
break;
case 'L':
/* linefeed */
set_l = 1;
linefeed = (atoi(buf_ptr) ? 1 : 0);
break;
case 'E':
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] == '%')
d *= (win.r - win.l) / 100.0;
else if (buf_ptr[buf_len - 1] != 'p')
d = D_u_to_d_col(d);
x = prev_x = orig_x = d + (i ? orig_x : win.l);
break;
case 'N':
i = 0;
if (strchr("+-", buf_ptr[0]))
i = 1;
d = atof(buf_ptr);
if (buf_ptr[buf_len - 1] == '%')
d *= (win.b - win.t) / 100.0;
else if (buf_ptr[buf_len - 1] != 'p')
d = D_u_to_d_row(d);
y = prev_y = orig_y = d + (i ? orig_y : win.t);
break;
}
}
else {
buf_ptr = buf;
if (buf[0] == '.' && buf[1] == '.')
buf_ptr++;
if (!first_text && (linefeed || set_l)) {
/* if x is not given, increment x */
if (!set_x)
x = prev_x +
(size * linespacing + 0.5) * sin(rotation);
/* if y is not given, increment y */
if (!set_y)
y = prev_y +
(size * linespacing + 0.5) * cos(rotation);
prev_x = x;
prev_y = y;
}
set_x = set_y = set_l = first_text = 0;
draw_text(buf_ptr, &x, &y, size, align, rotation, bold, do_background, fg_color, bg_color);
}
}
if (cmd_fp != stdin)
fclose(cmd_fp);
/* reset */
D_text_size(5, 5);
D_text_rotation(0.0);
D_close_driver();
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int i, row, col; /* counters */
unsigned long filesize;
int endianness; /* 0=little, 1=big */
int data_format; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int (ie text) */
int data_type; /* 0=numbers 1=text */
int format_block; /* combo of endianness, 0, data_format, and type */
int realflag = 0; /* 0=only real values used */
/* should type be specifically uint32 ??? */
char array_name[32]; /* variable names must start with a letter (case
sensitive) followed by letters, numbers, or
underscores. 31 chars max. */
int name_len;
int mrows, ncols; /* text/data/map array dimensions */
int val_i; /* for misc use */
float val_f; /* for misc use */
double val_d; /* for misc use */
char *infile, *outfile, *maptitle, *basename;
struct Cell_head region;
void *raster, *ptr;
RASTER_MAP_TYPE map_type;
struct Option *inputfile, *outputfile;
struct GModule *module;
int fd;
FILE *fp1;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("export"));
module->description = _("Exports a GRASS raster to a binary MAT-File.");
/* Define the different options */
inputfile = G_define_standard_option(G_OPT_R_INPUT);
outputfile = G_define_option();
outputfile->key = "output";
outputfile->type = TYPE_STRING;
outputfile->required = YES;
outputfile->gisprompt = "new_file,file,output";
outputfile->description = _("Name for the output binary MAT-File");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
infile = inputfile->answer;
basename = G_store(outputfile->answer);
G_basename(basename, "mat");
outfile = G_malloc(strlen(basename) + 5);
sprintf(outfile, "%s.mat", basename);
fd = Rast_open_old(infile, "");
map_type = Rast_get_map_type(fd);
/* open bin file for writing */
fp1 = fopen(outfile, "wb");
if (NULL == fp1)
G_fatal_error(_("Unable to open output file <%s>"), outfile);
/* Check Endian State of Host Computer */
if (G_is_little_endian())
endianness = 0; /* ie little endian */
else
endianness = 1; /* ie big endian */
G_debug(1, "Machine is %s endian.\n", endianness ? "big" : "little");
G_get_window(®ion);
/********** Write map **********/
/** write text element (map name) **/
strncpy(array_name, "map_name", 31);
mrows = 1;
ncols = strlen(infile);
data_format = 5; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int(text) */
data_type = 1; /* 0=numbers 1=text */
G_verbose_message(_("Exporting <%s>"), infile);
/* 4 byte data format */
format_block = endianness * 1000 + data_format * 10 + data_type;
fwrite(&format_block, sizeof(int), 1, fp1);
/* fprintf(stderr, "name data format is [%04ld]\n", format_block); */
/* 4 byte number of rows & columns */
fwrite(&mrows, sizeof(int), 1, fp1);
fwrite(&ncols, sizeof(int), 1, fp1);
/* 4 byte real/imag flag 0=real vals only */
fwrite(&realflag, sizeof(int), 1, fp1);
/* length of array_name+1 */
name_len = strlen(array_name) + 1;
fwrite(&name_len, sizeof(int), 1, fp1);
/* array name */
fprintf(fp1, "%s%c", array_name, '\0');
/* array data */
fprintf(fp1, "%s", infile);
/********** Write title (if there is one) **********/
maptitle = Rast_get_cell_title(infile, "");
if (strlen(maptitle) >= 1) {
/** write text element (map title) **/
strncpy(array_name, "map_title", 31);
mrows = 1;
ncols = strlen(maptitle);
data_format = 5; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int(text) */
data_type = 1; /* 0=numbers 1=text */
/* 4 byte data format */
format_block = endianness * 1000 + data_format * 10 + data_type;
fwrite(&format_block, sizeof(int), 1, fp1);
/* 4 byte number of rows & columns */
fwrite(&mrows, sizeof(int), 1, fp1);
fwrite(&ncols, sizeof(int), 1, fp1);
/* 4 byte real/imag flag 0=real vals only */
fwrite(&realflag, sizeof(int), 1, fp1);
/* length of array_name+1 */
name_len = strlen(array_name) + 1;
fwrite(&name_len, sizeof(int), 1, fp1);
/* array name */
fprintf(fp1, "%s%c", array_name, '\0');
/* array data */
fprintf(fp1, "%s", maptitle);
}
/***** Write bounds *****/
G_verbose_message("");
G_verbose_message(_("Using the Current Region settings:"));
G_verbose_message(_("northern edge=%f"), region.north);
G_verbose_message(_("southern edge=%f"), region.south);
G_verbose_message(_("eastern edge=%f"), region.east);
G_verbose_message(_("western edge=%f"), region.west);
G_verbose_message(_("nsres=%f"), region.ns_res);
G_verbose_message(_("ewres=%f"), region.ew_res);
G_verbose_message(_("rows=%d"), region.rows);
G_verbose_message(_("cols=%d"), region.cols);
G_verbose_message("");
for (i = 0; i < 4; i++) {
switch (i) {
case 0:
strncpy(array_name, "map_northern_edge", 31);
val_d = region.north;
break;
case 1:
strncpy(array_name, "map_southern_edge", 31);
val_d = region.south;
break;
case 2:
strncpy(array_name, "map_eastern_edge", 31);
val_d = region.east;
break;
case 3:
strncpy(array_name, "map_western_edge", 31);
val_d = region.west;
break;
default:
fclose(fp1);
G_fatal_error("please contact development team");
break;
}
/** write data element **/
data_format = 0; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int(text) */
data_type = 0; /* 0=numbers 1=text */
mrows = 1;
ncols = 1;
/* 4 byte data format */
format_block = endianness * 1000 + data_format * 10 + data_type;
fwrite(&format_block, sizeof(int), 1, fp1);
/* fprintf(stderr, "bounds data format is [%04ld]\n", format_block); */
/* 4 byte number of rows , 4 byte number of colums */
fwrite(&mrows, sizeof(int), 1, fp1);
fwrite(&ncols, sizeof(int), 1, fp1);
/* 4 byte real/imag flag 0=only real */
fwrite(&realflag, sizeof(int), 1, fp1);
/* length of array_name+1 */
name_len = strlen(array_name) + 1;
fwrite(&name_len, sizeof(int), 1, fp1);
/* array name */
fprintf(fp1, "%s%c", array_name, '\0');
/* write array data, by increasing column */
fwrite(&val_d, sizeof(double), 1, fp1);
/** end of data element **/
}
/***** Write map data *****/
strncpy(array_name, "map_data", 31);
switch (map_type) { /* data_format: 0=double 1=float 2=32bit signed int 5=8bit unsigned int (ie text) */
case CELL_TYPE:
data_format = 2;
G_verbose_message(_("Exporting raster as integer values"));
break;
case FCELL_TYPE:
data_format = 1;
G_verbose_message(_("Exporting raster as floating point values"));
break;
case DCELL_TYPE:
data_format = 0;
G_verbose_message(_("Exporting raster as double FP values"));
break;
default:
fclose(fp1);
G_fatal_error("Please contact development team");
break;
}
data_type = 0; /* 0=numbers 1=text */
mrows = region.rows;
ncols = region.cols;
/* 4 byte data format */
format_block = (endianness * 1000) + (data_format * 10) + data_type;
fwrite(&format_block, sizeof(int), 1, fp1);
G_debug(3, "map data format is [%04d]\n", format_block);
/* 4 byte number of rows & columns */
fwrite(&mrows, sizeof(int), 1, fp1);
fwrite(&ncols, sizeof(int), 1, fp1);
/* 4 byte real/imag flag 0=only real */
fwrite(&realflag, sizeof(int), 1, fp1);
/* length of array_name+1 */
name_len = strlen(array_name) + 1;
fwrite(&name_len, sizeof(int), 1, fp1);
/* array name */
fprintf(fp1, "%s%c", array_name, '\0');
/* data array, by increasing column */
raster =
G_calloc((Rast_window_rows() + 1) * (Rast_window_cols() + 1),
Rast_cell_size(map_type));
G_debug(1, "mem alloc is %d bytes\n", /* I think _cols()+1 is unneeded? */
Rast_cell_size(map_type) * (Rast_window_rows() +
1) * (Rast_window_cols() + 1));
G_verbose_message(_("Reading in map ... "));
/* load entire map into memory */
for (row = 0, ptr = raster; row < mrows; row++,
ptr =
G_incr_void_ptr(ptr,
(Rast_window_cols() + 1) * Rast_cell_size(map_type))) {
Rast_get_row(fd, ptr, row, map_type);
G_percent(row, mrows, 2);
}
G_percent(row, mrows, 2); /* finish it off */
G_verbose_message(_("Writing out map..."));
/* then write it to disk */
/* NoGood: fwrite(raster, Rast_cell_size(map_type), mrows*ncols, fp1); */
for (col = 0; col < ncols; col++) {
for (row = 0; row < mrows; row++) {
ptr = raster;
ptr =
G_incr_void_ptr(ptr,
(col +
row * (ncols +
1)) * Rast_cell_size(map_type));
if (!Rast_is_null_value(ptr, map_type)) {
if (map_type == CELL_TYPE) {
val_i = *((CELL *) ptr);
fwrite(&val_i, sizeof(int), 1, fp1);
}
else if (map_type == FCELL_TYPE) {
val_f = *((FCELL *) ptr);
fwrite(&val_f, sizeof(float), 1, fp1);
}
else if (map_type == DCELL_TYPE) {
val_d = *((DCELL *) ptr);
fwrite(&val_d, sizeof(double), 1, fp1);
}
}
else { /* ie if NULL cell -> write IEEE NaN value */
if (map_type == CELL_TYPE) {
val_i = *((CELL *) ptr); /* int has no NaN value, so use whatever GRASS uses */
fwrite(&val_i, sizeof(int), 1, fp1);
}
else if (map_type == FCELL_TYPE) {
if (endianness) /* ie big */
fprintf(fp1, "%c%c%c%c", 0xff, 0xf8, 0, 0);
else /* ie little */
fprintf(fp1, "%c%c%c%c", 0, 0, 0xf8, 0xff);
}
else if (map_type == DCELL_TYPE) {
if (endianness)
fprintf(fp1, "%c%c%c%c%c%c%c%c", 0xff, 0xf8, 0, 0, 0,
0, 0, 0);
else
fprintf(fp1, "%c%c%c%c%c%c%c%c", 0, 0, 0, 0, 0, 0,
0xf8, 0xff);
}
}
}
G_percent(col, ncols, 2);
}
G_percent(col, ncols, 2); /* finish it off */
/*** end of data element ***/
/* done! */
filesize = G_ftell(fp1);
fclose(fp1);
G_verbose_message(_("%ld bytes written to '%s'"), filesize, outfile);
G_done_msg("");
G_free(basename);
G_free(outfile);
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int i, cat, with_z, more, ctype, nrows;
char buf[DB_SQL_MAX];
int count;
double coor[3];
int ncoor;
struct Option *driver_opt, *database_opt, *table_opt;
struct Option *xcol_opt, *ycol_opt, *zcol_opt, *keycol_opt, *where_opt,
*outvect;
struct Flag *same_table_flag;
struct GModule *module;
struct Map_info Map;
struct line_pnts *Points;
struct line_cats *Cats;
dbString sql;
dbDriver *driver;
dbCursor cursor;
dbTable *table;
dbColumn *column;
dbValue *value;
struct field_info *fi;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("vector"));
G_add_keyword(_("import"));
G_add_keyword(_("database"));
G_add_keyword(_("points"));
module->description =
_("Creates new vector (points) map from database table containing coordinates.");
table_opt = G_define_standard_option(G_OPT_DB_TABLE);
table_opt->required = YES;
table_opt->description = _("Input table name");
driver_opt = G_define_standard_option(G_OPT_DB_DRIVER);
driver_opt->options = db_list_drivers();
driver_opt->answer = (char *)db_get_default_driver_name();
driver_opt->guisection = _("Input DB");
database_opt = G_define_standard_option(G_OPT_DB_DATABASE);
database_opt->answer = (char *)db_get_default_database_name();
database_opt->guisection = _("Input DB");
xcol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
xcol_opt->key = "x";
xcol_opt->required = YES;
xcol_opt->description = _("Name of column containing x coordinate");
ycol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
ycol_opt->key = "y";
ycol_opt->required = YES;
ycol_opt->description = _("Name of column containing y coordinate");
zcol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
zcol_opt->key = "z";
zcol_opt->description = _("Name of column containing z coordinate");
zcol_opt->guisection = _("3D output");
keycol_opt = G_define_standard_option(G_OPT_DB_COLUMN);
keycol_opt->key = "key";
keycol_opt->required = NO;
keycol_opt->label = _("Name of column containing category number");
keycol_opt->description = _("Must refer to an integer column");
where_opt = G_define_standard_option(G_OPT_DB_WHERE);
where_opt->guisection = _("Selection");
outvect = G_define_standard_option(G_OPT_V_OUTPUT);
same_table_flag = G_define_flag();
same_table_flag->key = 't';
same_table_flag->description =
_("Use imported table as attribute table for new map");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (zcol_opt->answer) {
with_z = WITH_Z;
ncoor = 3;
}
else {
with_z = WITHOUT_Z;
ncoor = 2;
}
Points = Vect_new_line_struct();
Cats = Vect_new_cats_struct();
db_init_string(&sql);
if (G_get_overwrite()) {
/* We don't want to delete the input table when overwriting the output
* vector. */
char name[GNAME_MAX], mapset[GMAPSET_MAX];
if (!G_name_is_fully_qualified(outvect->answer, name, mapset)) {
strcpy(name, outvect->answer);
strcpy(mapset, G_mapset());
}
Vect_set_open_level(1); /* no topo needed */
if (strcmp(mapset, G_mapset()) == 0 && G_find_vector2(name, mapset) &&
Vect_open_old(&Map, name, mapset) >= 0) {
int num_dblinks;
num_dblinks = Vect_get_num_dblinks(&Map);
for (i = 0; i < num_dblinks; i++) {
if ((fi = Vect_get_dblink(&Map, i)) != NULL &&
strcmp(fi->driver, driver_opt->answer) == 0 &&
strcmp(fi->database, database_opt->answer) == 0 &&
strcmp(fi->table, table_opt->answer) == 0)
G_fatal_error(_("Vector map <%s> cannot be overwritten "
"because input table <%s> is linked to "
"this map."),
outvect->answer, table_opt->answer);
}
Vect_close(&Map);
}
}
if (Vect_open_new(&Map, outvect->answer, with_z) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
outvect->answer);
Vect_set_error_handler_io(NULL, &Map);
Vect_hist_command(&Map);
fi = Vect_default_field_info(&Map, 1, NULL, GV_1TABLE);
/* Open driver */
driver = db_start_driver_open_database(driver_opt->answer,
database_opt->answer);
if (driver == NULL) {
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
fi->database, fi->driver);
}
db_set_error_handler_driver(driver);
/* check if target table already exists */
G_debug(3, "Output vector table <%s>, driver: <%s>, database: <%s>",
outvect->answer, db_get_default_driver_name(),
db_get_default_database_name());
if (!same_table_flag->answer &&
db_table_exists(db_get_default_driver_name(),
db_get_default_database_name(), outvect->answer) == 1)
G_fatal_error(_("Output vector map, table <%s> (driver: <%s>, database: <%s>) "
"already exists"), outvect->answer,
db_get_default_driver_name(),
db_get_default_database_name());
if (keycol_opt->answer) {
int coltype;
coltype = db_column_Ctype(driver, table_opt->answer, keycol_opt->answer);
if (coltype == -1)
G_fatal_error(_("Column <%s> not found in table <%s>"),
keycol_opt->answer, table_opt->answer);
if (coltype != DB_C_TYPE_INT)
G_fatal_error(_("Data type of key column must be integer"));
}
else {
if (same_table_flag->answer) {
G_fatal_error(_("Option <%s> must be specified when -%c flag is given"),
keycol_opt->key, same_table_flag->key);
}
if (strcmp(db_get_default_driver_name(), "sqlite") != 0)
G_fatal_error(_("Unable to define key column. This operation is not supported "
"by <%s> driver. You need to define <%s> option."),
fi->driver, keycol_opt->key);
}
/* Open select cursor */
sprintf(buf, "SELECT %s, %s", xcol_opt->answer, ycol_opt->answer);
db_set_string(&sql, buf);
if (with_z) {
sprintf(buf, ", %s", zcol_opt->answer);
db_append_string(&sql, buf);
}
if (keycol_opt->answer) {
sprintf(buf, ", %s", keycol_opt->answer);
db_append_string(&sql, buf);
}
sprintf(buf, " FROM %s", table_opt->answer);
db_append_string(&sql, buf);
if (where_opt->answer) {
sprintf(buf, " WHERE %s", where_opt->answer);
db_append_string(&sql, buf);
}
G_debug(2, "SQL: %s", db_get_string(&sql));
if (db_open_select_cursor(driver, &sql, &cursor, DB_SEQUENTIAL) != DB_OK) {
G_fatal_error(_("Unable to open select cursor: '%s'"),
db_get_string(&sql));
}
table = db_get_cursor_table(&cursor);
nrows = db_get_num_rows(&cursor);
G_debug(2, "%d points selected", nrows);
count = cat = 0;
G_message(_("Writing features..."));
while (db_fetch(&cursor, DB_NEXT, &more) == DB_OK && more) {
G_percent(count, nrows, 2);
/* key column */
if (keycol_opt->answer) {
column = db_get_table_column(table, with_z ? 3 : 2);
ctype = db_sqltype_to_Ctype(db_get_column_sqltype(column));
if (ctype != DB_C_TYPE_INT)
G_fatal_error(_("Key column must be integer"));
value = db_get_column_value(column);
cat = db_get_value_int(value);
}
else {
cat++;
}
/* coordinates */
for (i = 0; i < ncoor; i++) {
column = db_get_table_column(table, i);
ctype = db_sqltype_to_Ctype(db_get_column_sqltype(column));
if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_DOUBLE)
G_fatal_error(_("x/y/z column must be integer or double"));
value = db_get_column_value(column);
if (ctype == DB_C_TYPE_INT)
coor[i] = (double)db_get_value_int(value);
else
coor[i] = db_get_value_double(value);
}
Vect_reset_line(Points);
Vect_reset_cats(Cats);
Vect_append_point(Points, coor[0], coor[1], coor[2]);
Vect_cat_set(Cats, 1, cat);
Vect_write_line(&Map, GV_POINT, Points, Cats);
count++;
}
G_percent(1, 1, 1);
/* close connection to input DB before copying attributes */
db_close_database_shutdown_driver(driver);
/* Copy table */
if (!same_table_flag->answer) {
G_message(_("Copying attributes..."));
if (DB_FAILED == db_copy_table_where(driver_opt->answer, database_opt->answer,
table_opt->answer,
fi->driver, fi->database, fi->table,
where_opt->answer)) { /* where can be NULL */
G_warning(_("Unable to copy table"));
}
else {
Vect_map_add_dblink(&Map, 1, NULL, fi->table,
keycol_opt->answer ? keycol_opt->answer : GV_KEY_COLUMN,
fi->database, fi->driver);
}
if (!keycol_opt->answer) {
/* TODO: implement for all DB drivers in generic way if
* possible */
driver = db_start_driver_open_database(fi->driver, fi->database);
if (driver == NULL) {
G_fatal_error(_("Unable to open database <%s> by driver <%s>"),
fi->database, fi->driver);
}
db_set_error_handler_driver(driver);
/* add key column */
sprintf(buf, "ALTER TABLE %s ADD COLUMN %s INTEGER",
fi->table, GV_KEY_COLUMN);
db_set_string(&sql, buf);
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Unable to add key column <%s>: "
"SERIAL type is not supported by <%s>"),
GV_KEY_COLUMN, fi->driver);
}
/* update key column */
sprintf(buf, "UPDATE %s SET %s = _ROWID_",
fi->table, GV_KEY_COLUMN);
db_set_string(&sql, buf);
if (db_execute_immediate(driver, &sql) != DB_OK) {
G_fatal_error(_("Failed to update key column <%s>"),
GV_KEY_COLUMN);
}
}
}
else {
/* do not copy attributes, link original table */
Vect_map_add_dblink(&Map, 1, NULL, table_opt->answer,
keycol_opt->answer ? keycol_opt->answer : GV_KEY_COLUMN,
database_opt->answer, driver_opt->answer);
}
Vect_build(&Map);
Vect_close(&Map);
G_done_msg(_n("%d point written to vector map.",
"%d points written to vector map.",
count), count);
return (EXIT_SUCCESS);
}
int main( int argc, char **argv )
{
struct GModule *module;
struct Option *info_opt, *rast_opt, *vect_opt, *coor_opt;
struct Cell_head window;
/* Initialize the GIS calls */
G_gisinit( argv[0] );
module = G_define_module();
module->description = ( "Get info about locations,mapsets,maps" );
info_opt = G_define_option();
info_opt->key = "info";
info_opt->type = TYPE_STRING;
info_opt->description = "info key";
info_opt->options = "proj,window,query";
rast_opt = G_define_standard_option( G_OPT_R_INPUT );
rast_opt->key = "rast";
rast_opt->required = NO;
vect_opt = G_define_standard_option( G_OPT_V_INPUT );
vect_opt->key = "vect";
vect_opt->required = NO;
coor_opt = G_define_option();
coor_opt->key = "coor";
coor_opt->type = TYPE_DOUBLE;
coor_opt->multiple = YES;
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
if ( strcmp( "proj", info_opt->answer ) == 0 )
{
G_get_window( &window );
/* code from g.proj */
if ( window.proj != PROJECTION_XY )
{
struct Key_Value *projinfo, *projunits;
char *wkt;
projinfo = G_get_projinfo();
projunits = G_get_projunits();
wkt = GPJ_grass_to_wkt( projinfo, projunits, 0, 0 );
fprintf( stdout, "%s", wkt );
}
}
else if ( strcmp( "window", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%f,%f,%f,%f", window.west, window.south, window.east, window.north );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
else if ( strcmp( "query", info_opt->answer ) == 0 )
{
double x, y;
int row, col;
x = atof( coor_opt->answers[0] );
y = atof( coor_opt->answers[1] );
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
G_get_cellhd( rast_opt->answer, "", &window );
G_set_window( &window );
fd = G_open_cell_old( rast_opt->answer, "" );
col = ( int ) G_easting_to_col( x, &window );
row = ( int ) G_northing_to_row( y, &window );
if ( col == window.cols ) col--;
if ( row == window.rows ) row--;
if ( col < 0 || col > window.cols || row < 0 || row > window.rows )
{
fprintf( stdout, "value:null\n" );
}
else
{
void *ptr;
double val;
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
if ( rast_type == CELL_TYPE )
{
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = cell[col];
ptr = &( cell[col] );
}
else
{
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
val = dcell[col];
ptr = &( dcell[col] );
}
if ( G_is_null_value( ptr, rast_type ) )
{
fprintf( stdout, "value:null\n" );
}
else
{
fprintf( stdout, "value:%f\n", val );
}
}
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
exit( EXIT_SUCCESS );
}
int main(int argc, char *argv[])
{
char *name, *outfile;
const char *unit;
int unit_id;
double factor;
int fd, projection;
FILE *fp, *coor_fp;
double res;
char *null_string;
char ebuf[256], nbuf[256], label[512], formatbuff[256];
char b1[100], b2[100];
int n;
int havefirst = FALSE;
int coords = 0, i, k = -1;
double e1, e2, n1, n2;
RASTER_MAP_TYPE data_type;
struct Cell_head window;
struct
{
struct Option *opt1, *profile, *res, *output, *null_str, *coord_file, *units;
struct Flag *g, *c, *m;
}
parm;
struct GModule *module;
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("raster"));
G_add_keyword(_("profile"));
module->description =
_("Outputs the raster map layer values lying on user-defined line(s).");
parm.opt1 = G_define_standard_option(G_OPT_R_INPUT);
parm.output = G_define_standard_option(G_OPT_F_OUTPUT);
parm.output->required = NO;
parm.output->answer = "-";
parm.output->description =
_("Name of file for output (use output=- for stdout)");
parm.profile = G_define_standard_option(G_OPT_M_COORDS);
parm.profile->required = NO;
parm.profile->multiple = YES;
parm.profile->description = _("Profile coordinate pairs");
parm.coord_file = G_define_standard_option(G_OPT_F_INPUT);
parm.coord_file->key = "file";
parm.coord_file->required = NO;
parm.coord_file->label =
_("Name of input file containing coordinate pairs");
parm.coord_file->description =
_("Use instead of the 'coordinates' option. "
"\"-\" reads from stdin.");
parm.res = G_define_option();
parm.res->key = "resolution";
parm.res->type = TYPE_DOUBLE;
parm.res->required = NO;
parm.res->description =
_("Resolution along profile (default = current region resolution)");
parm.null_str = G_define_option();
parm.null_str->key = "null";
parm.null_str->type = TYPE_STRING;
parm.null_str->required = NO;
parm.null_str->answer = "*";
parm.null_str->description = _("Character to represent no data cell");
parm.g = G_define_flag();
parm.g->key = 'g';
parm.g->description =
_("Output easting and northing in first two columns of four column output");
parm.c = G_define_flag();
parm.c->key = 'c';
parm.c->description =
_("Output RRR:GGG:BBB color values for each profile point");
parm.units = G_define_standard_option(G_OPT_M_UNITS);
parm.units->options = "meters,kilometers,feet,miles";
parm.units->label = parm.units->description;
parm.units->description = _("If units are not specified, current location units are used. "
"Meters are used by default in geographic (latlon) locations.");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
clr = 0;
if (parm.c->answer)
clr = 1; /* color output */
null_string = parm.null_str->answer;
if ((parm.profile->answer && parm.coord_file->answer) ||
(!parm.profile->answer && !parm.coord_file->answer))
G_fatal_error(_("Either use profile option or coordinate_file "
" option, but not both"));
G_get_window(&window);
projection = G_projection();
/* get conversion factor and units name */
if (parm.units->answer) {
unit_id = G_units(parm.units->answer);
factor = 1. / G_meters_to_units_factor(unit_id);
unit = G_get_units_name(unit_id, 1, 0);
}
/* keep meters in case of latlon */
else if (projection == PROJECTION_LL) {
factor = 1;
unit = "meters";
}
else {
/* get conversion factor to current units */
unit = G_database_unit_name(1);
factor = G_database_units_to_meters_factor();
}
if (parm.res->answer) {
res = atof(parm.res->answer);
/* Catch bad resolution ? */
if (res <= 0)
G_fatal_error(_("Illegal resolution %g [%s]"), res / factor, unit);
}
else {
/* Do average of EW and NS res */
res = (window.ew_res + window.ns_res) / 2;
}
G_message(_("Using resolution: %g [%s]"), res / factor, unit);
G_begin_distance_calculations();
/* Open Input File for reading */
/* Get Input Name */
name = parm.opt1->answer;
if (parm.g->answer)
coords = 1;
/* Open Raster File */
fd = Rast_open_old(name, "");
/* initialize color structure */
if (clr)
Rast_read_colors(name, "", &colors);
/* Open ASCII file for output or stdout */
outfile = parm.output->answer;
if ((strcmp("-", outfile)) == 0) {
fp = stdout;
}
else if (NULL == (fp = fopen(outfile, "w")))
G_fatal_error(_("Unable to open file <%s>"), outfile);
/* Get Raster Type */
data_type = Rast_get_map_type(fd);
/* Done with file */
/* Show message giving output format */
G_message(_("Output columns:"));
if (coords == 1)
sprintf(formatbuff,
_("Easting, Northing, Along track dist. [%s], Elevation"), unit);
else
sprintf(formatbuff, _("Along track dist. [%s], Elevation"), unit);
if (clr)
strcat(formatbuff, _(" RGB color"));
G_message(formatbuff);
/* Get Profile Start Coords */
if (parm.coord_file->answer) {
if (strcmp("-", parm.coord_file->answer) == 0)
coor_fp = stdin;
else
coor_fp = fopen(parm.coord_file->answer, "r");
if (coor_fp == NULL)
G_fatal_error(_("Could not open <%s>"), parm.coord_file->answer);
for (n = 1; input(b1, ebuf, b2, nbuf, label, coor_fp); n++) {
G_debug(4, "stdin line %d: ebuf=[%s] nbuf=[%s]", n, ebuf, nbuf);
if (!G_scan_easting(ebuf, &e2, G_projection()) ||
!G_scan_northing(nbuf, &n2, G_projection()))
G_fatal_error(_("Invalid coordinates %s %s"), ebuf, nbuf);
if (havefirst)
do_profile(e1, e2, n1, n2, coords, res, fd, data_type,
fp, null_string, unit, factor);
e1 = e2;
n1 = n2;
havefirst = TRUE;
}
if (coor_fp != stdin)
fclose(coor_fp);
}
else {
/* Coords given on the Command Line using the profile= option */
for (i = 0; parm.profile->answers[i]; i += 2) {
/* Test for number coordinate pairs */
k = i;
}
if (k == 0) {
/* Only one coordinate pair supplied */
G_scan_easting(parm.profile->answers[0], &e1, G_projection());
G_scan_northing(parm.profile->answers[1], &n1, G_projection());
e2 = e1;
n2 = n1;
/* Get profile info */
do_profile(e1, e2, n1, n2, coords, res, fd, data_type, fp,
null_string, unit, factor);
}
else {
for (i = 0; i <= k - 2; i += 2) {
G_scan_easting(parm.profile->answers[i], &e1, G_projection());
G_scan_northing(parm.profile->answers[i + 1], &n1,
G_projection());
G_scan_easting(parm.profile->answers[i + 2], &e2,
G_projection());
G_scan_northing(parm.profile->answers[i + 3], &n2,
G_projection());
/* Get profile info */
do_profile(e1, e2, n1, n2, coords, res, fd, data_type,
fp, null_string, unit, factor);
}
}
}
Rast_close(fd);
fclose(fp);
if (clr)
Rast_free_colors(&colors);
exit(EXIT_SUCCESS);
} /* Done with main */
