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) { int i; G_gisinit(argv[0]); for (i = 0; i < MAXVIEWS; i++) { char buf[BUFSIZ]; viewopts[i] = G_define_option(); sprintf(buf, "view%d", i + 1); viewopts[i]->key = G_store(buf); viewopts[i]->type = TYPE_STRING; viewopts[i]->required = (i ? NO : YES); viewopts[i]->multiple = YES; viewopts[i]->gisprompt = "old,cell,Raster";; sprintf(buf, _("Raster file(s) for View%d"), i + 1); viewopts[i]->description = G_store(buf); } if (G_parser(argc, argv)) exit(EXIT_FAILURE); parse_command(viewopts, vfiles, &numviews, &frames); return wxEntry(argc, argv); }
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); }
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[]) { 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); }
void user_input(int argc, char **argv) { struct Flag *bound; struct Flag *trace; struct Option *name; struct Option *out; bound = G_define_flag(); bound->key = 'p'; bound->description = "Include sampling area boundary as perimeter"; trace = G_define_flag(); trace->key = 't'; trace->description = "Use 4 neighbor tracing instead of 8 neighbor"; name = G_define_option(); name->key = "map"; name->description = "Raster map to be analyzed"; name->type = TYPE_STRING; name->gisprompt = "old,cell,raster"; name->required = YES; out = G_define_option(); out->key = "out"; out->description = "Name of output file to store patch data"; out->type = TYPE_STRING; out->required = NO; if (G_parser(argc, argv)) exit(EXIT_FAILURE); strcpy(choice->fn, name->answer); if (out->answer) strcpy(choice->out, out->answer); else strcpy(choice->out, ""); /* if the 4 neighbor tracing flag -t is specified, then set the choice->trace flag to 1 */ choice->trace = 1; if (trace->answer) choice->trace = 0; /* if the -p flag is specified, then set the choice->perim2 flag to 0 */ if (bound->answer) choice->perim2 = 0; else choice->perim2 = 1; }
void parse_args(int argc, char** argv, char** input, char** field, int* history, int* columns, int *shell) { int i; const char *answer; struct Option *input_opt, *field_opt; struct Flag *hist_flag, *col_flag, *shell_flag, *region_flag, *topo_flag; input_opt = G_define_standard_option(G_OPT_V_MAP); field_opt = G_define_standard_option(G_OPT_V_FIELD); hist_flag = G_define_flag(); hist_flag->key = 'h'; hist_flag->description = _("Print history instead of info and exit"); hist_flag->guisection = _("Print"); col_flag = G_define_flag(); col_flag->key = 'c'; col_flag->description = _("Print types/names of table columns for specified layer instead of info and exit"); col_flag->guisection = _("Print"); shell_flag = G_define_flag(); shell_flag->key = 'g'; shell_flag->description = _("Print basic info in shell script style"); shell_flag->guisection = _("Print"); region_flag = G_define_flag(); region_flag->key = 'e'; region_flag->description = _("Print also region info in shell script style"); region_flag->guisection = _("Print"); topo_flag = G_define_flag(); topo_flag->key = 't'; topo_flag->description = _("Print also topology info in shell script style"); topo_flag->guisection = _("Print"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); *input = G_store(input_opt->answer); *field = G_store(field_opt->answer); *history = hist_flag->answer ? TRUE : FALSE; *columns = col_flag->answer ? TRUE : FALSE; i = 0; *shell = SHELL_NO; if (shell_flag->answer) *shell |= SHELL_BASIC; if (region_flag->answer) *shell |= SHELL_REGION; if (topo_flag->answer) *shell |= SHELL_TOPO; }
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); }
void parse_args(int argc, char **argv, struct _options *options, struct _flags* flags) { options->dsn = G_define_option(); options->dsn->key = "dsn"; options->dsn->type = TYPE_STRING; options->dsn->label = _("Name of input OGR or PostGIS data source"); options->dsn->description = _("Examples:\n" "\t\tESRI Shapefile: directory containing a shapefile\n" "\t\tMapInfo File: directory containing a mapinfo file\n" "\t\tPostGIS database: connection string, eg. 'PG:dbname=db user=grass'"); options->dsn->required = YES; options->layer = G_define_option(); options->layer->key = "layer"; options->layer->type = TYPE_STRING; options->layer->required = NO; options->layer->multiple = NO; options->layer->label = _("Name of OGR layer or PostGIS feature table to be linked"); options->layer->description = _("Examples:\n" "\t\tESRI Shapefile: shapefile name\n" "\t\tMapInfo File: mapinfo file name\n" "\t\tPostGIS database: table name"); options->layer->required = YES; options->layer->key_desc = "name"; options->output = G_define_standard_option(G_OPT_V_OUTPUT); options->output->required = NO; options->output->description = _("Name for output GRASS vector map (default: input layer)"); flags->format = G_define_flag(); flags->format->key = 'f'; flags->format->description = _("List supported formats and exit"); flags->format->guisection = _("Print"); flags->format->suppress_required = YES; flags->list = G_define_flag(); flags->list->key = 'l'; flags->list->description = _("List available layers in data source and exit"); flags->list->guisection = _("Print"); flags->list->suppress_required = YES; flags->tlist = G_define_flag(); flags->tlist->key = 't'; flags->tlist->label = _("List available layers including feature type " "in data source and exit"); flags->tlist->description = _("Format: layer name,type,projection check"); flags->tlist->guisection = _("Print"); flags->tlist->suppress_required = YES; flags->topo = G_define_standard_flag(G_FLG_V_TOPO); if (G_parser(argc, argv)) exit(EXIT_FAILURE); }
int parse(int argc, char *argv[], struct parms *parms) { struct Option *group, *subgroup, *sigfile, *output; struct Option *blocksize; struct Flag *ml; group = G_define_standard_option(G_OPT_I_GROUP); subgroup = G_define_standard_option(G_OPT_I_SUBGROUP); sigfile = G_define_option(); sigfile->key = "signaturefile"; sigfile->label = _("Name of file containing signatures"); sigfile->description = _("Generated by i.gensigset"); sigfile->key_desc = "name"; sigfile->required = YES; sigfile->type = TYPE_STRING; output = G_define_standard_option(G_OPT_R_OUTPUT); blocksize = G_define_option(); blocksize->key = "blocksize"; blocksize->description = _("Size of submatrix to process at one time"); blocksize->required = NO; blocksize->type = TYPE_INTEGER; blocksize->answer = "128"; ml = G_define_flag(); ml->key = 'm'; ml->description = _("Use maximum likelihood estimation (instead of smap)"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); parms->ml = ml->answer; parms->output_map = output->answer; parms->group = group->answer; parms->subgroup = subgroup->answer; parms->sigfile = sigfile->answer; /* check all the inputs */ if (!I_find_group(parms->group)) G_fatal_error(_("Group <%s> not found"), parms->group); if (!I_find_subgroup(parms->group, parms->subgroup)) G_fatal_error(_("Subgroup <%s> not found"), parms->subgroup); if (sscanf(blocksize->answer, "%d", &parms->blocksize) != 1 || parms->blocksize <= 8) parms->blocksize = 8; return 0; }
void parse(int argc, char *argv[], struct Parms *parms) { struct Option *maps, *fs; struct Flag *labels, *overlap; const char *name, *mapset; maps = G_define_option(); maps->key = "maps"; maps->key_desc = "map1,map2"; maps->required = YES; maps->multiple = NO; maps->type = TYPE_STRING; maps->description = _("Maps for computing inter-class distances"); maps->gisprompt = "old,cell,raster"; fs = G_define_option(); fs->key = "fs"; fs->required = NO; fs->multiple = NO; fs->answer = ":"; /* colon is default output fs */ fs->type = TYPE_STRING; fs->description = _("Output field separator"); labels = G_define_flag(); labels->key = 'l'; labels->description = _("Include category labels in the output"); overlap = G_define_flag(); overlap->key = 'o'; overlap->description = _("Report zero distance if rasters are overlapping"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); name = parms->map1.name = maps->answers[0]; mapset = parms->map1.mapset = G_find_raster2(name, ""); if (mapset == NULL) G_fatal_error(_("Raster map <%s> not found"), name); parms->map1.fullname = G_fully_qualified_name(name, mapset); name = parms->map2.name = maps->answers[1]; mapset = parms->map2.mapset = G_find_raster2(name, ""); if (mapset == NULL) G_fatal_error(_("Raster map <%s> not found"), name); parms->map2.fullname = G_fully_qualified_name(name, mapset); parms->labels = labels->answer ? 1 : 0; parms->fs = fs->answer; parms->overlap = overlap->answer ? 1 : 0; }
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 parse(int argc, char *argv[], struct parms *parms) { struct Option *group, *subgroup, *sigfile, *trainingmap, *maxsig; trainingmap = G_define_standard_option(G_OPT_R_MAP); trainingmap->key = "trainingmap"; trainingmap->description = _("Ground truth training map"); group = G_define_standard_option(G_OPT_I_GROUP); subgroup = G_define_standard_option(G_OPT_I_SUBGROUP); sigfile = G_define_option(); sigfile->key = "signaturefile"; sigfile->description = _("Name for output file containing result signatures"); sigfile->required = YES; sigfile->type = TYPE_STRING; maxsig = G_define_option(); maxsig->key = "maxsig"; maxsig->description = _("Maximum number of sub-signatures in any class"); maxsig->required = NO; maxsig->type = TYPE_INTEGER; maxsig->answer = "10"; if (G_parser(argc, argv)) exit(EXIT_FAILURE); parms->training_map = trainingmap->answer; parms->group = group->answer; parms->subgroup = subgroup->answer; parms->sigfile = sigfile->answer; /* check all the inputs */ if (G_find_raster(parms->training_map, "") == NULL) { G_fatal_error(_("Raster map <%s> not found"), parms->training_map); } if (!I_find_group(parms->group)) { G_fatal_error(_("Group <%s> not found"), parms->group); } if (!I_find_subgroup(parms->group, parms->subgroup)) { G_fatal_error(_("Subgroup <%s> not found"), parms->subgroup); } if (sscanf(maxsig->answer, "%d", &parms->maxsubclasses) != 1 || parms->maxsubclasses <= 0) { G_fatal_error(_("Illegal number of sub-signatures (%s)"), maxsig->answer); } return 0; }
void parse_args(int argc, char **argv, struct _options *options, struct _flags *flags) { options->dsn = G_define_option(); options->dsn->key = "dsn"; options->dsn->description = _("Name for output OGR datasource"); options->dsn->required = YES; options->dsn->type = TYPE_STRING; options->format = G_define_option(); options->format->key = "format"; options->format->description = _("Format of output files"); options->format->required = YES; options->format->type = TYPE_STRING; options->format->options = format_list(); options->opts = G_define_option(); options->opts->key = "options"; options->opts->description = _("Creation options"); options->opts->required = NO; options->opts->multiple = YES; options->opts->type = TYPE_STRING; flags->f = G_define_flag(); flags->f->key = 'f'; flags->f->description = _("List supported formats and exit"); flags->f->guisection = _("Print"); flags->f->suppress_required = YES; flags->r = G_define_flag(); flags->r->key = 'r'; flags->r->description = _("Cease using OGR, revert to native output and exit"); flags->r->suppress_required = YES; flags->r->guisection = _("Native"); flags->p = G_define_flag(); flags->p->key = 'p'; flags->p->description = _("Print current status"); flags->p->guisection = _("Print"); flags->p->suppress_required = YES; flags->g = G_define_flag(); flags->g->key = 'g'; flags->g->description = _("Print current status in shell script style"); flags->g->guisection = _("Print"); flags->g->suppress_required = YES; if (G_parser(argc, argv)) exit(EXIT_FAILURE); }
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); }
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) { 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); }