/* ************************************************************************* */ void set_params(void) { param.phead = G_define_standard_option(G_OPT_R_INPUT); param.phead->key = "phead"; param.phead->description = _("The initial piezometric head in [m]"); param.status = G_define_standard_option(G_OPT_R_INPUT); param.status->key = "status"; param.status->description = _("Boundary condition status, 0-inactive, 1-active, 2-dirichlet"); param.hc_x = G_define_standard_option(G_OPT_R_INPUT); param.hc_x->key = "hc_x"; param.hc_x->description = _("X-part of the hydraulic conductivity tensor in [m/s]"); param.hc_y = G_define_standard_option(G_OPT_R_INPUT); param.hc_y->key = "hc_y"; param.hc_y->description = _("Y-part of the hydraulic conductivity tensor in [m/s]"); param.q = G_define_standard_option(G_OPT_R_INPUT); param.q->key = "q"; param.q->required = NO; param.q->description = _("Water sources and sinks in [m^3/s]"); param.s = G_define_standard_option(G_OPT_R_INPUT); param.s->key = "s"; param.s->description = _("Specific yield in [1/m]"); param.r = G_define_standard_option(G_OPT_R_INPUT); param.r->key = "r"; param.r->required = NO; param.r->guisection = _("Recharge"); param.r->description = _("Recharge map e.g: 6*10^-9 per cell in [m^3/s*m^2]"); param.top = G_define_standard_option(G_OPT_R_INPUT); param.top->key = "top"; param.top->description = _("Top surface of the aquifer in [m]"); param.bottom = G_define_standard_option(G_OPT_R_INPUT); param.bottom->key = "bottom"; param.bottom->description = _("Bottom surface of the aquifer in [m]"); param.output = G_define_standard_option(G_OPT_R_OUTPUT); param.output->key = "output"; param.output->description = _("The map storing the numerical result [m]"); param.vector = G_define_standard_option(G_OPT_R_OUTPUT); param.vector->key = "velocity"; param.vector->required = NO; param.vector->description = _("Calculate the groundwater filter velocity vector field [m/s]\n" "and write the x, and y components to maps named name_[xy]"); param.type = G_define_option(); param.type->key = "type"; param.type->type = TYPE_STRING; param.type->required = NO; param.type->answer = "confined"; param.type->options = "confined,unconfined"; param.type->description = _("The type of groundwater flow"); /*Variants of the cauchy boundary condition */ param.river_bed = G_define_standard_option(G_OPT_R_INPUT); param.river_bed->key = "river_bed"; param.river_bed->guisection = "River"; param.river_bed->required = NO; param.river_bed->description = _("The height of the river bed in [m]"); param.river_head = G_define_standard_option(G_OPT_R_INPUT); param.river_head->key = "river_head"; param.river_head->guisection = "River"; param.river_head->required = NO; param.river_head->description = _("Water level (head) of the river with leakage connection in [m]"); param.river_leak = G_define_standard_option(G_OPT_R_INPUT); param.river_leak->key = "river_leak"; param.river_leak->guisection = "River"; param.river_leak->required = NO; param.river_leak->description = _("The leakage coefficient of the river bed in [1/s]."); param.drain_bed = G_define_standard_option(G_OPT_R_INPUT); param.drain_bed->key = "drain_bed";; param.drain_bed->guisection = "Drainage"; param.drain_bed->required = NO; param.drain_bed->description = _("The height of the drainage bed in [m]"); param.drain_leak = G_define_standard_option(G_OPT_R_INPUT); param.drain_leak->key = "drain_leak"; param.drain_leak->guisection = "Drainage"; param.drain_leak->required = NO; param.drain_leak->description = _("The leakage coefficient of the drainage bed in [1/s]"); param.dt = N_define_standard_option(N_OPT_CALC_TIME); param.maxit = N_define_standard_option(N_OPT_MAX_ITERATIONS); param.error = N_define_standard_option(N_OPT_ITERATION_ERROR); param.solver = N_define_standard_option(N_OPT_SOLVER_SYMM); param.sor = N_define_standard_option(N_OPT_SOR_VALUE); param.sparse = G_define_flag(); param.sparse->key = 's'; param.sparse->guisection = "Solver"; param.sparse->description = _("Use a sparse matrix, only available with iterative solvers"); }
int main(int argc, char *argv[]) { void *raster, *ptr; /* char *null_row; */ RASTER_MAP_TYPE out_type, map_type; char *outfile; char null_str[80]; char cell_buf[300]; int fd; int row, col; int nrows, ncols, dp; int do_stdout; FILE *fp; double cellsize; struct GModule *module; struct { struct Option *map; struct Option *output; struct Option *dp; struct Option *null; } parm; struct { struct Flag *noheader; struct Flag *singleline; struct Flag *ccenter; } flag; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("export")); module->description = _("Converts a raster map layer into an ESRI ARCGRID file."); /* Define the different options */ parm.map = G_define_standard_option(G_OPT_R_INPUT); parm.output = G_define_standard_option(G_OPT_R_OUTPUT); parm.output->gisprompt = "new_file,file,output"; parm.output->description = _("Name of an output ARC-GRID map (use out=- for stdout)"); parm.dp = G_define_option(); parm.dp->key = "dp"; parm.dp->type = TYPE_INTEGER; parm.dp->required = NO; parm.dp->answer = "8"; parm.dp->description = _("Number of decimal places"); flag.noheader = G_define_flag(); flag.noheader->key = 'h'; flag.noheader->description = _("Suppress printing of header information"); /* Added to optionally produce a single line output. -- emes -- 12.10.92 */ flag.singleline = G_define_flag(); flag.singleline->key = '1'; flag.singleline->description = _("List one entry per line instead of full row"); /* use cell center in header instead of cell corner */ flag.ccenter = G_define_flag(); flag.ccenter->key = 'c'; flag.ccenter->description = _("Use cell center reference in header instead of cell corner"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); sscanf(parm.dp->answer, "%d", &dp); if (dp > 20 || dp < 0) G_fatal_error("dp has to be from 0 to 20"); outfile = parm.output->answer; if ((strcmp("-", outfile)) == 0) do_stdout = 1; else do_stdout = 0; sprintf(null_str, "-9999"); fd = Rast_open_old(parm.map->answer, ""); map_type = Rast_get_map_type(fd); out_type = map_type; /* null_row = Rast_allocate_null_buf(); */ raster = Rast_allocate_buf(out_type); nrows = Rast_window_rows(); ncols = Rast_window_cols(); /* open arc file for writing */ if (do_stdout) fp = stdout; else if (NULL == (fp = fopen(outfile, "w"))) G_fatal_error(_("Unable to open file <%s>"), outfile); if (!flag.noheader->answer) { struct Cell_head region; char buf[128]; G_get_window(®ion); fprintf(fp, "ncols %d\n", region.cols); fprintf(fp, "nrows %d\n", region.rows); cellsize = fabs(region.east - region.west) / region.cols; if (G_projection() != PROJECTION_LL) { /* Is Projection != LL (3) */ if (!flag.ccenter->answer) { G_format_easting(region.west, buf, region.proj); fprintf(fp, "xllcorner %s\n", buf); G_format_northing(region.south, buf, region.proj); fprintf(fp, "yllcorner %s\n", buf); } else { G_format_easting(region.west + cellsize / 2., buf, region.proj); fprintf(fp, "xllcenter %s\n", buf); G_format_northing(region.south + cellsize / 2., buf, region.proj); fprintf(fp, "yllcenter %s\n", buf); } } else { /* yes, lat/long */ fprintf(fp, "xllcorner %f\n", region.west); fprintf(fp, "yllcorner %f\n", region.south); } fprintf(fp, "cellsize %f\n", cellsize); fprintf(fp, "NODATA_value %s\n", null_str); } for (row = 0; row < nrows; row++) { G_percent(row, nrows, 2); Rast_get_row(fd, raster, row, out_type); /* Rast_get_null_value_row(fd, null_row, row); */ for (col = 0, ptr = raster; col < ncols; col++, ptr = G_incr_void_ptr(ptr, Rast_cell_size(out_type))) { if (!Rast_is_null_value(ptr, out_type)) { if (out_type == CELL_TYPE) fprintf(fp, "%d", *((CELL *) ptr)); else if (out_type == FCELL_TYPE) { sprintf(cell_buf, "%.*f", dp, *((FCELL *) ptr)); G_trim_decimal(cell_buf); fprintf(fp, "%s", cell_buf); } else if (out_type == DCELL_TYPE) { sprintf(cell_buf, "%.*f", dp, *((DCELL *) ptr)); G_trim_decimal(cell_buf); fprintf(fp, "%s", cell_buf); } } else fprintf(fp, "%s", null_str); if (!flag.singleline->answer) fprintf(fp, " "); else fprintf(fp, "\n"); } if (!flag.singleline->answer) fprintf(fp, "\n"); /* for (col = 0; col < ncols; col++) fprintf (fp,"%d ", null_row[col]); fprintf (fp,"\n"); */ } /* make sure it got to 100% */ G_percent(1, 1, 2); Rast_close(fd); fclose(fp); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { int out_fd, base_raster; char *infile, *outmap; int percent; double zrange_min, zrange_max, d_tmp; double irange_min, irange_max; unsigned long estimated_lines; RASTER_MAP_TYPE rtype, base_raster_data_type; struct History history; char title[64]; SEGMENT base_segment; struct PointBinning point_binning; void *base_array; void *raster_row; struct Cell_head region; struct Cell_head input_region; int rows, last_rows, row0, cols; /* scan box size */ int row; /* counters */ int pass, npasses; unsigned long line, line_total; unsigned int counter; unsigned long n_invalid; char buff[BUFFSIZE]; double x, y, z; double intensity; int arr_row, arr_col; unsigned long count, count_total; int point_class; double zscale = 1.0; double iscale = 1.0; double res = 0.0; struct BinIndex bin_index_nodes; bin_index_nodes.num_nodes = 0; bin_index_nodes.max_nodes = 0; bin_index_nodes.nodes = 0; struct GModule *module; struct Option *input_opt, *output_opt, *percent_opt, *type_opt, *filter_opt, *class_opt; struct Option *method_opt, *base_raster_opt; struct Option *zrange_opt, *zscale_opt; struct Option *irange_opt, *iscale_opt; struct Option *trim_opt, *pth_opt, *res_opt; struct Option *file_list_opt; struct Flag *print_flag, *scan_flag, *shell_style, *over_flag, *extents_flag; struct Flag *intens_flag, *intens_import_flag; struct Flag *set_region_flag; struct Flag *base_rast_res_flag; struct Flag *only_valid_flag; /* LAS */ LASReaderH LAS_reader; LASHeaderH LAS_header; LASSRSH LAS_srs; LASPointH LAS_point; int return_filter; const char *projstr; struct Cell_head cellhd, loc_wind; unsigned int n_filtered; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("import")); G_add_keyword(_("LIDAR")); G_add_keyword(_("statistics")); G_add_keyword(_("conversion")); G_add_keyword(_("aggregation")); G_add_keyword(_("binning")); module->description = _("Creates a raster map from LAS LiDAR points using univariate statistics."); input_opt = G_define_standard_option(G_OPT_F_BIN_INPUT); input_opt->required = NO; input_opt->label = _("LAS input file"); input_opt->description = _("LiDAR input files in LAS format (*.las or *.laz)"); input_opt->guisection = _("Input"); output_opt = G_define_standard_option(G_OPT_R_OUTPUT); output_opt->required = NO; output_opt->guisection = _("Output"); file_list_opt = G_define_standard_option(G_OPT_F_INPUT); file_list_opt->key = "file"; file_list_opt->label = _("File containing names of LAS input files"); file_list_opt->description = _("LiDAR input files in LAS format (*.las or *.laz)"); file_list_opt->required = NO; file_list_opt->guisection = _("Input"); method_opt = G_define_option(); method_opt->key = "method"; method_opt->type = TYPE_STRING; method_opt->required = NO; method_opt->description = _("Statistic to use for raster values"); method_opt->options = "n,min,max,range,sum,mean,stddev,variance,coeff_var,median,percentile,skewness,trimmean"; method_opt->answer = "mean"; method_opt->guisection = _("Statistic"); G_asprintf((char **)&(method_opt->descriptions), "n;%s;" "min;%s;" "max;%s;" "range;%s;" "sum;%s;" "mean;%s;" "stddev;%s;" "variance;%s;" "coeff_var;%s;" "median;%s;" "percentile;%s;" "skewness;%s;" "trimmean;%s", _("Number of points in cell"), _("Minimum value of point values in cell"), _("Maximum value of point values in cell"), _("Range of point values in cell"), _("Sum of point values in cell"), _("Mean (average) value of point values in cell"), _("Standard deviation of point values in cell"), _("Variance of point values in cell"), _("Coefficient of variance of point values in cell"), _("Median value of point values in cell"), _("pth (nth) percentile of point values in cell"), _("Skewness of point values in cell"), _("Trimmed mean of point values in cell")); type_opt = G_define_standard_option(G_OPT_R_TYPE); type_opt->required = NO; type_opt->answer = "FCELL"; base_raster_opt = G_define_standard_option(G_OPT_R_INPUT); base_raster_opt->key = "base_raster"; base_raster_opt->required = NO; base_raster_opt->label = _("Subtract raster values from the Z coordinates"); base_raster_opt->description = _("The scale for Z is applied beforehand, the range filter for" " Z afterwards"); base_raster_opt->guisection = _("Transform"); zrange_opt = G_define_option(); zrange_opt->key = "zrange"; zrange_opt->type = TYPE_DOUBLE; zrange_opt->required = NO; zrange_opt->key_desc = "min,max"; zrange_opt->description = _("Filter range for Z data (min,max)"); zrange_opt->guisection = _("Selection"); zscale_opt = G_define_option(); zscale_opt->key = "zscale"; zscale_opt->type = TYPE_DOUBLE; zscale_opt->required = NO; zscale_opt->answer = "1.0"; zscale_opt->description = _("Scale to apply to Z data"); zscale_opt->guisection = _("Transform"); irange_opt = G_define_option(); irange_opt->key = "intensity_range"; irange_opt->type = TYPE_DOUBLE; irange_opt->required = NO; irange_opt->key_desc = "min,max"; irange_opt->description = _("Filter range for intensity values (min,max)"); irange_opt->guisection = _("Selection"); iscale_opt = G_define_option(); iscale_opt->key = "intensity_scale"; iscale_opt->type = TYPE_DOUBLE; iscale_opt->required = NO; iscale_opt->answer = "1.0"; iscale_opt->description = _("Scale to apply to intensity values"); iscale_opt->guisection = _("Transform"); percent_opt = G_define_option(); percent_opt->key = "percent"; percent_opt->type = TYPE_INTEGER; percent_opt->required = NO; percent_opt->answer = "100"; percent_opt->options = "1-100"; percent_opt->description = _("Percent of map to keep in memory"); /* I would prefer to call the following "percentile", but that has too * much namespace overlap with the "percent" option above */ pth_opt = G_define_option(); pth_opt->key = "pth"; pth_opt->type = TYPE_INTEGER; pth_opt->required = NO; pth_opt->options = "1-100"; pth_opt->description = _("pth percentile of the values"); pth_opt->guisection = _("Statistic"); trim_opt = G_define_option(); trim_opt->key = "trim"; trim_opt->type = TYPE_DOUBLE; trim_opt->required = NO; trim_opt->options = "0-50"; trim_opt->label = _("Discard given percentage of the smallest and largest values"); trim_opt->description = _("Discard <trim> percent of the smallest and <trim> percent of the largest observations"); trim_opt->guisection = _("Statistic"); res_opt = G_define_option(); res_opt->key = "resolution"; res_opt->type = TYPE_DOUBLE; res_opt->required = NO; res_opt->description = _("Output raster resolution"); res_opt->guisection = _("Output"); filter_opt = G_define_option(); filter_opt->key = "return_filter"; filter_opt->type = TYPE_STRING; filter_opt->required = NO; filter_opt->label = _("Only import points of selected return type"); filter_opt->description = _("If not specified, all points are imported"); filter_opt->options = "first,last,mid"; filter_opt->guisection = _("Selection"); class_opt = G_define_option(); class_opt->key = "class_filter"; class_opt->type = TYPE_INTEGER; class_opt->multiple = YES; class_opt->required = NO; class_opt->label = _("Only import points of selected class(es)"); class_opt->description = _("Input is comma separated integers. " "If not specified, all points are imported."); class_opt->guisection = _("Selection"); print_flag = G_define_flag(); print_flag->key = 'p'; print_flag->description = _("Print LAS file info and exit"); extents_flag = G_define_flag(); extents_flag->key = 'e'; extents_flag->label = _("Use the extent of the input for the raster extent"); extents_flag->description = _("Set internally computational region extents based on the" " point cloud"); extents_flag->guisection = _("Output"); set_region_flag = G_define_flag(); set_region_flag->key = 'n'; set_region_flag->label = _("Set computation region to match the new raster map"); set_region_flag->description = _("Set computation region to match the 2D extent and resolution" " of the newly created new raster map"); set_region_flag->guisection = _("Output"); over_flag = G_define_flag(); over_flag->key = 'o'; over_flag->label = _("Override projection check (use current location's projection)"); over_flag->description = _("Assume that the dataset has same projection as the current location"); scan_flag = G_define_flag(); scan_flag->key = 's'; scan_flag->description = _("Scan data file for extent then exit"); shell_style = G_define_flag(); shell_style->key = 'g'; shell_style->description = _("In scan mode, print using shell script style"); intens_flag = G_define_flag(); intens_flag->key = 'i'; intens_flag->label = _("Use intensity values rather than Z values"); intens_flag->description = _("Uses intensity values everywhere as if they would be Z" " coordinates"); intens_import_flag = G_define_flag(); intens_import_flag->key = 'j'; intens_import_flag->description = _("Use Z values for filtering, but intensity values for statistics"); base_rast_res_flag = G_define_flag(); base_rast_res_flag->key = 'd'; base_rast_res_flag->label = _("Use base raster resolution instead of computational region"); base_rast_res_flag->description = _("For getting values from base raster, use its actual" " resolution instead of computational region resolution"); only_valid_flag = G_define_flag(); only_valid_flag->key = 'v'; only_valid_flag->label = _("Use only valid points"); only_valid_flag->description = _("Points invalid according to APSRS LAS specification will be" " filtered out"); only_valid_flag->guisection = _("Selection"); G_option_required(input_opt, file_list_opt, NULL); G_option_exclusive(input_opt, file_list_opt, NULL); G_option_required(output_opt, print_flag, scan_flag, shell_style, NULL); G_option_exclusive(intens_flag, intens_import_flag, NULL); G_option_requires(base_rast_res_flag, base_raster_opt, NULL); if (G_parser(argc, argv)) exit(EXIT_FAILURE); int only_valid = FALSE; n_invalid = 0; if (only_valid_flag->answer) only_valid = TRUE; /* we could use rules but this gives more info and allows continuing */ if (set_region_flag->answer && !(extents_flag->answer || res_opt->answer)) { G_warning(_("Flag %c makes sense only with %s option or -%c flag"), set_region_flag->key, res_opt->key, extents_flag->key); /* avoid the call later on */ set_region_flag->answer = '\0'; } struct StringList infiles; if (file_list_opt->answer) { if (access(file_list_opt->answer, F_OK) != 0) G_fatal_error(_("File <%s> does not exist"), file_list_opt->answer); string_list_from_file(&infiles, file_list_opt->answer); } else { string_list_from_one_item(&infiles, input_opt->answer); } /* parse input values */ outmap = output_opt->answer; if (shell_style->answer && !scan_flag->answer) { scan_flag->answer = 1; /* pointer not int, so set = shell_style->answer ? */ } /* check zrange and extent relation */ if (scan_flag->answer || extents_flag->answer) { if (zrange_opt->answer) G_warning(_("zrange will not be taken into account during scan")); } Rast_get_window(®ion); /* G_get_window seems to be unreliable if the location has been changed */ G_get_set_window(&loc_wind); /* TODO: v.in.lidar uses G_get_default_window() */ estimated_lines = 0; int i; for (i = 0; i < infiles.num_items; i++) { infile = infiles.items[i]; /* don't if file not found */ if (access(infile, F_OK) != 0) G_fatal_error(_("Input file <%s> does not exist"), infile); /* Open LAS file*/ LAS_reader = LASReader_Create(infile); if (LAS_reader == NULL) G_fatal_error(_("Unable to open file <%s> as a LiDAR point cloud"), infile); LAS_header = LASReader_GetHeader(LAS_reader); if (LAS_header == NULL) { G_fatal_error(_("Unable to read LAS header of <%s>"), infile); } LAS_srs = LASHeader_GetSRS(LAS_header); /* print info or check projection if we are actually importing */ if (print_flag->answer) { /* print filename when there is more than one file */ if (infiles.num_items > 1) fprintf(stdout, "File: %s\n", infile); /* Print LAS header */ print_lasinfo(LAS_header, LAS_srs); } else { /* report that we are checking more files */ if (i == 1) G_message(_("First file's projection checked," " checking projection of the other files...")); /* Fetch input map projection in GRASS form. */ projstr = LASSRS_GetWKT_CompoundOK(LAS_srs); /* we are printing the non-warning messages only for first file */ projection_check_wkt(cellhd, loc_wind, projstr, over_flag->answer, shell_style->answer || i); /* if there is a problem in some other file, first OK message * is printed but than a warning, this is not ideal but hopefully * not so confusing when importing multiple files */ } if (scan_flag->answer || extents_flag->answer) { /* we assign to the first one (i==0) but update for the rest */ scan_bounds(LAS_reader, shell_style->answer, extents_flag->answer, i, zscale, ®ion); } /* number of estimated point across all files */ /* TODO: this should be ull which won't work with percent report */ estimated_lines += LASHeader_GetPointRecordsCount(LAS_header); /* We are closing all again and we will be opening them later, * so we don't have to worry about limit for open files. */ LASSRS_Destroy(LAS_srs); LASHeader_Destroy(LAS_header); LASReader_Destroy(LAS_reader); } /* if we are not importing, end */ if (print_flag->answer || scan_flag->answer) exit(EXIT_SUCCESS); return_filter = LAS_ALL; if (filter_opt->answer) { if (strcmp(filter_opt->answer, "first") == 0) return_filter = LAS_FIRST; else if (strcmp(filter_opt->answer, "last") == 0) return_filter = LAS_LAST; else if (strcmp(filter_opt->answer, "mid") == 0) return_filter = LAS_MID; else G_fatal_error(_("Unknown filter option <%s>"), filter_opt->answer); } struct ReturnFilter return_filter_struct; return_filter_struct.filter = return_filter; struct ClassFilter class_filter; class_filter_create_from_strings(&class_filter, class_opt->answers); percent = atoi(percent_opt->answer); /* TODO: we already used zscale */ /* TODO: we don't report intensity range */ if (zscale_opt->answer) zscale = atof(zscale_opt->answer); if (iscale_opt->answer) iscale = atof(iscale_opt->answer); /* parse zrange */ if (zrange_opt->answer != NULL) { if (zrange_opt->answers[0] == NULL) G_fatal_error(_("Invalid zrange")); sscanf(zrange_opt->answers[0], "%lf", &zrange_min); sscanf(zrange_opt->answers[1], "%lf", &zrange_max); if (zrange_min > zrange_max) { d_tmp = zrange_max; zrange_max = zrange_min; zrange_min = d_tmp; } } /* parse irange */ if (irange_opt->answer != NULL) { if (irange_opt->answers[0] == NULL) G_fatal_error(_("Invalid %s"), irange_opt->key); sscanf(irange_opt->answers[0], "%lf", &irange_min); sscanf(irange_opt->answers[1], "%lf", &irange_max); if (irange_min > irange_max) { d_tmp = irange_max; irange_max = irange_min; irange_min = d_tmp; } } point_binning_set(&point_binning, method_opt->answer, pth_opt->answer, trim_opt->answer, FALSE); base_array = NULL; if (strcmp("CELL", type_opt->answer) == 0) rtype = CELL_TYPE; else if (strcmp("DCELL", type_opt->answer) == 0) rtype = DCELL_TYPE; else rtype = FCELL_TYPE; if (point_binning.method == METHOD_N) rtype = CELL_TYPE; if (res_opt->answer) { /* align to resolution */ res = atof(res_opt->answer); if (!G_scan_resolution(res_opt->answer, &res, region.proj)) G_fatal_error(_("Invalid input <%s=%s>"), res_opt->key, res_opt->answer); if (res <= 0) G_fatal_error(_("Option '%s' must be > 0.0"), res_opt->key); region.ns_res = region.ew_res = res; region.north = ceil(region.north / res) * res; region.south = floor(region.south / res) * res; region.east = ceil(region.east / res) * res; region.west = floor(region.west / res) * res; G_adjust_Cell_head(®ion, 0, 0); } else if (extents_flag->answer) { /* align to current region */ Rast_align_window(®ion, &loc_wind); } Rast_set_output_window(®ion); rows = last_rows = region.rows; npasses = 1; if (percent < 100) { rows = (int)(region.rows * (percent / 100.0)); npasses = region.rows / rows; last_rows = region.rows - npasses * rows; if (last_rows) npasses++; else last_rows = rows; } cols = region.cols; G_debug(2, "region.n=%f region.s=%f region.ns_res=%f", region.north, region.south, region.ns_res); G_debug(2, "region.rows=%d [box_rows=%d] region.cols=%d", region.rows, rows, region.cols); /* using row-based chunks (used for output) when input and output * region matches and using segment library when they don't */ int use_segment = 0; int use_base_raster_res = 0; /* TODO: see if the input region extent is smaller than the raster * if yes, the we need to load the whole base raster if the -e * flag was defined (alternatively clip the regions) */ if (base_rast_res_flag->answer) use_base_raster_res = 1; if (base_raster_opt->answer && (res_opt->answer || use_base_raster_res || extents_flag->answer)) use_segment = 1; if (base_raster_opt->answer && !use_segment) { /* TODO: do we need to test existence first? mapset? */ base_raster = Rast_open_old(base_raster_opt->answer, ""); base_raster_data_type = Rast_get_map_type(base_raster); base_array = G_calloc((size_t)rows * (cols + 1), Rast_cell_size(base_raster_data_type)); } if (base_raster_opt->answer && use_segment) { if (use_base_raster_res) { /* read raster actual extent and resolution */ Rast_get_cellhd(base_raster_opt->answer, "", &input_region); /* TODO: make it only as small as the output is or points are */ Rast_set_input_window(&input_region); /* we have split window */ } else { Rast_get_input_window(&input_region); } rast_segment_open(&base_segment, base_raster_opt->answer, &base_raster_data_type); } if (!scan_flag->answer) { if (!check_rows_cols_fit_to_size_t(rows, cols)) G_fatal_error(_("Unable to process the hole map at once. " "Please set the '%s' option to some value lower than 100."), percent_opt->key); point_binning_memory_test(&point_binning, rows, cols, rtype); } /* open output map */ out_fd = Rast_open_new(outmap, rtype); /* allocate memory for a single row of output data */ raster_row = Rast_allocate_output_buf(rtype); G_message(_("Reading data ...")); count_total = line_total = 0; /* main binning loop(s) */ for (pass = 1; pass <= npasses; pass++) { if (npasses > 1) G_message(_("Pass #%d (of %d) ..."), pass, npasses); /* figure out segmentation */ row0 = (pass - 1) * rows; if (pass == npasses) { rows = last_rows; } if (base_array) { G_debug(2, "filling base raster array"); for (row = 0; row < rows; row++) { Rast_get_row(base_raster, base_array + ((size_t) row * cols * Rast_cell_size(base_raster_data_type)), row, base_raster_data_type); } } G_debug(2, "pass=%d/%d rows=%d", pass, npasses, rows); point_binning_allocate(&point_binning, rows, cols, rtype); line = 0; count = 0; counter = 0; G_percent_reset(); /* loop of input files */ for (i = 0; i < infiles.num_items; i++) { infile = infiles.items[i]; /* we already know file is there, so just do basic checks */ LAS_reader = LASReader_Create(infile); if (LAS_reader == NULL) G_fatal_error(_("Unable to open file <%s>"), infile); while ((LAS_point = LASReader_GetNextPoint(LAS_reader)) != NULL) { line++; counter++; if (counter == 100000) { /* speed */ if (line < estimated_lines) G_percent(line, estimated_lines, 3); counter = 0; } /* We always count them and report because behavior * changed in between 7.0 and 7.2 from undefined (but skipping * invalid points) to filtering them out only when requested. */ if (!LASPoint_IsValid(LAS_point)) { n_invalid++; if (only_valid) continue; } x = LASPoint_GetX(LAS_point); y = LASPoint_GetY(LAS_point); if (intens_flag->answer) /* use intensity as z here to allow all filters (and * modifications) below to be applied for intensity */ z = LASPoint_GetIntensity(LAS_point); else z = LASPoint_GetZ(LAS_point); int return_n = LASPoint_GetReturnNumber(LAS_point); int n_returns = LASPoint_GetNumberOfReturns(LAS_point); if (return_filter_is_out(&return_filter_struct, return_n, n_returns)) { n_filtered++; continue; } point_class = (int) LASPoint_GetClassification(LAS_point); if (class_filter_is_out(&class_filter, point_class)) continue; if (y <= region.south || y > region.north) { continue; } if (x < region.west || x >= region.east) { continue; } /* find the bin in the current array box */ arr_row = (int)((region.north - y) / region.ns_res) - row0; if (arr_row < 0 || arr_row >= rows) continue; arr_col = (int)((x - region.west) / region.ew_res); z = z * zscale; if (base_array) { double base_z; if (row_array_get_value_row_col(base_array, arr_row, arr_col, cols, base_raster_data_type, &base_z)) z -= base_z; else continue; } else if (use_segment) { double base_z; if (rast_segment_get_value_xy(&base_segment, &input_region, base_raster_data_type, x, y, &base_z)) z -= base_z; else continue; } if (zrange_opt->answer) { if (z < zrange_min || z > zrange_max) { continue; } } if (intens_import_flag->answer || irange_opt->answer) { intensity = LASPoint_GetIntensity(LAS_point); intensity *= iscale; if (irange_opt->answer) { if (intensity < irange_min || intensity > irange_max) { continue; } } /* use intensity for statistics */ if (intens_import_flag->answer) z = intensity; } count++; /* G_debug(5, "x: %f, y: %f, z: %f", x, y, z); */ update_value(&point_binning, &bin_index_nodes, cols, arr_row, arr_col, rtype, x, y, z); } /* while !EOF of one input file */ /* close input LAS file */ LASReader_Destroy(LAS_reader); } /* end of loop for all input files files */ G_percent(1, 1, 1); /* flush */ G_debug(2, "pass %d finished, %lu coordinates in box", pass, count); count_total += count; line_total += line; /* calc stats and output */ G_message(_("Writing to map ...")); for (row = 0; row < rows; row++) { /* potentially vector writing can be independent on the binning */ write_values(&point_binning, &bin_index_nodes, raster_row, row, cols, rtype, NULL); /* write out line of raster data */ Rast_put_row(out_fd, raster_row, rtype); } /* free memory */ point_binning_free(&point_binning, &bin_index_nodes); } /* passes loop */ if (base_array) Rast_close(base_raster); if (use_segment) Segment_close(&base_segment); G_percent(1, 1, 1); /* flush */ G_free(raster_row); /* close raster file & write history */ Rast_close(out_fd); sprintf(title, "Raw X,Y,Z data binned into a raster grid by cell %s", method_opt->answer); Rast_put_cell_title(outmap, title); Rast_short_history(outmap, "raster", &history); Rast_command_history(&history); Rast_set_history(&history, HIST_DATSRC_1, infile); Rast_write_history(outmap, &history); /* set computation region to the new raster map */ /* TODO: should be in the done message */ if (set_region_flag->answer) G_put_window(®ion); if (n_invalid && only_valid) G_message(_("%lu input points were invalid and filtered out"), n_invalid); if (n_invalid && !only_valid) G_message(_("%lu input points were invalid, use -%c flag to filter" " them out"), n_invalid, only_valid_flag->key); if (infiles.num_items > 1) { sprintf(buff, _("Raster map <%s> created." " %lu points from %d files found in region."), outmap, count_total, infiles.num_items); } else { sprintf(buff, _("Raster map <%s> created." " %lu points found in region."), outmap, count_total); } G_done_msg("%s", buff); G_debug(1, "Processed %lu points.", line_total); string_list_free(&infiles); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { struct GModule *module; struct Option *group_opt, *xc_opt, *yc_opt, *zc_opt, *xcsd_opt, *ycsd_opt, *zcsd_opt, *omega_opt, *phi_opt, *kappa_opt, *omegasd_opt, *phisd_opt, *kappasd_opt; struct Flag *use_flag, *print_flag; struct Ortho_Image_Group group; struct Ortho_Camera_Exp_Init *init_info; double deg2rad, rad2deg; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("imagery")); G_add_keyword(_("orthorectify")); module->description = _("Interactively creates or modifies entries in a camera " "initial exposure station file for imagery group referenced " "by a sub-block."); group_opt = G_define_standard_option(G_OPT_I_GROUP); group_opt->required = YES; group_opt->description = _("Name of imagery group for ortho-rectification"); xc_opt = G_define_option(); xc_opt->key = "xc"; xc_opt->type = TYPE_DOUBLE; xc_opt->description = _("Initial Camera Exposure X-coordinate"); yc_opt = G_define_option(); yc_opt->key = "yc"; yc_opt->type = TYPE_DOUBLE; yc_opt->description = _("Initial Camera Exposure Y-coordinate"); zc_opt = G_define_option(); zc_opt->key = "zc"; zc_opt->type = TYPE_DOUBLE; zc_opt->description = _("Initial Camera Exposure Z-coordinate"); xcsd_opt = G_define_option(); xcsd_opt->key = "xc_sd"; xcsd_opt->type = TYPE_DOUBLE; xcsd_opt->description = _("X-coordinate standard deviation"); ycsd_opt = G_define_option(); ycsd_opt->key = "yc_sd"; ycsd_opt->type = TYPE_DOUBLE; ycsd_opt->description = _("Y-coordinate standard deviation"); zcsd_opt = G_define_option(); zcsd_opt->key = "zc_sd"; zcsd_opt->type = TYPE_DOUBLE; zcsd_opt->description = _("Z-coordinate standard deviation"); omega_opt = G_define_option(); omega_opt->key = "omega"; omega_opt->type = TYPE_DOUBLE; omega_opt->description = _("Initial Camera Omega (roll) degrees"); phi_opt = G_define_option(); phi_opt->key = "omega"; phi_opt->type = TYPE_DOUBLE; phi_opt->description = _("Initial Camera Phi (pitch) degrees"); kappa_opt = G_define_option(); kappa_opt->key = "omega"; kappa_opt->type = TYPE_DOUBLE; kappa_opt->description = _("Initial Camera Kappa (yaw) degrees"); omegasd_opt = G_define_option(); omegasd_opt->key = "omega"; omegasd_opt->type = TYPE_DOUBLE; omegasd_opt->description = _("Omega (roll) standard deviation"); phisd_opt = G_define_option(); phisd_opt->key = "omega"; phisd_opt->type = TYPE_DOUBLE; phisd_opt->description = _("Phi (pitch) standard deviation"); kappasd_opt = G_define_option(); kappasd_opt->key = "omega"; kappasd_opt->type = TYPE_DOUBLE; kappasd_opt->description = _("Kappa (yaw) standard deviation"); use_flag = G_define_flag(); use_flag->key = 'r'; use_flag->description = _("Use initial values at run time"); print_flag = G_define_flag(); print_flag->key = 'p'; print_flag->description = _("Print initial values"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); deg2rad = M_PI / 180.; rad2deg = 180. / M_PI; /* get group ref */ strcpy(group.name, group_opt->answer); if (!I_find_group(group.name)) { G_fatal_error(_("Group [%s] not found"), group.name); } G_debug(1, "Found group %s", group.name); /* get initial camera exposure info */ if (I_find_initial(group.name)) { I_get_init_info(group.name, &group.camera_exp); } else { /* create new initial camera exposure info */ /* all values must be given */ if (!xc_opt->answer) { G_fatal_error(_("Option '%s' is required for new exposure info"), xc_opt->key); } if (!yc_opt->answer) { G_fatal_error(_("Option '%s' is required for new exposure info"), yc_opt->key); } if (!zc_opt->answer) { G_fatal_error(_("Option '%s' is required for new exposure info"), zc_opt->key); } if (!xcsd_opt->answer) { G_fatal_error(_("Option '%s' is required for new exposure info"), xcsd_opt->key); } if (!ycsd_opt->answer) { G_fatal_error(_("Option '%s' is required for new exposure info"), ycsd_opt->key); } if (!zcsd_opt->answer) { G_fatal_error(_("Option '%s' is required for new exposure info"), zcsd_opt->key); } if (!omega_opt->answer) { G_fatal_error(_("Option '%s' is required for new exposure info"), omega_opt->key); } if (!phi_opt->answer) { G_fatal_error(_("Option '%s' is required for new exposure info"), phi_opt->key); } if (!kappa_opt->answer) { G_fatal_error(_("Option '%s' is required for new exposure info"), kappa_opt->key); } if (!omegasd_opt->answer) { G_fatal_error(_("Option '%s' is required for new exposure info"), omegasd_opt->key); } if (!phisd_opt->answer) { G_fatal_error(_("Option '%s' is required for new exposure info"), phisd_opt->key); } if (!kappasd_opt->answer) { G_fatal_error(_("Option '%s' is required for new exposure info"), kappasd_opt->key); } } /* modify info */ init_info = &group.camera_exp; if (xc_opt->answer) { init_info->XC_init = atof(xc_opt->answer); } if (yc_opt->answer) { init_info->YC_init = atof(yc_opt->answer); } if (zc_opt->answer) { init_info->ZC_init = atof(zc_opt->answer); } if (xcsd_opt->answer) { init_info->XC_var = atof(xcsd_opt->answer); } if (ycsd_opt->answer) { init_info->YC_var = atof(ycsd_opt->answer); } if (zcsd_opt->answer) { init_info->ZC_var = atof(zcsd_opt->answer); } if (omega_opt->answer) { init_info->omega_init = atof(omega_opt->answer) * deg2rad; } if (phi_opt->answer) { init_info->phi_init = atof(phi_opt->answer) * deg2rad; } if (kappa_opt->answer) { init_info->kappa_init = atof(kappa_opt->answer) * deg2rad; } if (omegasd_opt->answer) { init_info->omega_var = atof(omegasd_opt->answer) * deg2rad; } if (phisd_opt->answer) { init_info->phi_var = atof(phisd_opt->answer) * deg2rad; } if (kappasd_opt->answer) { init_info->kappa_var = atof(kappasd_opt->answer) * deg2rad; } init_info->status = use_flag->answer != 0; if (print_flag->answer) { /* do not translate, scripts might want to parse the output */ fprintf(stdout, "xc=%.17g\n", init_info->XC_init); fprintf(stdout, "yc=%.17g\n", init_info->YC_init); fprintf(stdout, "zc=%.17g\n", init_info->ZC_init); fprintf(stdout, "xc_sd=%.17g\n", init_info->XC_var); fprintf(stdout, "yc_sd=%.17g\n", init_info->YC_var); fprintf(stdout, "zc_sd=%.17g\n", init_info->ZC_var); fprintf(stdout, "omega=%.17g\n", init_info->omega_init * rad2deg); fprintf(stdout, "phi=%.17g\n", init_info->phi_init * rad2deg); fprintf(stdout, "kappa=%.17g\n", init_info->kappa_init * rad2deg); fprintf(stdout, "omega_sd=%.17g\n", init_info->omega_var * rad2deg); fprintf(stdout, "phi_sd=%.17g\n", init_info->phi_var * rad2deg); fprintf(stdout, "kappa_sd=%.17g\n", init_info->kappa_var * rad2deg); fprintf(stdout, "use=%d", init_info->status); } /* save info */ I_put_init_info(group.name, &group.camera_exp); exit(EXIT_SUCCESS); }
void user_input(int argc, char **argv) { int i; /* setup the GRASS parsing routine structures to be used to read in the user's parameter choices */ struct Flag *units; struct Flag *zscore; struct Flag *edgemap; struct Option *name; struct Option *sampling_method; struct Option *region; struct Option *att; struct Option *diversity; struct Option *measure_code; struct Option *method_code; struct Option *juxtaposition; struct Option *edge; /* use the GRASS parsing routines to read in the user's parameter choices */ edgemap = G_define_flag(); edgemap->key = 'e'; edgemap->description = "Output map 'edge' of edges given a '1' in r.le.para/edge file"; units = G_define_flag(); units->key = 'u'; units->description = "Output maps 'units_x' with sampling units for each scale x "; zscore = G_define_flag(); zscore->key = 'z'; zscore->description = "Output map 'zscores' with standardized scores"; 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; sampling_method = G_define_option(); sampling_method->answer = "w"; sampling_method->key = "sam"; sampling_method->description = "Sampling method (choose only 1 method):\n" "\tw = whole map u = units m = moving window r = regions"; sampling_method->type = TYPE_STRING; sampling_method->multiple = NO; sampling_method->required = NO; region = G_define_option(); region->key = "reg"; region->description = "Name of regions map, only when sam = r; omit otherwise"; region->type = TYPE_STRING; region->gisprompt = "old,cell,raster"; region->required = NO; att = G_define_option(); att->key = "att"; att->description = "b1 = mn. pixel att. b2 = s.d. pixel att.\n" "\tb3 = min. pixel att. b4 = max. pixel att."; att->options = "b1,b2,b3,b4"; att->type = TYPE_STRING; att->multiple = YES; att->required = NO; diversity = G_define_option(); diversity->key = "div"; diversity->description = "d1 = richness d2 = Shannon d3 = dominance d4 = inv. Simpson"; diversity->options = "d1,d2,d3,d4"; diversity->type = TYPE_STRING; diversity->multiple = YES; diversity->required = NO; method_code = G_define_option(); method_code->key = "te1"; method_code->description = "Texture method (choose only 1 method):\n" "\tm1 = 2N-H m2 = 2N-45 m3 = 2N-V m4 = 2N-135\n" "\tm5 = 4N-HV m6 = 4N-DIAG m7 = 8N"; method_code->options = "m1,m2,m3,m4,m5,m6,m7"; method_code->type = TYPE_STRING; method_code->multiple = NO; method_code->required = NO; measure_code = G_define_option(); measure_code->key = "te2"; measure_code->description = "Texture measures (required if te1 was specified):\n" "\tt1 = contagion t2 = ang. sec. mom. t3 = inv. diff. mom.\n" "\tt4 = entropy t5 = contrast"; measure_code->options = "t1,t2,t3,t4,t5"; measure_code->type = TYPE_STRING; measure_code->multiple = YES; measure_code->required = NO; juxtaposition = G_define_option(); juxtaposition->key = "jux"; juxtaposition->description = "Juxtaposition measures (weight file in r.le.para needed):\n" "\tj1 = mn. juxtaposition j2 = s.d. juxtaposition"; juxtaposition->options = "j1,j2"; juxtaposition->type = TYPE_STRING; juxtaposition->multiple = YES; juxtaposition->required = NO; edge = G_define_option(); edge->key = "edg"; edge->description = "e1 = sum of edges e2 = sum of edges by type (need edge file: r.le.para)"; edge->options = "e1,e2"; edge->type = TYPE_STRING; edge->multiple = YES; edge->required = NO; if (G_parser(argc, argv)) exit(EXIT_FAILURE); /* record the user inputs for map, sam, run, and out parameters */ G_strcpy(choice->fn, name->answer); choice->wrum = sampling_method->answer[0]; /* check for unacceptable values for input parameters */ if (strcmp(sampling_method->answer, "w") && strcmp(sampling_method->answer, "u") && strcmp(sampling_method->answer, "m") && strcmp(sampling_method->answer, "r")) { fprintf(stdout, "\n"); fprintf(stdout, " ***************************************************\n"); fprintf(stdout, " You input an unacceptable value for parameter sam \n"); fprintf(stdout, " ***************************************************\n"); exit(EXIT_FAILURE); } /* check for multiple values for te1 */ if (method_code->answer) if (method_code->answers[1]) { fprintf(stdout, "\n"); fprintf(stdout, " **********************************************\n"); fprintf(stdout, " You input multiple values for parameter te1, \n"); fprintf(stdout, " but only one is allowed \n"); fprintf(stdout, " **********************************************\n"); exit(EXIT_FAILURE); } /* if the -u flag is specified, then set the choice->units flag to 1 */ choice->units = 0; if (!strcmp(sampling_method->answer, "u") && units->answer) choice->units = 1; else if (strcmp(sampling_method->answer, "u") && units->answer) { fprintf(stdout, "\n"); fprintf(stdout, " ***************************************************\n"); fprintf(stdout, " You requested output of map 'units' with sampling \n"); fprintf(stdout, " units, by using flag -u, but this option is only \n"); fprintf(stdout, " available when sam=u \n"); fprintf(stdout, " ***************************************************\n"); exit(EXIT_FAILURE); } /* if sampling_method is by REGION get region file name. Check to see that the name was input */ if (!strcmp(sampling_method->answer, "r")) { if (region->answer) G_strcpy(choice->reg, region->answer); else { fprintf(stdout, "\n"); fprintf(stdout, " ***********************************************\n"); fprintf(stdout, " You requested sampling by region, but did not \n"); fprintf(stdout, " input the name of the region using the reg= \n"); fprintf(stdout, " parameter \n"); fprintf(stdout, " ***********************************************\n"); exit(EXIT_FAILURE); } } if (region->answer) if (strcmp(sampling_method->answer, "r")) { fprintf(stdout, "\n"); fprintf(stdout, " ***********************************************\n"); fprintf(stdout, " You requested sampling by region, by using \n"); fprintf(stdout, " the reg= parameter, but did not input the \n"); fprintf(stdout, " sam=r parameter \n"); fprintf(stdout, " ***********************************************\n"); exit(EXIT_FAILURE); } /* initialize flag arrays in choice data structure. */ for (i = 0; i < 5; i++) choice->att[i] = 0; for (i = 0; i < 5; i++) choice->div[i] = 0; for (i = 0; i < 6; i++) choice->te2[i] = 0; for (i = 0; i < 3; i++) choice->jux[i] = 0; for (i = 0; i < 3; i++) choice->edg[i] = 0; /* fill measure_code and method code arrays */ if (att->answer) { choice->att[0] = 1; for (i = 0; att->answers[i] != NULL; i++) { if (!strcmp(att->answers[i], "b1")) choice->att[1] = 1; else if (!strcmp(att->answers[i], "b2")) choice->att[2] = 1; else if (!strcmp(att->answers[i], "b3")) choice->att[3] = 1; else if (!strcmp(att->answers[i], "b4")) choice->att[4] = 1; } } if (edgemap->answer && choice->wrum == 'w') { choice->edgemap = edgemap->answer; choice->edg[0] = 1; choice->edg[2] = 1; } else if (edgemap->answer && choice->wrum != 'w') { fprintf(stdout, "\n"); fprintf(stdout, " ****************************************************\n"); fprintf(stdout, " An edge map (flag is -e) is not available unless \n"); fprintf(stdout, " sam=w \n"); fprintf(stdout, " ****************************************************\n"); exit(EXIT_FAILURE); } if (zscore->answer && choice->wrum == 'w') { choice->z = zscore->answer; choice->att[0] = 1; choice->att[1] = 1; choice->att[2] = 1; } else if (zscore->answer && choice->wrum != 'w') { fprintf(stdout, "\n"); fprintf(stdout, " ****************************************************\n"); fprintf(stdout, " A zscores map (flag is -z) is not available unless \n"); fprintf(stdout, " sam=w \n"); fprintf(stdout, " ****************************************************\n"); exit(EXIT_FAILURE); } if (diversity->answer) { choice->div[0] = 1; for (i = 0; diversity->answers[i] != NULL; i++) { if (!strcmp(diversity->answers[i], "d1")) choice->div[1] = 1; else if (!strcmp(diversity->answers[i], "d2")) choice->div[2] = 1; else if (!strcmp(diversity->answers[i], "d3")) choice->div[3] = 1; else if (!strcmp(diversity->answers[i], "d4")) choice->div[4] = 1; } } choice->tex = 0; if (measure_code->answer || method_code->answer) { if (measure_code->answer && method_code->answer) { choice->te2[0] = 1; for (i = 0; measure_code->answers[i] != NULL; i++) { if (!strcmp(measure_code->answers[i], "t1")) choice->te2[1] = 1; else if (!strcmp(measure_code->answers[i], "t2")) choice->te2[2] = 1; else if (!strcmp(measure_code->answers[i], "t3")) choice->te2[3] = 1; else if (!strcmp(measure_code->answers[i], "t4")) choice->te2[4] = 1; else if (!strcmp(measure_code->answers[i], "t5")) choice->te2[5] = 1; } if (!strcmp(method_code->answer, "m1")) choice->tex = 1; else if (!strcmp(method_code->answer, "m2")) choice->tex = 2; else if (!strcmp(method_code->answer, "m3")) choice->tex = 3; else if (!strcmp(method_code->answer, "m4")) choice->tex = 4; else if (!strcmp(method_code->answer, "m5")) choice->tex = 5; else if (!strcmp(method_code->answer, "m6")) choice->tex = 6; else if (!strcmp(method_code->answer, "m7")) choice->tex = 7; } else { fprintf(stdout, "\n"); fprintf(stdout, " ************************************************\n"); fprintf(stdout, " You requested texture measurement, but did not \n"); fprintf(stdout, " input both parameter te1 and te2 \n"); fprintf(stdout, " ************************************************\n"); exit(EXIT_FAILURE); } } if (juxtaposition->answer) { choice->jux[0] = 1; for (i = 0; juxtaposition->answers[i] != NULL; i++) { if (!strcmp(juxtaposition->answers[i], "j1")) choice->jux[1] = 1; else if (!strcmp(juxtaposition->answers[i], "j2")) choice->jux[2] = 1; } } if (edge->answer) { choice->edg[0] = 1; for (i = 0; edge->answers[i] != NULL; i++) { if (!strcmp(edge->answers[i], "e1")) choice->edg[1] = 1; else if (!strcmp(edge->answers[i], "e2")) choice->edg[2] = 1; } } if (!att->answer && !diversity->answer && !measure_code->answer && !juxtaposition->answer && !edge->answer && !zscore->answer && !edgemap->answer) { fprintf(stdout, "\n"); fprintf(stdout, " **************************************************\n"); fprintf(stdout, " You did not select any measures to be calculated \n"); fprintf(stdout, " **************************************************\n"); exit(EXIT_FAILURE); } return; }
/* ---------------------------------------------------------------------- */ void parse_args(int argc, char *argv[]) { /* input elevation grid */ struct Option *input_elev; input_elev = G_define_standard_option(G_OPT_R_ELEV); /* output filled elevation grid */ struct Option *output_elev; output_elev = G_define_standard_option(G_OPT_R_OUTPUT); output_elev->key = "filled"; output_elev->description= _("Name for output filled (flooded) elevation raster map"); /* output direction grid */ struct Option *output_dir; output_dir = G_define_standard_option(G_OPT_R_OUTPUT); output_dir->key = "direction"; output_dir->description= _("Name for output flow direction raster map"); /* output sinkwatershed grid */ struct Option *output_watershed; output_watershed = G_define_standard_option(G_OPT_R_OUTPUT); output_watershed->key = "swatershed"; output_watershed->description= _("Name for output sink-watershed raster map"); /* output flow accumulation grid */ struct Option *output_accu; output_accu = G_define_standard_option(G_OPT_R_OUTPUT); output_accu->key = "accumulation"; output_accu->description= _("Name for output flow accumulation raster map"); #ifdef OUTPUT_TCI struct Option *output_tci; output_tci = G_define_standard_option(G_OPT_R_OUTPUT); output_tci->key = "tci"; output_tci->description= _("Name for output topographic convergence index (tci) raster map"); #endif /* MFD/SFD flag */ struct Flag *sfd_flag; sfd_flag = G_define_flag() ; sfd_flag->key = 's'; sfd_flag->description= _("SFD (D8) flow (default is MFD)"); /* D8CUT value*/ struct Option *d8cut; d8cut = G_define_option(); d8cut->key = "d8cut"; d8cut->type = TYPE_DOUBLE; d8cut->required = NO; d8cut->answer = G_store("infinity"); /* default value */ d8cut->label = _("Routing using SFD (D8) direction"); d8cut->description = _("If flow accumulation is larger than this value it is routed using " "SFD (D8) direction (meaningfull only for MFD flow)"); /* main memory */ struct Option *mem; mem = G_define_option() ; mem->key = "memory"; mem->type = TYPE_INTEGER; mem->required = NO; mem->answer = G_store("300"); /* 300MB default value */ mem->description = _("Maximum runtime memory size (in MB)"); /* temporary STREAM path */ struct Option *streamdir; streamdir = G_define_option() ; streamdir->key = "stream_dir"; streamdir->type = TYPE_STRING; streamdir->required = NO; #ifdef __MINGW32__ streamdir->answer = G_convert_dirseps_from_host(G_store(getenv("TEMP"))); #else streamdir->answer = G_store("/var/tmp/"); #endif streamdir->description= _("Directory to hold temporary files (they can be large)"); /* stats file */ struct Option *stats_opt; stats_opt = G_define_option() ; stats_opt->key = "stats"; stats_opt->type = TYPE_STRING; stats_opt->required = NO; stats_opt->description= _("Name of file containing runtime statistics"); stats_opt->answer = G_store("stats.out"); if (G_parser(argc, argv)) { exit (EXIT_FAILURE); } /* ************************* */ assert(opt); opt->elev_grid = input_elev->answer; opt->filled_grid = output_elev->answer; opt->dir_grid = output_dir->answer; opt->watershed_grid = output_watershed->answer; opt->flowaccu_grid = output_accu->answer; #ifdef OUTPUT_TCI opt->tci_grid = output_tci->answer; #endif opt->d8 = sfd_flag->answer; if (strcmp(d8cut->answer, "infinity") == 0) { opt->d8cut = MAX_ACCU; } else { opt->d8cut = atof(d8cut->answer); } opt->mem = atoi(mem->answer); opt->streamdir = streamdir->answer; opt->verbose = G_verbose() == G_verbose_max(); opt->stats = stats_opt->answer; /* somebody should delete the options */ }
int main(int argc, char **argv) { unsigned char *hue_n, *hue_r, *hue_g, *hue_b; unsigned char *int_n, *int_r; unsigned char *sat_n, *sat_r; unsigned char *dummy; CELL *r_array, *g_array, *b_array; char *name_h, *name_i, *name_s; int intensity; int saturation; int atrow, atcol; int hue_file; int int_file = 0; int int_used; int sat_file = 0; int sat_used; char *name_r, *name_g, *name_b; int r_file = 0; int r_used; int g_file = 0; int g_used; int b_file = 0; int b_used; struct Cell_head window; struct Colors hue_colors; struct Colors int_colors; struct Colors sat_colors; struct Colors gray_colors; struct History history; struct GModule *module; struct Option *opt_h, *opt_i, *opt_s; struct Option *opt_r, *opt_g, *opt_b; struct Flag *nulldraw; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("color transformation")); G_add_keyword(_("RGB")); G_add_keyword(_("HIS")); module->description = _("Generates red, green and blue raster map layers " "combining hue, intensity and saturation (HIS) " "values from user-specified input raster map layers."); opt_h = G_define_option(); opt_h->key = "h_map"; opt_h->type = TYPE_STRING; opt_h->required = YES; opt_h->gisprompt = "old,cell,raster"; opt_h->description = _("Name of layer to be used for HUE"); opt_i = G_define_option(); opt_i->key = "i_map"; opt_i->type = TYPE_STRING; opt_i->required = NO; opt_i->gisprompt = "old,cell,raster"; opt_i->description = _("Name of layer to be used for INTENSITY"); opt_s = G_define_option(); opt_s->key = "s_map"; opt_s->type = TYPE_STRING; opt_s->required = NO; opt_s->gisprompt = "old,cell,raster"; opt_s->description = _("Name of layer to be used for SATURATION"); opt_r = G_define_option(); opt_r->key = "r_map"; opt_r->type = TYPE_STRING; opt_r->required = YES; opt_r->gisprompt = "new,cell,raster"; opt_r->description = _("Name of output layer to be used for RED"); opt_g = G_define_option(); opt_g->key = "g_map"; opt_g->type = TYPE_STRING; opt_g->required = YES; opt_g->gisprompt = "new,cell,raster"; opt_g->description = _("Name of output layer to be used for GREEN"); opt_b = G_define_option(); opt_b->key = "b_map"; opt_b->type = TYPE_STRING; opt_b->required = YES; opt_b->gisprompt = "new,cell,raster"; opt_b->description = _("Name of output layer to be used for BLUE"); nulldraw = G_define_flag(); nulldraw->key = 'n'; nulldraw->description = _("Respect NULL values while drawing"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); /* read in current window */ G_get_window(&window); /* Get name of layer to be used for hue */ name_h = opt_h->answer; /* Make sure map is available */ hue_file = Rast_open_old(name_h, ""); hue_r = G_malloc(window.cols); hue_g = G_malloc(window.cols); hue_b = G_malloc(window.cols); hue_n = G_malloc(window.cols); dummy = G_malloc(window.cols); /* Reading color lookup table */ if (Rast_read_colors(name_h, "", &hue_colors) == -1) G_fatal_error(_("Color file for <%s> not available"), name_h); int_used = 0; if (opt_i->answer != NULL) { /* Get name of layer to be used for intensity */ name_i = opt_i->answer; int_used = 1; /* Make sure map is available */ int_file = Rast_open_old(name_i, ""); int_r = G_malloc(window.cols); int_n = G_malloc(window.cols); /* Reading color lookup table */ if (Rast_read_colors(name_i, "", &int_colors) == -1) G_fatal_error(_("Color file for <%s> not available"), name_i); } sat_used = 0; if (opt_s->answer != NULL) { /* Get name of layer to be used for saturation */ name_s = opt_s->answer; sat_used = 1; /* Make sure map is available */ sat_file = Rast_open_old(name_s, ""); sat_r = G_malloc(window.cols); sat_n = G_malloc(window.cols); /* Reading color lookup table */ if (Rast_read_colors(name_s, "", &sat_colors) == -1) G_fatal_error(_("Color file for <%s> not available"), name_s); } r_used = 0; if (opt_r->answer != NULL) { name_r = opt_r->answer; r_file = Rast_open_c_new(name_r); r_used = 1; } g_used = 0; if (opt_g->answer != NULL) { name_g = opt_g->answer; g_file = Rast_open_c_new(name_g); g_used = 1; } b_used = 0; if (opt_b->answer != NULL) { name_b = opt_b->answer; b_file = Rast_open_c_new(name_b); b_used = 1; } r_array = Rast_allocate_c_buf(); g_array = Rast_allocate_c_buf(); b_array = Rast_allocate_c_buf(); /* Make color table */ make_gray_scale(&gray_colors); /* Now do the work */ intensity = 255; /* default is to not change intensity */ saturation = 255; /* default is to not change saturation */ for (atrow = 0; atrow < window.rows; atrow++) { G_percent(atrow, window.rows, 2); Rast_get_row_colors(hue_file, atrow, &hue_colors, hue_r, hue_g, hue_b, hue_n); if (int_used) Rast_get_row_colors(int_file, atrow, &int_colors, int_r, dummy, dummy, int_n); if (sat_used) Rast_get_row_colors(sat_file, atrow, &sat_colors, sat_r, dummy, dummy, sat_n); for (atcol = 0; atcol < window.cols; atcol++) { if (nulldraw->answer) { if (hue_n[atcol] || (int_used && int_n[atcol]) || (sat_used && sat_n[atcol])) { Rast_set_c_null_value(&r_array[atcol], 1); Rast_set_c_null_value(&g_array[atcol], 1); Rast_set_c_null_value(&b_array[atcol], 1); continue; } } if (int_used) intensity = int_r[atcol]; if (sat_used) saturation = sat_r[atcol]; HIS_to_RGB(hue_r[atcol], hue_g[atcol], hue_b[atcol], intensity, saturation, &r_array[atcol], &g_array[atcol], &b_array[atcol]); } if (r_used) Rast_put_row(r_file, r_array, CELL_TYPE); if (g_used) Rast_put_row(g_file, g_array, CELL_TYPE); if (b_used) Rast_put_row(b_file, b_array, CELL_TYPE); } G_percent(window.rows, window.rows, 5); /* Close the cell files */ Rast_close(hue_file); if (int_used) Rast_close(int_file); if (sat_used) Rast_close(sat_file); if (r_used) { Rast_close(r_file); Rast_write_colors(name_r, G_mapset(), &gray_colors); Rast_short_history(name_r, "raster", &history); Rast_command_history(&history); Rast_write_history(name_r, &history); Rast_put_cell_title(name_r, "Red extracted from HIS"); } if (g_used) { Rast_close(g_file); Rast_write_colors(name_g, G_mapset(), &gray_colors); Rast_short_history(name_g, "raster", &history); Rast_command_history(&history); Rast_write_history(name_g, &history); Rast_put_cell_title(name_g, "Green extracted from HIS"); } if (b_used) { Rast_close(b_file); Rast_write_colors(name_b, G_mapset(), &gray_colors); Rast_short_history(name_b, "raster", &history); Rast_command_history(&history); Rast_write_history(name_b, &history); Rast_put_cell_title(name_b, "Blue extracted from HIS"); } return EXIT_SUCCESS; }
/* Define the options and flags */ static struct Options define_options(void) { struct Options opts; opts.iimg = G_define_standard_option(G_OPT_R_INPUT); opts.iscl = G_define_option(); opts.iscl->key = "range"; opts.iscl->type = TYPE_INTEGER; opts.iscl->key_desc = "min,max"; opts.iscl->required = NO; opts.iscl->answer = "0,255"; opts.iscl->description = _("Input range"); opts.iscl->guisection = _("Input"); opts.ialt = G_define_standard_option(G_OPT_R_ELEV); opts.ialt->required = NO; opts.ialt->description = _("Name of input elevation raster map (in m)"); opts.ialt->guisection = _("Input"); opts.ivis = G_define_standard_option(G_OPT_R_INPUT); opts.ivis->key = "visibility"; opts.ivis->required = NO; opts.ivis->description = _("Name of input visibility raster map (in km)"); opts.ivis->guisection = _("Input"); opts.icnd = G_define_standard_option(G_OPT_F_INPUT); opts.icnd->key = "parameters"; opts.icnd->required = YES; opts.icnd->description = _("Name of input text file with 6S parameters"); opts.oimg = G_define_standard_option(G_OPT_R_OUTPUT); opts.oscl = G_define_option(); opts.oscl->key = "rescale"; opts.oscl->type = TYPE_INTEGER; opts.oscl->key_desc = "min,max"; opts.oscl->answer = "0,255"; opts.oscl->required = NO; opts.oscl->description = _("Rescale output raster map"); opts.oscl->guisection = _("Output"); opts.oint = G_define_flag(); opts.oint->key = 'i'; opts.oint->description = _("Output raster map as integer"); opts.oint->guisection = _("Output"); opts.irad = G_define_flag(); opts.irad->key = 'r'; opts.irad->description = _("Input raster map converted to reflectance (default is radiance)"); opts.irad->guisection = _("Input"); opts.etmafter = G_define_flag(); opts.etmafter->key = 'a'; opts.etmafter->description = _("Input from ETM+ image taken after July 1, 2000"); opts.etmafter->guisection = _("Input"); opts.etmbefore = G_define_flag(); opts.etmbefore->key = 'b'; opts.etmbefore->description = _("Input from ETM+ image taken before July 1, 2000"); opts.etmbefore->guisection = _("Input"); return opts; }
int main(int argc, char **argv) { struct Cell_head window; RASTER_MAP_TYPE raster_type, mag_raster_type = -1; int layer_fd; void *raster_row, *ptr; int nrows, ncols; int aspect_c = -1; float aspect_f = -1.0; double scale; int skip, no_arrow; char *mag_map = NULL; void *mag_raster_row = NULL, *mag_ptr = NULL; double length = -1; int mag_fd = -1; struct FPRange range; double mag_min, mag_max; struct GModule *module; struct Option *opt1, *opt2, *opt3, *opt4, *opt5, *opt6, *opt7, *opt8, *opt9; struct Flag *align; double t, b, l, r; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("display")); G_add_keyword(_("map annotations")); G_add_keyword(_("raster")); module->description = _("Draws arrows representing cell aspect direction " "for a raster map containing aspect data."); opt1 = G_define_standard_option(G_OPT_R_MAP); opt1->description = _("Name of raster aspect map to be displayed"); opt2 = G_define_option(); opt2->key = "type"; opt2->type = TYPE_STRING; opt2->required = NO; opt2->answer = "grass"; opt2->options = "grass,compass,agnps,answers"; opt2->description = _("Type of existing raster aspect map"); opt3 = G_define_standard_option(G_OPT_C); opt3->key = "color"; opt3->answer = "green"; opt3->label = _("Color for drawing arrows"); opt3->guisection = _("Colors"); opt4 = G_define_standard_option(G_OPT_CN); opt4->key = "grid_color"; opt4->answer = "gray"; opt4->label = _("Color for drawing drawing grid"); opt4->guisection = _("Colors"); opt5 = G_define_standard_option(G_OPT_CN); opt5->key = "null_color"; opt5->answer = DEFAULT_FG_COLOR; opt5->label = _("Color for drawing null values (X symbol)"); opt5->guisection = _("Colors"); opt6 = G_define_standard_option(G_OPT_CN); opt6->key = "unknown_color"; opt6->answer = "red"; opt6->label = _("Color for showing unknown information (? symbol)"); opt6->guisection = _("Colors"); opt9 = G_define_option(); opt9->key = "skip"; opt9->type = TYPE_INTEGER; opt9->required = NO; opt9->answer = "1"; opt9->description = _("Draw arrow every Nth grid cell"); opt7 = G_define_option(); opt7->key = "magnitude_map"; opt7->type = TYPE_STRING; opt7->required = NO; opt7->multiple = NO; opt7->gisprompt = "old,cell,raster"; opt7->description = _("Raster map containing values used for arrow length"); opt8 = G_define_option(); opt8->key = "scale"; opt8->type = TYPE_DOUBLE; opt8->required = NO; opt8->answer = "1.0"; opt8->description = _("Scale factor for arrows (magnitude map)"); align = G_define_flag(); align->key = 'a'; align->description = _("Align grids with raster cells"); /* Check command line */ if (G_parser(argc, argv)) exit(EXIT_FAILURE); layer_name = opt1->answer; arrow_color = D_translate_color(opt3->answer); /* Convert none (transparent) to -1 which in this module means that we will not draw things having this color (-1). We don't do that for arrow because we always want them. (This is specified by the gisprompt ('type') of the options.) */ if (strcmp("none", opt4->answer) == 0) grid_color = -1; else grid_color = D_translate_color(opt4->answer); if (strcmp("none", opt5->answer) == 0) x_color = -1; else x_color = D_translate_color(opt5->answer); if (strcmp("none", opt6->answer) == 0) unknown_color = -1; else unknown_color = D_translate_color(opt6->answer); if (strcmp("grass", opt2->answer) == 0) map_type = 1; else if (strcmp("agnps", opt2->answer) == 0) map_type = 2; else if (strcmp("answers", opt2->answer) == 0) map_type = 3; else if (strcmp("compass", opt2->answer) == 0) map_type = 4; scale = atof(opt8->answer); if (scale <= 0.0) G_fatal_error(_("Illegal value for scale factor")); skip = atoi(opt9->answer); if (skip <= 0) G_fatal_error(_("Illegal value for skip factor")); if (opt7->answer) { if (map_type != 1 && map_type != 4) G_fatal_error(_("Magnitude is only supported for GRASS and compass aspect maps.")); mag_map = opt7->answer; } else if (scale != 1.0) G_warning(_("Scale option requires magnitude_map")); /* Setup driver and check important information */ D_open_driver(); D_setup(0); /* Read in the map window associated with window */ G_get_window(&window); if (align->answer) { struct Cell_head wind; Rast_get_cellhd(layer_name, "", &wind); /* expand window extent by one wind resolution */ wind.west += wind.ew_res * ((int)((window.west - wind.west) / wind.ew_res) - (window.west < wind.west)); wind.east += wind.ew_res * ((int)((window.east - wind.east) / wind.ew_res) + (window.east > wind.east)); wind.south += wind.ns_res * ((int)((window.south - wind.south) / wind.ns_res) - (window.south < wind.south)); wind.north += wind.ns_res * ((int)((window.north - wind.north) / wind.ns_res) + (window.north > wind.north)); wind.rows = (wind.north - wind.south) / wind.ns_res; wind.cols = (wind.east - wind.west) / wind.ew_res; Rast_set_window(&wind); nrows = wind.rows; ncols = wind.cols; t = (wind.north - window.north) * nrows / (wind.north - wind.south); b = t + (window.north - window.south) * nrows / (wind.north - wind.south); l = (window.west - wind.west) * ncols / (wind.east - wind.west); r = l + (window.east - window.west) * ncols / (wind.east - wind.west); } else { nrows = window.rows; ncols = window.cols; t = 0; b = nrows; l = 0; r = ncols; } D_set_src(t, b, l, r); D_update_conversions(); /* figure out arrow scaling if using a magnitude map */ if (opt7->answer) { Rast_init_fp_range(&range); /* really needed? */ if (Rast_read_fp_range(mag_map, "", &range) != 1) G_fatal_error(_("Problem reading range file")); Rast_get_fp_range_min_max(&range, &mag_min, &mag_max); scale *= 1.5 / fabs(mag_max); G_debug(3, "scaling=%.2f rast_max=%.2f", scale, mag_max); } if (grid_color > 0) { /* ie not "none" */ /* Set color */ D_use_color(grid_color); /* Draw vertical grids */ for (col = 0; col < ncols; col++) D_line_abs(col, 0, col, nrows); /* Draw horizontal grids */ for (row = 0; row < nrows; row++) D_line_abs(0, row, ncols, row); } /* open the raster map */ layer_fd = Rast_open_old(layer_name, ""); raster_type = Rast_get_map_type(layer_fd); /* allocate the cell array */ raster_row = Rast_allocate_buf(raster_type); if (opt7->answer) { /* open the magnitude raster map */ mag_fd = Rast_open_old(mag_map, ""); mag_raster_type = Rast_get_map_type(mag_fd); /* allocate the cell array */ mag_raster_row = Rast_allocate_buf(mag_raster_type); } /* loop through cells, find value, determine direction (n,s,e,w,ne,se,sw,nw), and call appropriate function to draw an arrow on the cell */ for (row = 0; row < nrows; row++) { Rast_get_row(layer_fd, raster_row, row, raster_type); ptr = raster_row; if (opt7->answer) { Rast_get_row(mag_fd, mag_raster_row, row, mag_raster_type); mag_ptr = mag_raster_row; } for (col = 0; col < ncols; col++) { if (row % skip != 0) no_arrow = TRUE; else no_arrow = FALSE; if (col % skip != 0) no_arrow = TRUE; /* find aspect direction based on cell value */ if (raster_type == CELL_TYPE) aspect_f = *((CELL *) ptr); else if (raster_type == FCELL_TYPE) aspect_f = *((FCELL *) ptr); else if (raster_type == DCELL_TYPE) aspect_f = *((DCELL *) ptr); if (opt7->answer) { if (mag_raster_type == CELL_TYPE) length = *((CELL *) mag_ptr); else if (mag_raster_type == FCELL_TYPE) length = *((FCELL *) mag_ptr); else if (mag_raster_type == DCELL_TYPE) length = *((DCELL *) mag_ptr); length *= scale; if (Rast_is_null_value(mag_ptr, mag_raster_type)) { G_debug(5, "Invalid arrow length [NULL]. Skipping."); no_arrow = TRUE; } else if (length <= 0.0) { /* use fabs() or theta+=180? */ G_debug(5, "Illegal arrow length [%.3f]. Skipping.", length); no_arrow = TRUE; } } if (no_arrow) { ptr = G_incr_void_ptr(ptr, Rast_cell_size(raster_type)); if (opt7->answer) mag_ptr = G_incr_void_ptr(mag_ptr, Rast_cell_size(mag_raster_type)); no_arrow = FALSE; continue; } /* treat AGNPS and ANSWERS data like old zero-as-null CELL */ /* TODO: update models */ if (map_type == 2 || map_type == 3) { if (Rast_is_null_value(ptr, raster_type)) aspect_c = 0; else aspect_c = (int)(aspect_f + 0.5); } /** Now draw the arrows **/ /* case switch for standard GRASS aspect map measured in degrees counter-clockwise from east */ if (map_type == 1) { D_use_color(arrow_color); if (Rast_is_null_value(ptr, raster_type)) { /* don't draw anything if x_color is none (transparent) */ if (x_color > 0) { D_use_color(x_color); draw_x(); D_use_color(arrow_color); } } else if (aspect_f >= 0.0 && aspect_f <= 360.0) { if (opt7->answer) arrow_mag(aspect_f, length); else arrow_360(aspect_f); } else if (unknown_color > 0) { /* don't draw if unknown_color is none (transparent) */ D_use_color(unknown_color); unknown_(); D_use_color(arrow_color); } } /* case switch for AGNPS type aspect map */ else if (map_type == 2) { D_use_color(arrow_color); switch (aspect_c) { case 0: /* only draw if x_color is not none (transparent) */ if (x_color > 0) { D_use_color(x_color); draw_x(); D_use_color(arrow_color); } break; case 1: arrow_n(); break; case 2: arrow_ne(); break; case 3: arrow_e(); break; case 4: arrow_se(); break; case 5: arrow_s(); break; case 6: arrow_sw(); break; case 7: arrow_w(); break; case 8: arrow_nw(); break; default: /* only draw if unknown_color is not none */ if (unknown_color > 0) { D_use_color(unknown_color); unknown_(); D_use_color(arrow_color); } break; } } /* case switch for ANSWERS type aspect map */ else if (map_type == 3) { D_use_color(arrow_color); if (aspect_c >= 15 && aspect_c <= 360) /* start at zero? */ arrow_360((double)aspect_c); else if (aspect_c == 400) { if (unknown_color > 0) { /* only draw if unknown_color is not none */ D_use_color(unknown_color); unknown_(); D_use_color(arrow_color); } } else if (x_color > 0) { /* only draw if x_color is not none (transparent) */ D_use_color(x_color); draw_x(); D_use_color(arrow_color); } } /* case switch for compass type aspect map measured in degrees clockwise from north */ else if (map_type == 4) { D_use_color(arrow_color); if (Rast_is_null_value(ptr, raster_type)) { if (x_color > 0) { /* only draw if x_color is not none */ D_use_color(x_color); draw_x(); D_use_color(arrow_color); } } else if (aspect_f >= 0.0 && aspect_f <= 360.0) { if (opt7->answer) arrow_mag(90 - aspect_f, length); else arrow_360(90 - aspect_f); } else if (unknown_color > 0) { /* only draw if unknown_color is not none */ D_use_color(unknown_color); unknown_(); D_use_color(arrow_color); } } ptr = G_incr_void_ptr(ptr, Rast_cell_size(raster_type)); if (opt7->answer) mag_ptr = G_incr_void_ptr(mag_ptr, Rast_cell_size(mag_raster_type)); } } Rast_close(layer_fd); if (opt7->answer) Rast_close(mag_fd); D_save_command(G_recreate_command()); D_close_driver(); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { struct GModule *module; struct { struct Option *input, *output, *zshift, *height, *elevation, *hcolumn, *type, *field, *cats, *where, *interp, *scale, *null; } opt; struct { struct Flag *trace; } flag; struct Map_info In, Out; struct line_pnts *Points; struct line_cats *Cats; struct bound_box map_box; struct cat_list *cat_list; struct Cell_head window; int field; int only_type, cat; int fdrast, interp_method, trace; double objheight, objheight_default, voffset; double scale, null_val; struct field_info *Fi; dbDriver *driver = NULL; char *comment; module = G_define_module(); G_add_keyword(_("vector")); G_add_keyword(_("geometry")); G_add_keyword(_("sampling")); G_add_keyword(_("3D")); module->label = _("Extrudes flat vector features to 3D vector features with defined height."); module->description = _("Optionally the height can be derived from sampling of elevation raster map."); flag.trace = G_define_flag(); flag.trace->key = 't'; flag.trace->description = _("Trace elevation"); flag.trace->guisection = _("Elevation"); opt.input = G_define_standard_option(G_OPT_V_INPUT); opt.field = G_define_standard_option(G_OPT_V_FIELD_ALL); opt.field->guisection = _("Selection"); opt.cats = G_define_standard_option(G_OPT_V_CATS); opt.cats->guisection = _("Selection"); opt.where = G_define_standard_option(G_OPT_DB_WHERE); opt.where->guisection = _("Selection"); opt.type = G_define_standard_option(G_OPT_V_TYPE); opt.type->answer = "point,line,area"; opt.type->options = "point,line,area"; opt.type->guisection = _("Selection"); opt.output = G_define_standard_option(G_OPT_V_OUTPUT); opt.zshift = G_define_option(); opt.zshift->key = "zshift"; opt.zshift->description = _("Shifting value for z coordinates"); opt.zshift->type = TYPE_DOUBLE; opt.zshift->required = NO; opt.zshift->answer = "0"; opt.zshift->guisection = _("Height"); opt.height = G_define_option(); opt.height->key = "height"; opt.height->type = TYPE_DOUBLE; opt.height->required = NO; opt.height->multiple = NO; opt.height->description = _("Fixed height for 3D vector features"); opt.height->guisection = _("Height"); opt.hcolumn = G_define_standard_option(G_OPT_DB_COLUMN); opt.hcolumn->key = "height_column"; opt.hcolumn->multiple = NO; opt.hcolumn->description = _("Name of attribute column with feature height"); opt.hcolumn->guisection = _("Height"); /* raster sampling */ opt.elevation = G_define_standard_option(G_OPT_R_ELEV); opt.elevation->required = NO; opt.elevation->description = _("Elevation raster map for height extraction"); opt.elevation->guisection = _("Elevation"); opt.interp = G_define_standard_option(G_OPT_R_INTERP_TYPE); opt.interp->answer = "nearest"; opt.interp->guisection = _("Elevation"); opt.scale = G_define_option(); opt.scale->key = "scale"; opt.scale->type = TYPE_DOUBLE; opt.scale->description = _("Scale factor sampled raster values"); opt.scale->answer = "1.0"; opt.scale->guisection = _("Elevation"); opt.null = G_define_option(); opt.null->key = "null_value"; opt.null->type = TYPE_DOUBLE; opt.null->description = _("Height for sampled raster NULL values"); opt.null->guisection = _("Elevation"); G_gisinit(argv[0]); if (G_parser(argc, argv)) exit(EXIT_FAILURE); if (!opt.height->answer && !opt.hcolumn->answer) { G_fatal_error(_("One of '%s' or '%s' parameters must be set"), opt.height->key, opt.hcolumn->key); } sscanf(opt.zshift->answer, "%lf", &voffset); G_debug(1, "voffset = %f", voffset); if (opt.height->answer) sscanf(opt.height->answer, "%lf", &objheight); else objheight = 0.; G_debug(1, "objheight = %f", objheight); objheight_default = objheight; only_type = Vect_option_to_types(opt.type); /* sampling method */ interp_method = Rast_option_to_interp_type(opt.interp); /* used to scale sampled raster values */ scale = atof(opt.scale->answer); /* is null value defined */ if (opt.null->answer) null_val = atof(opt.null->answer); /* trace elevation */ trace = flag.trace->answer ? TRUE : FALSE; /* set input vector map name and mapset */ Vect_check_input_output_name(opt.input->answer, opt.output->answer, G_FATAL_EXIT); Points = Vect_new_line_struct(); Cats = Vect_new_cats_struct(); Vect_set_open_level(2); /* topology required for input */ /* opening input vector map */ if (Vect_open_old2(&In, opt.input->answer, "", opt.field->answer) < 0) G_fatal_error(_("Unable to open vector map <%s>"), opt.input->answer); Vect_set_error_handler_io(&In, &Out); /* creating output vector map */ if (Vect_open_new(&Out, opt.output->answer, WITH_Z) < 0) G_fatal_error(_("Unable to create vector map <%s>"), opt.output->answer); field = Vect_get_field_number(&In, opt.field->answer); if ((opt.hcolumn->answer || opt.cats->answer || opt.where->answer) && field == -1) { G_warning(_("Invalid layer number (%d). " "Parameter '%s', '%s' or '%s' specified, assuming layer '1'."), field, opt.hcolumn->key, opt.cats->key, opt.where->key); field = 1; } /* set constraint for cats or where */ cat_list = NULL; if (field > 0) cat_list = Vect_cats_set_constraint(&In, field, opt.where->answer, opt.cats->answer); Vect_hist_copy(&In, &Out); Vect_hist_command(&Out); /* opening database connection, if required */ if (opt.hcolumn->answer) { int ctype; dbColumn *column; if ((Fi = Vect_get_field(&In, field)) == NULL) G_fatal_error(_("Database connection not defined for layer %d"), field); if ((driver = db_start_driver_open_database(Fi->driver, Fi->database)) == NULL) G_fatal_error(_("Unable to open database <%s> by driver <%s>"), Fi->database, Fi->driver); db_set_error_handler_driver(driver); if (db_get_column(driver, Fi->table, opt.hcolumn->answer, &column) != DB_OK) G_fatal_error(_("Column <%s> does not exist"), opt.hcolumn->answer); else db_free_column(column); ctype = db_column_Ctype(driver, Fi->table, opt.hcolumn->answer); if (ctype != DB_C_TYPE_INT && ctype != DB_C_TYPE_STRING && ctype != DB_C_TYPE_DOUBLE) { G_fatal_error(_("Column <%s>: invalid data type"), opt.hcolumn->answer); } } /* do we work with elevation raster? */ fdrast = -1; if (opt.elevation->answer) { /* raster setup */ G_get_window(&window); /* open the elev raster, and check for error condition */ fdrast = Rast_open_old(opt.elevation->answer, ""); } /* if area */ if (only_type & GV_AREA) { int area, nareas, centroid; nareas = Vect_get_num_areas(&In); G_debug(2, "n_areas = %d", nareas); if (nareas > 0) G_message(_("Extruding areas...")); for (area = 1; area <= nareas; area++) { G_debug(3, "area = %d", area); G_percent(area, nareas, 2); if (!Vect_area_alive(&In, area)) continue; centroid = Vect_get_area_centroid(&In, area); if (!centroid) { G_warning(_("Skipping area %d without centroid"), area); continue; } Vect_read_line(&In, NULL, Cats, centroid); if (field > 0 && !Vect_cats_in_constraint(Cats, field, cat_list)) continue; /* height attribute */ if (opt.hcolumn->answer) { cat = Vect_get_area_cat(&In, area, field); if (cat == -1) { G_warning(_("No category defined for area %d. Using default fixed height %f."), area, objheight_default); objheight = objheight_default; } if (get_height(Fi, opt.hcolumn->answer, driver, cat, &objheight) != 0) { G_warning(_("Unable to fetch height from DB for area %d. Using default fixed height %f."), area, objheight_default); objheight = objheight_default; } } /* if opt.hcolumn->answer */ Vect_get_area_points(&In, area, Points); G_debug(3, "area: %d height: %f", area, objheight); extrude(&In, &Out, Cats, Points, fdrast, trace, interp_method, scale, opt.null->answer ? TRUE : FALSE, null_val, objheight, voffset, &window, GV_AREA, centroid); } /* foreach area */ } if (only_type > 0) { int line, nlines; int type; G_debug(1, "other than areas"); /* loop through each line in the dataset */ nlines = Vect_get_num_lines(&In); G_message(_("Extruding features...")); for (line = 1; line <= nlines; line++) { /* progress feedback */ G_percent(line, nlines, 2); if (!Vect_line_alive(&In, line)) continue; /* read line */ type = Vect_read_line(&In, Points, Cats, line); if (!(type & only_type)) continue; if (field > 0 && !Vect_cats_in_constraint(Cats, field, cat_list)) continue; /* height attribute */ if (opt.hcolumn->answer) { cat = Vect_get_line_cat(&In, line, field); if (cat == -1) { G_warning(_("No category defined for feature %d. Using default fixed height %f."), line, objheight_default); objheight = objheight_default; } if (get_height(Fi, opt.hcolumn->answer, driver, cat, &objheight) != 0) { G_warning(_("Unable to fetch height from DB for line %d. Using default fixed height %f."), line, objheight_default); objheight = objheight_default; } } /* if opt.hcolumn->answer */ extrude(&In, &Out, Cats, Points, fdrast, trace, interp_method, scale, opt.null->answer ? TRUE : FALSE, null_val, objheight, voffset, &window, type, -1); } /* for each line */ } /* else if area */ if (driver) { db_close_database(driver); db_shutdown_driver(driver); } G_important_message(_("Copying attribute table...")); if (field < 0) Vect_copy_tables(&In, &Out, 0); else Vect_copy_table_by_cat_list(&In, &Out, field, field, NULL, GV_1TABLE, cat_list); Vect_build(&Out); /* header */ G_asprintf(&comment, "Generated by %s from vector map <%s>", G_program_name(), Vect_get_full_name(&In)); Vect_set_comment(&Out, comment); G_free(comment); Vect_get_map_box(&Out, &map_box); Vect_close(&In); Vect_close(&Out); Vect_destroy_line_struct(Points); Vect_destroy_cats_struct(Cats); G_done_msg("T: %f B: %f.", map_box.T, map_box.B); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { short percent; double percentage; long targets; long count; struct rr_state myState; struct GModule *module; struct { struct Option *input, *cover, *raster, *sites, *npoints; } parm; struct { struct Flag *zero, *info, *z_geometry, *notopol_flag; } flag; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("sampling")); G_add_keyword(_("vector")); G_add_keyword(_("random")); module->description = _("Creates a raster map layer and vector point map " "containing randomly located points."); parm.input = G_define_standard_option(G_OPT_R_INPUT); parm.input->description = _("Name of input raster map"); parm.cover = G_define_standard_option(G_OPT_R_INPUT); parm.cover->key = "cover"; parm.cover->required = NO; parm.cover->description = _("Name of cover raster map"); parm.npoints = G_define_option(); parm.npoints->key = "npoints"; parm.npoints->key_desc = "number[%]"; parm.npoints->type = TYPE_STRING; parm.npoints->required = YES; parm.npoints->description = _("The number of points to allocate"); parm.raster = G_define_standard_option(G_OPT_R_OUTPUT); parm.raster->required = NO; parm.raster->key = "raster"; parm.sites = G_define_standard_option(G_OPT_V_OUTPUT); parm.sites->required = NO; parm.sites->key = "vector"; flag.zero = G_define_flag(); flag.zero->key = 'z'; flag.zero->description = _("Generate points also for NULL category"); flag.info = G_define_flag(); flag.info->key = 'i'; flag.info->description = _("Report information about input raster and exit"); flag.z_geometry = G_define_flag(); flag.z_geometry->key = 'd'; flag.z_geometry->description = _("Generate vector points as 3D points"); flag.notopol_flag = G_define_standard_flag(G_FLG_V_TOPO); flag.notopol_flag->description = _("Do not build topology in points mode"); flag.notopol_flag->guisection = _("Points"); if (G_parser(argc, argv) != 0) exit(EXIT_FAILURE); /* Set some state variables */ myState.use_nulls = flag.zero->answer; myState.inraster = parm.input->answer; if (parm.cover->answer) { myState.docover = TRUE; myState.inrcover = parm.cover->answer; } else { myState.docover = FALSE; myState.inrcover = NULL; } myState.outraster = parm.raster->answer; myState.outvector = parm.sites->answer; myState.z_geometry = flag.z_geometry->answer; myState.notopol = flag.notopol_flag->answer; /* If they only want info we ignore the rest */ get_stats(&myState); if (flag.info->answer) { G_message("Raster: %s\n" "Cover: %s\n" "Cell Count: %d\n" "Null Cells: %d\n\n", myState.inraster, myState.inrcover, (int)myState.nCells, (int)myState.nNulls); exit(EXIT_SUCCESS); } if (!(parm.raster->answer || parm.sites->answer)) G_fatal_error(_("Note: one (or both) of %s and %s must be specified"), parm.raster->key, parm.sites->key); /* look for n[%] */ percent = has_percent(parm.npoints->answer); if (percent) { if (sscanf(parm.npoints->answer, "%lf", &percentage) != 1 || percentage <= 0.0 || percentage > 100.0) { G_fatal_error(_("<%s=%s> invalid percentage"), parm.npoints->key, parm.npoints->answer); } } else { if (sscanf(parm.npoints->answer, "%ld", &targets) != 1 || targets <= 0) { G_fatal_error(_("<%s=%s> invalid number of points"), parm.npoints->key, parm.npoints->answer); } } count = (myState.use_nulls) ? myState.nCells : myState.nCells - myState.nNulls; if (percent) myState.nRand = (int)(count * percentage / 100.0 + .5); else { if (targets > count) { if (myState.use_nulls) G_fatal_error(_("There aren't [%ld] cells in the current region"), targets); else G_fatal_error(_("There aren't [%ld] non-NULL cells in the current region"), targets); } if (targets <= 0) G_fatal_error(_("There are no valid locations in the current region")); myState.nRand = targets; } execute_random(&myState); if (myState.outraster) make_support(&myState, percent, percentage); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { struct Cell_head cellhd; /*region+header info */ char *mapset; /*mapset name */ int nrows, ncols; int row, col; struct GModule *module; struct Option *input, *input1, *input2, *input3, *input4, *input5, *output; struct History history; /*metadata */ struct Colors colors; /*Color rules */ /************************************/ char *name, *name1, *name2; /*input raster name */ char *result; /*output raster name */ /*File Descriptors */ int nfiles, nfiles1, nfiles2; int infd[MAXFILES], infd1[MAXFILES], infd2[MAXFILES]; int outfd; /****************************************/ /* Pointers for file names */ char **names; char **ptr; char **names1; char **ptr1; char **names2; char **ptr2; /****************************************/ int DOYbeforeETa[MAXFILES], DOYafterETa[MAXFILES]; int bfr, aft; /****************************************/ int ok; int i = 0, j = 0; double etodoy; /*minimum ETo DOY */ double startperiod, endperiod; /*first and last days (DOYs) of the period studied */ void *inrast[MAXFILES], *inrast1[MAXFILES], *inrast2[MAXFILES]; DCELL *outrast; CELL val1, val2; RASTER_MAP_TYPE in_data_type[MAXFILES]; /* ETa */ RASTER_MAP_TYPE in_data_type1[MAXFILES]; /* DOY of ETa */ RASTER_MAP_TYPE in_data_type2[MAXFILES]; /* ETo */ RASTER_MAP_TYPE out_data_type = DCELL_TYPE; /************************************/ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("imagery")); G_add_keyword(_("evapotranspiration")); module->description =_("Computes temporal integration of satellite " "ET actual (ETa) following the daily ET reference " "(ETo) from meteorological station(s)."); /* Define the different options */ input = G_define_standard_option(G_OPT_R_INPUTS); input->key = "eta"; input->description = _("Names of satellite ETa raster maps [mm/d or cm/d]"); input1 = G_define_standard_option(G_OPT_R_INPUTS); input1->key = "eta_doy"; input1->description = _("Names of satellite ETa Day of Year (DOY) raster maps [0-400] [-]"); input2 = G_define_standard_option(G_OPT_R_INPUTS); input2->key = "eto"; input2->description = _("Names of meteorological station ETo raster maps [0-400] [mm/d or cm/d]"); input3 = G_define_option(); input3->key = "eto_doy_min"; input3->type = TYPE_DOUBLE; input3->required = YES; input3->description = _("Value of DOY for ETo first day"); input4 = G_define_option(); input4->key = "start_period"; input4->type = TYPE_DOUBLE; input4->required = YES; input4->description = _("Value of DOY for the first day of the period studied"); input5 = G_define_option(); input5->key = "end_period"; input5->type = TYPE_DOUBLE; input5->required = YES; input5->description = _("Value of DOY for the last day of the period studied"); output = G_define_standard_option(G_OPT_R_OUTPUT); /* init nfiles */ nfiles = 1; nfiles1 = 1; nfiles2 = 1; /********************/ if (G_parser(argc, argv)) exit(EXIT_FAILURE); ok = 1; names = input->answers; ptr = input->answers; names1 = input1->answers; ptr1 = input1->answers; names2 = input2->answers; ptr2 = input2->answers; etodoy = atof(input3->answer); startperiod = atof(input4->answer); endperiod = atof(input5->answer); result = output->answer; /****************************************/ if (endperiod<startperiod) { G_fatal_error(_("The DOY for end_period can not be smaller than start_period")); ok = 0; } if (etodoy>startperiod) { G_fatal_error(_("The DOY for start_period can not be smaller than eto_doy_min")); ok = 0; } for (; *ptr != NULL; ptr++) { if (nfiles > MAXFILES) G_fatal_error(_("Too many ETa files. Only %d allowed."), MAXFILES); name = *ptr; /* Allocate input buffer */ infd[nfiles] = Rast_open_old(name, ""); Rast_get_cellhd(name, "", &cellhd); inrast[nfiles] = Rast_allocate_d_buf(); nfiles++; } nfiles--; if (nfiles <= 1) G_fatal_error(_("The min specified input map is two")); /****************************************/ for (; *ptr1 != NULL; ptr1++) { if (nfiles1 > MAXFILES) G_fatal_error(_("Too many ETa_doy files. Only %d allowed."), MAXFILES); name1 = *ptr1; /* Allocate input buffer */ infd1[nfiles1] = Rast_open_old(name1, ""); Rast_get_cellhd(name1, "", &cellhd); inrast1[nfiles1] = Rast_allocate_d_buf(); nfiles1++; } nfiles1--; if (nfiles1 <= 1) G_fatal_error(_("The min specified input map is two")); /****************************************/ if (nfiles != nfiles1) G_fatal_error(_("ETa and ETa_DOY file numbers are not equal!")); /****************************************/ for (; *ptr2 != NULL; ptr2++) { if (nfiles > MAXFILES) G_fatal_error(_("Too many ETo files. Only %d allowed."), MAXFILES); name2 = *ptr2; /* Allocate input buffer */ infd2[nfiles2] = Rast_open_old(name2, ""); Rast_get_cellhd(name2, "", &cellhd); inrast2[nfiles2] = Rast_allocate_d_buf(); nfiles2++; } nfiles2--; if (nfiles2 <= 1) G_fatal_error(_("The min specified input map is two")); /* Allocate output buffer, use input map data_type */ nrows = Rast_window_rows(); ncols = Rast_window_cols(); outrast = Rast_allocate_d_buf(); /* Create New raster files */ outfd = Rast_open_new(result, 1); /*******************/ /* Process pixels */ double doy[MAXFILES]; double sum[MAXFILES]; for (row = 0; row < nrows; row++) { DCELL d_out; DCELL d_ETrF[MAXFILES]; DCELL d[MAXFILES]; DCELL d1[MAXFILES]; DCELL d2[MAXFILES]; G_percent(row, nrows, 2); /* read input map */ for (i = 1; i <= nfiles; i++) Rast_get_d_row(infd[i], inrast[i], row); for (i = 1; i <= nfiles1; i++) Rast_get_d_row(infd1[i], inrast1[i], row); for (i = 1; i <= nfiles2; i++) Rast_get_d_row (infd2[i], inrast2[i], row); /*process the data */ for (col = 0; col < ncols; col++) { int d1_null=0; int d_null=0; for (i = 1; i <= nfiles; i++) { if (Rast_is_d_null_value(&((DCELL *) inrast[i])[col])) d_null=1; else d[i] = ((DCELL *) inrast[i])[col]; } for (i = 1; i <= nfiles1; i++) { if (Rast_is_d_null_value(&((DCELL *) inrast1[i])[col])) d1_null=1; else d1[i] = ((DCELL *) inrast1[i])[col]; } for (i = 1; i <= nfiles2; i++) d2[i] = ((DCELL *) inrast2[i])[col]; /* Find out the DOY of the eto image */ for (i = 1; i <= nfiles1; i++) { if ( d_null==1 || d1_null==1 ) Rast_set_d_null_value(&outrast[col],1); else { doy[i] = d1[i] - etodoy+1; if (Rast_is_d_null_value(&d2[(int)doy[i]]) || d2[(int)doy[i]]==0 ) Rast_set_d_null_value(&outrast[col],1); else d_ETrF[i] = d[i] / d2[(int)doy[i]]; } } for (i = 1; i <= nfiles1; i++) { /* do nothing */ if ( d_null==1 || d1_null==1) { /*G_message(" null value ");*/ } else { DOYbeforeETa[i]=0; DOYafterETa[i]=0; if (i == 1) DOYbeforeETa[i] = startperiod; else { int k=i-1; while (d1[k]>=startperiod ) { if (d1[k]<0) // case were d1[k] is null k=k-1; else { DOYbeforeETa[i] = 1+((d1[i] + d1[k])/2.0); break; } } } if (i == nfiles1) DOYafterETa[i] = endperiod; else { int k=i+1; while (d1[k]<=endperiod) { if (d1[k]<0) // case were d1[k] is null k=k+1; else { DOYafterETa[i] = (d1[i] + d1[k]) / 2.0; break; } } } } } sum[MAXFILES] = 0.0; for (i = 1; i <= nfiles1; i++) { if(d_null==1 || d1_null==1) { /* do nothing */ } else { if (DOYbeforeETa[i]==0 || DOYbeforeETa[i]==0 ) Rast_set_d_null_value(&outrast[col],1); else { bfr = (int)DOYbeforeETa[i]; aft = (int)DOYafterETa[i]; sum[i]=0.0; for (j = bfr; j < aft; j++) sum[i] += d2[(int)(j-etodoy+1)]; } } } d_out = 0.0; for (i = 1; i <= nfiles1; i++) { if(d_null==1 || d_null==1) Rast_set_d_null_value(&outrast[col],1); else { d_out += d_ETrF[i] * sum[i]; outrast[col] = d_out; } } } Rast_put_row(outfd, outrast, out_data_type); } for (i = 1; i <= nfiles; i++) { G_free(inrast[i]); Rast_close(infd[i]); } for (i = 1; i <= nfiles1; i++) { G_free(inrast1[i]); Rast_close(infd1[i]); } for (i = 1; i <= nfiles2; i++) { G_free(inrast2[i]); Rast_close(infd2[i]); } G_free(outrast); Rast_close(outfd); /* Color table from 0.0 to 10.0 */ Rast_init_colors(&colors); val1 = 0; val2 = 10; Rast_add_c_color_rule(&val1, 0, 0, 0, &val2, 255, 255, 255, &colors); /* Metadata */ Rast_short_history(result, "raster", &history); Rast_command_history(&history); Rast_write_history(result, &history); exit(EXIT_SUCCESS); }
int main( int argc, char *argv[] ) { Shypothesis **samples; /* Data to be combined */ unsigned int i; FILE *kb; char **groups; int norm = 1; /* turn on normalisation of evidence by default */ /* these are for time keeping in the logfile */ time_t systime; clock_t proctime; unsigned long timeused; unsigned int days, hours, mins, secs; xmlDocPtr dstXMLFile; Sfp_struct* file_pointers; G_gisinit ( argv[0] ); module = G_define_module (); module->description = "Combines evidences from a DST knowledge base"; parm.file = G_define_option (); parm.file->key = "file"; parm.file->type = TYPE_STRING; parm.file->required = YES; parm.file->description = "Name of the knowledge base that contains the evidence"; parm.groups = G_define_option (); parm.groups->key = "sources"; parm.groups->type = TYPE_STRING; parm.groups->required = NO; parm.groups->multiple = YES; parm.groups->description = "Evidences to be combined (default: all)"; parm.type = G_define_option (); parm.type->key = "type"; parm.type->type = TYPE_STRING; parm.type->required = NO; parm.type->options = "const,rast,vect"; parm.type->answer = "rast"; parm.type->description = "Type(s) of evidences to combine"; parm.output = G_define_option (); parm.output->key = "output"; parm.output->type = TYPE_STRING; parm.output->required = NO; parm.output->answer = G_location (); parm.output->description = "Prefix for result maps (dflt: location name)"; parm.vals = G_define_option (); parm.vals->key = "values"; parm.vals->type = TYPE_STRING; parm.vals->required = NO; parm.vals->multiple = YES; parm.vals->options = "bel,pl,doubt,common,bint,woc,maxbpa,minbpa,maxsrc,minsrc"; parm.vals->answer = "bel"; parm.vals->description = "Dempster-Shafer values to map"; parm.hyps = G_define_option (); parm.hyps->key = "hypotheses"; parm.hyps->type = TYPE_STRING; parm.hyps->required = NO; parm.hyps->multiple = NO; parm.hyps->description = "Hypotheses to map (default: all)"; parm.logfile = G_define_option (); parm.logfile->key = "logfile"; parm.logfile->type = TYPE_STRING; parm.logfile->required = NO; parm.logfile->description = "Name of logfile"; /* TODO: not implemented yet parm.warnings = G_define_option (); parm.warnings->key = "warnings"; parm.warnings->type = TYPE_STRING; parm.warnings->required = NO; parm.warnings->description = "Name of site list to store locations of warnings." ; */ flag.norm = G_define_flag (); flag.norm->key = 'n'; flag.norm->description = "Turn off normalisation"; flag.quiet = G_define_flag (); flag.quiet->key = 'q'; flag.quiet->description = "Quiet operation: no progress diplay"; /* append output to existing logfile ? */ flag.append = G_define_flag (); flag.append->key = 'a'; flag.append->description = "Append log output to existing file"; no_assigns = 0; /* INIT GLOBAL VARS */ WOC_MIN = 0; WOC_MAX = 0; /* do not pause after a warning message was displayed */ G_sleep_on_error (0); /* parse command line */ if (G_parser (argc, argv)) { exit (-1); } /* check if given parameters are valid */ if (G_legal_filename (parm.file->answer) == -1) { G_fatal_error ("Please provide the name of an existing DST knowledge base.\n"); } if (G_find_file ("DST",parm.file->answer,G_mapset()) == NULL) { G_fatal_error ("Knowledge base does not exist in user's MAPSET!\n"); } /* check logfile */ if (parm.logfile->answer != NULL) { if ( !G_legal_filename (parm.logfile->answer) ) { G_fatal_error ("Please specify a legal filename for the logfile.\n"); } /* attempt to write to logfile */ if (flag.append->answer) { if (fopen (parm.logfile->answer, "r") == NULL) { lp = fopen (parm.logfile->answer, "w+"); if (lp == NULL) { G_fatal_error ("Logfile error: %s\n", strerror (errno)); } } else { lp = fopen (parm.logfile->answer, "a"); if (lp == NULL) { G_fatal_error ("Logfile error: %s\n", strerror (errno)); } fprintf (lp,"\n\n * * * * * \n\n"); } } else { if ( (lp = fopen ( parm.logfile->answer, "w+" ) ) == NULL ) { G_fatal_error ("Logfile error: %s\n", strerror (errno)); } } /* we want unbuffered output for the logfile */ setvbuf (lp,NULL,_IONBF,0); } else { /* log output to stderr by default */ lp = stderr; } /* setup coordinate file storage, if desired */ /* try to create a sites file to store coordinates */ /* set 'warn' to point to the user-defined sites file */ /* warn = NULL; if ( parm.warnings != NULL ) { } */ /* check if we have read/write access to knowledge base */ kb = G_fopen_old ("DST",parm.file->answer,G_mapset()); if ( kb == NULL ) { G_fatal_error ("Cannot open knowledge base file for reading and writing!\n"); } fclose(kb); /* start logfile */ if ( parm.logfile->answer != NULL) { fprintf (lp,"This is %s, version %.2f\n",argv[0],PROGVERSION); systime = time (NULL); fprintf (lp,"Calculation started on %s\n",ctime(&systime)); } /* open DST file and get basic evidence group information */ dstXMLFile = stat_XML ( parm.file->answer, &NO_SINGLETONS, &N ); groups = get_groups_XML ( N, dstXMLFile ); if ( NO_SINGLETONS == 1 ) { G_fatal_error ("Knowledge base does not contain any user-supplied hypotheses.\n"); } if ( parm.groups->answer != NULL ) { /* user specified a subset of groups */ N = check_groups ( groups ); } if ( N < 2 ) { G_fatal_error ("At least two groups of evidences must be present in the knowledge base.\n"); } /* allocate memory for all samples a sample holds one double for bel, pl and bpn for each piece of evidence. The number of pieces of evidence is the number of possible subsets in Theta = 2^NO_SINGLETONS ! The number of samples is = number of groups in the XML knowledge base file (N) ! */ samples = (Shypothesis**) G_malloc ((N * sizeof(Shypothesis*))); for ( i=0; i < N; i ++ ) { samples[i] = (Shypothesis*) G_malloc (sizeof(Shypothesis)); } /* turn off normalisation if user wants it so */ if ( flag.norm->answer == 1 ) { norm = 0; } /* do some type-dependant checking */ /* and open file pointers for all the maps to read! */ file_pointers = NULL; if ( !strcmp (parm.type->answer,"rast") ) { if ( parm.groups->answer != NULL ) { /* check only user-specified groups */ file_pointers = test_rast_XML ( parm.groups->answers, dstXMLFile ); } else { /* check all groups */ file_pointers = test_rast_XML ( groups, dstXMLFile ); } } /* read in all samples in a type-dependant manner */ if ( parm.groups->answer != NULL ) { /* read only user-specified groups */ if ( !strcmp (parm.type->answer,"const") ) { if ( strcmp (parm.output->answer,G_location ()) != 0) { G_warning ("Ignoring parameter 'output='.\n"); } if ( strcmp (parm.vals->answer,"bel") !=0 ) { G_warning ("Ignoring parameter 'values='.\n"); } if ( parm.hyps->answer != NULL ) { G_warning ("Ignoring parameter 'hypotheses='.\n"); } do_calculations_const (samples,parm.groups->answers, norm, dstXMLFile); } if ( !strcmp (parm.type->answer,"rast") ) { do_calculations_rast (samples,parm.groups->answers, norm, parm.output->answer, parm.vals->answers, parm.hyps->answer, flag.quiet->answer, parm.logfile->answer, dstXMLFile, file_pointers ); } } else { /* read all groups */ if ( !strcmp (parm.type->answer,"const") ) { if ( strcmp (parm.output->answer,G_location ()) != 0) { G_warning ("Ignoring parameter 'output='.\n"); } if ( strcmp (parm.vals->answer,"bel") !=0 ) { G_warning ("Ignoring parameter 'values='.\n"); } if ( parm.hyps->answer != NULL ) { G_warning ("Ignoring parameter 'hypotheses='.\n"); } do_calculations_const (samples,groups, norm, dstXMLFile); } if ( !strcmp (parm.type->answer,"rast") ) { do_calculations_rast (samples,groups, norm, parm.output->answer, parm.vals->answers, parm.hyps->answer, flag.quiet->answer, parm.logfile->answer, dstXMLFile, file_pointers ); } } /* close logfile */ /* write processing time to logfile */ proctime = clock (); timeused = (unsigned long) proctime / CLOCKS_PER_SEC; days = timeused / 86400; hours = (timeused - (days * 86400)) / 3600; mins = (timeused - (days * 86400) - (hours * 3600)) / 60; secs = (timeused - (days * 86400) - (hours * 3600) - (mins * 60)); systime = time (NULL); if ( parm.logfile->answer != NULL ) { fprintf (lp,"\nCalculation finished on %s",ctime(&systime)); fprintf (lp,"Processing time: %id, %ih, %im, %is\n", days, hours, mins, secs ); fflush (lp); } for (i=0; i<N; i++) { G_free (groups[i]); } G_free (groups); return (EXIT_SUCCESS); }
int main(int argc, char **argv) { char name[128] = ""; struct Option *map; struct GModule *module; char *mapset; char buff[500]; /* must run in a term window */ G_putenv("GRASS_UI_TERM", "1"); /* Initialize the GIS calls */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("display")); G_add_keyword(_("raster")); module->description = "Allows the user to interactively change the color table " "of a raster map layer displayed on the graphics monitor."; map = G_define_option(); map->key = "map"; map->type = TYPE_STRING; if (*name) map->answer = name; if (*name) map->required = NO; else map->required = YES; map->gisprompt = "old,cell,raster"; map->description = "Name of raster map"; if (G_parser(argc, argv)) exit(1); /* Make sure map is available */ if (map->answer == NULL) exit(0); mapset = G_find_raster2(map->answer, ""); if (mapset == NULL) { char msg[256]; sprintf(msg, "Raster file [%s] not available", map->answer); G_fatal_error(msg); } if (Rast_map_is_fp(map->answer, mapset)) { sprintf(buff, "Raster file [%s] is floating point! \nd.colors only works with integer maps", map->answer); G_fatal_error(buff); } /* connect to the driver */ if (R_open_driver() != 0) G_fatal_error("No graphics device selected"); /* Read in the map region associated with graphics window */ D_setup(0); get_map_info(map->answer, mapset); R_close_driver(); exit(0); }
int main(int argc, char *argv[]) { int fd, maskfd; CELL *mask; DCELL *dcell; struct GModule *module; struct History history; int row, col; int searchrow, searchcolumn, pointsfound; int *shortlistrows = NULL, *shortlistcolumns = NULL; long ncells = 0; double north, east; double dist; double sum1, sum2, interp_value; int n; double p; struct { struct Option *input, *npoints, *power, *output, *dfield, *col; } parm; struct { struct Flag *noindex; } flag; struct cell_list { int row, column; struct cell_list *next; }; struct cell_list **search_list = NULL, **search_list_start = NULL; int max_radius, radius; int searchallpoints = 0; char *tmpstr1, *tmpstr2; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("vector")); G_add_keyword(_("surface")); G_add_keyword(_("interpolation")); G_add_keyword(_("IDW")); module->description = _("Provides surface interpolation from vector point data by Inverse " "Distance Squared Weighting."); parm.input = G_define_standard_option(G_OPT_V_INPUT); parm.dfield = G_define_standard_option(G_OPT_V_FIELD); parm.col = G_define_standard_option(G_OPT_DB_COLUMN); parm.col->required = NO; parm.col->label = _("Name of attribute column with values to interpolate"); parm.col->description = _("If not given and input is 2D vector map then category values are used. " "If input is 3D vector map then z-coordinates are used."); parm.col->guisection = _("Values"); parm.output = G_define_standard_option(G_OPT_R_OUTPUT); parm.npoints = G_define_option(); parm.npoints->key = "npoints"; parm.npoints->key_desc = "count"; parm.npoints->type = TYPE_INTEGER; parm.npoints->required = NO; parm.npoints->description = _("Number of interpolation points"); parm.npoints->answer = "12"; parm.npoints->guisection = _("Settings"); parm.power = G_define_option(); parm.power->key = "power"; parm.power->type = TYPE_DOUBLE; parm.power->answer = "2.0"; parm.power->label = _("Power parameter"); parm.power->description = _("Greater values assign greater influence to closer points"); parm.power->guisection = _("Settings"); flag.noindex = G_define_flag(); flag.noindex->key = 'n'; flag.noindex->label = _("Don't index points by raster cell"); flag.noindex->description = _("Slower but uses" " less memory and includes points from outside region" " in the interpolation"); flag.noindex->guisection = _("Settings"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); if (sscanf(parm.npoints->answer, "%d", &search_points) != 1 || search_points < 1) G_fatal_error(_("Illegal number (%s) of interpolation points"), parm.npoints->answer); list = (struct list_Point *) G_calloc((size_t) search_points, sizeof(struct list_Point)); p = atof(parm.power->answer); /* get the window, dimension arrays */ G_get_window(&window); if (!flag.noindex->answer) { npoints_currcell = (long **)G_malloc(window.rows * sizeof(long *)); points = (struct Point ***)G_malloc(window.rows * sizeof(struct Point **)); for (row = 0; row < window.rows; row++) { npoints_currcell[row] = (long *)G_malloc(window.cols * sizeof(long)); points[row] = (struct Point **)G_malloc(window.cols * sizeof(struct Point *)); for (col = 0; col < window.cols; col++) { npoints_currcell[row][col] = 0; points[row][col] = NULL; } } } /* read the elevation points from the input sites file */ read_sites(parm.input->answer, parm.dfield->answer, parm.col->answer, flag.noindex->answer); if (npoints == 0) G_fatal_error(_("No points found")); nsearch = npoints < search_points ? npoints : search_points; if (!flag.noindex->answer) { /* Arbitrary point to switch between searching algorithms. Could do * with refinement PK */ if ((window.rows * window.cols) / npoints > 400) { /* Using old algorithm.... */ searchallpoints = 1; ncells = 0; /* Make an array to contain the row and column indices that have * sites in them; later will just search through all these. */ for (searchrow = 0; searchrow < window.rows; searchrow++) for (searchcolumn = 0; searchcolumn < window.cols; searchcolumn++) if (npoints_currcell[searchrow][searchcolumn] > 0) { shortlistrows = (int *)G_realloc(shortlistrows, (1 + ncells) * sizeof(int)); shortlistcolumns = (int *)G_realloc(shortlistcolumns, (1 + ncells) * sizeof(int)); shortlistrows[ncells] = searchrow; shortlistcolumns[ncells] = searchcolumn; ncells++; } } else { /* Fill look-up table of row and column offsets for * doing a circular region growing search looking for sites */ /* Use units of column width */ max_radius = (int)(0.5 + sqrt(window.cols * window.cols + (window.rows * window.ns_res / window.ew_res) * (window.rows * window.ns_res / window.ew_res))); search_list = (struct cell_list **)G_malloc(max_radius * sizeof(struct cell_list *)); search_list_start = (struct cell_list **)G_malloc(max_radius * sizeof(struct cell_list *)); for (radius = 0; radius < max_radius; radius++) search_list[radius] = NULL; for (row = 0; row < window.rows; row++) for (col = 0; col < window.cols; col++) { radius = (int)sqrt(col * col + (row * window.ns_res / window.ew_res) * (row * window.ns_res / window.ew_res)); if (search_list[radius] == NULL) search_list[radius] = search_list_start[radius] = G_malloc(sizeof(struct cell_list)); else search_list[radius] = search_list[radius]->next = G_malloc(sizeof(struct cell_list)); search_list[radius]->row = row; search_list[radius]->column = col; search_list[radius]->next = NULL; } } } /* allocate buffers, etc. */ dcell = Rast_allocate_d_buf(); if ((maskfd = Rast_maskfd()) >= 0) mask = Rast_allocate_c_buf(); else mask = NULL; fd = Rast_open_new(parm.output->answer, DCELL_TYPE); /* GTC Count of window rows */ G_asprintf(&tmpstr1, n_("%d row", "%d rows", window.rows), window.rows); /* GTC Count of window columns */ G_asprintf(&tmpstr2, n_("%d column", "%d columns", window.cols), window.cols); /* GTC First argument is map name, second - message about number of rows, third - columns. */ G_important_message(_("Interpolating raster map <%s> (%s, %s)..."), parm.output->answer, tmpstr1, tmpstr2); G_free(tmpstr1); G_free(tmpstr2); north = window.north + window.ns_res / 2.0; for (row = 0; row < window.rows; row++) { G_percent(row, window.rows, 1); if (mask) Rast_get_c_row(maskfd, mask, row); north -= window.ns_res; east = window.west - window.ew_res / 2.0; for (col = 0; col < window.cols; col++) { east += window.ew_res; /* don't interpolate outside of the mask */ if (mask && mask[col] == 0) { Rast_set_d_null_value(&dcell[col], 1); continue; } /* If current cell contains more than nsearch points just average * all the points in this cell and don't look in any others */ if (!(flag.noindex->answer) && npoints_currcell[row][col] >= nsearch) { sum1 = 0.0; for (i = 0; i < npoints_currcell[row][col]; i++) sum1 += points[row][col][i].z; interp_value = sum1 / npoints_currcell[row][col]; } else { if (flag.noindex->answer) calculate_distances_noindex(north, east); else { pointsfound = 0; i = 0; if (searchallpoints == 1) { /* If there aren't many sites just check them all to find * the nearest */ for (n = 0; n < ncells; n++) calculate_distances(shortlistrows[n], shortlistcolumns[n], north, east, &pointsfound); } else { radius = 0; while (pointsfound < nsearch) { /* Keep widening the search window until we find * enough points */ search_list[radius] = search_list_start[radius]; while (search_list[radius] != NULL) { /* Always */ if (row < (window.rows - search_list[radius]->row) && col < (window.cols - search_list[radius]->column)) { searchrow = row + search_list[radius]->row; searchcolumn = col + search_list[radius]->column; calculate_distances(searchrow, searchcolumn, north, east, &pointsfound); } /* Only if at least one offset is not 0 */ if ((search_list[radius]->row > 0 || search_list[radius]->column > 0) && row >= search_list[radius]->row && col >= search_list[radius]->column) { searchrow = row - search_list[radius]->row; searchcolumn = col - search_list[radius]->column; calculate_distances(searchrow, searchcolumn, north, east, &pointsfound); } /* Only if both offsets are not 0 */ if (search_list[radius]->row > 0 && search_list[radius]->column > 0) { if (row < (window.rows - search_list[radius]->row) && col >= search_list[radius]->column) { searchrow = row + search_list[radius]->row; searchcolumn = col - search_list[radius]->column; calculate_distances(searchrow, searchcolumn, north, east, &pointsfound); } if (row >= search_list[radius]->row && col < (window.cols - search_list[radius]->column)) { searchrow = row - search_list[radius]->row; searchcolumn = col + search_list[radius]->column; calculate_distances(searchrow, searchcolumn, north, east, &pointsfound); } } search_list[radius] = search_list[radius]->next; } radius++; } } } /* interpolate */ sum1 = 0.0; sum2 = 0.0; for (n = 0; n < nsearch; n++) { if ((dist = sqrt(list[n].dist))) { sum1 += list[n].z / pow(dist, p); sum2 += 1.0 / pow(dist, p); } else { /* If one site is dead on the centre of the cell, ignore * all the other sites and just use this value. * (Unlikely when using floating point numbers?) */ sum1 = list[n].z; sum2 = 1.0; break; } } interp_value = sum1 / sum2; } dcell[col] = (DCELL) interp_value; } Rast_put_d_row(fd, dcell); } G_percent(1, 1, 1); Rast_close(fd); /* writing history file */ Rast_short_history(parm.output->answer, "raster", &history); Rast_command_history(&history); Rast_write_history(parm.output->answer, &history); G_done_msg(" "); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { struct Flag *tostdout, *overwrite; struct Option *extradirs; struct GModule *module; FILE *outstream; char *fontcapfile; struct stat status; int i; G_set_program_name(argv[0]); G_no_gisinit(); G_set_gisrc_mode(G_GISRC_MODE_MEMORY); module = G_define_module(); module->keywords = "general"; module->description = "Generates the font configuration file by scanning various directories " "for fonts"; overwrite = G_define_flag(); overwrite->key = 'o'; overwrite->description = "Overwrite font configuration file if already existing"; tostdout = G_define_flag(); tostdout->key = 's'; tostdout->description = "Write font configuration file to standard output instead of " "$GISBASE/etc"; extradirs = G_define_option(); extradirs->key = "extradirs"; extradirs->type = TYPE_STRING; extradirs->required = NO; extradirs->description = "Comma-separated list of extra directories to scan for " "Freetype-compatible fonts as well as the defaults (see documentation)"; if (argc > 1 && G_parser(argc, argv)) exit(EXIT_FAILURE); if (!tostdout->answer) { const char *gisbase = G_gisbase(); const char *alt_file = getenv("GRASS_FONT_CAP"); if (alt_file) fontcapfile = G_store(alt_file); else G_asprintf(&fontcapfile, "%s/etc/fontcap", gisbase); if (!stat(fontcapfile, &status)) { /* File exists? */ if (!overwrite->answer) G_fatal_error ("Fontcap file %s already exists; use -%c flag if you " "wish to overwrite it", fontcapfile, overwrite->key); } } searchdirs = NULL; numsearchdirs = 0; /* Prepare list of directories to search */ if (extradirs->answer) { #ifndef HAVE_FT2BUILD_H G_warning("This GRASS installation was compiled without Freetype support, extradirs parameter ignored"); #endif char *str = G_store(extradirs->answer); while ((str = strtok(str, ","))) { add_search_dir(str); str = NULL; } } i = -1; while (standarddirs[++i]) add_search_dir(standarddirs[i]); totalfonts = maxfonts = 0; fontcap = NULL; find_stroke_fonts(); find_freetype_fonts(); qsort(fontcap, totalfonts, sizeof(struct GFONT_CAP), compare_fonts); if (tostdout->answer) outstream = stdout; else { outstream = fopen(fontcapfile, "w"); if (outstream == NULL) G_fatal_error("Cannot open %s for writing: %s", fontcapfile, strerror(errno)); } for (i = 0; i < totalfonts; i++) fprintf(outstream, "%s|%s|%d|%s|%d|%s|\n", fontcap[i].name, fontcap[i].longname, fontcap[i].type, fontcap[i].path, fontcap[i].index, fontcap[i].encoding); fclose(outstream); exit(EXIT_SUCCESS); }
int main(int argc, char **argv) { int field, type, vertex_type; double dmax; char buf[DB_SQL_MAX]; struct { struct Option *input, *output, *type, *dmax, *lfield, *use; } opt; struct { struct Flag *table, *inter; } flag; struct GModule *module; struct Map_info In, Out; struct line_cats *LCats; struct line_pnts *LPoints; dbDriver *driver; struct field_info *Fi; dbString stmt; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("vector")); G_add_keyword(_("geometry")); G_add_keyword("3D"); G_add_keyword(_("node")); G_add_keyword(_("vertex")); module->description = _("Creates points along input lines in new vector map with 2 layers."); opt.input = G_define_standard_option(G_OPT_V_INPUT); opt.lfield = G_define_standard_option(G_OPT_V_FIELD); opt.lfield->key = "llayer"; opt.lfield->answer = "1"; opt.lfield->label = "Line layer number or name"; opt.lfield->guisection = _("Selection"); opt.type = G_define_standard_option(G_OPT_V3_TYPE); opt.type->answer = "point,line,boundary,centroid,face"; opt.type->guisection = _("Selection"); opt.output = G_define_standard_option(G_OPT_V_OUTPUT); opt.use = G_define_option(); opt.use->key = "use"; opt.use->type = TYPE_STRING; opt.use->required = NO; opt.use->description = _("Use line nodes or vertices only"); opt.use->options = "node,vertex"; opt.dmax = G_define_option(); opt.dmax->key = "dmax"; opt.dmax->type = TYPE_DOUBLE; opt.dmax->required = NO; opt.dmax->answer = "100"; opt.dmax->description = _("Maximum distance between points in map units"); flag.inter = G_define_flag(); flag.inter->key = 'i'; flag.inter->description = _("Interpolate points between line vertices (only for use=vertex)"); flag.table = G_define_standard_flag(G_FLG_V_TABLE); if (G_parser(argc, argv)) exit(EXIT_FAILURE); LCats = Vect_new_cats_struct(); LPoints = Vect_new_line_struct(); db_init_string(&stmt); type = Vect_option_to_types(opt.type); dmax = atof(opt.dmax->answer); vertex_type = 0; if (opt.use->answer) { if (opt.use->answer[0] == 'n') vertex_type = GV_NODE; else vertex_type = GV_VERTEX; } Vect_check_input_output_name(opt.input->answer, opt.output->answer, G_FATAL_EXIT); /* Open input lines */ Vect_set_open_level(2); if (Vect_open_old2(&In, opt.input->answer, "", opt.lfield->answer) < 0) G_fatal_error(_("Unable to open vector map <%s>"), opt.input->answer); Vect_set_error_handler_io(&In, &Out); field = Vect_get_field_number(&In, opt.lfield->answer); /* Open output segments */ if (Vect_open_new(&Out, opt.output->answer, Vect_is_3d(&In)) < 0) G_fatal_error(_("Unable to create vector map <%s>"), opt.output->answer); Vect_copy_head_data(&In, &Out); Vect_hist_copy(&In, &Out); Vect_hist_command(&Out); /* Table */ Fi = NULL; if (!flag.table->answer) { struct field_info *Fin; /* copy input table */ Fin = Vect_get_field(&In, field); if (Fin) { /* table defined */ int ret; Fi = Vect_default_field_info(&Out, 1, NULL, GV_MTABLE); Vect_map_add_dblink(&Out, 1, NULL, Fi->table, Fin->key, Fi->database, Fi->driver); ret = db_copy_table(Fin->driver, Fin->database, Fin->table, Fi->driver, Vect_subst_var(Fi->database, &Out), Fi->table); if (ret == DB_FAILED) { G_fatal_error(_("Unable to copy table <%s>"), Fin->table); } } Fi = Vect_default_field_info(&Out, 2, NULL, GV_MTABLE); Vect_map_add_dblink(&Out, 2, NULL, Fi->table, GV_KEY_COLUMN, Fi->database, Fi->driver); /* Open driver */ 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); if (field == -1) sprintf(buf, "create table %s ( cat int, along double precision )", Fi->table); else sprintf(buf, "create table %s ( cat int, lcat int, along double precision )", Fi->table); db_append_string(&stmt, buf); if (db_execute_immediate(driver, &stmt) != DB_OK) { G_fatal_error(_("Unable to create table: '%s'"), db_get_string(&stmt)); } if (db_create_index2(driver, Fi->table, GV_KEY_COLUMN) != DB_OK) G_warning(_("Unable to create index for table <%s>, key <%s>"), Fi->table, GV_KEY_COLUMN); if (db_grant_on_table (driver, Fi->table, DB_PRIV_SELECT, DB_GROUP | DB_PUBLIC) != DB_OK) G_fatal_error(_("Unable to grant privileges on table <%s>"), Fi->table); db_begin_transaction(driver); } if (type & (GV_POINTS | GV_LINES | GV_FACE)) { int line, nlines, nskipped; nskipped = 0; nlines = Vect_get_num_lines(&In); for (line = 1; line <= nlines; line++) { int ltype, cat; G_debug(3, "line = %d", line); G_percent(line, nlines, 2); ltype = Vect_read_line(&In, LPoints, LCats, line); if (!(ltype & type)) continue; if (!Vect_cat_get(LCats, field, &cat) && field != -1) { nskipped++; continue; } /* Assign CAT for layer 0 objects (i.e. boundaries) */ if (field == -1) cat = -1; if (LPoints->n_points <= 1) { write_point(&Out, LPoints->x[0], LPoints->y[0], LPoints->z[0], cat, 0.0, driver, Fi); } else { /* lines */ write_line(&Out, LPoints, cat, vertex_type, flag.inter->answer, dmax, driver, Fi); } } if (nskipped > 0) G_warning(_("%d features without category in layer <%d> skipped. " "Note that features without category (usually boundaries) are not " "skipped when '%s=-1' is given."), nskipped, field, opt.lfield->key); } if (type == GV_AREA) { int area, nareas, centroid, cat; nareas = Vect_get_num_areas(&In); for (area = 1; area <= nareas; area++) { int i, isle, nisles; G_percent(area, nareas, 2); centroid = Vect_get_area_centroid(&In, area); cat = -1; if (centroid > 0) { Vect_read_line(&In, NULL, LCats, centroid); if (!Vect_cat_get(LCats, field, &cat)) continue; } Vect_get_area_points(&In, area, LPoints); write_line(&Out, LPoints, cat, vertex_type, flag.inter->answer, dmax, driver, Fi); nisles = Vect_get_area_num_isles(&In, area); for (i = 0; i < nisles; i++) { isle = Vect_get_area_isle(&In, area, i); Vect_get_isle_points(&In, isle, LPoints); write_line(&Out, LPoints, cat, vertex_type, flag.inter->answer, dmax, driver, Fi); } } } if (!flag.table->answer) { db_commit_transaction(driver); db_close_database_shutdown_driver(driver); } Vect_build(&Out); /* Free, close ... */ Vect_close(&In); G_done_msg(_("%d points written to output vector map."), Vect_get_num_primitives(&Out, GV_POINT)); Vect_close(&Out); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { struct GModule *module; struct Option *rastin, *rastout, *method; struct History history; char title[64]; char buf_nsres[100], buf_ewres[100]; struct Colors colors; int infile, outfile; DCELL *outbuf; int row, col; struct Cell_head dst_w, src_w; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("resample")); module->description = _("Resamples raster map layers to a finer grid using interpolation."); rastin = G_define_standard_option(G_OPT_R_INPUT); rastout = G_define_standard_option(G_OPT_R_OUTPUT); method = G_define_option(); method->key = "method"; method->type = TYPE_STRING; method->required = NO; method->description = _("Interpolation method"); method->options = "nearest,bilinear,bicubic,lanczos"; method->answer = "bilinear"; if (G_parser(argc, argv)) exit(EXIT_FAILURE); if (G_strcasecmp(method->answer, "nearest") == 0) neighbors = 1; else if (G_strcasecmp(method->answer, "bilinear") == 0) neighbors = 2; else if (G_strcasecmp(method->answer, "bicubic") == 0) neighbors = 4; else if (G_strcasecmp(method->answer, "lanczos") == 0) neighbors = 5; else G_fatal_error(_("Invalid method: %s"), method->answer); G_get_set_window(&dst_w); /* set window to old map */ Rast_get_cellhd(rastin->answer, "", &src_w); /* enlarge source window */ { double north = Rast_row_to_northing(0.5, &dst_w); double south = Rast_row_to_northing(dst_w.rows - 0.5, &dst_w); int r0 = (int)floor(Rast_northing_to_row(north, &src_w) - 0.5) - 2; int r1 = (int)floor(Rast_northing_to_row(south, &src_w) - 0.5) + 3; double west = Rast_col_to_easting(0.5, &dst_w); double east = Rast_col_to_easting(dst_w.cols - 0.5, &dst_w); int c0 = (int)floor(Rast_easting_to_col(west, &src_w) - 0.5) - 2; int c1 = (int)floor(Rast_easting_to_col(east, &src_w) - 0.5) + 3; src_w.south -= src_w.ns_res * (r1 - src_w.rows); src_w.north += src_w.ns_res * (-r0); src_w.west -= src_w.ew_res * (-c0); src_w.east += src_w.ew_res * (c1 - src_w.cols); src_w.rows = r1 - r0; src_w.cols = c1 - c0; } Rast_set_input_window(&src_w); /* allocate buffers for input rows */ for (row = 0; row < neighbors; row++) bufs[row] = Rast_allocate_d_input_buf(); cur_row = -100; /* open old map */ infile = Rast_open_old(rastin->answer, ""); /* reset window to current region */ Rast_set_output_window(&dst_w); outbuf = Rast_allocate_d_output_buf(); /* open new map */ outfile = Rast_open_new(rastout->answer, DCELL_TYPE); switch (neighbors) { case 1: /* nearest */ for (row = 0; row < dst_w.rows; row++) { double north = Rast_row_to_northing(row + 0.5, &dst_w); double maprow_f = Rast_northing_to_row(north, &src_w) - 0.5; int maprow0 = (int)floor(maprow_f + 0.5); G_percent(row, dst_w.rows, 2); read_rows(infile, maprow0); for (col = 0; col < dst_w.cols; col++) { double east = Rast_col_to_easting(col + 0.5, &dst_w); double mapcol_f = Rast_easting_to_col(east, &src_w) - 0.5; int mapcol0 = (int)floor(mapcol_f + 0.5); double c = bufs[0][mapcol0]; if (Rast_is_d_null_value(&c)) { Rast_set_d_null_value(&outbuf[col], 1); } else { outbuf[col] = c; } } Rast_put_d_row(outfile, outbuf); } break; case 2: /* bilinear */ for (row = 0; row < dst_w.rows; row++) { double north = Rast_row_to_northing(row + 0.5, &dst_w); double maprow_f = Rast_northing_to_row(north, &src_w) - 0.5; int maprow0 = (int)floor(maprow_f); double v = maprow_f - maprow0; G_percent(row, dst_w.rows, 2); read_rows(infile, maprow0); for (col = 0; col < dst_w.cols; col++) { double east = Rast_col_to_easting(col + 0.5, &dst_w); double mapcol_f = Rast_easting_to_col(east, &src_w) - 0.5; int mapcol0 = (int)floor(mapcol_f); int mapcol1 = mapcol0 + 1; double u = mapcol_f - mapcol0; double c00 = bufs[0][mapcol0]; double c01 = bufs[0][mapcol1]; double c10 = bufs[1][mapcol0]; double c11 = bufs[1][mapcol1]; if (Rast_is_d_null_value(&c00) || Rast_is_d_null_value(&c01) || Rast_is_d_null_value(&c10) || Rast_is_d_null_value(&c11)) { Rast_set_d_null_value(&outbuf[col], 1); } else { outbuf[col] = Rast_interp_bilinear(u, v, c00, c01, c10, c11); } } Rast_put_d_row(outfile, outbuf); } break; case 4: /* bicubic */ for (row = 0; row < dst_w.rows; row++) { double north = Rast_row_to_northing(row + 0.5, &dst_w); double maprow_f = Rast_northing_to_row(north, &src_w) - 0.5; int maprow1 = (int)floor(maprow_f); int maprow0 = maprow1 - 1; double v = maprow_f - maprow1; G_percent(row, dst_w.rows, 2); read_rows(infile, maprow0); for (col = 0; col < dst_w.cols; col++) { double east = Rast_col_to_easting(col + 0.5, &dst_w); double mapcol_f = Rast_easting_to_col(east, &src_w) - 0.5; int mapcol1 = (int)floor(mapcol_f); int mapcol0 = mapcol1 - 1; int mapcol2 = mapcol1 + 1; int mapcol3 = mapcol1 + 2; double u = mapcol_f - mapcol1; double c00 = bufs[0][mapcol0]; double c01 = bufs[0][mapcol1]; double c02 = bufs[0][mapcol2]; double c03 = bufs[0][mapcol3]; double c10 = bufs[1][mapcol0]; double c11 = bufs[1][mapcol1]; double c12 = bufs[1][mapcol2]; double c13 = bufs[1][mapcol3]; double c20 = bufs[2][mapcol0]; double c21 = bufs[2][mapcol1]; double c22 = bufs[2][mapcol2]; double c23 = bufs[2][mapcol3]; double c30 = bufs[3][mapcol0]; double c31 = bufs[3][mapcol1]; double c32 = bufs[3][mapcol2]; double c33 = bufs[3][mapcol3]; if (Rast_is_d_null_value(&c00) || Rast_is_d_null_value(&c01) || Rast_is_d_null_value(&c02) || Rast_is_d_null_value(&c03) || Rast_is_d_null_value(&c10) || Rast_is_d_null_value(&c11) || Rast_is_d_null_value(&c12) || Rast_is_d_null_value(&c13) || Rast_is_d_null_value(&c20) || Rast_is_d_null_value(&c21) || Rast_is_d_null_value(&c22) || Rast_is_d_null_value(&c23) || Rast_is_d_null_value(&c30) || Rast_is_d_null_value(&c31) || Rast_is_d_null_value(&c32) || Rast_is_d_null_value(&c33)) { Rast_set_d_null_value(&outbuf[col], 1); } else { outbuf[col] = Rast_interp_bicubic(u, v, c00, c01, c02, c03, c10, c11, c12, c13, c20, c21, c22, c23, c30, c31, c32, c33); } } Rast_put_d_row(outfile, outbuf); } break; case 5: /* lanczos */ for (row = 0; row < dst_w.rows; row++) { double north = Rast_row_to_northing(row + 0.5, &dst_w); double maprow_f = Rast_northing_to_row(north, &src_w) - 0.5; int maprow1 = (int)floor(maprow_f + 0.5); int maprow0 = maprow1 - 2; double v = maprow_f - maprow1; G_percent(row, dst_w.rows, 2); read_rows(infile, maprow0); for (col = 0; col < dst_w.cols; col++) { double east = Rast_col_to_easting(col + 0.5, &dst_w); double mapcol_f = Rast_easting_to_col(east, &src_w) - 0.5; int mapcol2 = (int)floor(mapcol_f + 0.5); int mapcol0 = mapcol2 - 2; int mapcol4 = mapcol2 + 2; double u = mapcol_f - mapcol2; double c[25]; int ci = 0, i, j, do_lanczos = 1; for (i = 0; i < 5; i++) { for (j = mapcol0; j <= mapcol4; j++) { c[ci] = bufs[i][j]; if (Rast_is_d_null_value(&(c[ci]))) { Rast_set_d_null_value(&outbuf[col], 1); do_lanczos = 0; break; } ci++; } if (!do_lanczos) break; } if (do_lanczos) { outbuf[col] = Rast_interp_lanczos(u, v, c); } } Rast_put_d_row(outfile, outbuf); } break; } G_percent(dst_w.rows, dst_w.rows, 2); Rast_close(infile); Rast_close(outfile); /* record map metadata/history info */ sprintf(title, "Resample by %s interpolation", method->answer); Rast_put_cell_title(rastout->answer, title); Rast_short_history(rastout->answer, "raster", &history); Rast_set_history(&history, HIST_DATSRC_1, rastin->answer); G_format_resolution(src_w.ns_res, buf_nsres, src_w.proj); G_format_resolution(src_w.ew_res, buf_ewres, src_w.proj); Rast_format_history(&history, HIST_DATSRC_2, "Source map NS res: %s EW res: %s", buf_nsres, buf_ewres); Rast_command_history(&history); Rast_write_history(rastout->answer, &history); /* copy color table from source map */ if (Rast_read_colors(rastin->answer, "", &colors) < 0) G_fatal_error(_("Unable to read color table for %s"), rastin->answer); Rast_mark_colors_as_fp(&colors); Rast_write_colors(rastout->answer, G_mapset(), &colors); return (EXIT_SUCCESS); }
int main(int argc, char *argv[]) { /* loop */ int i, j; /* store filename and path */ char *dig_file; char buf[2000]; /* Other local variables */ int attCount, nbreaks; struct grid_description grid_info; struct Cell_head window; struct Map_info Map; struct Option *vectname, *grid, *coord, *box, *angle, *position_opt, *breaks; struct GModule *module; struct Flag *points_fl, *line_fl; int points_p, line_p, output_type; char *desc; struct line_pnts *Points; struct line_cats *Cats; /* Attributes */ struct field_info *Fi; dbDriver *Driver; dbString sql; G_gisinit(argv[0]); /* Set description */ module = G_define_module(); G_add_keyword(_("vector")); G_add_keyword(_("geometry")); module->description = _("Creates a vector map of a user-defined grid."); vectname = G_define_standard_option(G_OPT_V_OUTPUT); vectname->key = "map"; grid = G_define_option(); grid->key = "grid"; grid->key_desc = _("rows,columns"); grid->type = TYPE_INTEGER; grid->required = YES; grid->multiple = NO; grid->description = _("Number of rows and columns in grid"); position_opt = G_define_option(); position_opt->key = "position"; position_opt->type = TYPE_STRING; position_opt->required = NO; position_opt->multiple = NO; position_opt->options = "region,coor"; position_opt->answer = "region"; position_opt->description = _("Where to place the grid"); desc = NULL; G_asprintf(&desc, "region;%s;coor;%s", _("current region"), _("use 'coor' and 'box' options")); position_opt->descriptions = desc; coord = G_define_option(); coord->key = "coor"; coord->key_desc = "x,y"; coord->type = TYPE_DOUBLE; coord->required = NO; coord->multiple = NO; coord->description = _("Lower left easting and northing coordinates of map"); box = G_define_option(); box->key = "box"; box->key_desc = _("width,height"); box->type = TYPE_DOUBLE; box->required = NO; box->multiple = NO; box->description = _("Width and height of boxes in grid"); angle = G_define_option(); angle->key = "angle"; angle->type = TYPE_DOUBLE; angle->required = NO; angle->description = _("Angle of rotation (in degrees counter-clockwise)"); angle->answer = "0"; breaks = G_define_option(); breaks->key = "breaks"; breaks->type = TYPE_INTEGER; breaks->required = NO; breaks->description = _("Number of vertex points per grid cell"); breaks->options = "0-60"; breaks->answer = "3"; points_fl = G_define_flag(); points_fl->key = 'p'; points_fl->description = _("Create grid of points instead of areas and centroids"); line_fl = G_define_flag(); line_fl->key = 'l'; line_fl->description = _("Create grid as lines, instead of areas"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); line_p = line_fl->answer; if (line_p) { output_type = GV_LINE; } else { output_type = GV_BOUNDARY; } points_p = points_fl->answer; /* get the current window */ G_get_window(&window); /* * information we need to collect from user: origin point x and y (lower * left), shift in x, shift in y, number of rows, number of cols */ dig_file = G_store(vectname->answer); /* Number of row and cols */ grid_info.num_rows = atoi(grid->answers[0]); grid_info.num_cols = atoi(grid->answers[1]); grid_info.angle = M_PI / 180 * atof(angle->answer); nbreaks = atoi(breaks->answer); /* Position */ if (position_opt->answer[0] == 'r') { /* region */ if (coord->answer) G_fatal_error(_("'coor' and 'position=region' are exclusive options")); if (box->answer) G_fatal_error(_("'box' and 'position=region' are exclusive options")); if (grid_info.angle != 0.0) G_fatal_error(_("'angle' and 'position=region' are exclusive options")); grid_info.origin_x = window.west; grid_info.origin_y = window.south; grid_info.length = (window.east - window.west) / grid_info.num_cols; grid_info.width = (window.north - window.south) / grid_info.num_rows; G_debug(2, "x = %e y = %e l = %e w = %e", grid_info.origin_x, grid_info.origin_y, grid_info.length, grid_info.width); } else { if (!coord->answer) G_fatal_error(_("'coor' option missing")); if (!box->answer) G_fatal_error(_("'box' option missing")); if (!G_scan_easting (coord->answers[0], &(grid_info.origin_x), window.proj)) G_fatal_error(_("Invalid easting"));; if (!G_scan_northing (coord->answers[1], &(grid_info.origin_y), window.proj)) G_fatal_error(_("Invalid northing"));; if (!G_scan_resolution (box->answers[0], &(grid_info.length), window.proj)) G_fatal_error(_("Invalid distance"));; if (!G_scan_resolution (box->answers[1], &(grid_info.width), window.proj)) G_fatal_error(_("Invalid distance"));; } /* * vector rows are the actual number of rows of vectors to make up the * entire grid. ditto for cols. */ grid_info.num_vect_rows = grid_info.num_rows + 1; grid_info.num_vect_cols = grid_info.num_cols + 1; Points = Vect_new_line_struct(); Cats = Vect_new_cats_struct(); db_init_string(&sql); /* Open output map */ if (0 > Vect_open_new(&Map, dig_file, 0)) { G_fatal_error(_("Unable to create vector map <%s>"), dig_file); } Vect_hist_command(&Map); /* Open database, create table */ Fi = Vect_default_field_info(&Map, 1, NULL, GV_1TABLE); Vect_map_add_dblink(&Map, Fi->number, Fi->name, Fi->table, Fi->key, Fi->database, Fi->driver); Driver = db_start_driver_open_database(Fi->driver, Vect_subst_var(Fi->database, &Map)); if (Driver == NULL) G_fatal_error(_("Unable to open database <%s> by driver <%s>"), Fi->database, Fi->driver); db_set_error_handler_driver(Driver); if (grid_info.num_rows < 27 && grid_info.num_cols < 27) { sprintf(buf, "create table %s ( cat integer, row integer, col integer, " "rown varchar(1), coln varchar(1))", Fi->table); } else { sprintf(buf, "create table %s ( cat integer, row integer, col integer)", Fi->table); } db_set_string(&sql, buf); G_debug(1, "SQL: %s", db_get_string(&sql)); if (db_execute_immediate(Driver, &sql) != DB_OK) { G_fatal_error(_("Unable to create table: %s"), db_get_string(&sql)); } if (db_create_index2(Driver, Fi->table, Fi->key) != DB_OK) G_warning(_("Unable to create index")); if (db_grant_on_table (Driver, Fi->table, DB_PRIV_SELECT, DB_GROUP | DB_PUBLIC) != DB_OK) G_fatal_error(_("Unable to grant privileges on table <%s>"), Fi->table); if (!points_p) { /* create areas */ write_grid(&grid_info, &Map, nbreaks, output_type); } /* Create a grid of label points at the centres of the grid cells */ G_verbose_message(_("Creating centroids...")); /* Write out centroids and attributes */ /* If the output id is lines it skips to add centroids and attributes TODO decide what to write in the attribute table */ if (!line_p) { db_begin_transaction(Driver); attCount = 0; for (i = 0; i < grid_info.num_rows; ++i) { for (j = 0; j < grid_info.num_cols; ++j) { double x, y; const int point_type = points_p ? GV_POINT : GV_CENTROID; x = grid_info.origin_x + (0.5 + j) * grid_info.length; y = grid_info.origin_y + (0.5 + i) * grid_info.width; rotate(&x, &y, grid_info.origin_x, grid_info.origin_y, grid_info.angle); Vect_reset_line(Points); Vect_reset_cats(Cats); Vect_append_point(Points, x, y, 0.0); Vect_cat_set(Cats, 1, attCount + 1); Vect_write_line(&Map, point_type, Points, Cats); sprintf(buf, "insert into %s values ", Fi->table); if (db_set_string(&sql, buf) != DB_OK) G_fatal_error(_("Unable to fill attribute table")); if (grid_info.num_rows < 27 && grid_info.num_cols < 27) { sprintf(buf, "( %d, %d, %d, '%c', '%c' )", attCount + 1, grid_info.num_rows - i, j + 1, 'A' + grid_info.num_rows - i - 1, 'A' + j); } else { sprintf(buf, "( %d, %d, %d )", attCount + 1, i + 1, j + 1); } if (db_append_string(&sql, buf) != DB_OK) G_fatal_error(_("Unable to fill attribute table")); G_debug(3, "SQL: %s", db_get_string(&sql)); if (db_execute_immediate(Driver, &sql) != DB_OK) { G_fatal_error(_("Unable to insert new record: %s"), db_get_string(&sql)); } attCount++; } } } db_commit_transaction(Driver); db_close_database_shutdown_driver(Driver); Vect_build(&Map); Vect_close(&Map); exit(EXIT_SUCCESS); }
int main( int argc, char **argv ) { char *mapset; char *name; struct GModule *module; struct Option *map; struct Option *win; struct Option *format; struct Cell_head window; RASTER_MAP_TYPE raster_type; /* 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" ); format = G_define_option(); format->key = "format"; format->type = TYPE_STRING; format->description = "format"; format->options = "color,value"; 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 */ #if GRASS_VERSION_MAJOR < 7 mapset = G_find_cell2( name, "" ); if ( mapset == NULL ) G_fatal_error(( "Raster map <%s> not found" ), name ); #else mapset = ""; #endif /* 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 ); raster_type = G_raster_map_type( name, "" ); display( name, mapset, raster_type, format->answer ); exit( EXIT_SUCCESS ); }
int main(int argc, char *argv[]) { FILE *ascii; struct Option *input, *output, *type_opt, *dp_opt, *layer_opt, *scale; struct Flag *coorcorr, *numatts, *labels; int itype, *types = NULL, typenum = 0, dp, i; struct Map_info Map; struct bound_box box; struct GModule *module; int layer, level; double zscale = 1.0, llscale = 1.0; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("vector")); G_add_keyword(_("export")); G_add_keyword("VTK"); module->description = _("Converts a vector map to VTK ASCII output."); input = G_define_standard_option(G_OPT_V_INPUT); output = G_define_standard_option(G_OPT_F_OUTPUT); output->required = NO; output->description = _("Name for output VTK file"); type_opt = G_define_standard_option(G_OPT_V_TYPE); type_opt->answer = "point,kernel,centroid,line,boundary,area,face"; type_opt->options = "point,kernel,centroid,line,boundary,area,face"; dp_opt = G_define_option(); dp_opt->key = "dp"; dp_opt->type = TYPE_INTEGER; dp_opt->required = NO; dp_opt->description = _("Number of significant digits (floating point only)"); scale = G_define_option(); scale->key = "scale"; scale->type = TYPE_DOUBLE; scale->required = NO; scale->description = _("Scale factor for elevation"); scale->answer = "1.0"; layer_opt = G_define_option(); layer_opt->key = "layer"; layer_opt->type = TYPE_INTEGER; layer_opt->required = NO; layer_opt->answer = "1"; layer_opt->description = _("Layer number"); coorcorr = G_define_flag(); coorcorr->key = 'c'; coorcorr->description = _("Correct the coordinates to fit the VTK-OpenGL precision"); numatts = G_define_flag(); numatts->key = 'n'; numatts->description = _("Export numeric attribute table fields as VTK scalar variables"); labels = NULL; /* to avoid compiler warning about "unused variable"*/ /* not yet supported labels = G_define_flag(); labels->key = 'l'; labels->description = _("Export text attribute table fields as VTK labels"); */ if (G_parser(argc, argv)) exit(EXIT_FAILURE); for (i = 0; type_opt->answers && type_opt->answers[i]; i++) typenum++; if (typenum > 0) { types = (int *)calloc(typenum, sizeof(int)); } else { G_fatal_error("Usage: Wrong vector type"); } i = 0; while (type_opt->answers[i]) { types[i] = -1; switch (type_opt->answers[i][0]) { case 'p': types[i] = GV_POINT; break; case 'k': types[i] = GV_KERNEL; break; case 'c': types[i] = GV_CENTROID; break; case 'l': types[i] = GV_LINE; break; case 'b': types[i] = GV_BOUNDARY; break; case 'a': types[i] = GV_AREA; break; case 'f': types[i] = GV_FACE; break; } i++; } itype = Vect_option_to_types(type_opt); /* read and compute the scale factor */ sscanf(scale->answer, "%lf", &zscale); /*if LL projection, convert the elevation values to degrees */ if (G_projection() == PROJECTION_LL) { llscale = M_PI / (180) * 6378137; zscale /= llscale; printf("Scale %g\n", zscale); } /*The precision of the output */ if (dp_opt->answer) { if (sscanf(dp_opt->answer, "%d", &dp) != 1) G_fatal_error(_("Failed to interpret 'dp' parameter as an integer")); if (dp > 8 || dp < 0) G_fatal_error(_("dp has to be from 0 to 8")); } else { dp = 8; /*This value is taken from the lib settings in G_feature_easting */ } /*The Layer */ if (layer_opt->answer) { if (sscanf(layer_opt->answer, "%d", &layer) != 1) G_fatal_error(_("Failed to interpret 'layer' parameter as an integer")); } else { layer = 1; } if (output->answer) { ascii = fopen(output->answer, "w"); if (ascii == NULL) { G_fatal_error(_("Unable to open file <%s>"), output->answer); } } else { ascii = stdout; } /* Open input vector */ level = Vect_open_old(&Map, input->answer, ""); if (level < 2 && (itype & GV_AREA)) G_fatal_error(_("Export of areas requires topology. " "Please adjust '%s' option or rebuild topology."), type_opt->key); if (level == 2) Vect_get_map_box(&Map, &box); else { int i, type, first = TRUE; struct line_pnts *Points = Vect_new_line_struct(); Vect_rewind(&Map); while ((type = Vect_read_next_line(&Map, Points, NULL)) > 0) { if (first) { box.E = box.W = Points->x[0]; box.N = box.S = Points->y[0]; box.B = box.T = Points->z[0]; first = FALSE; } for (i = 1; i < Points->n_points; i++) { if (Points->x[i] > box.E) box.E = Points->x[i]; else if (Points->x[i] < box.W) box.W = Points->x[i]; if (Points->y[i] > box.N) box.N = Points->y[i]; else if (Points->y[i] < box.S) box.S = Points->y[i]; if (Points->z[i] > box.T) box.T = Points->z[i]; else if (Points->z[i] < box.B) box.B = Points->z[i]; } } Vect_destroy_line_struct(Points); } /*Correct the coordinates, so the precision of VTK is not hurt :( */ if (coorcorr->answer) { /*Use the center of the vector's bbox as extent */ y_extent = (box.N + box.S) / 2; x_extent = (box.W + box.E) / 2; } else { x_extent = 0; y_extent = 0; } /*Write the header */ write_vtk_head(ascii, &Map); /*Write the geometry and data */ write_vtk(ascii, &Map, layer, types, typenum, dp, zscale, numatts->answer, 0 ); /* change to this, when labels get supported: write_vtk(ascii, &Map, layer, types, typenum, dp, zscale, numatts->answer, labels->answer ); */ if (ascii != NULL) fclose(ascii); Vect_close(&Map); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { int i, j; /* Loop control variables */ int bands; /* Number of image bands */ double *mu; /* Mean vector for image bands */ double **covar; /* Covariance Matrix */ double *eigval; double **eigmat; int *inp_fd; int scale, scale_max, scale_min; struct GModule *module; struct Option *opt_in, *opt_out, *opt_scale; /* initialize GIS engine */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("imagery")); G_add_keyword(_("image transformation")); G_add_keyword(_("PCA")); module->description = _("Principal components analysis (PCA) " "for image processing."); /* Define options */ opt_in = G_define_standard_option(G_OPT_R_INPUTS); opt_in->description = _("Name of two or more input raster maps"); opt_out = G_define_option(); opt_out->label = _("Base name for output raster maps"); opt_out->description = _("A numerical suffix will be added for each component map"); opt_out->key = "output_prefix"; opt_out->type = TYPE_STRING; opt_out->key_desc = "string"; opt_out->required = YES; opt_scale = G_define_option(); opt_scale->key = "rescale"; opt_scale->type = TYPE_INTEGER; opt_scale->key_desc = "min,max"; opt_scale->required = NO; opt_scale->answer = "0,255"; opt_scale->label = _("Rescaling range for output maps"); opt_scale->description = _("For no rescaling use 0,0"); opt_scale->guisection = _("Rescale"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); /* determine number of bands passed in */ for (bands = 0; opt_in->answers[bands] != NULL; bands++) ; if (bands < 2) G_fatal_error(_("Sorry, at least 2 input bands must be provided")); /* default values */ scale = 1; scale_min = 0; scale_max = 255; /* get scale parameters */ set_output_scale(opt_scale, &scale, &scale_min, &scale_max); /* allocate memory */ covar = G_alloc_matrix(bands, bands); mu = G_alloc_vector(bands); inp_fd = G_alloc_ivector(bands); eigmat = G_alloc_matrix(bands, bands); eigval = G_alloc_vector(bands); /* open and check input/output files */ for (i = 0; i < bands; i++) { char tmpbuf[128]; sprintf(tmpbuf, "%s.%d", opt_out->answer, i + 1); G_check_input_output_name(opt_in->answers[i], tmpbuf, GR_FATAL_EXIT); inp_fd[i] = Rast_open_old(opt_in->answers[i], ""); } G_verbose_message(_("Calculating covariance matrix...")); calc_mu(inp_fd, mu, bands); calc_covariance(inp_fd, covar, mu, bands); for (i = 0; i < bands; i++) { for (j = 0; j < bands; j++) { covar[i][j] = covar[i][j] / ((double)((Rast_window_rows() * Rast_window_cols()) - 1)); G_debug(3, "covar[%d][%d] = %f", i, j, covar[i][j]); } } G_math_d_copy(covar[0], eigmat[0], bands*bands); G_debug(1, "Calculating eigenvalues and eigenvectors..."); G_math_eigen(eigmat, eigval, bands); #ifdef PCA_DEBUG /* dump eigen matrix and eigen values */ dump_eigen(bands, eigmat, eigval); #endif G_debug(1, "Ordering eigenvalues in descending order..."); G_math_egvorder(eigval, eigmat, bands); G_debug(1, "Transposing eigen matrix..."); G_math_d_A_T(eigmat, bands); /* write output images */ write_pca(eigmat, inp_fd, opt_out->answer, bands, scale, scale_min, scale_max); /* write colors and history to output */ for (i = 0; i < bands; i++) { char outname[80]; sprintf(outname, "%s.%d", opt_out->answer, i + 1); /* write colors and history to file */ write_support(bands, outname, eigmat, eigval); /* close output file */ Rast_unopen(inp_fd[i]); } /* free memory */ G_free_matrix(covar); G_free_vector(mu); G_free_ivector(inp_fd); G_free_matrix(eigmat); G_free_vector(eigval); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { struct Map_info In, Out; static struct line_pnts *Points; struct line_cats *Cats; struct field_info *Fi; struct cat_list *Clist; int i, j, ret, option, otype, type, with_z, step, id; int n_areas, centr, new_centr, nmodified; int open_level; double x, y; int cat, ocat, scat, *fields, nfields, field; struct GModule *module; struct Option *in_opt, *out_opt, *option_opt, *type_opt; struct Option *cat_opt, *field_opt, *step_opt, *id_opt; struct Flag *shell, *notab; FREPORT **freps; int nfreps, rtype, fld; char *desc; module = G_define_module(); G_add_keyword(_("vector")); G_add_keyword(_("category")); G_add_keyword(_("layer")); module->description = _("Attaches, deletes or reports vector categories to map geometry."); in_opt = G_define_standard_option(G_OPT_V_INPUT); field_opt = G_define_standard_option(G_OPT_V_FIELD); field_opt->multiple = YES; field_opt->guisection = _("Selection"); type_opt = G_define_standard_option(G_OPT_V3_TYPE); type_opt->answer = "point,line,centroid,face"; type_opt->guisection = _("Selection"); id_opt = G_define_standard_option(G_OPT_V_IDS); id_opt->label = _("Feature ids (by default all features are processed)"); id_opt->guisection = _("Selection"); out_opt = G_define_standard_option(G_OPT_V_OUTPUT); out_opt->required = NO; option_opt = G_define_option(); option_opt->key = "option"; option_opt->type = TYPE_STRING; option_opt->required = YES; option_opt->multiple = NO; option_opt->options = "add,del,chlayer,sum,report,print,layers,transfer"; option_opt->description = _("Action to be done"); desc = NULL; G_asprintf(&desc, "add;%s;" "del;%s;" "chlayer;%s;" "sum;%s;" "transfer;%s;" "report;%s;" "print;%s;" "layers;%s", _("add a category to features without category in the given layer"), _("delete category (cat=-1 to delete all categories of given layer)"), _("change layer number (e.g. layer=3,1 changes layer 3 to layer 1)"), _("add the value specified by cat option to the current category value"), _("copy values from one layer to another (e.g. layer=1,2,3 copies values from layer 1 to layer 2 and 3)"), _("print report (statistics), in shell style: layer type count min max"), _("print category values, layers are separated by '|', more cats in the same layer are separated by '/'"), _("print only layer numbers")); option_opt->descriptions = desc; cat_opt = G_define_standard_option(G_OPT_V_CAT); cat_opt->answer = "1"; step_opt = G_define_option(); step_opt->key = "step"; step_opt->type = TYPE_INTEGER; step_opt->required = NO; step_opt->multiple = NO; step_opt->answer = "1"; step_opt->description = _("Category increment"); shell = G_define_flag(); shell->key = 'g'; shell->label = _("Shell script style, currently only for report"); shell->description = _("Format: layer type count min max"); notab = G_define_standard_flag(G_FLG_V_TABLE); notab->description = _("Do not copy attribute table(s)"); G_gisinit(argv[0]); if (G_parser(argc, argv)) exit(EXIT_FAILURE); /* read options */ option = 0; switch (option_opt->answer[0]) { case ('a'): option = O_ADD; break; case ('d'): option = O_DEL; break; case ('c'): option = O_CHFIELD; G_warning(_("Database connection and attribute tables for concerned layers are not changed")); break; case ('s'): option = O_SUM; break; case ('t'): option = O_TRANS; break; case ('r'): option = O_REP; break; case ('p'): option = O_PRN; break; case ('l'): option = O_LYR; break; } if (option == O_LYR) { /* print vector layer numbers */ /* open vector on level 2 head only, this is why this option * is processed here, all other options need (?) to fully open * the input vector */ Vect_set_open_level(2); if (Vect_open_old_head2(&In, in_opt->answer, "", field_opt->answer) < 2) { G_fatal_error(_("Unable to open vector map <%s> at topological level %d"), Vect_get_full_name(&In), 2); } if (In.format == GV_FORMAT_NATIVE) { nfields = Vect_cidx_get_num_fields(&In); for (i = 0; i < nfields; i++) { if ((field = Vect_cidx_get_field_number(&In, i)) > 0) fprintf(stdout, "%d\n", field); } } else fprintf(stdout, "%s\n", field_opt->answer); Vect_close(&In); exit(EXIT_SUCCESS); } cat = atoi(cat_opt->answer); step = atoi(step_opt->answer); otype = Vect_option_to_types(type_opt); if (cat < 0 && option == O_ADD) G_fatal_error(_("Invalid category number (must be equal to or greater than 0). " "Normally category number starts at 1.")); /* collect ids */ if (id_opt->answer) { Clist = Vect_new_cat_list(); Clist->field = atoi(field_opt->answer); ret = Vect_str_to_cat_list(id_opt->answer, Clist); if (ret > 0) { G_warning(n_("%d error in id option", "%d errors in id option", ret), ret); } } else { Clist = NULL; } if ((option != O_REP) && (option != O_PRN) && (option != O_LYR)) { if (out_opt->answer == NULL) G_fatal_error(_("Output vector wasn't entered")); Vect_check_input_output_name(in_opt->answer, out_opt->answer, G_FATAL_EXIT); } Points = Vect_new_line_struct(); Cats = Vect_new_cats_struct(); /* do we need topology ? */ if ((option == O_ADD && (otype & GV_AREA)) || (option == O_REP && (otype & GV_AREA)) || (option == O_TRANS) || /* topo for cidx check */ (option == O_LYR)) /* topo for cidx check */ open_level = 2; else open_level = 1; /* open input vector */ if (open_level > 1) { Vect_set_open_level(open_level); if (Vect_open_old2(&In, in_opt->answer, "", field_opt->answer) < open_level) { G_warning(_("Unable to open vector map <%s> at topological level %d"), Vect_get_full_name(&In), open_level); open_level = 1; } } if (open_level == 1) { Vect_set_open_level(open_level); if (Vect_open_old2(&In, in_opt->answer, "", field_opt->answer) < open_level) { G_fatal_error(_("Unable to open vector map <%s> at topological level %d"), Vect_get_full_name(&In), open_level); } } /* read fields */ i = nfields = 0; while (field_opt->answers[i++]) nfields++; fields = (int *)G_malloc(nfields * sizeof(int)); i = 0; while (field_opt->answers[i]) { fields[i] = Vect_get_field_number(&In, field_opt->answers[i]); i++; } if (nfields > 1 && option != O_PRN && option != O_CHFIELD && option != O_TRANS) G_fatal_error(_("Too many layers for this operation")); if (nfields != 2 && option == O_CHFIELD) G_fatal_error(_("2 layers must be specified")); if (option == O_TRANS && open_level == 1 && nfields < 2) { G_fatal_error(_("2 layers must be specified")); } if (option == O_TRANS && open_level > 1) { /* check if field[>0] already exists */ if (nfields > 1) { for(i = 1; i < nfields; i++) { if (Vect_cidx_get_field_index(&In, fields[i]) != -1) G_warning(_("Categories already exist in layer %d"), fields[i]); } } /* find next free layer number */ else if (nfields == 1) { int max = -1; for (i = 0; i < Vect_cidx_get_num_fields(&In); i++) { if (max < Vect_cidx_get_field_number(&In, i)) max = Vect_cidx_get_field_number(&In, i); } max++; nfields++; fields = (int *)G_realloc(fields, nfields * sizeof(int)); fields[nfields - 1] = max; } } if (otype & GV_AREA && option == O_TRANS && !(otype & GV_CENTROID)) otype |= GV_CENTROID; /* open output vector if needed */ if (option == O_ADD || option == O_DEL || option == O_CHFIELD || option == O_SUM || option == O_TRANS) { with_z = Vect_is_3d(&In); if (0 > Vect_open_new(&Out, out_opt->answer, with_z)) { Vect_close(&In); exit(EXIT_FAILURE); } Vect_copy_head_data(&In, &Out); Vect_hist_copy(&In, &Out); Vect_hist_command(&Out); } id = 0; nmodified = 0; if (option == O_ADD || option == O_DEL || option == O_CHFIELD || option == O_SUM || option == O_TRANS) { G_message(_("Processing features...")); } switch (option) { case (O_ADD): /* Lines */ while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) { id++; if (type & otype && (!Clist || (Clist && Vect_cat_in_cat_list(id, Clist) == TRUE))) { if ((Vect_cat_get(Cats, fields[0], &ocat)) == 0) { if (ocat < 0) { if (Vect_cat_set(Cats, fields[0], cat) > 0) { nmodified++; } cat += step; } } } Vect_write_line(&Out, type, Points, Cats); } /* Areas */ if ((otype & GV_AREA) && open_level > 1) { n_areas = Vect_get_num_areas(&In); new_centr = 0; for (i = 1; i <= n_areas; i++) { centr = Vect_get_area_centroid(&In, i); if (centr > 0) continue; /* Centroid exists and may be processed as line */ ret = Vect_get_point_in_area(&In, i, &x, &y); if (ret < 0) { G_warning(_("Unable to calculate area centroid")); continue; } Vect_reset_line(Points); Vect_reset_cats(Cats); Vect_append_point(Points, x, y, 0.0); if (Vect_cat_set(Cats, fields[0], cat) > 0) { nmodified++; } cat += step; Vect_write_line(&Out, GV_CENTROID, Points, Cats); new_centr++; } if (new_centr > 0) G_message(n_("%d new centroid placed in output map", "%d new centroids placed in output map", new_centr), new_centr); } break; case (O_TRANS): /* Lines */ while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) { id++; if (type & otype && (!Clist || (Clist && Vect_cat_in_cat_list(id, Clist) == TRUE))) { int n = Cats->n_cats; scat = -1; for (i = 0; i < n; i++) { if (Cats->field[i] == fields[0]) { scat = Cats->cat[i]; for (j = 1; j < nfields; j++) { if (Vect_cat_set(Cats, fields[j], scat) > 0) { G_debug(4, "Copy cat %i of field %i to field %i", scat, fields[0], fields[j]); } } } } if (scat != -1) nmodified++; } Vect_write_line(&Out, type, Points, Cats); } break; case (O_DEL): while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) { id++; if (type & otype && (!Clist || (Clist && Vect_cat_in_cat_list(id, Clist) == TRUE))) { ret = Vect_field_cat_del(Cats, fields[0], cat); if (ret > 0) { nmodified++; } } Vect_write_line(&Out, type, Points, Cats); } break; case (O_CHFIELD): while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) { id++; if (type & otype && (!Clist || (Clist && Vect_cat_in_cat_list(id, Clist) == TRUE))) { i = 0; while (i < Cats->n_cats) { if (Cats->field[i] == fields[0]) { int found = -1; /* check if cat already exists in layer fields[1] */ for (j = 0; j < Cats->n_cats; j++) { if (Cats->field[j] == fields[1] && Cats->cat[j] == Cats->cat[i]) { found = j; break; } } /* does not exist, change layer */ if (found < 0) { Cats->field[i] = fields[1]; i++; } /* exists already in fields[1], delete from fields[0] */ else Vect_field_cat_del(Cats, fields[0], Cats->cat[found]); nmodified++; } } } Vect_write_line(&Out, type, Points, Cats); } break; case (O_SUM): while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) { id++; if (type & otype && (!Clist || (Clist && Vect_cat_in_cat_list(id, Clist) == TRUE))) { for (i = 0; i < Cats->n_cats; i++) { if (Cats->field[i] == fields[0]) { Cats->cat[i] += cat; } } nmodified++; } Vect_write_line(&Out, type, Points, Cats); } break; case (O_REP): nfreps = 0; freps = NULL; while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) { id++; if (Clist && Vect_cat_in_cat_list(id, Clist) == FALSE) continue; switch (type) { case (GV_POINT): rtype = FR_POINT; break; case (GV_LINE): rtype = FR_LINE; break; case (GV_BOUNDARY): rtype = FR_BOUNDARY; break; case (GV_CENTROID): rtype = FR_CENTROID; break; case (GV_FACE): rtype = FR_FACE; break; case (GV_KERNEL): rtype = FR_KERNEL; break; default: rtype = FR_UNKNOWN; } for (i = 0; i < Cats->n_cats; i++) { field = Cats->field[i]; cat = Cats->cat[i]; ret = FALSE; for (j = 0; j < nfreps; j++) { if (freps[j]->field == field) { fld = j; ret = TRUE; break; } } if (!ret) { /* field report doesn't exist */ nfreps++; freps = (FREPORT **) G_realloc(freps, nfreps * sizeof(FREPORT *)); fld = nfreps - 1; freps[fld] = (FREPORT *) G_calloc(1, sizeof(FREPORT)); freps[fld]->field = field; for (j = 0; j < FRTYPES; j++) { /* cat '0' is valid category number */ freps[fld]->min[j] = -1; } if ((Fi = Vect_get_field(&In, field)) != NULL) { freps[fld]->table = G_store(Fi->table); } else { freps[fld]->table = '\0'; } } freps[fld]->count[rtype]++; freps[fld]->count[FR_ALL]++; if (freps[fld]->min[rtype] == -1 || freps[fld]->min[rtype] > cat) freps[fld]->min[rtype] = cat; if ((freps[fld]->max[rtype] == 0) || freps[fld]->max[rtype] < cat) freps[fld]->max[rtype] = cat; if (freps[fld]->min[FR_ALL] == -1 || freps[fld]->min[FR_ALL] > cat) freps[fld]->min[FR_ALL] = cat; if ((freps[fld]->max[FR_ALL] == 0) || freps[fld]->max[FR_ALL] < cat) freps[fld]->max[FR_ALL] = cat; } } /* Areas */ if ((otype & GV_AREA) && open_level > 1 && !Clist) { n_areas = Vect_get_num_areas(&In); for (i = 1; i <= n_areas; i++) { int k; centr = Vect_get_area_centroid(&In, i); if (centr <= 0) continue; /* Area without centroid */ Vect_read_line(&In, NULL, Cats, centr); for (j = 0; j < Cats->n_cats; j++) { field = Cats->field[j]; cat = Cats->cat[j]; ret = FALSE; for (k = 0; k < nfreps; k++) { if (freps[k]->field == field) { fld = k; ret = TRUE; break; } } if (!ret) { /* field report doesn't exist */ nfreps++; freps = (FREPORT **) G_realloc(freps, nfreps * sizeof(FREPORT *)); fld = nfreps - 1; freps[fld] = (FREPORT *) G_calloc(1, sizeof(FREPORT)); freps[fld]->field = field; for (j = 0; j < FRTYPES; j++) { /* cat '0' is valid category number */ freps[fld]->min[k] = -1; } if ((Fi = Vect_get_field(&In, field)) != NULL) { freps[fld]->table = G_store(Fi->table); } else { freps[fld]->table = '\0'; } } freps[fld]->count[FR_AREA]++; if (freps[fld]->min[FR_AREA] == -1 || freps[fld]->min[FR_AREA] > cat) freps[fld]->min[FR_AREA] = cat; if ((freps[fld]->max[FR_AREA] == 0) || freps[fld]->max[FR_AREA] < cat) freps[fld]->max[FR_AREA] = cat; } } } for (i = 0; i < nfreps; i++) { if (shell->answer) { if (freps[i]->count[FR_POINT] > 0) fprintf(stdout, "%d point %d %d %d\n", freps[i]->field, freps[i]->count[FR_POINT], (freps[i]->min[FR_POINT] < 0 ? 0 : freps[i]->min[FR_POINT]), freps[i]->max[FR_POINT]); if (freps[i]->count[FR_LINE] > 0) fprintf(stdout, "%d line %d %d %d\n", freps[i]->field, freps[i]->count[FR_LINE], (freps[i]->min[FR_LINE] < 0 ? 0 : freps[i]->min[FR_LINE]), freps[i]->max[FR_LINE]); if (freps[i]->count[FR_BOUNDARY] > 0) fprintf(stdout, "%d boundary %d %d %d\n", freps[i]->field, freps[i]->count[FR_BOUNDARY], (freps[i]->min[FR_BOUNDARY] < 0 ? 0 : freps[i]->min[FR_BOUNDARY]), freps[i]->max[FR_BOUNDARY]); if (freps[i]->count[FR_CENTROID] > 0) fprintf(stdout, "%d centroid %d %d %d\n", freps[i]->field, freps[i]->count[FR_CENTROID], (freps[i]->min[FR_BOUNDARY] < 0 ? 0 : freps[i]->min[FR_BOUNDARY]), freps[i]->max[FR_CENTROID]); if (freps[i]->count[FR_AREA] > 0) fprintf(stdout, "%d area %d %d %d\n", freps[i]->field, freps[i]->count[FR_AREA], (freps[i]->min[FR_AREA] < 0 ? 0 : freps[i]->min[FR_AREA]), freps[i]->max[FR_AREA]); if (freps[i]->count[FR_FACE] > 0) fprintf(stdout, "%d face %d %d %d\n", freps[i]->field, freps[i]->count[FR_FACE], (freps[i]->min[FR_FACE] < 0 ? 0 : freps[i]->min[FR_FACE]), freps[i]->max[FR_FACE]); if (freps[i]->count[FR_KERNEL] > 0) fprintf(stdout, "%d kernel %d %d %d\n", freps[i]->field, freps[i]->count[FR_KERNEL], (freps[i]->min[FR_KERNEL] < 0 ? 0 : freps[i]->min[FR_KERNEL]), freps[i]->max[FR_KERNEL]); if (freps[i]->count[FR_ALL] > 0) fprintf(stdout, "%d all %d %d %d\n", freps[i]->field, freps[i]->count[FR_ALL], (freps[i]->min[FR_ALL] < 0 ? 0 : freps[i]->min[FR_ALL]), freps[i]->max[FR_ALL]); } else { if (freps[i]->table != '\0') { fprintf(stdout, "%s: %d/%s\n", _("Layer/table"), freps[i]->field, freps[i]->table); } else { fprintf(stdout, "%s: %d\n", _("Layer"), freps[i]->field); } fprintf(stdout, _("type count min max\n")); fprintf(stdout, "%s %7d %10d %10d\n", _("point"), freps[i]->count[FR_POINT], (freps[i]->min[FR_POINT] < 0) ? 0 : freps[i]->min[FR_POINT], freps[i]->max[FR_POINT]); fprintf(stdout, "%s %7d %10d %10d\n", _("line"), freps[i]->count[FR_LINE], (freps[i]->min[FR_LINE] < 0) ? 0 : freps[i]->min[FR_LINE], freps[i]->max[FR_LINE]); fprintf(stdout, "%s %7d %10d %10d\n", _("boundary"), freps[i]->count[FR_BOUNDARY], (freps[i]->min[FR_BOUNDARY] < 0) ? 0 : freps[i]->min[FR_BOUNDARY], freps[i]->max[FR_BOUNDARY]); fprintf(stdout, "%s %7d %10d %10d\n", _("centroid"), freps[i]->count[FR_CENTROID], (freps[i]->min[FR_CENTROID] < 0) ? 0 : freps[i]->min[FR_CENTROID], freps[i]->max[FR_CENTROID]); fprintf(stdout, "%s %7d %10d %10d\n", _("area"), freps[i]->count[FR_AREA], (freps[i]->min[FR_AREA] < 0) ? 0 : freps[i]->min[FR_AREA], freps[i]->max[FR_AREA]); fprintf(stdout, "%s %7d %10d %10d\n", _("face"), freps[i]->count[FR_FACE], (freps[i]->min[FR_FACE] < 0) ? 0 : freps[i]->min[FR_FACE], freps[i]->max[FR_FACE]); fprintf(stdout, "%s %7d %10d %10d\n", _("kernel"), freps[i]->count[FR_KERNEL], (freps[i]->min[FR_KERNEL] < 0) ? 0 : freps[i]->min[FR_KERNEL], freps[i]->max[FR_KERNEL]); fprintf(stdout, "%s %7d %10d %10d\n", _("all"), freps[i]->count[FR_ALL], (freps[i]->min[FR_ALL] < 0) ? 0 : freps[i]->min[FR_ALL], freps[i]->max[FR_ALL]); } } break; case (O_PRN): while ((type = Vect_read_next_line(&In, Points, Cats)) > 0) { id++; int has = 0; if (!(type & otype)) continue; if (Clist && Vect_cat_in_cat_list(id, Clist) == FALSE) continue; /* Check if the line has at least one cat */ for (i = 0; i < nfields; i++) { for (j = 0; j < Cats->n_cats; j++) { if (Cats->field[j] == fields[i]) { has = 1; break; } } } if (!has) continue; for (i = 0; i < nfields; i++) { int first = 1; if (i > 0) fprintf(stdout, "|"); for (j = 0; j < Cats->n_cats; j++) { if (Cats->field[j] == fields[i]) { if (!first) fprintf(stdout, "/"); fprintf(stdout, "%d", Cats->cat[j]); first = 0; } } } fprintf(stdout, "\n"); } break; } if (option == O_ADD || option == O_DEL || option == O_CHFIELD || option == O_SUM || option == O_TRANS){ if (!notab->answer){ G_message(_("Copying attribute table(s)...")); if (Vect_copy_tables(&In, &Out, 0)) G_warning(_("Failed to copy attribute table to output map")); } Vect_build(&Out); Vect_close(&Out); } if (option == O_TRANS && nmodified > 0) for(i = 1; i < nfields; i++) G_important_message(_("Categories copied from layer %d to layer %d"), fields[0], fields[i]); if (option != O_REP && option != O_PRN) G_done_msg(n_("%d feature modified.", "%d features modified.", nmodified), nmodified); Vect_close(&In); exit(EXIT_SUCCESS); }
void parse_args(int argc, char **argv, struct _options *options, struct _flags *flags) { options->dsn = G_define_option(); options->dsn->key = "output"; options->dsn->type = TYPE_STRING; options->dsn->label = _("Name of output directory or 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 = NO; options->dsn->guisection = _("Settings"); options->format = G_define_option(); options->format->key = "format"; options->format->description = _("Format for output vector data"); options->format->required = NO; options->format->type = TYPE_STRING; options->format->options = format_options(); #ifdef HAVE_OGR options->format->answer = "ESRI_Shapefile"; #else #ifdef HAVE_POSTGRES options->format->answer = "PostgreSQL"; #endif /* HAVE_POSTGRES */ #endif /* HAVE_OGR */ options->format->guisection = _("Settings"); options->opts = G_define_option(); options->opts->key = "options"; options->opts->label = _("Creation options"); options->opts->description = _("Examples:\n" "\t\t'SHPT=POINTZ': create 3D point Shapefile data\n" "\t\t'GEOM_TYPE=geography': use geography PostGIS data\n" "\t\t'SCHEMA=grass': create new PostGIS tables in 'grass' schema"); options->opts->required = NO; options->opts->multiple = YES; options->opts->type = TYPE_STRING; options->opts->guisection = _("Settings"); options->input = G_define_standard_option(G_OPT_F_INPUT); options->input->key = "loadsettings"; options->input->required = NO; options->input->description = _("Name of input file to read settings from"); options->input->guisection = _("Settings"); options->output = G_define_standard_option(G_OPT_F_OUTPUT); options->output->key = "savesettings"; options->output->required = NO; options->output->description = _("Name for output file where to save current settings"); 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/PostGIS, 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); /* check options */ if (options->dsn->answer && options->format->answer && options->input->answer) G_fatal_error(_("%s= and %s=/%s= are mutually exclusive"), options->input->key, options->dsn->key, options->format->key); if (flags->f->answer || flags->p->answer || flags->r->answer || flags->g->answer || options->output->answer) return; if (!options->dsn->answer && !options->input->answer) G_fatal_error(_("%s= or %s= must be specified"), options->dsn->key, options->input->key); if (options->dsn->answer && !options->format->answer) G_fatal_error(_("%s= must be specified"), options->format->key); }
int main(int argc, char **argv) { int line; struct line_pnts *points; struct line_cats *Cats; struct Map_info map, Out; struct GModule *module; struct Option *input; struct Option *output; struct Option *cats; struct Option *type_opt; char *desc; int polyline; int *lines_visited; int points_in_polyline; int start_line; int nlines; int write_cats, copy_tables; int type, ltype; /* Initialize the GIS calls */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("vector")); G_add_keyword(_("topology")); G_add_keyword(_("geometry")); G_add_keyword(_("line")); G_add_keyword(_("node")); G_add_keyword(_("vertex")); module->description = _("Builds polylines from lines or boundaries."); /* Define the options */ input = G_define_standard_option(G_OPT_V_INPUT); output = G_define_standard_option(G_OPT_V_OUTPUT); cats = G_define_option(); cats->key = "cats"; cats->type = TYPE_STRING; cats->description = _("Category number mode"); cats->options = "no,first,multi,same"; desc = NULL; G_asprintf(&desc, "no;%s;first;%s;multi;%s;same;%s", _("Do not assign any category number to polyline"), _("Assign category number of first line to polyline"), _("Assign multiple category numbers to polyline"), _("Create polyline from lines with same categories")); cats->descriptions = desc; cats->answer = "no"; type_opt = G_define_standard_option(G_OPT_V_TYPE); type_opt->options = "line,boundary"; type_opt->answer = "line,boundary"; if (G_parser(argc, argv)) exit(EXIT_FAILURE); Vect_check_input_output_name(input->answer, output->answer, G_FATAL_EXIT); /* Open binary vector map at level 2 */ Vect_set_open_level(2); if (Vect_open_old(&map, input->answer, "") < 0) G_fatal_error(_("Unable to open vector map <%s>"), input->answer); /* Open new vector */ G_find_vector2(output->answer, ""); if (Vect_open_new(&Out, output->answer, Vect_is_3d(&map)) < 0) G_fatal_error(_("Unable to create vector map <%s>"), output->answer); /* Copy header info. */ Vect_copy_head_data(&map, &Out); /* History */ Vect_hist_copy(&map, &Out); Vect_hist_command(&Out); /* Get the number of lines in the binary map and set up record of lines visited */ lines_visited = (int *)G_calloc(Vect_get_num_lines(&map) + 1, sizeof(int)); /* Set up points structure and coordinate arrays */ points = Vect_new_line_struct(); Cats = Vect_new_cats_struct(); /* Write cats */ if (strcmp(cats->answer, "no") == 0) write_cats = NO_CATS; else if (strcmp(cats->answer, "first") == 0) write_cats = ONE_CAT; else write_cats = MULTI_CATS; if (type_opt->answer) type = Vect_option_to_types(type_opt); else type = GV_LINES; /* Step over all lines in binary map */ polyline = 0; nlines = 0; copy_tables = (write_cats != NO_CATS); for (line = 1; line <= Vect_get_num_lines(&map); line++) { Vect_reset_cats(Cats); ltype = Vect_read_line(&map, NULL, NULL, line); if ((ltype & GV_LINES) && (ltype & type)) nlines++; else { /* copy points to output as they are, with cats */ Vect_read_line(&map, points, Cats, line); Vect_write_line(&Out, ltype, points, Cats); if (Cats->n_cats > 0) copy_tables = 1; continue; } /* Skip line if already visited from another */ if (lines_visited[line]) continue; /* Only get here if line is not previously visited */ /* Find start of this polyline */ start_line = walk_back(&map, line, ltype); G_debug(1, "Polyline %d: start line = %d", polyline, start_line); /* Walk forward and pick up coordinates */ points_in_polyline = walk_forward_and_pick_up_coords(&map, start_line, ltype, points, lines_visited, Cats, write_cats); /* Write the line (type of the first line is used) */ Vect_write_line(&Out, ltype, points, Cats); polyline++; } G_verbose_message(n_("%d line or boundaries found in input vector map", "%d lines or boundaries found in input vector map", nlines), nlines, Vect_get_name(&map), Vect_get_mapset(&map)); G_verbose_message(n_("%d polyline stored in output vector map", "%d polylines stored in output vector map", polyline), polyline, Vect_get_name(&Out), Vect_get_mapset(&Out)); /* Copy (all linked) tables if needed */ if (copy_tables) { if (Vect_copy_tables(&map, &Out, 0)) G_warning(_("Failed to copy attribute table to output map")); } /* Tidy up */ Vect_destroy_line_struct(points); Vect_destroy_cats_struct(Cats); G_free(lines_visited); Vect_close(&map); Vect_build(&Out); Vect_close(&Out); exit(EXIT_SUCCESS); }
int main(int argc, char **argv) { int field, type, vertex_type; double dmax; struct Option *in_opt, *out_opt, *type_opt, *dmax_opt, *lfield_opt; struct Flag *inter_flag, *vertex_flag, *table_flag, *node_flag; struct GModule *module; char *mapset; struct Map_info In, Out; struct line_cats *LCats; struct line_pnts *LPoints; char buf[2000]; G_gisinit(argv[0]); module = G_define_module(); module->keywords = _("vector, geometry"); module->description = _("Create points along input lines in new vector with 2 layers."); in_opt = G_define_standard_option(G_OPT_V_INPUT); in_opt->description = _("Input vector map containing lines"); out_opt = G_define_standard_option(G_OPT_V_OUTPUT); out_opt->description = _("Output vector map where points will be written"); type_opt = G_define_standard_option(G_OPT_V_TYPE); type_opt->answer = "point,line,boundary,centroid"; lfield_opt = G_define_standard_option(G_OPT_V_FIELD); lfield_opt->key = "llayer"; lfield_opt->answer = "1"; lfield_opt->description = "Line layer"; node_flag = G_define_flag(); node_flag->key = 'n'; node_flag->description = _("Write line nodes"); vertex_flag = G_define_flag(); vertex_flag->key = 'v'; vertex_flag->description = _("Write line vertices"); inter_flag = G_define_flag(); inter_flag->key = 'i'; inter_flag->description = _("Interpolate points between line vertices"); dmax_opt = G_define_option(); dmax_opt->key = "dmax"; dmax_opt->type = TYPE_DOUBLE; dmax_opt->required = NO; dmax_opt->answer = "100"; dmax_opt->description = _("Maximum distance between points in map units"); table_flag = G_define_flag(); table_flag->key = 't'; table_flag->description = _("Do not create attribute table"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); LCats = Vect_new_cats_struct(); PCats = Vect_new_cats_struct(); LPoints = Vect_new_line_struct(); PPoints = Vect_new_line_struct(); db_init_string(&stmt); field = atoi(lfield_opt->answer); type = Vect_option_to_types(type_opt); dmax = atof(dmax_opt->answer); if (node_flag->answer && vertex_flag->answer) G_fatal_error(_("Use either -n or -v flag, not both")); if (node_flag->answer) vertex_type = GV_NODE; else if (vertex_flag->answer) vertex_type = GV_VERTEX; else vertex_type = 0; Vect_check_input_output_name(in_opt->answer, out_opt->answer, GV_FATAL_EXIT); /* Open input lines */ mapset = G_find_vector2(in_opt->answer, NULL); if (mapset == NULL) G_fatal_error(_("Vector map <%s> not found"), in_opt->answer); Vect_set_open_level(2); Vect_open_old(&In, in_opt->answer, mapset); /* Open output segments */ Vect_open_new(&Out, out_opt->answer, Vect_is_3d(&In)); Vect_copy_head_data(&In, &Out); Vect_hist_copy(&In, &Out); Vect_hist_command(&Out); /* Table */ if (!table_flag->answer) { struct field_info *Fin; /* copy input table */ Fin = Vect_get_field(&In, field); if (Fin) { /* table defined */ int ret; Fi = Vect_default_field_info(&Out, 1, NULL, GV_MTABLE); Vect_map_add_dblink(&Out, 1, NULL, Fi->table, Fin->key, Fi->database, Fi->driver); ret = db_copy_table(Fin->driver, Fin->database, Fin->table, Fi->driver, Vect_subst_var(Fi->database, &Out), Fi->table); if (ret == DB_FAILED) { G_fatal_error(_("Unable to copy table <%s>"), Fin->table); } } Fi = Vect_default_field_info(&Out, 2, NULL, GV_MTABLE); Vect_map_add_dblink(&Out, 2, NULL, Fi->table, "cat", Fi->database, Fi->driver); /* Open driver */ 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); sprintf(buf, "create table %s ( cat int, lcat int, along double precision )", Fi->table); db_append_string(&stmt, buf); if (db_execute_immediate(driver, &stmt) != DB_OK) { db_close_database_shutdown_driver(driver); G_fatal_error(_("Unable to create table: '%s'"), db_get_string(&stmt)); } if (db_create_index2(driver, Fi->table, "cat") != DB_OK) G_warning(_("Unable to create index for table <%s>, key <%s>"), Fi->table, "cat"); if (db_grant_on_table (driver, Fi->table, DB_PRIV_SELECT, DB_GROUP | DB_PUBLIC) != DB_OK) G_fatal_error(_("Unable to grant privileges on table <%s>"), Fi->table); db_begin_transaction(driver); } point_cat = 1; if (type & (GV_POINTS | GV_LINES)) { int line, nlines; nlines = Vect_get_num_lines(&In); for (line = 1; line <= nlines; line++) { int ltype, cat; G_debug(3, "line = %d", line); ltype = Vect_read_line(&In, LPoints, LCats, line); if (!(ltype & type)) continue; Vect_cat_get(LCats, field, &cat); if (LPoints->n_points <= 1) { write_point(&Out, LPoints->x[0], LPoints->y[0], LPoints->z[0], cat, 0.0, table_flag->answer); } else { /* lines */ write_line(&Out, LPoints, cat, vertex_type, inter_flag->answer, dmax, table_flag->answer); } G_percent(line, nlines, 2); } } if (type == GV_AREA) { int area, nareas, centroid, cat; nareas = Vect_get_num_areas(&In); for (area = 1; area <= nareas; area++) { int i, isle, nisles; centroid = Vect_get_area_centroid(&In, area); cat = -1; if (centroid > 0) { Vect_read_line(&In, NULL, LCats, centroid); Vect_cat_get(LCats, field, &cat); } Vect_get_area_points(&In, area, LPoints); write_line(&Out, LPoints, cat, vertex_type, inter_flag->answer, dmax, table_flag->answer); nisles = Vect_get_area_num_isles(&In, area); for (i = 0; i < nisles; i++) { isle = Vect_get_area_isle(&In, area, i); Vect_get_isle_points(&In, isle, LPoints); write_line(&Out, LPoints, cat, vertex_type, inter_flag->answer, dmax, table_flag->answer); } G_percent(area, nareas, 2); } } if (!table_flag->answer) { db_commit_transaction(driver); db_close_database_shutdown_driver(driver); } Vect_build(&Out); /* Free, close ... */ Vect_close(&In); Vect_close(&Out); G_done_msg(_("%d points written to output vector map"), point_cat - 1); exit(EXIT_SUCCESS); }
int main( int argc, char **argv ) { struct GModule *module; struct Option *info_opt, *rast_opt, *vect_opt, *coor_opt, *north_opt, *south_opt, *east_opt, *west_opt, *rows_opt, *cols_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,size,query,info,colors,stats"; 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; north_opt = G_define_option(); north_opt->key = "north"; north_opt->type = TYPE_STRING; south_opt = G_define_option(); south_opt->key = "south"; south_opt->type = TYPE_STRING; east_opt = G_define_option(); east_opt->key = "east"; east_opt->type = TYPE_STRING; west_opt = G_define_option(); west_opt->key = "west"; west_opt->type = TYPE_STRING; rows_opt = G_define_option(); rows_opt->key = "rows"; rows_opt->type = TYPE_INTEGER; cols_opt = G_define_option(); cols_opt->key = "cols"; cols_opt->type = TYPE_INTEGER; 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" ); } } // raster width and height else if ( strcmp( "size", info_opt->answer ) == 0 ) { if ( rast_opt->answer ) { G_get_cellhd( rast_opt->answer, "", &window ); fprintf( stdout, "%d,%d", window.cols, window.rows ); } else if ( vect_opt->answer ) { G_fatal_error( "Not yet supported" ); } } // raster information else if ( strcmp( "info", info_opt->answer ) == 0 ) { struct FPRange range; double zmin, zmax; // Data type RASTER_MAP_TYPE raster_type = G_raster_map_type( rast_opt->answer, "" ); fprintf( stdout, "TYPE:%d\n", raster_type ); // Statistics if ( G_read_fp_range( rast_opt->answer, "", &range ) < 0 ) { G_fatal_error(( "Unable to read range file" ) ); } G_get_fp_range_min_max( &range, &zmin, &zmax ); fprintf( stdout, "MIN_VALUE:%.17e\n", zmin ); fprintf( stdout, "MAX_VALUE:%.17e\n", zmax ); } else if ( strcmp( "colors", info_opt->answer ) == 0 ) { // Color table struct Colors colors; int i, ccount; if ( G_read_colors( rast_opt->answer, "", &colors ) == 1 ) { //int maxcolor; //CELL min, max; //G_get_color_range ( &min, &max, &colors); ccount = G_colors_count( &colors ); for ( i = ccount - 1; i >= 0; i-- ) { DCELL val1, val2; unsigned char r1, g1, b1, r2, g2, b2; G_get_f_color_rule( &val1, &r1, &g1, &b1, &val2, &r2, &g2, &b2, &colors, i ); fprintf( stdout, "%.17e %.17e %d %d %d %d %d %d\n", val1, val2, r1, g1, b1, r2, g2, b2 ); } } } 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; char buff[101]; G_get_cellhd( rast_opt->answer, "", &window ); G_set_window( &window ); G_suppress_masking(); // must be after G_set_window() fd = G_open_cell_old( rast_opt->answer, "" ); // wait for coords from stdin while ( fgets( buff, 100, stdin ) != 0 ) { if ( sscanf( buff, "%lf%lf", &x, &y ) != 2 ) { fprintf( stdout, "value:error\n" ); } else { 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:out\n" ); fprintf( stdout, "value:nan\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 GRASS_VERSION_MAJOR < 7 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 ); } #else G_get_c_raster_row( fd, cell, row ); #endif val = cell[col]; ptr = &( cell[col] ); } else { #if GRASS_VERSION_MAJOR < 7 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 ); } #else G_get_d_raster_row( fd, dcell, row ); #endif val = dcell[col]; ptr = &( dcell[col] ); } if ( G_is_null_value( ptr, rast_type ) ) { fprintf( stdout, "value:nan\n" ); } else { fprintf( stdout, "value:%f\n", val ); } } } fflush( stdout ); } G_close_cell( fd ); } else if ( vect_opt->answer ) { G_fatal_error( "Not yet supported" ); } } else if ( strcmp( "stats", info_opt->answer ) == 0 ) { if ( rast_opt->answer ) { int fd; RASTER_MAP_TYPE rast_type; DCELL *dcell; CELL *cell; int ncols, nrows; int row, col; void *ptr; double val; double min = DBL_MAX; double max = -DBL_MAX; double sum = 0; // sum of values int count = 0; // count of non null values double mean = 0; double squares_sum = 0; // sum of squares double stdev = 0; // standard deviation G_get_cellhd( rast_opt->answer, "", &window ); window.north = atof( north_opt->answer ); window.south = atof( south_opt->answer ); window.east = atof( east_opt->answer ); window.west = atof( west_opt->answer ); window.rows = ( int ) atoi( rows_opt->answer ); window.cols = ( int ) atoi( cols_opt->answer ); G_set_window( &window ); G_suppress_masking(); // must be after G_set_window() fd = G_open_cell_old( rast_opt->answer, "" ); ncols = G_window_cols(); nrows = G_window_rows(); #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(); // Calc stats is very slow for large rasters -> prefer optimization for speed over // code length and readability (which is not currently true) for ( row = 0; row < nrows; row++ ) { if ( rast_type == CELL_TYPE ) { #if GRASS_VERSION_MAJOR < 7 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 ); } #else G_get_c_raster_row( fd, cell, row ); #endif } else { #if GRASS_VERSION_MAJOR < 7 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 ); } #else G_get_d_raster_row( fd, dcell, row ); #endif } for ( col = 0; col < ncols; col++ ) { if ( rast_type == CELL_TYPE ) { val = cell[col]; ptr = &( cell[col] ); } else { val = dcell[col]; ptr = &( dcell[col] ); } if ( ! G_is_null_value( ptr, rast_type ) ) { if ( val < min ) min = val; if ( val > max ) max = val; sum += val; count++; squares_sum += pow( val, 2 ); } } } mean = count > 0 ? sum / count : 0; squares_sum -= count * pow( mean, 2 ); stdev = sqrt( squares_sum / ( count - 1 ) ); fprintf( stdout, "MIN:%.17e\n", min ); fprintf( stdout, "MAX:%.17e\n", max ); fprintf( stdout, "SUM:%.17e\n", sum ); fprintf( stdout, "MEAN:%.17e\n", mean ); fprintf( stdout, "COUNT:%d\n", count ); fprintf( stdout, "STDEV:%.17e\n", stdev ); fprintf( stdout, "SQSUM:%.17e\n", squares_sum ); 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 *title; FILE *srcfp; struct GModule *module; struct { struct Option *input, *output, *title, *rules; struct Flag *a, *d; } parm; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("recode categories")); G_add_keyword(_("reclassification")); module->description = _("Recodes categorical raster maps."); parm.input = G_define_standard_option(G_OPT_R_INPUT); parm.input->description = _("Name of raster map to be recoded"); parm.output = G_define_standard_option(G_OPT_R_OUTPUT); parm.rules = G_define_standard_option(G_OPT_F_INPUT); parm.rules->key = "rules"; parm.rules->label = _("File containing recode rules"); parm.rules->description = _("'-' for standard input"); parm.title = G_define_option(); parm.title->key = "title"; parm.title->required = NO; parm.title->type = TYPE_STRING; parm.title->description = _("Title for output raster map"); parm.a = G_define_flag(); parm.a->key = 'a'; parm.a->description = _("Align the current region to the input raster map"); parm.d = G_define_flag(); parm.d->key = 'd'; parm.d->description = _("Force output to 'double' raster map type (DCELL)"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); name = parm.input->answer; result = parm.output->answer; title = parm.title->answer; align_wind = parm.a->answer; make_dcell = parm.d->answer; srcfp = stdin; if (strcmp(parm.rules->answer, "-") != 0) { srcfp = fopen(parm.rules->answer, "r"); if (!srcfp) G_fatal_error(_("Unable to open file <%s>"), parm.rules->answer); } if (!read_rules(srcfp)) { if (isatty(fileno(srcfp))) G_fatal_error(_("No rules specified. Raster map <%s> not created."), result); else G_fatal_error(_("No rules specified")); } no_mask = 0; do_recode(); if(title) Rast_put_cell_title(result, title); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { struct GModule *module; struct Option *in_dir_opt, *in_stm_opt, *in_elev_opt, *in_method_opt, *opt_swapsize, *out_dist_opt, *out_diff_opt; struct Flag *flag_outs, *flag_sub, *flag_near, *flag_segmentation; char *method_name[] = { "UPSTREAM", "DOWNSTREAM" }; int method; int number_of_segs; int outlets_num; int number_of_streams; int outs, subs, near, segmentation; /*flags */ int j; G_gisinit(argv[0]); module = G_define_module(); module->label = _("Calculates distance to and elevation above streams and outlet."); module->description = _("The module can work in stream mode where target are streams and " "outlets mode where targets are outlets."); G_add_keyword(_("raster")); G_add_keyword(_("hydrology")); G_add_keyword(_("stream network")); G_add_keyword(_("watercourse distance")); in_stm_opt = G_define_standard_option(G_OPT_R_INPUT); in_stm_opt->key = "stream_rast"; in_stm_opt->description = _("Name of input raster map with stream network " "(in outlet mode is the name for outlet raster map)"); in_dir_opt = G_define_standard_option(G_OPT_R_INPUT); in_dir_opt->key = "direction"; in_dir_opt->description = _("Name of input raster map with flow direction"); in_elev_opt = G_define_standard_option(G_OPT_R_ELEV); in_elev_opt->required = NO; in_elev_opt->guisection = _("Input maps"); in_method_opt = G_define_option(); in_method_opt->key = "method"; in_method_opt->description = _("Calculation method"); in_method_opt->type = TYPE_STRING; in_method_opt->required = YES; in_method_opt->options = "upstream,downstream"; in_method_opt->answer = "downstream"; out_dist_opt = G_define_standard_option(G_OPT_R_OUTPUT); out_dist_opt->key = "distance"; out_dist_opt->required = NO; out_dist_opt->description = _("Name for output distance raster map"); out_dist_opt->guisection = _("Output maps"); out_diff_opt = G_define_standard_option(G_OPT_R_OUTPUT); out_diff_opt->key = "difference"; out_diff_opt->required = NO; out_diff_opt->description = _("Name for output elevation difference raster map"); out_diff_opt->guisection = _("Output maps"); opt_swapsize = G_define_option(); opt_swapsize->key = "memory"; opt_swapsize->type = TYPE_INTEGER; opt_swapsize->answer = "300"; opt_swapsize->description = _("Max memory used in memory swap mode (MB)"); opt_swapsize->guisection = _("Memory settings"); flag_outs = G_define_flag(); flag_outs->key = 'o'; flag_outs->description = _("Calculate parameters for outlets (outlet mode) instead of (default) streams"); flag_sub = G_define_flag(); flag_sub->key = 's'; flag_sub->description = _("Calculate parameters for subbasins (ignored in stream mode)"); flag_near = G_define_flag(); flag_near->key = 'n'; flag_near->description = _("Calculate nearest local maximum (ignored in downstream calculation)"); flag_segmentation = G_define_flag(); flag_segmentation->key = 'm'; flag_segmentation->description = _("Use memory swap (operation is slow)"); flag_segmentation->guisection = _("Memory settings"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); if (!out_diff_opt->answer && !out_dist_opt->answer) G_fatal_error(_("You must select at least one output raster map")); if (out_diff_opt->answer && !in_elev_opt->answer) G_fatal_error(_("Output elevation difference raster map requires " "input elevation raster map to be specified")); if (!strcmp(in_method_opt->answer, "upstream")) method = UPSTREAM; else if (!strcmp(in_method_opt->answer, "downstream")) method = DOWNSTREAM; outs = (flag_outs->answer != 0); subs = (flag_sub->answer != 0); near = (flag_near->answer != 0); segmentation = (flag_segmentation->answer != 0); nrows = Rast_window_rows(); ncols = Rast_window_cols(); G_begin_distance_calculations(); fifo_max = 4 * (nrows + ncols); fifo_points = (POINT *) G_malloc((fifo_max + 1) * sizeof(POINT)); if (!segmentation) { G_message(_("All in RAM calculation - method <%s>..."), method_name[method]); MAP map_dirs, map_streams, map_distance, map_elevation, map_tmp_elevation; CELL **streams, **dirs; DCELL **distance; DCELL **elevation = NULL; DCELL **tmp_elevation = NULL; ram_create_map(&map_streams, CELL_TYPE); ram_read_map(&map_streams, in_stm_opt->answer, 1, CELL_TYPE); ram_create_map(&map_dirs, CELL_TYPE); ram_read_map(&map_dirs, in_dir_opt->answer, 1, CELL_TYPE); ram_create_map(&map_distance, DCELL_TYPE); streams = (CELL **) map_streams.map; dirs = (CELL **) map_dirs.map; distance = (DCELL **) map_distance.map; number_of_streams = (int)map_streams.max + 1; outlets_num = ram_find_outlets(streams, number_of_streams, dirs, subs, outs); ram_init_distance(streams, distance, outlets_num, outs); ram_release_map(&map_streams); if (in_elev_opt->answer) { ram_create_map(&map_elevation, DCELL_TYPE); ram_read_map(&map_elevation, in_elev_opt->answer, 0, -1); elevation = (DCELL **) map_elevation.map; } /* map elevation will be replaced by elevation difference map */ if (method == DOWNSTREAM) { G_message(_("Calculate downstream parameters...")); for (j = 0; j < outlets_num; ++j) { G_percent(j, outlets_num, 1); ram_calculate_downstream(dirs, distance, elevation, outlets[j], outs); } G_percent(j, outlets_num, 1); } else if (method == UPSTREAM) { if (out_diff_opt->answer) { ram_create_map(&map_tmp_elevation, DCELL_TYPE); tmp_elevation = (DCELL **) map_tmp_elevation.map; } for (j = 0; j < outlets_num; ++j) ram_fill_basins(outlets[j], distance, dirs); ram_calculate_upstream(distance, dirs, elevation, tmp_elevation, near); } else { G_fatal_error(_("Unrecognised method of processing")); } /* end methods */ if (out_diff_opt->answer) { ram_prep_null_elevation(distance, elevation); ram_write_map(&map_elevation, out_diff_opt->answer, DCELL_TYPE, 1, -1); } if (out_dist_opt->answer) ram_write_map(&map_distance, out_dist_opt->answer, DCELL_TYPE, 1, -1); ram_release_map(&map_dirs); ram_release_map(&map_distance); if (in_elev_opt->answer) ram_release_map(&map_elevation); if (in_elev_opt->answer && method == UPSTREAM) ram_release_map(&map_tmp_elevation); } if (segmentation) { G_message(_("Calculating segments in direction <%s> (may take some time)..."), method_name[method]); SEG map_dirs, map_streams, map_distance, map_elevation, map_tmp_elevation; SEGMENT *streams, *dirs, *distance; SEGMENT *elevation = NULL; SEGMENT *tmp_elevation = NULL; number_of_segs = (int)atof(opt_swapsize->answer); if (method == DOWNSTREAM) number_of_segs = number_of_segs < 32 ? (int)(32 / 0.18) : number_of_segs / 0.18; else /* two elevation maps */ number_of_segs = number_of_segs < 32 ? (int)(32 / 0.24) : number_of_segs / 0.24; seg_create_map(&map_streams, SROWS, SCOLS, number_of_segs, CELL_TYPE); seg_read_map(&map_streams, in_stm_opt->answer, 1, CELL_TYPE); seg_create_map(&map_dirs, SROWS, SCOLS, number_of_segs, CELL_TYPE); seg_read_map(&map_dirs, in_dir_opt->answer, 1, CELL_TYPE); seg_create_map(&map_distance, SROWS, SCOLS, number_of_segs, DCELL_TYPE); streams = &map_streams.seg; dirs = &map_dirs.seg; distance = &map_distance.seg; number_of_streams = (int)map_streams.max + 1; outlets_num = seg_find_outlets(streams, number_of_streams, dirs, subs, outs); seg_init_distance(streams, distance, outlets_num, outs); seg_release_map(&map_streams); if (in_elev_opt->answer) { seg_create_map(&map_elevation, SROWS, SCOLS, number_of_segs, DCELL_TYPE); seg_read_map(&map_elevation, in_elev_opt->answer, 0, -1); elevation = &map_elevation.seg; } /* map elevation will be replaced by elevation difference map */ if (method == DOWNSTREAM) { G_message(_("Calculate downstream parameters...")); for (j = 0; j < outlets_num; ++j) { G_percent(j, outlets_num, 1); seg_calculate_downstream(dirs, distance, elevation, outlets[j], outs); } G_percent(j, outlets_num, 1); } else if (method == UPSTREAM) { if (out_diff_opt->answer) { seg_create_map(&map_tmp_elevation, SROWS, SCOLS, number_of_segs, DCELL_TYPE); tmp_elevation = &map_tmp_elevation.seg; } for (j = 0; j < outlets_num; ++j) seg_fill_basins(outlets[j], distance, dirs); seg_calculate_upstream(distance, dirs, elevation, tmp_elevation, near); } else { G_fatal_error(_("Unrecognised method of processing")); } /* end methods */ if (out_dist_opt->answer) seg_write_map(&map_distance, out_dist_opt->answer, DCELL_TYPE, 1, -1); if (out_diff_opt->answer) { seg_prep_null_elevation(distance, elevation); seg_write_map(&map_elevation, out_diff_opt->answer, DCELL_TYPE, 1, -1); } seg_release_map(&map_dirs); seg_release_map(&map_distance); if (in_elev_opt->answer) seg_release_map(&map_elevation); if (in_elev_opt->answer && method == UPSTREAM) seg_release_map(&map_tmp_elevation); } G_free(fifo_points); exit(EXIT_SUCCESS); }
void parse_args(int argc, char **argv, char **input, char**output, int *format, int *dp, char **delim, char **field, char ***columns, char **where, int *region, int *old_format, int *header, struct cat_list **clist) { struct Option *input_opt, *output_opt, *format_opt, *dp_opt, *delim_opt, *field_opt, *column_opt, *where_opt, *cats_opt; struct Flag *old_flag, *header_flag, *region_flag; input_opt = G_define_standard_option(G_OPT_V_INPUT); field_opt = G_define_standard_option(G_OPT_V_FIELD); field_opt->guisection = _("Selection"); output_opt = G_define_standard_option(G_OPT_F_OUTPUT); output_opt->label = _("Name for output ASCII file " "or ASCII vector name if '-o' is defined"); output_opt->description = _("'-' for standard output"); output_opt->required = NO; output_opt->answer = "-"; column_opt = G_define_standard_option(G_OPT_DB_COLUMNS); column_opt->description = _("Name of attribute column(s) to be exported (point mode)"); column_opt->guisection = _("Points"); cats_opt = G_define_standard_option(G_OPT_V_CATS); cats_opt->guisection = _("Selection"); where_opt = G_define_standard_option(G_OPT_DB_WHERE); where_opt->guisection = _("Selection"); format_opt = G_define_option(); format_opt->key = "format"; format_opt->type = TYPE_STRING; format_opt->required = YES; format_opt->multiple = NO; format_opt->options = "point,standard,wkt"; format_opt->answer = "point"; format_opt->description = _("Output format"); format_opt->descriptions = _("point;Simple point format (point per row);" "standard;GRASS ASCII vector format;" "wkt;OGC well-known text;"); delim_opt = G_define_standard_option(G_OPT_F_SEP); delim_opt->description = _("Field separator (points mode)"); delim_opt->guisection = _("Points"); dp_opt = G_define_option(); dp_opt->key = "dp"; dp_opt->type = TYPE_INTEGER; dp_opt->required = NO; dp_opt->options = "0-32"; dp_opt->answer = "8"; /* This value is taken from the lib settings in G_format_easting() */ dp_opt->description = _("Number of significant digits (floating point only)"); dp_opt->guisection = _("Points"); old_flag = G_define_flag(); old_flag->key = 'o'; old_flag->description = _("Create old (version 4) ASCII file"); header_flag = G_define_flag(); header_flag->key = 'c'; header_flag->description = _("Include column names in output (points mode)"); header_flag->guisection = _("Points"); region_flag = G_define_flag(); region_flag->key = 'r'; region_flag->description = _("Only export points falling within current 3D region (points mode)"); region_flag->guisection = _("Points"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); *input = G_store(input_opt->answer); *output = G_store(output_opt->answer); if (format_opt->answer[0] == 'p') *format = GV_ASCII_FORMAT_POINT; else if (format_opt->answer[0] == 's') *format = GV_ASCII_FORMAT_STD; else *format = GV_ASCII_FORMAT_WKT; if (sscanf(dp_opt->answer, "%d", dp) != 1) G_fatal_error(_("Failed to interpret 'dp' parameter as an integer")); /* the field separator */ if (strcmp(delim_opt->answer, "\\t") == 0) *delim = G_store("\t"); else if (strcmp(delim_opt->answer, "tab") == 0) *delim = G_store("\t"); else if (strcmp(delim_opt->answer, "space") == 0) *delim = G_store(" "); else if (strcmp(delim_opt->answer, "comma") == 0) *delim = G_store(","); else *delim = G_store(delim_opt->answer); *field = G_store(field_opt->answer); *columns = NULL; if (column_opt->answer) { int i, nopt; nopt = 0; while(column_opt->answers[nopt++]) ; *columns = (char **) G_malloc(nopt * sizeof(char *)); for (i = 0; i < nopt - 1; i++) (*columns)[i] = G_store(column_opt->answers[i]); (*columns)[nopt - 1] = NULL; } *where = NULL; if (where_opt->answer) { *where = G_store(where_opt->answer); } *clist = NULL; if (cats_opt->answer) { int ret; *clist = Vect_new_cat_list(); (*clist)->field = atoi(field_opt->answer); if ((*clist)->field < 1) G_fatal_error(_("Option <%s> must be > 0"), field_opt->key); ret = Vect_str_to_cat_list(cats_opt->answer, *clist); if (ret > 0) G_fatal_error(_("%d errors in cat option"), ret); } *region = region_flag->answer ? 1 : 0; *old_format = old_flag->answer ? 1 : 0; *header = header_flag->answer ? 1 : 0; }