int distdrop ( cell_map *elev, cell_map *dist, cell_map *dir, cell_map *up, cell_map *dw, seg_map *segment_info, move *movements, queue **redo_segments) { int all_done = 1; int **neighbours = new_int_map ( ( int ) sizeof ( movements ), ( int ) sizeof ( movements[0] ), NULL ); elev->fd = Rast_open_old ( elev->name, "" ); elev->type = Rast_get_map_type( elev->fd ); init_seg_map(elev, segment_info); copy_segment(elev, 0); //print_map_with_seg ( elev, segment_info ); while ( all_done ){ // if all_done != 0? continue: break all_done = queue_pixel ( redo_segments, elev, dist, dir, up, dw, segment_info, movements, neighbours); } return 0; }
static int calc_mu(int *fds, double *mu, int bands) { int i; int rows = Rast_window_rows(); int cols = Rast_window_cols(); void *rowbuf = NULL; for (i = 0; i < bands; i++) { RASTER_MAP_TYPE maptype; int row, col; double sum = 0.; maptype = Rast_get_map_type(fds[i]); /* don't assume each image is of the same type */ if (rowbuf) G_free(rowbuf); if ((rowbuf = Rast_allocate_buf(maptype)) == NULL) G_fatal_error(_("Unable allocate memory for row buffer")); G_message(_("Computing means for band %d..."), i + 1); for (row = 0; row < rows; row++) { void *ptr = rowbuf; G_percent(row, rows - 1, 2); Rast_get_row(fds[i], rowbuf, row, maptype); for (col = 0; col < cols; col++) { /* skip null cells */ if (Rast_is_null_value(ptr, maptype)) { ptr = G_incr_void_ptr(ptr, Rast_cell_size(maptype)); continue; } sum += Rast_get_d_value(ptr, maptype); ptr = G_incr_void_ptr(ptr, Rast_cell_size(maptype)); } } mu[i] = sum / (double)(rows * cols); } if (rowbuf) G_free(rowbuf); return 0; }
void rast_segment_open(SEGMENT * segment, const char *name, RASTER_MAP_TYPE * map_type) { /* TODO: check if not passing the mapset is OK */ int rowio = Rast_open_old(name, ""); *map_type = Rast_get_map_type(rowio); int segment_rows = 64; /* we use long segments because this is how the values a binned */ int segment_cols = Rast_input_window_cols(); int segments_in_memory = 4; if (Segment_open(segment, G_tempfile(), Rast_input_window_rows(), Rast_input_window_cols(), segment_rows, segment_cols, Rast_cell_size(*map_type), segments_in_memory) != 1) G_fatal_error(_("Cannot create temporary file with segments of a raster map")); rast_segment_load(segment, rowio, *map_type); Rast_close(rowio); /* we won't need the raster again */ }
int main(int argc, char **argv) { struct GModule *module; struct Option *opt_out; struct Option *opt_lev; struct Flag *flg_d; struct Flag *flg_c; int dither; char *out_name; int out_file; CELL *out_array; struct Colors out_colors; int levels; int atrow, atcol; struct Cell_head window; unsigned char *dummy, *nulls; int i, j; struct History history; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("composite")); G_add_keyword("RGB"); module->description = _("Combines red, green and blue raster maps into " "a single composite raster map."); for (i = 0; i < 3; i++) { struct Option *opt; char buff[80]; B[i].opt_name = opt = G_define_standard_option(G_OPT_R_INPUT); sprintf(buff, "%s", color_names[i]); opt->key = G_store(buff); opt->answer = NULL; sprintf(buff, _("Name of raster map to be used for <%s>"), color_names[i]); opt->description = G_store(buff); } opt_lev = G_define_option(); opt_lev->key = "levels"; opt_lev->type = TYPE_INTEGER; opt_lev->required = NO; opt_lev->options = "1-256"; opt_lev->answer = "32"; opt_lev->description = _("Number of levels to be used for each component"); opt_lev->guisection = _("Levels"); for (i = 0; i < 3; i++) { struct Option *opt; char buff[80]; B[i].opt_levels = opt = G_define_option(); sprintf(buff, "lev_%s", color_names[i]); opt->key = G_store(buff); opt->type = TYPE_INTEGER; opt->required = NO; opt->options = "1-256"; sprintf(buff, _("Number of levels to be used for <%s>"), color_names[i]); opt->description = G_store(buff); opt->guisection = _("Levels"); } opt_out = G_define_standard_option(G_OPT_R_OUTPUT); flg_d = G_define_flag(); flg_d->key = 'd'; flg_d->description = _("Dither"); flg_c = G_define_flag(); flg_c->key = 'c'; flg_c->description = _("Use closest color"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); levels = atoi(opt_lev->answer); dither = flg_d->answer; closest = flg_c->answer; /* read in current window */ G_get_window(&window); dummy = G_malloc(window.cols); nulls = G_malloc(window.cols); for (i = 0; i < 3; i++) { struct band *b = &B[i]; /* Get name of layer to be used */ b->name = b->opt_name->answer; /* Make sure map is available */ b->file = Rast_open_old(b->name, ""); b->type = Rast_get_map_type(b->file); b->size = Rast_cell_size(b->type); /* Reading color lookup table */ if (Rast_read_colors(b->name, "", &b->colors) == -1) G_fatal_error(_("Unable to read color file of raster map <%s>"), b->name); for (j = 0; j < 3; j++) b->array[j] = (i == j) ? G_malloc(window.cols) : dummy; b->levels = b->opt_levels->answer ? atoi(b->opt_levels->answer) : levels; b->maxlev = b->levels - 1; b->offset = 128 / b->maxlev; if (dither) for (j = 0; j < 2; j++) b->floyd[j] = G_calloc(window.cols + 2, sizeof(short)); } /* open output files */ out_name = opt_out->answer; out_file = Rast_open_c_new(out_name); out_array = Rast_allocate_c_buf(); /* Make color table */ make_color_cube(&out_colors); G_message(_("Writing raster map <%s>..."), out_name); for (atrow = 0; atrow < window.rows; atrow++) { G_percent(atrow, window.rows, 2); for (i = 0; i < 3; i++) { struct band *b = &B[i]; Rast_get_row_colors(b->file, atrow, &b->colors, b->array[0], b->array[1], b->array[2], nulls); if (dither) { short *tmp = b->floyd[0]; b->floyd[0] = b->floyd[1]; for (atcol = 0; atcol < window.cols + 2; atcol++) tmp[atcol] = 0; b->floyd[1] = tmp; } } for (atcol = 0; atcol < window.cols; atcol++) { int val[3]; if (nulls[atcol]) { Rast_set_c_null_value(&out_array[atcol], 1); continue; } for (i = 0; i < 3; i++) { struct band *b = &B[i]; int v = b->array[i][atcol]; if (dither) { int r, w, d; v += b->floyd[0][atcol + 1] / 16; v = (v < 0) ? 0 : (v > 255) ? 255 : v; r = quantize(i, v); w = r * 255 / b->maxlev; d = v - w; b->floyd[0][atcol + 2] += 7 * d; b->floyd[1][atcol + 0] += 3 * d; b->floyd[1][atcol + 1] += 5 * d; b->floyd[1][atcol + 2] += 1 * d; val[i] = r; } else val[i] = quantize(i, v); } out_array[atcol] = (CELL) (val[2] * B[1].levels + val[1]) * B[0].levels + val[0]; } Rast_put_row(out_file, out_array, CELL_TYPE); } G_percent(window.rows, window.rows, 1); /* Close the input files */ for (i = 0; i < 3; i++) Rast_close(B[i].file); /* Close the output file */ Rast_close(out_file); Rast_write_colors(out_name, G_mapset(), &out_colors); Rast_short_history(out_name, "raster", &history); Rast_command_history(&history); Rast_write_history(out_name, &history); G_done_msg(_("Raster map <%s> created."), out_name); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { int i, row, col; /* counters */ unsigned long filesize; int endianness; /* 0=little, 1=big */ int data_format; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int (ie text) */ int data_type; /* 0=numbers 1=text */ int format_block; /* combo of endianness, 0, data_format, and type */ int realflag = 0; /* 0=only real values used */ /* should type be specifically uint32 ??? */ char array_name[32]; /* variable names must start with a letter (case sensitive) followed by letters, numbers, or underscores. 31 chars max. */ int name_len; int mrows, ncols; /* text/data/map array dimensions */ int val_i; /* for misc use */ float val_f; /* for misc use */ double val_d; /* for misc use */ char *infile, *outfile, *maptitle, *basename; struct Cell_head region; void *raster, *ptr; RASTER_MAP_TYPE map_type; struct Option *inputfile, *outputfile; struct GModule *module; int fd; FILE *fp1; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("export")); module->description = _("Exports a GRASS raster to a binary MAT-File."); /* Define the different options */ inputfile = G_define_standard_option(G_OPT_R_INPUT); outputfile = G_define_option(); outputfile->key = "output"; outputfile->type = TYPE_STRING; outputfile->required = YES; outputfile->gisprompt = "new_file,file,output"; outputfile->description = _("Name for the output binary MAT-File"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); infile = inputfile->answer; basename = G_store(outputfile->answer); G_basename(basename, "mat"); outfile = G_malloc(strlen(basename) + 5); sprintf(outfile, "%s.mat", basename); fd = Rast_open_old(infile, ""); map_type = Rast_get_map_type(fd); /* open bin file for writing */ fp1 = fopen(outfile, "wb"); if (NULL == fp1) G_fatal_error(_("Unable to open output file <%s>"), outfile); /* Check Endian State of Host Computer */ if (G_is_little_endian()) endianness = 0; /* ie little endian */ else endianness = 1; /* ie big endian */ G_debug(1, "Machine is %s endian.\n", endianness ? "big" : "little"); G_get_window(®ion); /********** Write map **********/ /** write text element (map name) **/ strncpy(array_name, "map_name", 31); mrows = 1; ncols = strlen(infile); data_format = 5; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int(text) */ data_type = 1; /* 0=numbers 1=text */ G_verbose_message(_("Exporting <%s>"), infile); /* 4 byte data format */ format_block = endianness * 1000 + data_format * 10 + data_type; fwrite(&format_block, sizeof(int), 1, fp1); /* fprintf(stderr, "name data format is [%04ld]\n", format_block); */ /* 4 byte number of rows & columns */ fwrite(&mrows, sizeof(int), 1, fp1); fwrite(&ncols, sizeof(int), 1, fp1); /* 4 byte real/imag flag 0=real vals only */ fwrite(&realflag, sizeof(int), 1, fp1); /* length of array_name+1 */ name_len = strlen(array_name) + 1; fwrite(&name_len, sizeof(int), 1, fp1); /* array name */ fprintf(fp1, "%s%c", array_name, '\0'); /* array data */ fprintf(fp1, "%s", infile); /********** Write title (if there is one) **********/ maptitle = Rast_get_cell_title(infile, ""); if (strlen(maptitle) >= 1) { /** write text element (map title) **/ strncpy(array_name, "map_title", 31); mrows = 1; ncols = strlen(maptitle); data_format = 5; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int(text) */ data_type = 1; /* 0=numbers 1=text */ /* 4 byte data format */ format_block = endianness * 1000 + data_format * 10 + data_type; fwrite(&format_block, sizeof(int), 1, fp1); /* 4 byte number of rows & columns */ fwrite(&mrows, sizeof(int), 1, fp1); fwrite(&ncols, sizeof(int), 1, fp1); /* 4 byte real/imag flag 0=real vals only */ fwrite(&realflag, sizeof(int), 1, fp1); /* length of array_name+1 */ name_len = strlen(array_name) + 1; fwrite(&name_len, sizeof(int), 1, fp1); /* array name */ fprintf(fp1, "%s%c", array_name, '\0'); /* array data */ fprintf(fp1, "%s", maptitle); } /***** Write bounds *****/ G_verbose_message(""); G_verbose_message(_("Using the Current Region settings:")); G_verbose_message(_("northern edge=%f"), region.north); G_verbose_message(_("southern edge=%f"), region.south); G_verbose_message(_("eastern edge=%f"), region.east); G_verbose_message(_("western edge=%f"), region.west); G_verbose_message(_("nsres=%f"), region.ns_res); G_verbose_message(_("ewres=%f"), region.ew_res); G_verbose_message(_("rows=%d"), region.rows); G_verbose_message(_("cols=%d"), region.cols); G_verbose_message(""); for (i = 0; i < 4; i++) { switch (i) { case 0: strncpy(array_name, "map_northern_edge", 31); val_d = region.north; break; case 1: strncpy(array_name, "map_southern_edge", 31); val_d = region.south; break; case 2: strncpy(array_name, "map_eastern_edge", 31); val_d = region.east; break; case 3: strncpy(array_name, "map_western_edge", 31); val_d = region.west; break; default: fclose(fp1); G_fatal_error("please contact development team"); break; } /** write data element **/ data_format = 0; /* 0=double 1=float 2=32bit signed int 5=8bit unsigned int(text) */ data_type = 0; /* 0=numbers 1=text */ mrows = 1; ncols = 1; /* 4 byte data format */ format_block = endianness * 1000 + data_format * 10 + data_type; fwrite(&format_block, sizeof(int), 1, fp1); /* fprintf(stderr, "bounds data format is [%04ld]\n", format_block); */ /* 4 byte number of rows , 4 byte number of colums */ fwrite(&mrows, sizeof(int), 1, fp1); fwrite(&ncols, sizeof(int), 1, fp1); /* 4 byte real/imag flag 0=only real */ fwrite(&realflag, sizeof(int), 1, fp1); /* length of array_name+1 */ name_len = strlen(array_name) + 1; fwrite(&name_len, sizeof(int), 1, fp1); /* array name */ fprintf(fp1, "%s%c", array_name, '\0'); /* write array data, by increasing column */ fwrite(&val_d, sizeof(double), 1, fp1); /** end of data element **/ } /***** Write map data *****/ strncpy(array_name, "map_data", 31); switch (map_type) { /* data_format: 0=double 1=float 2=32bit signed int 5=8bit unsigned int (ie text) */ case CELL_TYPE: data_format = 2; G_verbose_message(_("Exporting raster as integer values")); break; case FCELL_TYPE: data_format = 1; G_verbose_message(_("Exporting raster as floating point values")); break; case DCELL_TYPE: data_format = 0; G_verbose_message(_("Exporting raster as double FP values")); break; default: fclose(fp1); G_fatal_error("Please contact development team"); break; } data_type = 0; /* 0=numbers 1=text */ mrows = region.rows; ncols = region.cols; /* 4 byte data format */ format_block = (endianness * 1000) + (data_format * 10) + data_type; fwrite(&format_block, sizeof(int), 1, fp1); G_debug(3, "map data format is [%04d]\n", format_block); /* 4 byte number of rows & columns */ fwrite(&mrows, sizeof(int), 1, fp1); fwrite(&ncols, sizeof(int), 1, fp1); /* 4 byte real/imag flag 0=only real */ fwrite(&realflag, sizeof(int), 1, fp1); /* length of array_name+1 */ name_len = strlen(array_name) + 1; fwrite(&name_len, sizeof(int), 1, fp1); /* array name */ fprintf(fp1, "%s%c", array_name, '\0'); /* data array, by increasing column */ raster = G_calloc((Rast_window_rows() + 1) * (Rast_window_cols() + 1), Rast_cell_size(map_type)); G_debug(1, "mem alloc is %d bytes\n", /* I think _cols()+1 is unneeded? */ Rast_cell_size(map_type) * (Rast_window_rows() + 1) * (Rast_window_cols() + 1)); G_verbose_message(_("Reading in map ... ")); /* load entire map into memory */ for (row = 0, ptr = raster; row < mrows; row++, ptr = G_incr_void_ptr(ptr, (Rast_window_cols() + 1) * Rast_cell_size(map_type))) { Rast_get_row(fd, ptr, row, map_type); G_percent(row, mrows, 2); } G_percent(row, mrows, 2); /* finish it off */ G_verbose_message(_("Writing out map...")); /* then write it to disk */ /* NoGood: fwrite(raster, Rast_cell_size(map_type), mrows*ncols, fp1); */ for (col = 0; col < ncols; col++) { for (row = 0; row < mrows; row++) { ptr = raster; ptr = G_incr_void_ptr(ptr, (col + row * (ncols + 1)) * Rast_cell_size(map_type)); if (!Rast_is_null_value(ptr, map_type)) { if (map_type == CELL_TYPE) { val_i = *((CELL *) ptr); fwrite(&val_i, sizeof(int), 1, fp1); } else if (map_type == FCELL_TYPE) { val_f = *((FCELL *) ptr); fwrite(&val_f, sizeof(float), 1, fp1); } else if (map_type == DCELL_TYPE) { val_d = *((DCELL *) ptr); fwrite(&val_d, sizeof(double), 1, fp1); } } else { /* ie if NULL cell -> write IEEE NaN value */ if (map_type == CELL_TYPE) { val_i = *((CELL *) ptr); /* int has no NaN value, so use whatever GRASS uses */ fwrite(&val_i, sizeof(int), 1, fp1); } else if (map_type == FCELL_TYPE) { if (endianness) /* ie big */ fprintf(fp1, "%c%c%c%c", 0xff, 0xf8, 0, 0); else /* ie little */ fprintf(fp1, "%c%c%c%c", 0, 0, 0xf8, 0xff); } else if (map_type == DCELL_TYPE) { if (endianness) fprintf(fp1, "%c%c%c%c%c%c%c%c", 0xff, 0xf8, 0, 0, 0, 0, 0, 0); else fprintf(fp1, "%c%c%c%c%c%c%c%c", 0, 0, 0, 0, 0, 0, 0xf8, 0xff); } } } G_percent(col, ncols, 2); } G_percent(col, ncols, 2); /* finish it off */ /*** end of data element ***/ /* done! */ filesize = G_ftell(fp1); fclose(fp1); G_verbose_message(_("%ld bytes written to '%s'"), filesize, outfile); G_done_msg(""); G_free(basename); G_free(outfile); exit(EXIT_SUCCESS); }
int main(int argc, char **argv) { char *mapname, /* ptr to name of output layer */ *setname, /* ptr to name of input mapset */ *ipolname; /* name of interpolation method */ int fdi, /* input map file descriptor */ fdo, /* output map file descriptor */ method, /* position of method in table */ permissions, /* mapset permissions */ cell_type, /* output celltype */ cell_size, /* size of a cell in bytes */ row, col, /* counters */ irows, icols, /* original rows, cols */ orows, ocols, have_colors, /* Input map has a colour table */ overwrite, /* Overwrite */ curr_proj; /* output projection (see gis.h) */ void *obuffer, /* buffer that holds one output row */ *obufptr; /* column ptr in output buffer */ struct cache *ibuffer; /* buffer that holds the input map */ func interpolate; /* interpolation routine */ double xcoord1, xcoord2, /* temporary x coordinates */ ycoord1, ycoord2, /* temporary y coordinates */ col_idx, /* column index in input matrix */ row_idx, /* row index in input matrix */ onorth, osouth, /* save original border coords */ oeast, owest, inorth, isouth, ieast, iwest; char north_str[30], south_str[30], east_str[30], west_str[30]; struct Colors colr; /* Input map colour table */ struct History history; struct pj_info iproj, /* input map proj parameters */ oproj; /* output map proj parameters */ struct Key_Value *in_proj_info, /* projection information of */ *in_unit_info, /* input and output mapsets */ *out_proj_info, *out_unit_info; struct GModule *module; struct Flag *list, /* list files in source location */ *nocrop, /* don't crop output map */ *print_bounds, /* print output bounds and exit */ *gprint_bounds; /* same but print shell style */ struct Option *imapset, /* name of input mapset */ *inmap, /* name of input layer */ *inlocation, /* name of input location */ *outmap, /* name of output layer */ *indbase, /* name of input database */ *interpol, /* interpolation method: nearest neighbor, bilinear, cubic */ *memory, /* amount of memory for cache */ *res; /* resolution of target map */ struct Cell_head incellhd, /* cell header of input map */ outcellhd; /* and output map */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("projection")); G_add_keyword(_("transformation")); module->description = _("Re-projects a raster map from given location to the current location."); inmap = G_define_standard_option(G_OPT_R_INPUT); inmap->description = _("Name of input raster map to re-project"); inmap->required = NO; inmap->guisection = _("Source"); inlocation = G_define_option(); inlocation->key = "location"; inlocation->type = TYPE_STRING; inlocation->required = YES; inlocation->description = _("Location containing input raster map"); inlocation->gisprompt = "old,location,location"; inlocation->key_desc = "name"; imapset = G_define_standard_option(G_OPT_M_MAPSET); imapset->label = _("Mapset containing input raster map"); imapset->description = _("default: name of current mapset"); imapset->guisection = _("Source"); indbase = G_define_option(); indbase->key = "dbase"; indbase->type = TYPE_STRING; indbase->required = NO; indbase->description = _("Path to GRASS database of input location"); indbase->gisprompt = "old,dbase,dbase"; indbase->key_desc = "path"; indbase->guisection = _("Source"); outmap = G_define_standard_option(G_OPT_R_OUTPUT); outmap->required = NO; outmap->description = _("Name for output raster map (default: same as 'input')"); outmap->guisection = _("Target"); ipolname = make_ipol_list(); interpol = G_define_option(); interpol->key = "method"; interpol->type = TYPE_STRING; interpol->required = NO; interpol->answer = "nearest"; interpol->options = ipolname; interpol->description = _("Interpolation method to use"); interpol->guisection = _("Target"); interpol->descriptions = make_ipol_desc(); memory = G_define_option(); memory->key = "memory"; memory->type = TYPE_INTEGER; memory->required = NO; memory->description = _("Cache size (MiB)"); res = G_define_option(); res->key = "resolution"; res->type = TYPE_DOUBLE; res->required = NO; res->description = _("Resolution of output raster map"); res->guisection = _("Target"); list = G_define_flag(); list->key = 'l'; list->description = _("List raster maps in input location and exit"); nocrop = G_define_flag(); nocrop->key = 'n'; nocrop->description = _("Do not perform region cropping optimization"); print_bounds = G_define_flag(); print_bounds->key = 'p'; print_bounds->description = _("Print input map's bounds in the current projection and exit"); print_bounds->guisection = _("Target"); gprint_bounds = G_define_flag(); gprint_bounds->key = 'g'; gprint_bounds->description = _("Print input map's bounds in the current projection and exit (shell style)"); gprint_bounds->guisection = _("Target"); /* The parser checks if the map already exists in current mapset, we switch out the check and do it in the module after the parser */ overwrite = G_check_overwrite(argc, argv); if (G_parser(argc, argv)) exit(EXIT_FAILURE); /* get the method */ for (method = 0; (ipolname = menu[method].name); method++) if (strcmp(ipolname, interpol->answer) == 0) break; if (!ipolname) G_fatal_error(_("<%s=%s> unknown %s"), interpol->key, interpol->answer, interpol->key); interpolate = menu[method].method; mapname = outmap->answer ? outmap->answer : inmap->answer; if (mapname && !list->answer && !overwrite && G_find_raster(mapname, G_mapset())) G_fatal_error(_("option <%s>: <%s> exists."), "output", mapname); setname = imapset->answer ? imapset->answer : G_store(G_mapset()); if (strcmp(inlocation->answer, G_location()) == 0 && (!indbase->answer || strcmp(indbase->answer, G_gisdbase()) == 0)) #if 0 G_fatal_error(_("Input and output locations can not be the same")); #else G_warning(_("Input and output locations are the same")); #endif G_get_window(&outcellhd); if(gprint_bounds->answer && !print_bounds->answer) print_bounds->answer = gprint_bounds->answer; curr_proj = G_projection(); /* Get projection info for output mapset */ if ((out_proj_info = G_get_projinfo()) == NULL) G_fatal_error(_("Unable to get projection info of output raster map")); if ((out_unit_info = G_get_projunits()) == NULL) G_fatal_error(_("Unable to get projection units of output raster map")); if (pj_get_kv(&oproj, out_proj_info, out_unit_info) < 0) G_fatal_error(_("Unable to get projection key values of output raster map")); /* Change the location */ G__create_alt_env(); G__setenv("GISDBASE", indbase->answer ? indbase->answer : G_gisdbase()); G__setenv("LOCATION_NAME", inlocation->answer); permissions = G__mapset_permissions(setname); if (permissions < 0) /* can't access mapset */ G_fatal_error(_("Mapset <%s> in input location <%s> - %s"), setname, inlocation->answer, permissions == 0 ? _("permission denied") : _("not found")); /* if requested, list the raster maps in source location - MN 5/2001 */ if (list->answer) { int i; char **list; G_verbose_message(_("Checking location <%s> mapset <%s>"), inlocation->answer, setname); list = G_list(G_ELEMENT_RASTER, G__getenv("GISDBASE"), G__getenv("LOCATION_NAME"), setname); for (i = 0; list[i]; i++) { fprintf(stdout, "%s\n", list[i]); } fflush(stdout); exit(EXIT_SUCCESS); /* leave r.proj after listing */ } if (!inmap->answer) G_fatal_error(_("Required parameter <%s> not set"), inmap->key); if (!G_find_raster(inmap->answer, setname)) G_fatal_error(_("Raster map <%s> in location <%s> in mapset <%s> not found"), inmap->answer, inlocation->answer, setname); /* Read input map colour table */ have_colors = Rast_read_colors(inmap->answer, setname, &colr); /* Get projection info for input mapset */ if ((in_proj_info = G_get_projinfo()) == NULL) G_fatal_error(_("Unable to get projection info of input map")); if ((in_unit_info = G_get_projunits()) == NULL) G_fatal_error(_("Unable to get projection units of input map")); if (pj_get_kv(&iproj, in_proj_info, in_unit_info) < 0) G_fatal_error(_("Unable to get projection key values of input map")); G_free_key_value(in_proj_info); G_free_key_value(in_unit_info); G_free_key_value(out_proj_info); G_free_key_value(out_unit_info); if (G_verbose() > G_verbose_std()) pj_print_proj_params(&iproj, &oproj); /* this call causes r.proj to read the entire map into memeory */ Rast_get_cellhd(inmap->answer, setname, &incellhd); Rast_set_input_window(&incellhd); if (G_projection() == PROJECTION_XY) G_fatal_error(_("Unable to work with unprojected data (xy location)")); /* Save default borders so we can show them later */ inorth = incellhd.north; isouth = incellhd.south; ieast = incellhd.east; iwest = incellhd.west; irows = incellhd.rows; icols = incellhd.cols; onorth = outcellhd.north; osouth = outcellhd.south; oeast = outcellhd.east; owest = outcellhd.west; orows = outcellhd.rows; ocols = outcellhd.cols; if (print_bounds->answer) { G_message(_("Input map <%s@%s> in location <%s>:"), inmap->answer, setname, inlocation->answer); if (pj_do_proj(&iwest, &isouth, &iproj, &oproj) < 0) G_fatal_error(_("Error in pj_do_proj (projection of input coordinate pair)")); if (pj_do_proj(&ieast, &inorth, &iproj, &oproj) < 0) G_fatal_error(_("Error in pj_do_proj (projection of input coordinate pair)")); G_format_northing(inorth, north_str, curr_proj); G_format_northing(isouth, south_str, curr_proj); G_format_easting(ieast, east_str, curr_proj); G_format_easting(iwest, west_str, curr_proj); if(gprint_bounds->answer) { fprintf(stdout, "n=%s s=%s w=%s e=%s rows=%d cols=%d\n", north_str, south_str, west_str, east_str, irows, icols); } else { fprintf(stdout, "Source cols: %d\n", icols); fprintf(stdout, "Source rows: %d\n", irows); fprintf(stdout, "Local north: %s\n", north_str); fprintf(stdout, "Local south: %s\n", south_str); fprintf(stdout, "Local west: %s\n", west_str); fprintf(stdout, "Local east: %s\n", east_str); } /* somehow approximate local ewres, nsres ?? (use 'g.region -m' on lat/lon side) */ exit(EXIT_SUCCESS); } /* Cut non-overlapping parts of input map */ if (!nocrop->answer) bordwalk(&outcellhd, &incellhd, &oproj, &iproj); /* Add 2 cells on each side for bilinear/cubic & future interpolation methods */ /* (should probably be a factor based on input and output resolution) */ incellhd.north += 2 * incellhd.ns_res; incellhd.east += 2 * incellhd.ew_res; incellhd.south -= 2 * incellhd.ns_res; incellhd.west -= 2 * incellhd.ew_res; if (incellhd.north > inorth) incellhd.north = inorth; if (incellhd.east > ieast) incellhd.east = ieast; if (incellhd.south < isouth) incellhd.south = isouth; if (incellhd.west < iwest) incellhd.west = iwest; Rast_set_input_window(&incellhd); /* And switch back to original location */ G__switch_env(); /* Adjust borders of output map */ if (!nocrop->answer) bordwalk(&incellhd, &outcellhd, &iproj, &oproj); #if 0 outcellhd.west = outcellhd.south = HUGE_VAL; outcellhd.east = outcellhd.north = -HUGE_VAL; for (row = 0; row < incellhd.rows; row++) { ycoord1 = Rast_row_to_northing((double)(row + 0.5), &incellhd); for (col = 0; col < incellhd.cols; col++) { xcoord1 = Rast_col_to_easting((double)(col + 0.5), &incellhd); pj_do_proj(&xcoord1, &ycoord1, &iproj, &oproj); if (xcoord1 > outcellhd.east) outcellhd.east = xcoord1; if (ycoord1 > outcellhd.north) outcellhd.north = ycoord1; if (xcoord1 < outcellhd.west) outcellhd.west = xcoord1; if (ycoord1 < outcellhd.south) outcellhd.south = ycoord1; } } #endif if (res->answer != NULL) /* set user defined resolution */ outcellhd.ns_res = outcellhd.ew_res = atof(res->answer); G_adjust_Cell_head(&outcellhd, 0, 0); Rast_set_output_window(&outcellhd); G_message(" "); G_message(_("Input:")); G_message(_("Cols: %d (%d)"), incellhd.cols, icols); G_message(_("Rows: %d (%d)"), incellhd.rows, irows); G_message(_("North: %f (%f)"), incellhd.north, inorth); G_message(_("South: %f (%f)"), incellhd.south, isouth); G_message(_("West: %f (%f)"), incellhd.west, iwest); G_message(_("East: %f (%f)"), incellhd.east, ieast); G_message(_("EW-res: %f"), incellhd.ew_res); G_message(_("NS-res: %f"), incellhd.ns_res); G_message(" "); G_message(_("Output:")); G_message(_("Cols: %d (%d)"), outcellhd.cols, ocols); G_message(_("Rows: %d (%d)"), outcellhd.rows, orows); G_message(_("North: %f (%f)"), outcellhd.north, onorth); G_message(_("South: %f (%f)"), outcellhd.south, osouth); G_message(_("West: %f (%f)"), outcellhd.west, owest); G_message(_("East: %f (%f)"), outcellhd.east, oeast); G_message(_("EW-res: %f"), outcellhd.ew_res); G_message(_("NS-res: %f"), outcellhd.ns_res); G_message(" "); /* open and read the relevant parts of the input map and close it */ G__switch_env(); Rast_set_input_window(&incellhd); fdi = Rast_open_old(inmap->answer, setname); cell_type = Rast_get_map_type(fdi); ibuffer = readcell(fdi, memory->answer); Rast_close(fdi); G__switch_env(); Rast_set_output_window(&outcellhd); if (strcmp(interpol->answer, "nearest") == 0) { fdo = Rast_open_new(mapname, cell_type); obuffer = (CELL *) Rast_allocate_output_buf(cell_type); } else { fdo = Rast_open_fp_new(mapname); cell_type = FCELL_TYPE; obuffer = (FCELL *) Rast_allocate_output_buf(cell_type); } cell_size = Rast_cell_size(cell_type); xcoord1 = xcoord2 = outcellhd.west + (outcellhd.ew_res / 2); /**/ ycoord1 = ycoord2 = outcellhd.north - (outcellhd.ns_res / 2); /**/ G_important_message(_("Projecting...")); G_percent(0, outcellhd.rows, 2); for (row = 0; row < outcellhd.rows; row++) { obufptr = obuffer; for (col = 0; col < outcellhd.cols; col++) { /* project coordinates in output matrix to */ /* coordinates in input matrix */ if (pj_do_proj(&xcoord1, &ycoord1, &oproj, &iproj) < 0) Rast_set_null_value(obufptr, 1, cell_type); else { /* convert to row/column indices of input matrix */ col_idx = (xcoord1 - incellhd.west) / incellhd.ew_res; row_idx = (incellhd.north - ycoord1) / incellhd.ns_res; /* and resample data point */ interpolate(ibuffer, obufptr, cell_type, &col_idx, &row_idx, &incellhd); } obufptr = G_incr_void_ptr(obufptr, cell_size); xcoord2 += outcellhd.ew_res; xcoord1 = xcoord2; ycoord1 = ycoord2; } Rast_put_row(fdo, obuffer, cell_type); xcoord1 = xcoord2 = outcellhd.west + (outcellhd.ew_res / 2); ycoord2 -= outcellhd.ns_res; ycoord1 = ycoord2; G_percent(row, outcellhd.rows - 1, 2); } Rast_close(fdo); if (have_colors > 0) { Rast_write_colors(mapname, G_mapset(), &colr); Rast_free_colors(&colr); } Rast_short_history(mapname, "raster", &history); Rast_command_history(&history); Rast_write_history(mapname, &history); G_done_msg(NULL); exit(EXIT_SUCCESS); }
int main(int argc, char **argv) { 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(_("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_option(); opt3->key = "arrow_color"; opt3->type = TYPE_STRING; opt3->required = NO; opt3->answer = "green"; opt3->gisprompt = "old_color,color,color"; opt3->description = _("Color for drawing arrows"); opt3->guisection = _("Colors"); opt4 = G_define_option(); opt4->key = "grid_color"; opt4->type = TYPE_STRING; opt4->required = NO; opt4->answer = "gray"; opt4->gisprompt = "old_color,color,color_none"; opt4->description = _("Color for drawing grid or \"none\""); opt4->guisection = _("Colors"); opt5 = G_define_option(); opt5->key = "x_color"; opt5->type = TYPE_STRING; opt5->required = NO; opt5->answer = DEFAULT_FG_COLOR; opt5->gisprompt = "old_color,color,color_none"; opt5->description = _("Color for drawing X's (null values)"); opt5->guisection = _("Colors"); opt6 = G_define_option(); opt6->key = "unknown_color"; opt6->type = TYPE_STRING; opt6->required = NO; opt6->answer = "red"; opt6->gisprompt = "old_color,color,color_none"; opt6->description = _("Color for showing unknown information"); 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); x_color = D_translate_color(opt5->answer); unknown_color = D_translate_color(opt6->answer); if (strcmp("none", opt4->answer) == 0) grid_color = -1; else grid_color = D_translate_color(opt4->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 */ if (D_open_driver() != 0) G_fatal_error(_("No graphics device selected. " "Use d.mon to select graphics device.")); 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)) { 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 { 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: 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: 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) { D_use_color(unknown_color); unknown_(); D_use_color(arrow_color); } else { 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)) { 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 { 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 open_file(char *name) { int cell_file, buf_len; int i, row; CELL *buf; /* open raster map */ cell_file = Rast_open_old(name, ""); if (Rast_get_map_type(cell_file) != CELL_TYPE) { Rast_close(cell_file); G_fatal_error(_("Input raster must be of type CELL.")); } n_rows = Rast_window_rows(); n_cols = Rast_window_cols(); G_message(_("File %s -- %d rows X %d columns"), name, n_rows, n_cols); n_cols += (PAD << 1); /* copy raster map into our read/write file */ work_file_name = G_tempfile(); /* create the file and then open it for read and write */ close(creat(work_file_name, 0666)); if ((work_file = open(work_file_name, 2)) < 0) { unlink(work_file_name); G_fatal_error(_("%s: Unable to create temporary file <%s> -- errno = %d"), error_prefix, work_file_name, errno); } buf_len = n_cols * sizeof(CELL); buf = (CELL *) G_malloc(buf_len); Rast_set_c_null_value(buf, n_cols); for (i = 0; i < PAD; i++) { if (write(work_file, buf, buf_len) != buf_len) { unlink(work_file_name); G_fatal_error(_("%s: Error writing temporary file"), error_prefix); } } for (row = 0; row < n_rows; row++) { Rast_get_c_row(cell_file, buf + PAD, row); if (write(work_file, buf, buf_len) != buf_len) { unlink(work_file_name); G_fatal_error(_("%s: Error writing temporary file"), error_prefix); } } Rast_set_c_null_value(buf, n_cols); for (i = 0; i < PAD; i++) { if (write(work_file, buf, buf_len) != buf_len) { unlink(work_file_name); G_fatal_error(_("%s: Error writing temporary file"), error_prefix); } } n_rows += (PAD << 1); G_free(buf); Rast_close(cell_file); Rowio_setup(&row_io, work_file, MAX_ROW, n_cols * sizeof(CELL), read_row, write_row); return 0; }
int main(int argc, char *argv[]) { struct GModule *module; struct Option *in_opt, *out_opt, *feature_opt, *column_name; struct Flag *smooth_flg, *value_flg, *z_flg, *no_topol; int feature; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("conversion")); G_add_keyword(_("geometry")); G_add_keyword(_("vectorization")); module->description = _("Converts a raster map into a vector map."); in_opt = G_define_standard_option(G_OPT_R_INPUT); out_opt = G_define_standard_option(G_OPT_V_OUTPUT); feature_opt = G_define_standard_option(G_OPT_V_TYPE); feature_opt->required = YES; feature_opt->multiple = NO; feature_opt->options = "point,line,area"; feature_opt->answer = NULL; column_name = G_define_standard_option(G_OPT_DB_COLUMN); column_name->label = _("Name of attribute column to store value"); column_name->description = _("Name must be SQL compliant"); column_name->answer = "value"; smooth_flg = G_define_flag(); smooth_flg->key = 's'; smooth_flg->description = _("Smooth corners of area features"); value_flg = G_define_flag(); value_flg->key = 'v'; value_flg->description = _("Use raster values as categories instead of unique sequence (CELL only)"); value_flg->guisection = _("Attributes"); z_flg = G_define_flag(); z_flg->key = 'z'; z_flg->label = _("Write raster values as z coordinate"); z_flg->description = _("Table is not created. " "Currently supported only for points."); z_flg->guisection = _("Attributes"); no_topol = G_define_flag(); no_topol->key = 'b'; no_topol->label = _("Do not build vector topology"); no_topol->description = _("Recommended for massive point conversion"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); feature = Vect_option_to_types(feature_opt); smooth_flag = (smooth_flg->answer) ? SMOOTH : NO_SMOOTH; value_flag = value_flg->answer; if (z_flg->answer && (feature != GV_POINT)) G_fatal_error(_("z flag is supported only for points")); /* Open files */ input_fd = Rast_open_old(in_opt->answer, ""); data_type = Rast_get_map_type(input_fd); data_size = Rast_cell_size(data_type); G_get_window(&cell_head); if (value_flag && data_type != CELL_TYPE) { G_warning(_("Raster is not CELL, '-v' flag ignored, raster values will be written to the table.")); value_flag = 0; } if (z_flg->answer) Vect_open_new(&Map, out_opt->answer, 1); else Vect_open_new(&Map, out_opt->answer, 0); Vect_hist_command(&Map); Cats = Vect_new_cats_struct(); /* Open category labels */ if (data_type == CELL_TYPE) { if (0 == Rast_read_cats(in_opt->answer, "", &RastCats)) has_cats = 1; } else has_cats = 0; db_init_string(&sql); db_init_string(&label); /* Create table */ if ((feature & (GV_AREA | GV_POINT | GV_LINE)) && (!value_flag || (value_flag && has_cats)) && !(z_flg->answer)) { char buf[1000]; Fi = Vect_default_field_info(&Map, 1, NULL, GV_1TABLE); Vect_map_add_dblink(&Map, 1, NULL, Fi->table, GV_KEY_COLUMN, 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); /* Create new table */ db_zero_string(&sql); sprintf(buf, "create table %s ( cat integer", Fi->table); db_append_string(&sql, buf); if (!value_flag) { /* add value to the table */ if (data_type == CELL_TYPE) { db_append_string(&sql, ", "); db_append_string(&sql, column_name->answer); db_append_string(&sql, " integer"); } else { db_append_string(&sql, ","); db_append_string(&sql, column_name->answer); db_append_string(&sql, " double precision"); } } if (has_cats) { int i, len; int clen = 0; /* Get maximum column length */ for (i = 0; i < RastCats.ncats; i++) { len = strlen(RastCats.labels[i]); if (len > clen) clen = len; } clen += 10; sprintf(buf, ", label varchar(%d)", clen); db_append_string(&sql, buf); } db_append_string(&sql, ")"); G_debug(3, 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, GV_KEY_COLUMN) != 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); db_begin_transaction(driver); } else { driver = NULL; } /* init variables for lines and areas */ first_read = 1; last_read = 0; direction = FORWARD; row_length = cell_head.cols; n_rows = cell_head.rows; row_count = 0; if (feature == GV_LINE) { alloc_lines_bufs(row_length + 2); extract_lines(); } else if (feature == GV_AREA) { alloc_areas_bufs(row_length + 2); extract_areas(); } else { /* GV_POINT */ extract_points(z_flg->answer); } Rast_close(input_fd); if (!no_topol->answer) Vect_build(&Map); /* insert cats and optionally labels if raster cats were used */ if (driver && value_flag) { char buf[1000]; int c, i, cat, fidx, ncats, lastcat, tp, id; fidx = Vect_cidx_get_field_index(&Map, 1); if (fidx >= 0) { ncats = Vect_cidx_get_num_cats_by_index(&Map, fidx); lastcat = -1; for (c = 0; c < ncats; c++) { Vect_cidx_get_cat_by_index(&Map, fidx, c, &cat, &tp, &id); if (lastcat == cat) continue; /* find label, slow -> TODO faster */ db_set_string(&label, ""); for (i = 0; i < RastCats.ncats; i++) { if (cat == (int)RastCats.q.table[i].dLow) { /* cats are in dLow/High not in cLow/High !!! */ db_set_string(&label, RastCats.labels[i]); db_double_quote_string(&label); break; } } G_debug(3, "cat = %d label = %s", cat, db_get_string(&label)); sprintf(buf, "insert into %s values ( %d, '%s')", Fi->table, cat, db_get_string(&label)); db_set_string(&sql, buf); G_debug(3, db_get_string(&sql)); if (db_execute_immediate(driver, &sql) != DB_OK) G_fatal_error(_("Unable to insert into table: %s"), db_get_string(&sql)); lastcat = cat; } } } if (has_cats) Rast_free_cats(&RastCats); if (driver != NULL) { db_commit_transaction(driver); db_close_database_shutdown_driver(driver); } Vect_close(&Map); G_done_msg(" "); exit(EXIT_SUCCESS); }
/* ************************************************************************* */ int main(int argc, char *argv[]) { struct Cell_head region; struct Cell_head default_region; FILE *fp = NULL; struct GModule *module; int i = 0, polytype = 0; char *null_value; int out_type; int fd; /*Normale maps ;) */ int rgbfd[3]; int vectfd[3]; int celltype[3] = { 0, 0, 0 }; int headertype; double scale = 1.0, llscale = 1.0, eleval = 0.0; int digits = 12; /* Initialize GRASS */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("export")); module->description = _("Converts raster maps into the VTK-ASCII format."); /* Get parameters from user */ set_params(); /* Have GRASS get inputs */ if (G_parser(argc, argv)) exit(EXIT_FAILURE); if (param.input->answers == NULL && param.rgbmaps->answers == NULL && param.vectmaps->answers == NULL) { G_fatal_error(_("No input maps specified. You need to specify at least one input map or three vector maps or three rgb maps.")); } /*open the output */ if (param.output->answer) { fp = fopen(param.output->answer, "w"); if (fp == NULL) { perror(param.output->answer); G_usage(); exit(EXIT_FAILURE); } } else fp = stdout; /*Correct the coordinates, so the precision of VTK is not hurt :( */ if (param.coorcorr->answer) { /*Get the default region for coordiante correction */ G_get_default_window(&default_region); /*Use the center of the current region as extent */ y_extent = (default_region.north + default_region.south) / 2; x_extent = (default_region.west + default_region.east) / 2; } else { x_extent = 0; y_extent = 0; } /* Figure out the region from the map */ G_get_window(®ion); /*Set the null Value, maybe i have to check this? */ null_value = param.null_val->answer; /*number of significant digits */ sscanf(param.decimals->answer, "%i", &digits); /* read and compute the scale factor */ sscanf(param.elevscale->answer, "%lf", &scale); sscanf(param.elev->answer, "%lf", &eleval); /*if LL projection, convert the elevation values to degrees */ if (region.proj == PROJECTION_LL) { llscale = M_PI / (180) * 6378137; scale /= llscale; } /********************* WRITE ELEVATION *************************************/ if (param.elevationmap->answer) { /*If the elevation is set, write the correct Header */ if (param.usestruct->answer) { write_vtk_structured_elevation_header(fp, region); } else { write_vtk_polygonal_elevation_header(fp, region); } G_debug(3, _("Open Raster file %s"), param.elevationmap->answer); /* open raster map */ fd = Rast_open_old(param.elevationmap->answer, ""); out_type = Rast_get_map_type(fd); /*The write the Coordinates */ if (param.usestruct->answer) { write_vtk_structured_coordinates(fd, fp, param.elevationmap->answer, region, out_type, null_value, scale, digits); } else { polytype = QUADS; /*The default */ if (param.usetriangle->answer) polytype = TRIANGLE_STRIPS; if (param.usevertices->answer) polytype = VERTICES; write_vtk_polygonal_coordinates(fd, fp, param.elevationmap->answer, region, out_type, null_value, scale, polytype, digits); } Rast_close(fd); } else { /*Should pointdata or celldata be written */ if (param.point->answer) headertype = 1; else headertype = 0; /*If no elevation is given, write the normal Header */ if (param.origin->answer) write_vtk_normal_header(fp, region, scale * eleval, headertype); else write_vtk_normal_header(fp, region, eleval / llscale, headertype); } /******************** WRITE THE POINT OR CELL DATA HEADER ******************/ if (param.input->answers != NULL || param.rgbmaps->answers != NULL) { if (param.point->answer || param.elevationmap->answer) write_vtk_pointdata_header(fp, region); else write_vtk_celldata_header(fp, region); } /********************** WRITE NORMAL DATA; CELL OR POINT *******************/ /*Loop over all input maps! */ if (param.input->answers != NULL) { for (i = 0; param.input->answers[i] != NULL; i++) { G_debug(3, _("Open Raster file %s"), param.input->answers[i]); /* open raster map */ fd = Rast_open_old(param.input->answers[i], ""); out_type = Rast_get_map_type(fd); /*Now write the data */ write_vtk_data(fd, fp, param.input->answers[i], region, out_type, null_value, digits); Rast_close(fd); } } /********************** WRITE RGB IMAGE DATA; CELL OR POINT ****************/ if (param.rgbmaps->answers != NULL) { if (param.rgbmaps->answers[0] != NULL && param.rgbmaps->answers[1] != NULL && param.rgbmaps->answers[2] != NULL) { /*Loop over all three rgb input maps! */ for (i = 0; i < 3; i++) { G_debug(3, _("Open Raster file %s"), param.rgbmaps->answers[i]); /* open raster map */ rgbfd[i] = Rast_open_old(param.rgbmaps->answers[i], ""); celltype[i] = Rast_get_map_type(rgbfd[i]); } /*Maps have to be from the same type */ if (celltype[0] == celltype[1] && celltype[0] == celltype[2]) { G_debug(3, _("Writing VTK ImageData\n")); out_type = celltype[0]; /*Now write the data */ write_vtk_rgb_image_data(rgbfd[0], rgbfd[1], rgbfd[2], fp, "RGB_Image", region, out_type, digits); } else { G_warning(_("Wrong RGB maps. Maps should have the same type! RGB output not added!")); /*do nothing */ } /*Close the maps */ for (i = 0; i < 3; i++) Rast_close(rgbfd[i]); } } /********************** WRITE VECTOR DATA; CELL OR POINT ****************/ if (param.vectmaps->answers != NULL) { if (param.vectmaps->answers[0] != NULL && param.vectmaps->answers[1] != NULL && param.vectmaps->answers[2] != NULL) { /*Loop over all three vect input maps! */ for (i = 0; i < 3; i++) { G_debug(3, _("Open Raster file %s"), param.vectmaps->answers[i]); /* open raster map */ vectfd[i] = Rast_open_old(param.vectmaps->answers[i], ""); celltype[i] = Rast_get_map_type(vectfd[i]); } /*Maps have to be from the same type */ if (celltype[0] == celltype[1] && celltype[0] == celltype[2]) { G_debug(3, _("Writing VTK Vector Data\n")); out_type = celltype[0]; /*Now write the data */ write_vtk_vector_data(vectfd[0], vectfd[1], vectfd[2], fp, "Vector_Data", region, out_type, digits); } else { G_warning(_("Wrong vector maps. Maps should have the same type! Vector output not added!")); /*do nothing */ } /*Close the maps */ for (i = 0; i < 3; i++) Rast_close(vectfd[i]); } } if (param.output->answer && fp != NULL) if (fclose(fp)) { G_fatal_error(_("Error closing VTK-ASCII file")); } return 0; }
static int write_pca(double **eigmat, int *inp_fd, char *out_basename, int bands, int scale, int scale_min, int scale_max) { int i, j; void *outbuf, *outptr; double min = 0.; double max = 0.; double old_range = 0.; double new_range = 0.; int rows = Rast_window_rows(); int cols = Rast_window_cols(); int cell_mapsiz = Rast_cell_size(CELL_TYPE); int dcell_mapsiz = Rast_cell_size(DCELL_TYPE); DCELL *d_buf; /* 2 passes for rescale. 1 pass for no rescale */ int PASSES = (scale) ? 2 : 1; /* temporary row storage */ d_buf = (DCELL *) G_malloc(cols * sizeof(double)); /* allocate memory for output row buffer */ outbuf = (scale) ? Rast_allocate_buf(CELL_TYPE) : Rast_allocate_buf(DCELL_TYPE); if (!outbuf) G_fatal_error(_("Unable to allocate memory for raster row")); for (i = 0; i < bands; i++) { char name[100]; int out_fd; int pass; sprintf(name, "%s.%d", out_basename, i + 1); G_message(_("Transforming <%s>..."), name); /* open a new file for output */ if (scale) out_fd = Rast_open_c_new(name); else { out_fd = Rast_open_fp_new(name); Rast_set_fp_type(DCELL_TYPE); } for (pass = 1; pass <= PASSES; pass++) { void *rowbuf = NULL; int row, col; if (scale && (pass == PASSES)) { G_message(_("Rescaling <%s> to range %d,%d..."), name, scale_min, scale_max); old_range = max - min; new_range = (double)(scale_max - scale_min); } for (row = 0; row < rows; row++) { void *rowptr; G_percent(row, rows, 2); /* reset d_buf */ for (col = 0; col < cols; col++) d_buf[col] = 0.; for (j = 0; j < bands; j++) { RASTER_MAP_TYPE maptype = Rast_get_map_type(inp_fd[j]); /* don't assume each image is of the same type */ if (rowbuf) G_free(rowbuf); if (!(rowbuf = Rast_allocate_buf(maptype))) G_fatal_error(_("Unable allocate memory for row buffer")); Rast_get_row(inp_fd[j], rowbuf, row, maptype); rowptr = rowbuf; outptr = outbuf; /* add into the output cell eigmat[i][j] * corresp cell * of j-th band for current j */ for (col = 0; col < cols; col++) { /* handle null cells */ if (Rast_is_null_value(rowptr, maptype)) { if (scale) { Rast_set_null_value(outptr, 1, CELL_TYPE); outptr = G_incr_void_ptr(outptr, cell_mapsiz); } else { Rast_set_null_value(outptr, 1, DCELL_TYPE); outptr = G_incr_void_ptr(outptr, dcell_mapsiz); } rowptr = G_incr_void_ptr(rowptr, Rast_cell_size(maptype)); continue; } /* corresp. cell of j-th band */ d_buf[col] += eigmat[i][j] * Rast_get_d_value(rowptr, maptype); /* the cell entry is complete */ if (j == (bands - 1)) { if (scale && (pass == 1)) { if ((row == 0) && (col == 0)) min = max = d_buf[0]; if (d_buf[col] < min) min = d_buf[col]; if (d_buf[col] > max) max = d_buf[col]; } else if (scale) { if (min == max) { Rast_set_c_value(outptr, 1, CELL_TYPE); } else { /* map data to 0, (new_range-1) and then adding new_min */ CELL tmpcell = round_c((new_range * (d_buf[col] - min) / old_range) + scale_min); Rast_set_c_value(outptr, tmpcell, CELL_TYPE); } } else { /* (!scale) */ Rast_set_d_value(outptr, d_buf[col], DCELL_TYPE); } } outptr = (scale) ? G_incr_void_ptr(outptr, cell_mapsiz) : G_incr_void_ptr(outptr, dcell_mapsiz); rowptr = G_incr_void_ptr(rowptr, Rast_cell_size(maptype)); } } /* for j = 0 to bands */ if (pass == PASSES) { if (scale) Rast_put_row(out_fd, outbuf, CELL_TYPE); else Rast_put_row(out_fd, outbuf, DCELL_TYPE); } } G_percent(row, rows, 2); /* close output file */ if (pass == PASSES) Rast_close(out_fd); } } if (d_buf) G_free(d_buf); if (outbuf) G_free(outbuf); return 0; }
static int calc_covariance(int *fds, double **covar, double *mu, int bands) { int j, k; int rows = Rast_window_rows(); int cols = Rast_window_cols(); int row, col; for (j = 0; j < bands; j++) { RASTER_MAP_TYPE maptype = Rast_get_map_type(fds[j]); void *rowbuf1 = NULL; void *rowbuf2 = NULL; /* don't assume each image is of the same type */ if (rowbuf1) G_free(rowbuf1); if ((rowbuf1 = Rast_allocate_buf(maptype)) == NULL) G_fatal_error(_("Unable allocate memory for row buffer")); G_message(_("Computing row %d (of %d) of covariance matrix..."), j + 1, bands); for (row = 0; row < rows; row++) { void *ptr1, *ptr2; G_percent(row, rows - 1, 2); Rast_get_row(fds[j], rowbuf1, row, maptype); for (k = j; k < bands; k++) { RASTER_MAP_TYPE maptype2 = Rast_get_map_type(fds[k]); /* don't assume each image is of the same type */ if (rowbuf2) G_free(rowbuf2); if ((rowbuf2 = Rast_allocate_buf(maptype2)) == NULL) G_fatal_error(_("Unable to allocate memory for row buffer")); Rast_get_row(fds[k], rowbuf2, row, maptype2); ptr1 = rowbuf1; ptr2 = rowbuf2; for (col = 0; col < cols; col++) { /* skip null cells */ if (Rast_is_null_value(ptr1, maptype) || Rast_is_null_value(ptr2, maptype2)) { ptr1 = G_incr_void_ptr(ptr1, Rast_cell_size(maptype)); ptr2 = G_incr_void_ptr(ptr2, Rast_cell_size(maptype2)); continue; } covar[j][k] += ((double)Rast_get_d_value(ptr1, maptype) - mu[j]) * ((double)Rast_get_d_value(ptr2, maptype2) - mu[k]); ptr1 = G_incr_void_ptr(ptr1, Rast_cell_size(maptype)); ptr2 = G_incr_void_ptr(ptr2, Rast_cell_size(maptype2)); } covar[k][j] = covar[j][k]; } } } return 0; }
int main(int argc, char *argv[]) { struct GModule *module; struct { struct Option *input; struct Option *output; struct Option *null; struct Option *bytes; struct Option *order; } parm; struct { struct Flag *int_out; struct Flag *float_out; struct Flag *gmt_hd; struct Flag *bil_hd; struct Flag *swap; } flag; char *name; char *outfile; double null_val; int do_stdout; int is_fp; int bytes; int order; int swap_flag; struct Cell_head region; int nrows, ncols; DCELL *in_buf; unsigned char *out_buf; int fd; FILE *fp; struct GRD_HEADER header; int row; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("export")); module->description = _("Exports a GRASS raster to a binary array."); /* Define the different options */ parm.input = G_define_option(); parm.input->key = "input"; parm.input->type = TYPE_STRING; parm.input->required = YES; parm.input->gisprompt = "old,cell,raster"; parm.input->description = _("Name of input raster map"); parm.output = G_define_option(); parm.output->key = "output"; parm.output->type = TYPE_STRING; parm.output->required = NO; parm.output->description = _("Name for output binary map (use output=- for stdout)"); parm.null = G_define_option(); parm.null->key = "null"; parm.null->type = TYPE_DOUBLE; parm.null->required = NO; parm.null->answer = "0"; parm.null->description = _("Value to write out for null"); parm.bytes = G_define_option(); parm.bytes->key = "bytes"; parm.bytes->type = TYPE_INTEGER; parm.bytes->required = NO; parm.bytes->options = "1,2,4,8"; parm.bytes->description = _("Number of bytes per cell"); parm.order = G_define_option(); parm.order->key = "order"; parm.order->type = TYPE_STRING; parm.order->required = NO; parm.order->options = "big,little,native,swap"; parm.order->description = _("Output byte order"); parm.order->answer = "native"; flag.int_out = G_define_flag(); flag.int_out->key = 'i'; flag.int_out->description = _("Generate integer output"); flag.float_out = G_define_flag(); flag.float_out->key = 'f'; flag.float_out->description = _("Generate floating-point output"); flag.gmt_hd = G_define_flag(); flag.gmt_hd->key = 'h'; flag.gmt_hd->description = _("Export array with GMT compatible header"); flag.bil_hd = G_define_flag(); flag.bil_hd->key = 'b'; flag.bil_hd->description = _("Generate BIL world and header files"); flag.swap = G_define_flag(); flag.swap->key = 's'; flag.swap->description = _("Byte swap output"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); if (sscanf(parm.null->answer, "%lf", &null_val) != 1) G_fatal_error(_("Invalid value for null (integers only)")); name = parm.input->answer; if (parm.output->answer) outfile = parm.output->answer; else { outfile = G_malloc(strlen(name) + 4 + 1); sprintf(outfile, "%s.bin", name); } if (G_strcasecmp(parm.order->answer, "big") == 0) order = 0; else if (G_strcasecmp(parm.order->answer, "little") == 0) order = 1; else if (G_strcasecmp(parm.order->answer, "native") == 0) order = G_is_little_endian() ? 1 : 0; else if (G_strcasecmp(parm.order->answer, "swap") == 0) order = G_is_little_endian() ? 0 : 1; if (flag.swap->answer) { if (strcmp(parm.order->answer, "native") != 0) G_fatal_error(_("order= and -s are mutually exclusive")); order = G_is_little_endian() ? 0 : 1; } swap_flag = order == (G_is_little_endian() ? 0 : 1); do_stdout = strcmp("-", outfile) == 0; if (flag.int_out->answer && flag.float_out->answer) G_fatal_error(_("-i and -f are mutually exclusive")); fd = Rast_open_old(name, ""); if (flag.int_out->answer) is_fp = 0; else if (flag.float_out->answer) is_fp = 1; else is_fp = Rast_get_map_type(fd) != CELL_TYPE; if (parm.bytes->answer) bytes = atoi(parm.bytes->answer); else if (is_fp) bytes = 4; else bytes = 2; if (is_fp && bytes < 4) G_fatal_error(_("Floating-point output requires bytes=4 or bytes=8")); #ifndef HAVE_LONG_LONG_INT if (!is_fp && bytes > 4) G_fatal_error(_("Integer output doesn't support bytes=8 in this build")); #endif G_get_window(®ion); /* open bin file for writing */ if (do_stdout) fp = stdout; else if (NULL == (fp = fopen(outfile, "w"))) G_fatal_error(_("Unable to create file <%s>"), outfile); /* Set up Parameters for GMT header */ if (flag.gmt_hd->answer) { if (!is_fp && bytes > 4) G_fatal_error(_("GMT grid doesn't support 64-bit integers")); make_gmt_header(&header, name, outfile, ®ion, null_val); } /* Write out BIL support files compatible with Arc-View */ if (flag.bil_hd->answer) { G_message(_("Creating BIL support files...")); write_bil_hdr(outfile, ®ion, bytes, order, flag.gmt_hd->answer, null_val); write_bil_wld(outfile, ®ion); } /* Write out GMT Header if required */ if (flag.gmt_hd->answer) write_gmt_header(&header, swap_flag, fp); nrows = Rast_window_rows(); ncols = Rast_window_cols(); in_buf = Rast_allocate_d_buf(); out_buf = G_malloc(ncols * bytes); if (is_fp) { G_message(_("Exporting raster as floating values (bytes=%d)"), bytes); if (flag.gmt_hd->answer) G_message(_("Writing GMT float format ID=1")); } else { G_message(_("Exporting raster as integer values (bytes=%d)"), bytes); if (flag.gmt_hd->answer) G_message(_("Writing GMT integer format ID=2")); } G_verbose_message(_("Using the current region settings...")); G_verbose_message(_("north=%f"), region.north); G_verbose_message(_("south=%f"), region.south); G_verbose_message(_("east=%f"), region.east); G_verbose_message(_("west=%f"), region.west); G_verbose_message(_("r=%d"), region.rows); G_verbose_message(_("c=%d"), region.cols); for (row = 0; row < nrows; row++) { G_percent(row, nrows, 2); Rast_get_d_row(fd, in_buf, row); convert_row(out_buf, in_buf, ncols, is_fp, bytes, swap_flag, null_val); if (fwrite(out_buf, bytes, ncols, fp) != ncols) G_fatal_error(_("Error writing data")); } G_percent(row, nrows, 2); /* finish it off */ Rast_close(fd); fclose(fp); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { extern struct Cell_head window; union RASTER_PTR elevbuf, tmpbuf, outbuf; CELL min, max; DCELL dvalue, dvalue2, dmin, dmax; struct History hist; RASTER_MAP_TYPE data_type; struct Range range; struct FPRange fprange; double drow, dcol; int elev_fd, output_fd, zeros; struct { struct Option *opt1, *opt2, *opt3, *opt4, *north, *east, *year, *month, *day, *hour, *minutes, *seconds, *timezone; } parm; struct Flag *flag1, *flag3, *flag4; struct GModule *module; char *name, *outname; double dazi, dalti; double azi, alti; double nstep, estep; double maxh; double east, east1, north, north1; int row1, col1; char OK; double timezone; int year, month, day, hour, minutes, seconds; long retval; int solparms, locparms, use_solpos; double sunrise, sunset, current_time; int sretr = 0, ssetr = 0, sretr_sec = 0, ssetr_sec = 0; double dsretr, dssetr; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("sun position")); module->label = _("Calculates cast shadow areas from sun position and elevation raster map."); module->description = _("Either exact sun position (A) is specified, or date/time to calculate " "the sun position (B) by r.sunmask itself."); parm.opt1 = G_define_standard_option(G_OPT_R_ELEV); parm.opt2 = G_define_standard_option(G_OPT_R_OUTPUT); parm.opt2->required = NO; parm.opt3 = G_define_option(); parm.opt3->key = "altitude"; parm.opt3->type = TYPE_DOUBLE; parm.opt3->required = NO; parm.opt3->options = "0-89.999"; parm.opt3->description = _("Altitude of the sun above horizon, degrees (A)"); parm.opt3->guisection = _("Position"); parm.opt4 = G_define_option(); parm.opt4->key = "azimuth"; parm.opt4->type = TYPE_DOUBLE; parm.opt4->required = NO; parm.opt4->options = "0-360"; parm.opt4->description = _("Azimuth of the sun from the north, degrees (A)"); parm.opt4->guisection = _("Position"); parm.year = G_define_option(); parm.year->key = "year"; parm.year->type = TYPE_INTEGER; parm.year->required = NO; parm.year->description = _("Year (B)"); parm.year->options = "1950-2050"; parm.year->guisection = _("Time"); parm.month = G_define_option(); parm.month->key = "month"; parm.month->type = TYPE_INTEGER; parm.month->required = NO; parm.month->description = _("Month (B)"); parm.month->options = "0-12"; parm.month->guisection = _("Time"); parm.day = G_define_option(); parm.day->key = "day"; parm.day->type = TYPE_INTEGER; parm.day->required = NO; parm.day->description = _("Day (B)"); parm.day->options = "0-31"; parm.day->guisection = _("Time"); parm.hour = G_define_option(); parm.hour->key = "hour"; parm.hour->type = TYPE_INTEGER; parm.hour->required = NO; parm.hour->description = _("Hour (B)"); parm.hour->options = "0-24"; parm.hour->guisection = _("Time"); parm.minutes = G_define_option(); parm.minutes->key = "minute"; parm.minutes->type = TYPE_INTEGER; parm.minutes->required = NO; parm.minutes->description = _("Minutes (B)"); parm.minutes->options = "0-60"; parm.minutes->guisection = _("Time"); parm.seconds = G_define_option(); parm.seconds->key = "second"; parm.seconds->type = TYPE_INTEGER; parm.seconds->required = NO; parm.seconds->description = _("Seconds (B)"); parm.seconds->options = "0-60"; parm.seconds->guisection = _("Time"); parm.timezone = G_define_option(); parm.timezone->key = "timezone"; parm.timezone->type = TYPE_INTEGER; parm.timezone->required = NO; parm.timezone->label = _("Timezone"); parm.timezone->description = _("East positive, offset from GMT, also use to adjust daylight savings"); parm.timezone->guisection = _("Time"); parm.east = G_define_option(); parm.east->key = "east"; parm.east->key_desc = "value"; parm.east->type = TYPE_STRING; parm.east->required = NO; parm.east->label = _("Easting coordinate (point of interest)"); parm.east->description = _("Default: map center"); parm.east->guisection = _("Position"); parm.north = G_define_option(); parm.north->key = "north"; parm.north->key_desc = "value"; parm.north->type = TYPE_STRING; parm.north->required = NO; parm.north->label = _("Northing coordinate (point of interest)"); parm.north->description = _("Default: map center"); parm.north->guisection = _("Position"); flag1 = G_define_flag(); flag1->key = 'z'; flag1->description = _("Don't ignore zero elevation"); flag3 = G_define_flag(); flag3->key = 's'; flag3->description = _("Calculate sun position only and exit"); flag3->guisection = _("Print"); flag4 = G_define_flag(); flag4->key = 'g'; flag4->description = _("Print the sun position output in shell script style"); flag4->guisection = _("Print"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); zeros = flag1->answer; G_get_window(&window); /* if not given, get east and north: XX */ if (!parm.north->answer || !parm.east->answer) { north = (window.north - window.south) / 2. + window.south; east = (window.west - window.east) / 2. + window.east; G_verbose_message(_("Using map center coordinates: %f %f"), east, north); } else { /* user defined east, north: */ sscanf(parm.north->answer, "%lf", &north); sscanf(parm.east->answer, "%lf", &east); if (strlen(parm.east->answer) == 0) G_fatal_error(_("Empty east coordinate specified")); if (strlen(parm.north->answer) == 0) G_fatal_error(_("Empty north coordinate specified")); } /* check which method to use for sun position: either user defines directly sun position or it is calculated */ if (parm.opt3->answer && parm.opt4->answer) solparms = 1; /* opt3 & opt4 complete */ else solparms = 0; /* calculate sun position */ if (parm.year->answer && parm.month->answer && parm.day->answer && parm.hour->answer && parm.minutes->answer && parm.seconds->answer && parm.timezone->answer) locparms = 1; /* complete */ else locparms = 0; if (solparms && locparms) /* both defined */ G_fatal_error(_("Either define sun position or location/date/time parameters")); if (!solparms && !locparms) /* nothing defined */ G_fatal_error(_("Neither sun position nor east/north, date/time/timezone definition are complete")); /* if here, one definition was complete */ if (locparms) { G_message(_("Calculating sun position... (using solpos (V. %s) from NREL)"), SOLPOSVERSION); use_solpos = 1; } else { G_message(_("Using user defined sun azimuth, altitude settings (ignoring eventual other values)")); use_solpos = 0; } name = parm.opt1->answer; outname = parm.opt2->answer; if (!use_solpos) { sscanf(parm.opt3->answer, "%lf", &dalti); sscanf(parm.opt4->answer, "%lf", &dazi); } else { sscanf(parm.year->answer, "%i", &year); sscanf(parm.month->answer, "%i", &month); sscanf(parm.day->answer, "%i", &day); sscanf(parm.hour->answer, "%i", &hour); sscanf(parm.minutes->answer, "%i", &minutes); sscanf(parm.seconds->answer, "%i", &seconds); sscanf(parm.timezone->answer, "%lf", &timezone); } /* NOTES: G_calc_solar_position () - the algorithm will compensate for leap year. - longitude, latitude: decimal degree - timezone: DO NOT ADJUST FOR DAYLIGHT SAVINGS TIME. - timezone: negative for zones west of Greenwich - lat/long: east and north positive - the atmospheric refraction is calculated for 1013hPa, 15�C - time: local time from your watch Order of parameters: long, lat, timezone, year, month, day, hour, minutes, seconds */ if (use_solpos) { G_debug(3, "\nlat:%f long:%f", north, east); retval = calc_solar_position(east, north, timezone, year, month, day, hour, minutes, seconds); /* Remove +0.5 above if you want round-down instead of round-to-nearest */ sretr = (int)floor(pdat->sretr); /* sunrise */ dsretr = pdat->sretr; sretr_sec = (int) floor(((dsretr - floor(dsretr)) * 60 - floor((dsretr - floor(dsretr)) * 60)) * 60); ssetr = (int)floor(pdat->ssetr); /* sunset */ dssetr = pdat->ssetr; ssetr_sec = (int) floor(((dssetr - floor(dssetr)) * 60 - floor((dssetr - floor(dssetr)) * 60)) * 60); /* print the results */ if (retval == 0) { /* error check */ if (flag3->answer) { if (flag4->answer) { fprintf(stdout, "date=%d/%02d/%02d\n", pdat->year, pdat->month, pdat->day); fprintf(stdout, "daynum=%d\n", pdat->daynum); fprintf(stdout, "time=%02i:%02i:%02i\n", pdat->hour, pdat->minute, pdat->second); fprintf(stdout, "decimaltime=%f\n", pdat->hour + (pdat->minute * 100.0 / 60.0 + pdat->second * 100.0 / 3600.0) / 100.); fprintf(stdout, "longitudine=%f\n", pdat->longitude); fprintf(stdout, "latitude=%f\n", pdat->latitude); fprintf(stdout, "timezone=%f\n", pdat->timezone); fprintf(stdout, "sunazimuth=%f\n", pdat->azim); fprintf(stdout, "sunangleabovehorizon=%f\n", pdat->elevref); if (sretr / 60 <= 24.0) { fprintf(stdout, "sunrise=%02d:%02d:%02d\n", sretr / 60, sretr % 60, sretr_sec); fprintf(stdout, "sunset=%02d:%02d:%02d\n", ssetr / 60, ssetr % 60, ssetr_sec); } } else { fprintf(stdout, "%d/%02d/%02d, daynum: %d, time: %02i:%02i:%02i (decimal time: %f)\n", pdat->year, pdat->month, pdat->day, pdat->daynum, pdat->hour, pdat->minute, pdat->second, pdat->hour + (pdat->minute * 100.0 / 60.0 + pdat->second * 100.0 / 3600.0) / 100.); fprintf(stdout, "long: %f, lat: %f, timezone: %f\n", pdat->longitude, pdat->latitude, pdat->timezone); fprintf(stdout, "Solar position: sun azimuth: %f, sun angle above horz. (refraction corrected): %f\n", pdat->azim, pdat->elevref); if (sretr / 60 <= 24.0) { fprintf(stdout, "Sunrise time (without refraction): %02d:%02d:%02d\n", sretr / 60, sretr % 60, sretr_sec); fprintf(stdout, "Sunset time (without refraction): %02d:%02d:%02d\n", ssetr / 60, ssetr % 60, ssetr_sec); } } } sunrise = pdat->sretr / 60.; /* decimal minutes */ sunset = pdat->ssetr / 60.; current_time = pdat->hour + (pdat->minute / 60.) + (pdat->second / 3600.); } else /* fatal error in G_calc_solar_position() */ G_fatal_error(_("Please correct settings")); } if (use_solpos) { dalti = pdat->elevref; dazi = pdat->azim; } /* otherwise already defined */ /* check sunrise */ if (use_solpos) { G_debug(3, "current_time:%f sunrise:%f", current_time, sunrise); if ((current_time < sunrise)) { if (sretr / 60 <= 24.0) G_message(_("Time (%02i:%02i:%02i) is before sunrise (%02d:%02d:%02d)"), pdat->hour, pdat->minute, pdat->second, sretr / 60, sretr % 60, sretr_sec); else G_message(_("Time (%02i:%02i:%02i) is before sunrise"), pdat->hour, pdat->minute, pdat->second); G_warning(_("Nothing to calculate. Please verify settings.")); } if ((current_time > sunset)) { if (sretr / 60 <= 24.0) G_message(_("Time (%02i:%02i:%02i) is after sunset (%02d:%02d:%02d)"), pdat->hour, pdat->minute, pdat->second, ssetr / 60, ssetr % 60, ssetr_sec); else G_message(_("Time (%02i:%02i:%02i) is after sunset"), pdat->hour, pdat->minute, pdat->second); G_warning(_("Nothing to calculate. Please verify settings.")); } } if (flag3->answer && (use_solpos == 1)) { /* we only want the sun position */ exit(EXIT_SUCCESS); } else if (flag3->answer && (use_solpos == 0)) { /* are you joking ? */ G_message(_("You already know the sun position")); exit(EXIT_SUCCESS); } if (!outname) G_fatal_error(_("Option <%s> required"), parm.opt2->key); elev_fd = Rast_open_old(name, ""); output_fd = Rast_open_c_new(outname); data_type = Rast_get_map_type(elev_fd); elevbuf.v = Rast_allocate_buf(data_type); tmpbuf.v = Rast_allocate_buf(data_type); outbuf.v = Rast_allocate_buf(CELL_TYPE); /* binary map */ if (data_type == CELL_TYPE) { if ((Rast_read_range(name, "", &range)) < 0) G_fatal_error(_("Unable to open range file for raster map <%s>"), name); Rast_get_range_min_max(&range, &min, &max); dmin = (double)min; dmax = (double)max; } else { Rast_read_fp_range(name, "", &fprange); Rast_get_fp_range_min_max(&fprange, &dmin, &dmax); } azi = 2 * M_PI * dazi / 360; alti = 2 * M_PI * dalti / 360; nstep = cos(azi) * window.ns_res; estep = sin(azi) * window.ew_res; row1 = 0; G_message(_("Calculating shadows from DEM...")); while (row1 < window.rows) { G_percent(row1, window.rows, 2); col1 = 0; drow = -1; Rast_get_row(elev_fd, elevbuf.v, row1, data_type); while (col1 < window.cols) { dvalue = raster_value(elevbuf, data_type, col1); /* outbuf.c[col1]=1; */ Rast_set_null_value(&outbuf.c[col1], 1, CELL_TYPE); OK = 1; east = Rast_col_to_easting(col1 + 0.5, &window); north = Rast_row_to_northing(row1 + 0.5, &window); east1 = east; north1 = north; if (dvalue == 0.0 && !zeros) OK = 0; while (OK == 1) { east += estep; north += nstep; if (north > window.north || north < window.south || east > window.east || east < window.west) OK = 0; else { maxh = tan(alti) * sqrt((north1 - north) * (north1 - north) + (east1 - east) * (east1 - east)); if ((maxh) > (dmax - dvalue)) OK = 0; else { dcol = Rast_easting_to_col(east, &window); if (drow != Rast_northing_to_row(north, &window)) { drow = Rast_northing_to_row(north, &window); Rast_get_row(elev_fd, tmpbuf.v, (int)drow, data_type); } dvalue2 = raster_value(tmpbuf, data_type, (int)dcol); if ((dvalue2 - dvalue) > (maxh)) { OK = 0; outbuf.c[col1] = 1; } } } } G_debug(3, "Analysing col %i", col1); col1 += 1; } G_debug(3, "Writing result row %i of %i", row1, window.rows); Rast_put_row(output_fd, outbuf.c, CELL_TYPE); row1 += 1; } G_percent(1, 1, 1); Rast_close(output_fd); Rast_close(elev_fd); /* writing history file */ Rast_short_history(outname, "raster", &hist); Rast_format_history(&hist, HIST_DATSRC_1, "raster elevation map %s", name); Rast_command_history(&hist); Rast_write_history(outname, &hist); exit(EXIT_SUCCESS); }
/* ************************************************************************* */ int main(int argc, char *argv[]) { RASTER3D_Region region; struct Cell_head window2d; struct GModule *module; void *map = NULL; /*The 3D Rastermap */ int changemask = 0; int elevfd = -1, outfd = -1; /*file descriptors */ int output_type, cols, rows; /* Initialize GRASS */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster3d")); G_add_keyword(_("profile")); G_add_keyword(_("raster")); G_add_keyword(_("voxel")); module->description = _("Creates cross section 2D raster map from 3D raster map based on 2D elevation map"); /* Get parameters from user */ set_params(); /* Have GRASS get inputs */ if (G_parser(argc, argv)) exit(EXIT_FAILURE); G_debug(3, "Open 3D raster map %s", param.input->answer); if (NULL == G_find_raster3d(param.input->answer, "")) Rast3d_fatal_error(_("3D raster map <%s> not found"), param.input->answer); /* Figure out the region from the map */ Rast3d_init_defaults(); Rast3d_get_window(®ion); /*Check if the g3d-region is equal to the 2d rows and cols */ rows = Rast_window_rows(); cols = Rast_window_cols(); /*If not equal, set the 2D windows correct */ if (rows != region.rows || cols != region.cols) { G_message (_("The 2D and 3D region settings are different. Using the 3D raster map settings to adjust the 2D region.")); G_get_set_window(&window2d); window2d.ns_res = region.ns_res; window2d.ew_res = region.ew_res; window2d.rows = region.rows; window2d.cols = region.cols; Rast_set_window(&window2d); } /*******************/ /*Open the 3d raster map */ /*******************/ map = Rast3d_open_cell_old(param.input->answer, G_find_raster3d(param.input->answer, ""), ®ion, RASTER3D_TILE_SAME_AS_FILE, RASTER3D_USE_CACHE_DEFAULT); if (map == NULL) Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"), param.input->answer); /*Get the output type */ output_type = Rast3d_file_type_map(map); if (output_type == FCELL_TYPE || output_type == DCELL_TYPE) { /********************************/ /*Open the elevation raster map */ /********************************/ elevfd = Rast_open_old(param.elevation->answer, ""); globalElevMapType = Rast_get_map_type(elevfd); /**********************/ /*Open the Outputmap */ /**********************/ if (G_find_raster2(param.output->answer, "")) G_message(_("Output map already exists. Will be overwritten!")); if (output_type == FCELL_TYPE) outfd = Rast_open_new(param.output->answer, FCELL_TYPE); else if (output_type == DCELL_TYPE) outfd = Rast_open_new(param.output->answer, DCELL_TYPE); /*if requested set the Mask on */ if (param.mask->answer) { if (Rast3d_mask_file_exists()) { changemask = 0; if (Rast3d_mask_is_off(map)) { Rast3d_mask_on(map); changemask = 1; } } } /************************/ /*Create the Rastermaps */ /************************/ rast3d_cross_section(map, region, elevfd, outfd); /*We set the Mask off, if it was off before */ if (param.mask->answer) { if (Rast3d_mask_file_exists()) if (Rast3d_mask_is_on(map) && changemask) Rast3d_mask_off(map); } Rast_close(outfd); Rast_close(elevfd); } else { fatal_error(map, -1, -1, _("Wrong 3D raster datatype! Cannot create raster map")); } /* Close files and exit */ if (!Rast3d_close(map)) Rast3d_fatal_error(_("Unable to close 3D raster map <%s>"), param.input->answer); return (EXIT_SUCCESS); }
/*! \brief Get categories/labels Formats label as in d.what.rast -> (catval) catlabel \param filename raster map name \param drow \param dcol \param catstr category string \return 1 on success \return 0 on failure */ int Gs_get_cat_label(const char *filename, int drow, int dcol, char *catstr) { struct Categories cats; const char *mapset; CELL *buf; DCELL *dbuf; RASTER_MAP_TYPE map_type; int fd = -1; if ((mapset = G_find_raster2(filename, "")) == NULL) { G_warning(_("Raster map <%s> not found"), filename); return 0; } if (-1 != Rast_read_cats(filename, mapset, &cats)) { fd = Rast_open_old(filename, mapset); map_type = Rast_get_map_type(fd); if (map_type == CELL_TYPE) { buf = Rast_allocate_c_buf(); Rast_get_c_row(fd, buf, drow); if (Rast_is_c_null_value(&buf[dcol])) { sprintf(catstr, "(NULL) %s", Rast_get_c_cat(&buf[dcol], &cats)); } else { sprintf(catstr, "(%d) %s", buf[dcol], Rast_get_c_cat(&buf[dcol], &cats)); } G_free(buf); } else { /* fp map */ dbuf = Rast_allocate_d_buf(); Rast_get_d_row(fd, dbuf, drow); if (Rast_is_d_null_value(&dbuf[dcol])) { sprintf(catstr, "(NULL) %s", Rast_get_d_cat(&dbuf[dcol], &cats)); } else { sprintf(catstr, "(%g) %s", dbuf[dcol], Rast_get_d_cat(&dbuf[dcol], &cats)); } G_free(dbuf); } } else { strcpy(catstr, "no category label"); return 0; } /* TODO: may want to keep these around for multiple queries */ Rast_free_cats(&cats); if (fd >= 0) Rast_close(fd); return (1); }
int main(int argc, char **argv) { struct band B[3]; int row; int next_row; int overlay; struct Cell_head window; struct GModule *module; struct Flag *flag_n; int i; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("display")); G_add_keyword(_("graphics")); G_add_keyword(_("raster")); G_add_keyword("RGB"); module->description = _("Displays three user-specified raster maps " "as red, green, and blue overlays in the active graphics frame."); flag_n = G_define_flag(); flag_n->key = 'n'; flag_n->description = _("Make null cells opaque"); flag_n->guisection = _("Null cells"); for (i = 0; i < 3; i++) { char buff[80]; sprintf(buff, _("Name of raster map to be used for <%s>"), color_names[i]); B[i].opt = G_define_standard_option(G_OPT_R_MAP); B[i].opt->key = G_store(color_names[i]); B[i].opt->description = G_store(buff); } if (G_parser(argc, argv)) exit(EXIT_FAILURE); /* Do screen initializing stuff */ D_open_driver(); overlay = !flag_n->answer; D_setup(0); D_set_overlay_mode(overlay); for (i = 0; i < 3; i++) { /* Get name of layer to be used */ char *name = B[i].opt->answer; /* Make sure map is available */ B[i].file = Rast_open_old(name, ""); B[i].type = Rast_get_map_type(B[i].file); /* Reading color lookup table */ if (Rast_read_colors(name, "", &B[i].colors) == -1) G_fatal_error(_("Color file for <%s> not available"), name); B[i].array = Rast_allocate_buf(B[i].type); } /* read in current window */ G_get_window(&window); D_raster_draw_begin(); next_row = 0; for (row = 0; row < window.rows;) { G_percent(row, window.rows, 5); for (i = 0; i < 3; i++) Rast_get_row(B[i].file, B[i].array, row, B[i].type); if (row == next_row) next_row = D_draw_raster_RGB(next_row, B[0].array, B[1].array, B[2].array, &B[0].colors, &B[1].colors, &B[2].colors, B[0].type, B[1].type, B[2].type); else if (next_row > 0) row = next_row; else break; } G_percent(window.rows, window.rows, 5); D_raster_draw_end(); D_save_command(G_recreate_command()); D_close_driver(); /* Close the raster maps */ for (i = 0; i < 3; i++) Rast_close(B[i].file); exit(EXIT_SUCCESS); }
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 fe, fd, fm; int i, j, type; int new_id; int nrows, ncols, nbasins; int map_id, dir_id, bas_id; char map_name[GNAME_MAX], new_map_name[GNAME_MAX]; const char *tempfile1, *tempfile2, *tempfile3; char dir_name[GNAME_MAX]; char bas_name[GNAME_MAX]; struct Cell_head window; struct GModule *module; struct Option *opt1, *opt2, *opt3, *opt4, *opt5; struct Flag *flag1; int in_type, bufsz; void *in_buf; CELL *out_buf; struct band3 bnd, bndC; /* Initialize the GRASS environment variables */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("hydrology")); module->description = _("Filters and generates a depressionless elevation map and a " "flow direction map from a given elevation raster map."); opt1 = G_define_standard_option(G_OPT_R_ELEV); opt2 = G_define_standard_option(G_OPT_R_OUTPUT); opt2->key = "depressionless"; opt2->description = _("Name for output depressionless elevation raster map"); opt4 = G_define_standard_option(G_OPT_R_OUTPUT); opt4->key = "direction"; opt4->description = _("Name for output flow direction map for depressionless elevation raster map"); opt5 = G_define_standard_option(G_OPT_R_OUTPUT); opt5->key = "areas"; opt5->required = NO; opt5->description = _("Name for output raster map of problem areas"); opt3 = G_define_option(); opt3->key = "type"; opt3->type = TYPE_STRING; opt3->required = NO; opt3->description = _("Aspect direction format"); opt3->options = "agnps,answers,grass"; opt3->answer = "grass"; flag1 = G_define_flag(); flag1->key = 'f'; flag1->description = _("Find unresolved areas only"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); if (flag1->answer && opt5->answer == NULL) { G_fatal_error(_("The '%c' flag requires '%s'to be specified"), flag1->key, opt5->key); } type = 0; strcpy(map_name, opt1->answer); strcpy(new_map_name, opt2->answer); strcpy(dir_name, opt4->answer); if (opt5->answer != NULL) strcpy(bas_name, opt5->answer); if (strcmp(opt3->answer, "agnps") == 0) type = 1; else if (strcmp(opt3->answer, "answers") == 0) type = 2; else if (strcmp(opt3->answer, "grass") == 0) type = 3; G_debug(1, "output type (1=AGNPS, 2=ANSWERS, 3=GRASS): %d", type); if (type == 3) G_verbose_message(_("Direction map is D8 resolution, i.e. 45 degrees")); /* open the maps and get their file id */ map_id = Rast_open_old(map_name, ""); /* allocate cell buf for the map layer */ in_type = Rast_get_map_type(map_id); /* set the pointers for multi-typed functions */ set_func_pointers(in_type); /* get the window information */ G_get_window(&window); nrows = Rast_window_rows(); ncols = Rast_window_cols(); /* buffers for internal use */ bndC.ns = ncols; bndC.sz = sizeof(CELL) * ncols; bndC.b[0] = G_calloc(ncols, sizeof(CELL)); bndC.b[1] = G_calloc(ncols, sizeof(CELL)); bndC.b[2] = G_calloc(ncols, sizeof(CELL)); /* buffers for external use */ bnd.ns = ncols; bnd.sz = ncols * bpe(); bnd.b[0] = G_calloc(ncols, bpe()); bnd.b[1] = G_calloc(ncols, bpe()); bnd.b[2] = G_calloc(ncols, bpe()); in_buf = get_buf(); tempfile1 = G_tempfile(); tempfile2 = G_tempfile(); tempfile3 = G_tempfile(); fe = open(tempfile1, O_RDWR | O_CREAT, 0666); /* elev */ fd = open(tempfile2, O_RDWR | O_CREAT, 0666); /* dirn */ fm = open(tempfile3, O_RDWR | O_CREAT, 0666); /* problems */ G_message(_("Reading elevation map...")); for (i = 0; i < nrows; i++) { G_percent(i, nrows, 2); get_row(map_id, in_buf, i); write(fe, in_buf, bnd.sz); } G_percent(1, 1, 1); Rast_close(map_id); /* fill single-cell holes and take a first stab at flow directions */ G_message(_("Filling sinks...")); filldir(fe, fd, nrows, &bnd); /* determine flow directions for ambiguous cases */ G_message(_("Determining flow directions for ambiguous cases...")); resolve(fd, nrows, &bndC); /* mark and count the sinks in each internally drained basin */ nbasins = dopolys(fd, fm, nrows, ncols); if (flag1->answer) { /* determine the watershed for each sink */ wtrshed(fm, fd, nrows, ncols, 4); /* fill all of the watersheds up to the elevation necessary for drainage */ ppupdate(fe, fm, nrows, nbasins, &bnd, &bndC); /* repeat the first three steps to get the final directions */ G_message(_("Repeat to get the final directions...")); filldir(fe, fd, nrows, &bnd); resolve(fd, nrows, &bndC); nbasins = dopolys(fd, fm, nrows, ncols); } G_free(bndC.b[0]); G_free(bndC.b[1]); G_free(bndC.b[2]); G_free(bnd.b[0]); G_free(bnd.b[1]); G_free(bnd.b[2]); out_buf = Rast_allocate_c_buf(); bufsz = ncols * sizeof(CELL); lseek(fe, 0, SEEK_SET); new_id = Rast_open_new(new_map_name, in_type); lseek(fd, 0, SEEK_SET); dir_id = Rast_open_new(dir_name, CELL_TYPE); if (opt5->answer != NULL) { lseek(fm, 0, SEEK_SET); bas_id = Rast_open_new(bas_name, CELL_TYPE); for (i = 0; i < nrows; i++) { read(fm, out_buf, bufsz); Rast_put_row(bas_id, out_buf, CELL_TYPE); } Rast_close(bas_id); close(fm); } for (i = 0; i < nrows; i++) { read(fe, in_buf, bnd.sz); put_row(new_id, in_buf); read(fd, out_buf, bufsz); for (j = 0; j < ncols; j += 1) out_buf[j] = dir_type(type, out_buf[j]); Rast_put_row(dir_id, out_buf, CELL_TYPE); } Rast_close(new_id); close(fe); Rast_close(dir_id); close(fd); G_free(in_buf); G_free(out_buf); 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 rectify(char *name, char *mapset, struct cache *ebuffer, double aver_z, char *result, char *interp_method) { struct Cell_head cellhd; int ncols, nrows; int row, col; double row_idx, col_idx; int infd, outfd; RASTER_MAP_TYPE map_type; int cell_size; void *trast, *tptr; double n1, e1, z1; double nx, ex, nx1, ex1, zx1; struct cache *ibuffer; select_current_env(); Rast_get_cellhd(name, mapset, &cellhd); /* open the file to be rectified * set window to cellhd first to be able to read file exactly */ Rast_set_input_window(&cellhd); infd = Rast_open_old(name, mapset); map_type = Rast_get_map_type(infd); cell_size = Rast_cell_size(map_type); ibuffer = readcell(infd, seg_mb_img, 0); Rast_close(infd); /* (pmx) 17 april 2000 */ G_message(_("Rectify <%s@%s> (location <%s>)"), name, mapset, G_location()); select_target_env(); G_set_window(&target_window); G_message(_("into <%s@%s> (location <%s>) ..."), result, G_mapset(), G_location()); nrows = target_window.rows; ncols = target_window.cols; if (strcmp(interp_method, "nearest") != 0) { map_type = DCELL_TYPE; cell_size = Rast_cell_size(map_type); } /* open the result file into target window * this open must be first since we change the window later * raster maps open for writing are not affected by window changes * but those open for reading are */ outfd = Rast_open_new(result, map_type); trast = Rast_allocate_output_buf(map_type); for (row = 0; row < nrows; row++) { n1 = target_window.north - (row + 0.5) * target_window.ns_res; G_percent(row, nrows, 2); Rast_set_null_value(trast, ncols, map_type); tptr = trast; for (col = 0; col < ncols; col++) { DCELL *zp = CPTR(ebuffer, row, col); e1 = target_window.west + (col + 0.5) * target_window.ew_res; /* if target cell has no elevation, set to aver_z */ if (Rast_is_d_null_value(zp)) { G_warning(_("No elevation available at row = %d, col = %d"), row, col); z1 = aver_z; } else z1 = *zp; /* target coordinates e1, n1 to photo coordinates ex1, nx1 */ I_ortho_ref(e1, n1, z1, &ex1, &nx1, &zx1, &group.camera_ref, group.XC, group.YC, group.ZC, group.M); G_debug(5, "\t\tAfter ortho ref (photo cords): ex = %f \t nx = %f", ex1, nx1); /* photo coordinates ex1, nx1 to image coordinates ex, nx */ I_georef(ex1, nx1, &ex, &nx, group.E21, group.N21, 1); G_debug(5, "\t\tAfter geo ref: ex = %f \t nx = %f", ex, nx); /* convert to row/column indices of source raster */ row_idx = (cellhd.north - nx) / cellhd.ns_res; col_idx = (ex - cellhd.west) / cellhd.ew_res; /* resample data point */ interpolate(ibuffer, tptr, map_type, &row_idx, &col_idx, &cellhd); tptr = G_incr_void_ptr(tptr, cell_size); } Rast_put_row(outfd, trast, map_type); } G_percent(1, 1, 1); Rast_close(outfd); /* (pmx) 17 april 2000 */ G_free(trast); close(ibuffer->fd); release_cache(ibuffer); Rast_get_cellhd(result, G_mapset(), &cellhd); if (cellhd.proj == 0) { /* x,y imagery */ cellhd.proj = target_window.proj; cellhd.zone = target_window.zone; } if (target_window.proj != cellhd.proj) { cellhd.proj = target_window.proj; G_warning(_("Raster map <%s@%s>: projection don't match current settings"), name, mapset); } if (target_window.zone != cellhd.zone) { cellhd.zone = target_window.zone; G_warning(_("Raster map <%s@%s>: zone don't match current settings"), name, mapset); } select_current_env(); return 1; }
/* ************************************************************************* */ int main(int argc, char *argv[]) { char *output = NULL; RASTER3D_Region region; struct Cell_head window2d; struct Cell_head default_region; FILE *fp = NULL; struct GModule *module; int dp, i, changemask = 0; int rows, cols; const char *mapset, *name; double scale = 1.0, llscale = 1.0; input_maps *in; /* Initialize GRASS */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster3d")); G_add_keyword(_("export")); G_add_keyword(_("voxel")); G_add_keyword("VTK"); module->description = _("Converts 3D raster maps into the VTK-ASCII format."); /* Get parameters from user */ set_params(); /* Have GRASS get inputs */ if (G_parser(argc, argv)) exit(EXIT_FAILURE); /*The precision of the output */ if (param.decimals->answer) { if (sscanf(param.decimals->answer, "%d", &dp) != 1) G_fatal_error(_("failed to interpret dp as an integer")); if (dp > 20 || dp < 0) G_fatal_error(_("dp has to be from 0 to 20")); } else { dp = 8; /*This value is taken from the lib settings in G_format_easting */ } /*Check the input */ check_input_maps(); /*Correct the coordinates, so the precision of VTK is not hurt :( */ if (param.coorcorr->answer) { /*Get the default region for coordiante correction */ G_get_default_window(&default_region); /*Use the center of the current region as extent */ y_extent = (default_region.north + default_region.south) / 2; x_extent = (default_region.west + default_region.east) / 2; } else { x_extent = 0; y_extent = 0; } /*open the output */ if (param.output->answer) { fp = fopen(param.output->answer, "w"); if (fp == NULL) { perror(param.output->answer); G_usage(); exit(EXIT_FAILURE); } } else fp = stdout; /* Figure out the region from the map */ Rast3d_init_defaults(); Rast3d_get_window(®ion); /*initiate the input mpas structure */ in = create_input_maps_struct(); /* read and compute the scale factor */ sscanf(param.elevscale->answer, "%lf", &scale); /*if LL projection, convert the elevation values to degrees */ if (param.scalell->answer && region.proj == PROJECTION_LL) { llscale = M_PI / (180) * 6378137; scale /= llscale; } /*Open the top and bottom file */ if (param.structgrid->answer) { /*Check if the g3d-region is equal to the 2d rows and cols */ rows = Rast_window_rows(); cols = Rast_window_cols(); /*If not equal, set the 2D windows correct */ if (rows != region.rows || cols != region.cols) { G_message(_("The 2D and 3D region settings are different. " "Using the 2D window settings to adjust the 2D part of the 3D region.")); G_get_set_window(&window2d); window2d.ns_res = region.ns_res; window2d.ew_res = region.ew_res; window2d.rows = region.rows; window2d.cols = region.cols; Rast_set_window(&window2d); } /*open top */ mapset = NULL; name = NULL; name = param.top->answer; mapset = G_find_raster2(name, ""); in->top = open_input_map(name, mapset); in->topMapType = Rast_get_map_type(in->top); /*open bottom */ mapset = NULL; name = NULL; name = param.bottom->answer; mapset = G_find_raster2(name, ""); in->bottom = open_input_map(name, mapset); in->bottomMapType = Rast_get_map_type(in->bottom); /* Write the vtk-header and the points */ if (param.point->answer) { write_vtk_structured_grid_header(fp, output, region); write_vtk_points(in, fp, region, dp, 1, scale); } else { write_vtk_unstructured_grid_header(fp, output, region); write_vtk_points(in, fp, region, dp, 0, scale); write_vtk_unstructured_grid_cells(fp, region); } Rast_close(in->top); in->top = -1; Rast_close(in->bottom); in->bottom = -1; } else { /* Write the structured point vtk-header */ write_vtk_structured_point_header(fp, output, region, dp, scale); } /*Write the normal VTK data (cell or point data) */ /*Loop over all 3d input maps! */ if (param.input->answers != NULL) { for (i = 0; param.input->answers[i] != NULL; i++) { G_debug(3, "Open 3D raster map <%s>", param.input->answers[i]); /*Open the map */ in->map = Rast3d_open_cell_old(param.input->answers[i], G_find_raster3d(param.input->answers[i], ""), ®ion, RASTER3D_TILE_SAME_AS_FILE, RASTER3D_USE_CACHE_DEFAULT); if (in->map == NULL) { G_warning(_("Unable to open 3D raster map <%s>"), param.input->answers[i]); fatal_error(" ", in); } /*if requested set the Mask on */ if (param.mask->answer) { if (Rast3d_mask_file_exists()) { changemask = 0; if (Rast3d_mask_is_off(in->map)) { Rast3d_mask_on(in->map); changemask = 1; } } } /* Write the point or cell data */ write_vtk_data(fp, in->map, region, param.input->answers[i], dp); /*We set the Mask off, if it was off before */ if (param.mask->answer) { if (Rast3d_mask_file_exists()) if (Rast3d_mask_is_on(in->map) && changemask) Rast3d_mask_off(in->map); } /* Close the 3d raster map */ if (!Rast3d_close(in->map)) { in->map = NULL; fatal_error(_("Unable to close 3D raster map, the VTK file may be incomplete"), in); } in->map = NULL; } } /*Write the RGB voxel data */ open_write_rgb_maps(in, region, fp, dp); open_write_vector_maps(in, region, fp, dp); /*Close the output file */ if (param.output->answer && fp != NULL) if (fclose(fp)) fatal_error(_("Unable to close VTK-ASCII file"), in); /*close all open maps and free memory */ release_input_maps_struct(in); return 0; }
int main(int argc, char *argv[]) { struct GModule *module; int infile; const char *mapset; size_t cell_size; int ytile, xtile, y, overlap; int *outfiles; void *inbuf; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("tiling")); module->description = _("Splits a raster map into tiles."); parm.rastin = G_define_standard_option(G_OPT_R_INPUT); parm.rastout = G_define_option(); parm.rastout->key = "output"; parm.rastout->type = TYPE_STRING; parm.rastout->required = YES; parm.rastout->multiple = NO; parm.rastout->description = _("Output base name"); parm.width = G_define_option(); parm.width->key = "width"; parm.width->type = TYPE_INTEGER; parm.width->required = YES; parm.width->multiple = NO; parm.width->description = _("Width of tiles (columns)"); parm.height = G_define_option(); parm.height->key = "height"; parm.height->type = TYPE_INTEGER; parm.height->required = YES; parm.height->multiple = NO; parm.height->description = _("Height of tiles (rows)"); parm.overlap = G_define_option(); parm.overlap->key = "overlap"; parm.overlap->type = TYPE_INTEGER; parm.overlap->required = NO; parm.overlap->multiple = NO; parm.overlap->description = _("Overlap of tiles"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); G_get_set_window(&src_w); overlap = parm.overlap->answer ? atoi(parm.overlap->answer) : 0; mapset = G_find_raster2(parm.rastin->answer, ""); if (mapset == NULL) G_fatal_error(_("Raster map <%s> not found"), parm.rastin->answer); /* set window to old map */ Rast_get_cellhd(parm.rastin->answer, "", &src_w); dst_w = src_w; dst_w.cols = atoi(parm.width->answer); dst_w.rows = atoi(parm.height->answer); G_adjust_Cell_head(&dst_w, 1, 1); xtiles = (src_w.cols + dst_w.cols - 1) / dst_w.cols; ytiles = (src_w.rows + dst_w.rows - 1) / dst_w.rows; G_debug(1, "X: %d * %d, Y: %d * %d", xtiles, dst_w.cols, ytiles, dst_w.rows); src_w.cols = xtiles * dst_w.cols + 2 * overlap; src_w.rows = ytiles * dst_w.rows + 2 * overlap; src_w.west = src_w.west - overlap * src_w.ew_res; src_w.east = src_w.west + (src_w.cols + 2 * overlap) * src_w.ew_res; src_w.north = src_w.north + overlap * src_w.ns_res; src_w.south = src_w.north - (src_w.rows + 2 * overlap) * src_w.ns_res; Rast_set_input_window(&src_w); /* set the output region */ ovl_w = dst_w; ovl_w.cols = ovl_w.cols + 2 * overlap; ovl_w.rows = ovl_w.rows + 2 * overlap; G_adjust_Cell_head(&ovl_w, 1, 1); Rast_set_output_window(&ovl_w); infile = Rast_open_old(parm.rastin->answer, ""); map_type = Rast_get_map_type(infile); cell_size = Rast_cell_size(map_type); inbuf = Rast_allocate_input_buf(map_type); outfiles = G_malloc(xtiles * sizeof(int)); G_debug(1, "X: %d * %d, Y: %d * %d", xtiles, dst_w.cols, ytiles, dst_w.rows); G_message(_("Generating %d x %d = %d tiles..."), xtiles, ytiles, xtiles * ytiles); for (ytile = 0; ytile < ytiles; ytile++) { G_debug(1, "reading y tile: %d", ytile); G_percent(ytile, ytiles, 2); for (xtile = 0; xtile < xtiles; xtile++) { char name[GNAME_MAX]; sprintf(name, "%s-%03d-%03d", parm.rastout->answer, ytile, xtile); outfiles[xtile] = Rast_open_new(name, map_type); } for (y = 0; y < ovl_w.rows; y++) { int row = ytile * dst_w.rows + y; G_debug(1, "reading row: %d", row); Rast_get_row(infile, inbuf, row, map_type); for (xtile = 0; xtile < xtiles; xtile++) { int cells = xtile * dst_w.cols; void *ptr = G_incr_void_ptr(inbuf, cells * cell_size); Rast_put_row(outfiles[xtile], ptr, map_type); } } for (xtile = 0; xtile < xtiles; xtile++) { Rast_close(outfiles[xtile]); write_support_files(xtile, ytile, overlap); } } Rast_close(infile); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { char *p; int method; int in_fd; int selection_fd; int out_fd; DCELL *result; char *selection; RASTER_MAP_TYPE map_type; int row, col; int readrow; int nrows, ncols; int n; int copycolr; int half; stat_func *newvalue; stat_func_w *newvalue_w; ifunc cat_names; double quantile; const void *closure; struct Colors colr; struct Cell_head cellhd; struct Cell_head window; struct History history; struct GModule *module; struct { struct Option *input, *output, *selection; struct Option *method, *size; struct Option *title; struct Option *weight; struct Option *gauss; struct Option *quantile; } parm; struct { struct Flag *align, *circle; } flag; DCELL *values; /* list of neighborhood values */ DCELL(*values_w)[2]; /* list of neighborhood values and weights */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("algebra")); G_add_keyword(_("statistics")); module->description = _("Makes each cell category value a " "function of the category values assigned to the cells " "around it, and stores new cell values in an output raster " "map layer."); parm.input = G_define_standard_option(G_OPT_R_INPUT); parm.selection = G_define_standard_option(G_OPT_R_INPUT); parm.selection->key = "selection"; parm.selection->required = NO; parm.selection->description = _("Name of an input raster map to select the cells which should be processed"); parm.output = G_define_standard_option(G_OPT_R_OUTPUT); parm.method = G_define_option(); parm.method->key = "method"; parm.method->type = TYPE_STRING; parm.method->required = NO; parm.method->answer = "average"; p = G_malloc(1024); for (n = 0; menu[n].name; n++) { if (n) strcat(p, ","); else *p = 0; strcat(p, menu[n].name); } parm.method->options = p; parm.method->description = _("Neighborhood operation"); parm.method->guisection = _("Neighborhood"); parm.size = G_define_option(); parm.size->key = "size"; parm.size->type = TYPE_INTEGER; parm.size->required = NO; parm.size->description = _("Neighborhood size"); parm.size->answer = "3"; parm.size->guisection = _("Neighborhood"); parm.title = G_define_option(); parm.title->key = "title"; parm.title->key_desc = "phrase"; parm.title->type = TYPE_STRING; parm.title->required = NO; parm.title->description = _("Title of the output raster map"); parm.weight = G_define_standard_option(G_OPT_F_INPUT); parm.weight->key = "weight"; parm.weight->required = NO; parm.weight->description = _("Text file containing weights"); parm.gauss = G_define_option(); parm.gauss->key = "gauss"; parm.gauss->type = TYPE_DOUBLE; parm.gauss->required = NO; parm.gauss->description = _("Sigma (in cells) for Gaussian filter"); parm.quantile = G_define_option(); parm.quantile->key = "quantile"; parm.quantile->type = TYPE_DOUBLE; parm.quantile->required = NO; parm.quantile->description = _("Quantile to calculate for method=quantile"); parm.quantile->options = "0.0-1.0"; parm.quantile->answer = "0.5"; flag.align = G_define_flag(); flag.align->key = 'a'; flag.align->description = _("Do not align output with the input"); flag.circle = G_define_flag(); flag.circle->key = 'c'; flag.circle->description = _("Use circular neighborhood"); flag.circle->guisection = _("Neighborhood"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); sscanf(parm.size->answer, "%d", &ncb.nsize); if (ncb.nsize <= 0) G_fatal_error(_("Neighborhood size must be positive")); if (ncb.nsize % 2 == 0) G_fatal_error(_("Neighborhood size must be odd")); ncb.dist = ncb.nsize / 2; if (parm.weight->answer && flag.circle->answer) G_fatal_error(_("weight= and -c are mutually exclusive")); if (parm.weight->answer && parm.gauss->answer) G_fatal_error(_("weight= and gauss= are mutually exclusive")); ncb.oldcell = parm.input->answer; ncb.newcell = parm.output->answer; if (!flag.align->answer) { Rast_get_cellhd(ncb.oldcell, "", &cellhd); G_get_window(&window); Rast_align_window(&window, &cellhd); Rast_set_window(&window); } nrows = Rast_window_rows(); ncols = Rast_window_cols(); /* open raster maps */ in_fd = Rast_open_old(ncb.oldcell, ""); map_type = Rast_get_map_type(in_fd); /* get the method */ for (method = 0; (p = menu[method].name); method++) if ((strcmp(p, parm.method->answer) == 0)) break; if (!p) { G_warning(_("<%s=%s> unknown %s"), parm.method->key, parm.method->answer, parm.method->key); G_usage(); exit(EXIT_FAILURE); } if (menu[method].method == c_quant) { quantile = atoi(parm.quantile->answer); closure = &quantile; } half = (map_type == CELL_TYPE) ? menu[method].half : 0; /* establish the newvalue routine */ newvalue = menu[method].method; newvalue_w = menu[method].method_w; /* copy color table? */ copycolr = menu[method].copycolr; if (copycolr) { G_suppress_warnings(1); copycolr = (Rast_read_colors(ncb.oldcell, "", &colr) > 0); G_suppress_warnings(0); } /* read the weights */ if (parm.weight->answer) { read_weights(parm.weight->answer); if (!newvalue_w) weights_mask(); } else if (parm.gauss->answer) { if (!newvalue_w) G_fatal_error(_("Method %s not compatible with Gaussian filter"), parm.method->answer); gaussian_weights(atof(parm.gauss->answer)); } else newvalue_w = NULL; /* allocate the cell buffers */ allocate_bufs(); result = Rast_allocate_d_buf(); /* get title, initialize the category and stat info */ if (parm.title->answer) strcpy(ncb.title, parm.title->answer); else sprintf(ncb.title, "%dx%d neighborhood: %s of %s", ncb.nsize, ncb.nsize, menu[method].name, ncb.oldcell); /* initialize the cell bufs with 'dist' rows of the old cellfile */ readrow = 0; for (row = 0; row < ncb.dist; row++) readcell(in_fd, readrow++, nrows, ncols); /* open the selection raster map */ if (parm.selection->answer) { G_message(_("Opening selection map <%s>"), parm.selection->answer); selection_fd = Rast_open_old(parm.selection->answer, ""); selection = Rast_allocate_null_buf(); } else { selection_fd = -1; selection = NULL; } /*open the new raster map */ out_fd = Rast_open_new(ncb.newcell, map_type); if (flag.circle->answer) circle_mask(); if (newvalue_w) values_w = (DCELL(*)[2]) G_malloc(ncb.nsize * ncb.nsize * 2 * sizeof(DCELL)); else values = (DCELL *) G_malloc(ncb.nsize * ncb.nsize * sizeof(DCELL)); for (row = 0; row < nrows; row++) { G_percent(row, nrows, 2); readcell(in_fd, readrow++, nrows, ncols); if (selection) Rast_get_null_value_row(selection_fd, selection, row); for (col = 0; col < ncols; col++) { DCELL *rp = &result[col]; if (selection && selection[col]) { *rp = ncb.buf[ncb.dist][col]; continue; } if (newvalue_w) n = gather_w(values_w, col); else n = gather(values, col); if (n < 0) Rast_set_d_null_value(rp, 1); else { if (newvalue_w) newvalue_w(rp, values_w, n, closure); else newvalue(rp, values, n, closure); if (half && !Rast_is_d_null_value(rp)) *rp += 0.5; } } Rast_put_d_row(out_fd, result); } G_percent(row, nrows, 2); Rast_close(out_fd); Rast_close(in_fd); if (selection) Rast_close(selection_fd); /* put out category info */ null_cats(); if ((cat_names = menu[method].cat_names)) cat_names(); Rast_write_cats(ncb.newcell, &ncb.cats); if (copycolr) Rast_write_colors(ncb.newcell, G_mapset(), &colr); Rast_short_history(ncb.newcell, "raster", &history); Rast_command_history(&history); Rast_write_history(ncb.newcell, &history); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { int i, j, nlines, type, field, cat; int fd; /* struct Categories RCats; *//* TODO */ struct Cell_head window; RASTER_MAP_TYPE out_type; CELL *cell; DCELL *dcell; double drow, dcol; char buf[2000]; struct Option *vect_opt, *rast_opt, *field_opt, *col_opt, *where_opt; int Cache_size; struct order *cache; int cur_row; struct GModule *module; struct Map_info Map; struct line_pnts *Points; struct line_cats *Cats; int point; int point_cnt; /* number of points in cache */ int outside_cnt; /* points outside region */ int nocat_cnt; /* points inside region but without category */ int dupl_cnt; /* duplicate categories */ struct bound_box box; int *catexst, *cex; struct field_info *Fi; dbString stmt; dbDriver *driver; int select, norec_cnt, update_cnt, upderr_cnt, col_type; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("vector")); G_add_keyword(_("raster")); G_add_keyword(_("position")); G_add_keyword(_("querying")); G_add_keyword(_("attribute table")); module->description = _("Uploads raster values at positions of vector points to the table."); vect_opt = G_define_standard_option(G_OPT_V_INPUT); vect_opt->key = "vector"; vect_opt->description = _("Name of input vector points map for which to edit attribute table"); rast_opt = G_define_standard_option(G_OPT_R_INPUT); rast_opt->key = "raster"; rast_opt->description = _("Name of existing raster map to be queried"); field_opt = G_define_standard_option(G_OPT_V_FIELD); col_opt = G_define_option(); col_opt->key = "column"; col_opt->type = TYPE_STRING; col_opt->required = YES; col_opt->description = _("Column name (will be updated by raster values)"); where_opt = G_define_standard_option(G_OPT_DB_WHERE); if (G_parser(argc, argv)) exit(EXIT_FAILURE); field = atoi(field_opt->answer); db_init_string(&stmt); Points = Vect_new_line_struct(); Cats = Vect_new_cats_struct(); G_get_window(&window); Vect_region_box(&window, &box); /* T and B set to +/- PORT_DOUBLE_MAX */ /* Open vector */ Vect_set_open_level(2); Vect_open_old(&Map, vect_opt->answer, ""); Fi = Vect_get_field(&Map, field); if (Fi == NULL) G_fatal_error(_("Database connection not defined for layer %d"), field); /* 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); } /* Open raster */ fd = Rast_open_old(rast_opt->answer, ""); out_type = Rast_get_map_type(fd); /* TODO: Later possibly category labels */ /* if ( Rast_read_cats (name, "", &RCats) < 0 ) G_fatal_error ( "Cannot read category file"); */ /* Check column type */ col_type = db_column_Ctype(driver, Fi->table, col_opt->answer); if (col_type == -1) G_fatal_error(_("Column <%s> not found"), col_opt->answer); if (col_type != DB_C_TYPE_INT && col_type != DB_C_TYPE_DOUBLE) G_fatal_error(_("Column type not supported")); if (out_type == CELL_TYPE && col_type == DB_C_TYPE_DOUBLE) G_warning(_("Raster type is integer and column type is float")); if (out_type != CELL_TYPE && col_type == DB_C_TYPE_INT) G_warning(_("Raster type is float and column type is integer, some data lost!!")); /* Read vector points to cache */ Cache_size = Vect_get_num_primitives(&Map, GV_POINT); /* Note: Some space may be wasted (outside region or no category) */ cache = (struct order *)G_calloc(Cache_size, sizeof(struct order)); point_cnt = outside_cnt = nocat_cnt = 0; nlines = Vect_get_num_lines(&Map); G_debug(1, "Reading %d vector features fom map", nlines); for (i = 1; i <= nlines; i++) { type = Vect_read_line(&Map, Points, Cats, i); G_debug(4, "line = %d type = %d", i, type); /* check type */ if (!(type & GV_POINT)) continue; /* Points only */ /* check region */ if (!Vect_point_in_box(Points->x[0], Points->y[0], 0.0, &box)) { outside_cnt++; continue; } Vect_cat_get(Cats, field, &cat); if (cat < 0) { /* no category of given field */ nocat_cnt++; continue; } G_debug(4, " cat = %d", cat); /* Add point to cache */ drow = Rast_northing_to_row(Points->y[0], &window); dcol = Rast_easting_to_col(Points->x[0], &window); /* a special case. * if north falls at southern edge, or east falls on eastern edge, * the point will appear outside the window. * So, for these edges, bring the point inside the window */ if (drow == window.rows) drow--; if (dcol == window.cols) dcol--; cache[point_cnt].row = (int)drow; cache[point_cnt].col = (int)dcol; cache[point_cnt].cat = cat; cache[point_cnt].count = 1; point_cnt++; } Vect_set_db_updated(&Map); Vect_hist_command(&Map); Vect_close(&Map); G_debug(1, "Read %d vector points", point_cnt); /* Cache may contain duplicate categories, sort by cat, find and remove duplicates * and recalc count and decrease point_cnt */ qsort(cache, point_cnt, sizeof(struct order), by_cat); G_debug(1, "Points are sorted, starting duplicate removal loop"); for (i = 0, j = 1; j < point_cnt; j++) if (cache[i].cat != cache[j].cat) cache[++i] = cache[j]; else cache[i].count++; point_cnt = i + 1; G_debug(1, "%d vector points left after removal of duplicates", point_cnt); /* Report number of points not used */ if (outside_cnt) G_warning(_("%d points outside current region were skipped"), outside_cnt); if (nocat_cnt) G_warning(_("%d points without category were skipped"), nocat_cnt); /* Sort cache by current region row */ qsort(cache, point_cnt, sizeof(struct order), by_row); /* Allocate space for raster row */ if (out_type == CELL_TYPE) cell = Rast_allocate_c_buf(); else dcell = Rast_allocate_d_buf(); /* Extract raster values from file and store in cache */ G_debug(1, "Extracting raster values"); cur_row = -1; for (point = 0; point < point_cnt; point++) { if (cache[point].count > 1) continue; /* duplicate cats */ if (cur_row != cache[point].row) { if (out_type == CELL_TYPE) Rast_get_c_row(fd, cell, cache[point].row); else Rast_get_d_row(fd, dcell, cache[point].row); } cur_row = cache[point].row; if (out_type == CELL_TYPE) { cache[point].value = cell[cache[point].col]; } else { cache[point].dvalue = dcell[cache[point].col]; } } /* point loop */ /* Update table from cache */ G_debug(1, "Updating db table"); /* select existing categories to array (array is sorted) */ select = db_select_int(driver, Fi->table, Fi->key, NULL, &catexst); db_begin_transaction(driver); norec_cnt = update_cnt = upderr_cnt = dupl_cnt = 0; for (point = 0; point < point_cnt; point++) { if (cache[point].count > 1) { G_warning(_("More points (%d) of category %d, value set to 'NULL'"), cache[point].count, cache[point].cat); dupl_cnt++; } /* category exist in DB ? */ cex = (int *)bsearch((void *)&(cache[point].cat), catexst, select, sizeof(int), srch_cat); if (cex == NULL) { /* cat does not exist in DB */ norec_cnt++; G_warning(_("No record for category %d in table <%s>"), cache[point].cat, Fi->table); continue; } sprintf(buf, "update %s set %s = ", Fi->table, col_opt->answer); db_set_string(&stmt, buf); if (out_type == CELL_TYPE) { if (cache[point].count > 1 || Rast_is_c_null_value(&cache[point].value)) { sprintf(buf, "NULL"); } else { sprintf(buf, "%d ", cache[point].value); } } else { /* FCELL or DCELL */ if (cache[point].count > 1 || Rast_is_d_null_value(&cache[point].dvalue)) { sprintf(buf, "NULL"); } else { sprintf(buf, "%.10f", cache[point].dvalue); } } db_append_string(&stmt, buf); sprintf(buf, " where %s = %d", Fi->key, cache[point].cat); db_append_string(&stmt, buf); /* user provides where condition: */ if (where_opt->answer) { sprintf(buf, " AND %s", where_opt->answer); db_append_string(&stmt, buf); } G_debug(3, db_get_string(&stmt)); /* Update table */ if (db_execute_immediate(driver, &stmt) == DB_OK) { update_cnt++; } else { upderr_cnt++; } } G_debug(1, "Committing DB transaction"); db_commit_transaction(driver); G_free(catexst); db_close_database_shutdown_driver(driver); db_free_string(&stmt); /* Report */ G_message(_("%d categories loaded from table"), select); G_message(_("%d categories loaded from vector"), point_cnt); G_message(_("%d categories from vector missing in table"), norec_cnt); G_message(_("%d duplicate categories in vector"), dupl_cnt); if (!where_opt->answer) G_message(_("%d records updated"), update_cnt); G_message(_("%d update errors"), upderr_cnt); exit(EXIT_SUCCESS); }
int zoom(struct Cell_head *window, const char *name, const char *mapset) { int fd; void *raster, *rast_ptr; RASTER_MAP_TYPE map_type; int row, col; int nrows, ncols; int top, bottom, left, right, mark; double north, south, east, west; G_adjust_Cell_head3(window, 0, 0, 0); Rast_set_window(window); nrows = window->rows; ncols = window->cols; fd = Rast_open_old(name, mapset); map_type = Rast_get_map_type(fd); raster = Rast_allocate_buf(map_type); /* find first non-null row */ top = nrows; bottom = -1; left = ncols; right = -1; for (row = 0; row < nrows; row++) { Rast_get_row(fd, rast_ptr = raster, row, map_type); for (col = 0; col < ncols; col++) { if (!Rast_is_null_value(rast_ptr, map_type)) break; rast_ptr = G_incr_void_ptr(rast_ptr, Rast_cell_size(map_type)); } if (col == ncols) continue; if (row < top) top = row; if (row > bottom) bottom = row; if (col < left) left = col; for (mark = col; col < ncols; col++) { if (!Rast_is_null_value(rast_ptr, map_type)) mark = col; rast_ptr = G_incr_void_ptr(rast_ptr, Rast_cell_size(map_type)); } if (mark > right) right = mark; } Rast_close(fd); G_free(raster); /* no data everywhere? */ if (bottom < 0) return 0; north = window->north - top * window->ns_res; south = window->north - (bottom + 1) * window->ns_res; west = window->west + left * window->ew_res; east = window->west + (right + 1) * window->ew_res; window->north = north; window->south = south; window->east = east; window->west = west; return 1; }
int main(int argc, char *argv[]) { char *name, *outfile; const char *unit; int unit_id; double factor; int fd, projection; FILE *fp, *coor_fp; double res; char *null_string; char ebuf[256], nbuf[256], label[512], formatbuff[256]; char b1[100], b2[100]; int n; int havefirst = FALSE; int coords = 0, i, k = -1; double e1, e2, n1, n2; RASTER_MAP_TYPE data_type; struct Cell_head window; struct { struct Option *opt1, *profile, *res, *output, *null_str, *coord_file, *units; struct Flag *g, *c, *m; } parm; struct GModule *module; G_gisinit(argv[0]); /* Set description */ module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("profile")); module->description = _("Outputs the raster map layer values lying on user-defined line(s)."); parm.opt1 = G_define_standard_option(G_OPT_R_INPUT); parm.output = G_define_standard_option(G_OPT_F_OUTPUT); parm.output->required = NO; parm.output->answer = "-"; parm.output->description = _("Name of file for output (use output=- for stdout)"); parm.profile = G_define_standard_option(G_OPT_M_COORDS); parm.profile->required = NO; parm.profile->multiple = YES; parm.profile->description = _("Profile coordinate pairs"); parm.coord_file = G_define_standard_option(G_OPT_F_INPUT); parm.coord_file->key = "file"; parm.coord_file->required = NO; parm.coord_file->label = _("Name of input file containing coordinate pairs"); parm.coord_file->description = _("Use instead of the 'coordinates' option. " "\"-\" reads from stdin."); parm.res = G_define_option(); parm.res->key = "resolution"; parm.res->type = TYPE_DOUBLE; parm.res->required = NO; parm.res->description = _("Resolution along profile (default = current region resolution)"); parm.null_str = G_define_option(); parm.null_str->key = "null"; parm.null_str->type = TYPE_STRING; parm.null_str->required = NO; parm.null_str->answer = "*"; parm.null_str->description = _("Character to represent no data cell"); parm.g = G_define_flag(); parm.g->key = 'g'; parm.g->description = _("Output easting and northing in first two columns of four column output"); parm.c = G_define_flag(); parm.c->key = 'c'; parm.c->description = _("Output RRR:GGG:BBB color values for each profile point"); parm.units = G_define_standard_option(G_OPT_M_UNITS); parm.units->options = "meters,kilometers,feet,miles"; parm.units->label = parm.units->description; parm.units->description = _("If units are not specified, current location units are used. " "Meters are used by default in geographic (latlon) locations."); if (G_parser(argc, argv)) exit(EXIT_FAILURE); clr = 0; if (parm.c->answer) clr = 1; /* color output */ null_string = parm.null_str->answer; if ((parm.profile->answer && parm.coord_file->answer) || (!parm.profile->answer && !parm.coord_file->answer)) G_fatal_error(_("Either use profile option or coordinate_file " " option, but not both")); G_get_window(&window); projection = G_projection(); /* get conversion factor and units name */ if (parm.units->answer) { unit_id = G_units(parm.units->answer); factor = 1. / G_meters_to_units_factor(unit_id); unit = G_get_units_name(unit_id, 1, 0); } /* keep meters in case of latlon */ else if (projection == PROJECTION_LL) { factor = 1; unit = "meters"; } else { /* get conversion factor to current units */ unit = G_database_unit_name(1); factor = G_database_units_to_meters_factor(); } if (parm.res->answer) { res = atof(parm.res->answer); /* Catch bad resolution ? */ if (res <= 0) G_fatal_error(_("Illegal resolution %g [%s]"), res / factor, unit); } else { /* Do average of EW and NS res */ res = (window.ew_res + window.ns_res) / 2; } G_message(_("Using resolution: %g [%s]"), res / factor, unit); G_begin_distance_calculations(); /* Open Input File for reading */ /* Get Input Name */ name = parm.opt1->answer; if (parm.g->answer) coords = 1; /* Open Raster File */ fd = Rast_open_old(name, ""); /* initialize color structure */ if (clr) Rast_read_colors(name, "", &colors); /* Open ASCII file for output or stdout */ outfile = parm.output->answer; if ((strcmp("-", outfile)) == 0) { fp = stdout; } else if (NULL == (fp = fopen(outfile, "w"))) G_fatal_error(_("Unable to open file <%s>"), outfile); /* Get Raster Type */ data_type = Rast_get_map_type(fd); /* Done with file */ /* Show message giving output format */ G_message(_("Output columns:")); if (coords == 1) sprintf(formatbuff, _("Easting, Northing, Along track dist. [%s], Elevation"), unit); else sprintf(formatbuff, _("Along track dist. [%s], Elevation"), unit); if (clr) strcat(formatbuff, _(" RGB color")); G_message(formatbuff); /* Get Profile Start Coords */ if (parm.coord_file->answer) { if (strcmp("-", parm.coord_file->answer) == 0) coor_fp = stdin; else coor_fp = fopen(parm.coord_file->answer, "r"); if (coor_fp == NULL) G_fatal_error(_("Could not open <%s>"), parm.coord_file->answer); for (n = 1; input(b1, ebuf, b2, nbuf, label, coor_fp); n++) { G_debug(4, "stdin line %d: ebuf=[%s] nbuf=[%s]", n, ebuf, nbuf); if (!G_scan_easting(ebuf, &e2, G_projection()) || !G_scan_northing(nbuf, &n2, G_projection())) G_fatal_error(_("Invalid coordinates %s %s"), ebuf, nbuf); if (havefirst) do_profile(e1, e2, n1, n2, coords, res, fd, data_type, fp, null_string, unit, factor); e1 = e2; n1 = n2; havefirst = TRUE; } if (coor_fp != stdin) fclose(coor_fp); } else { /* Coords given on the Command Line using the profile= option */ for (i = 0; parm.profile->answers[i]; i += 2) { /* Test for number coordinate pairs */ k = i; } if (k == 0) { /* Only one coordinate pair supplied */ G_scan_easting(parm.profile->answers[0], &e1, G_projection()); G_scan_northing(parm.profile->answers[1], &n1, G_projection()); e2 = e1; n2 = n1; /* Get profile info */ do_profile(e1, e2, n1, n2, coords, res, fd, data_type, fp, null_string, unit, factor); } else { for (i = 0; i <= k - 2; i += 2) { G_scan_easting(parm.profile->answers[i], &e1, G_projection()); G_scan_northing(parm.profile->answers[i + 1], &n1, G_projection()); G_scan_easting(parm.profile->answers[i + 2], &e2, G_projection()); G_scan_northing(parm.profile->answers[i + 3], &n2, G_projection()); /* Get profile info */ do_profile(e1, e2, n1, n2, coords, res, fd, data_type, fp, null_string, unit, factor); } } } Rast_close(fd); fclose(fp); if (clr) Rast_free_colors(&colors); exit(EXIT_SUCCESS); } /* Done with main */
int init_vars(int argc, char *argv[]) { int r, c; int ele_fd, wat_fd, fd = -1; int seg_rows, seg_cols, num_cseg_total, num_open_segs, num_open_array_segs; double memory_divisor, heap_mem, seg_factor, disk_space; /* int page_block, num_cseg; */ int max_bytes; CELL *buf, alt_value, *alt_value_buf, block_value; char asp_value; DCELL wat_value; DCELL dvalue; WAT_ALT wa, *wabuf; ASP_FLAG af, af_nbr, *afbuf; char MASK_flag; void *elebuf, *ptr, *watbuf, *watptr; int ele_map_type, wat_map_type; size_t ele_size, wat_size; int ct_dir, r_nbr, c_nbr; G_gisinit(argv[0]); /* input */ ele_flag = pit_flag = run_flag = ril_flag = 0; /* output */ wat_flag = asp_flag = bas_flag = seg_flag = haf_flag = tci_flag = 0; bas_thres = 0; /* shed, unused */ arm_flag = dis_flag = 0; /* RUSLE */ ob_flag = st_flag = sl_flag = sg_flag = ls_flag = er_flag = 0; nxt_avail_pt = 0; /* dep_flag = 0; */ max_length = d_zero = 0.0; d_one = 1.0; ril_value = -1.0; /* dep_slope = 0.0; */ max_bytes = 0; sides = 8; mfd = 1; c_fac = 5; abs_acc = 0; ele_scale = 1; segs_mb = 300; /* scan options */ for (r = 1; r < argc; r++) { if (sscanf(argv[r], "elevation=%s", ele_name) == 1) ele_flag++; else if (sscanf(argv[r], "accumulation=%s", wat_name) == 1) wat_flag++; else if (sscanf(argv[r], "tci=%s", tci_name) == 1) tci_flag++; else if (sscanf(argv[r], "drainage=%s", asp_name) == 1) asp_flag++; else if (sscanf(argv[r], "depression=%s", pit_name) == 1) pit_flag++; else if (sscanf(argv[r], "threshold=%d", &bas_thres) == 1) ; else if (sscanf(argv[r], "max_slope_length=%lf", &max_length) == 1) ; else if (sscanf(argv[r], "basin=%s", bas_name) == 1) bas_flag++; else if (sscanf(argv[r], "stream=%s", seg_name) == 1) seg_flag++; else if (sscanf(argv[r], "half_basin=%s", haf_name) == 1) haf_flag++; else if (sscanf(argv[r], "flow=%s", run_name) == 1) run_flag++; else if (sscanf(argv[r], "ar=%s", arm_name) == 1) arm_flag++; /* slope length else if (sscanf(argv[r], "slope_length=%s", sl_name) == 1) sl_flag++; */ else if (sscanf(argv[r], "slope_steepness=%s", sg_name) == 1) sg_flag++; else if (sscanf(argv[r], "length_slope=%s", ls_name) == 1) ls_flag++; else if (sscanf(argv[r], "blocking=%s", ob_name) == 1) ob_flag++; else if (sscanf(argv[r], "memory=%lf", &segs_mb) == 1) ; else if (sscanf(argv[r], "disturbed_land=%s", ril_name) == 1) { if (sscanf(ril_name, "%lf", &ril_value) == 0) { ril_value = -1.0; ril_flag++; } } /* slope deposition else if (sscanf (argv[r], "sd=%[^\n]", dep_name) == 1) dep_flag++; */ else if (sscanf(argv[r], "-%d", &sides) == 1) { if (sides != 4) usage(argv[0]); } else if (sscanf(argv[r], "convergence=%d", &c_fac) == 1) ; else if (strcmp(argv[r], "-s") == 0) mfd = 0; else if (strcmp(argv[r], "-a") == 0) abs_acc = 1; else usage(argv[0]); } /* check options */ if (mfd == 1 && (c_fac < 1 || c_fac > 10)) { G_fatal_error("Convergence factor must be between 1 and 10."); } if ((ele_flag != 1) || ((arm_flag == 1) && ((bas_thres <= 0) || ((haf_flag != 1) && (bas_flag != 1)))) || ((bas_thres <= 0) && ((bas_flag == 1) || (seg_flag == 1) || (haf_flag == 1) || (sl_flag == 1) || (sg_flag == 1) || (ls_flag == 1))) ) usage(argv[0]); tot_parts = 4; if (sl_flag || sg_flag || ls_flag) er_flag = 1; /* do RUSLE */ if (er_flag) tot_parts++; /* define basins */ if (seg_flag || bas_flag || haf_flag) tot_parts++; G_message(_n("SECTION 1 beginning: Initiating Variables. %d section total.", "SECTION 1 beginning: Initiating Variables. %d sections total.", tot_parts), tot_parts); this_mapset = G_mapset(); /* for sd factor if (dep_flag) { if (sscanf (dep_name, "%lf", &dep_slope) != 1) { dep_flag = -1; } } */ G_get_set_window(&window); nrows = Rast_window_rows(); ncols = Rast_window_cols(); if (max_length <= d_zero) max_length = 10 * nrows * window.ns_res + 10 * ncols * window.ew_res; if (window.ew_res < window.ns_res) half_res = .5 * window.ew_res; else half_res = .5 * window.ns_res; diag = sqrt(window.ew_res * window.ew_res + window.ns_res * window.ns_res); if (sides == 4) diag *= 0.5; /* Segment rows and cols: 64 */ seg_rows = SROW; seg_cols = SCOL; /* seg_factor * <size in bytes> = segment size in KB */ seg_factor = seg_rows * seg_rows / 1024.; if (segs_mb < 3.0) { segs_mb = 3; G_warning(_("Maximum memory to be used was smaller than 3 MB," " set to 3 MB.")); } /* balance segment files */ /* elevation + accumulation: * 2 */ memory_divisor = sizeof(WAT_ALT) * 2; disk_space = sizeof(WAT_ALT); /* aspect and flags: * 4 */ memory_divisor += sizeof(ASP_FLAG) * 4; disk_space += sizeof(ASP_FLAG); /* astar_points: / 16 */ /* ideally only a few but large segments */ memory_divisor += sizeof(POINT) / 16.; disk_space += sizeof(POINT); /* heap points: / 4 */ memory_divisor += sizeof(HEAP_PNT) / 4.; disk_space += sizeof(HEAP_PNT); /* TCI: as is */ if (tci_flag) { memory_divisor += sizeof(double); disk_space += sizeof(double); } /* RUSLE */ if (er_flag) { /* r_h */ memory_divisor += 4; disk_space += 4; /* s_l */ memory_divisor += 8; disk_space += 8; /* s_g */ if (sg_flag) { memory_divisor += 8; disk_space += 8; } /* l_s */ if (ls_flag) { memory_divisor += 8; disk_space += 8; } /* ril */ if (ril_flag) { memory_divisor += 8; disk_space += 8; } } /* KB -> MB */ memory_divisor = memory_divisor * seg_factor / 1024.; disk_space = disk_space * seg_factor / 1024.; num_open_segs = segs_mb / memory_divisor; heap_mem = num_open_segs * seg_factor * sizeof(HEAP_PNT) / (4. * 1024.); G_debug(1, "segs MB: %.0f", segs_mb); G_debug(1, "region rows: %d", nrows); G_debug(1, "seg rows: %d", seg_rows); G_debug(1, "region cols: %d", ncols); G_debug(1, "seg cols: %d", seg_cols); num_cseg_total = nrows / SROW + 1; G_debug(1, " row segments:\t%d", num_cseg_total); num_cseg_total = ncols / SCOL + 1; G_debug(1, "column segments:\t%d", num_cseg_total); num_cseg_total = (ncols / seg_cols + 1) * (nrows / seg_rows + 1); G_debug(1, " total segments:\t%d", num_cseg_total); G_debug(1, " open segments:\t%d", num_open_segs); /* nonsense to have more segments open than exist */ if (num_open_segs > num_cseg_total) num_open_segs = num_cseg_total; G_debug(1, " open segments after adjusting:\t%d", num_open_segs); disk_space *= num_cseg_total; if (disk_space < 1024.0) G_verbose_message(_("Will need up to %.2f MB of disk space"), disk_space); else G_verbose_message(_("Will need up to %.2f GB (%.0f MB) of disk space"), disk_space / 1024.0, disk_space); if (er_flag) { cseg_open(&r_h, seg_rows, seg_cols, num_open_segs); cseg_read_cell(&r_h, ele_name, ""); } /* read elevation input and mark NULL/masked cells */ /* scattered access: alt, watalt, bitflags, asp */ seg_open(&watalt, nrows, ncols, seg_rows, seg_cols, num_open_segs * 2, sizeof(WAT_ALT)); seg_open(&aspflag, nrows, ncols, seg_rows, seg_cols, num_open_segs * 4, sizeof(ASP_FLAG)); if (tci_flag) dseg_open(&tci, seg_rows, seg_cols, num_open_segs); /* open elevation input */ ele_fd = Rast_open_old(ele_name, ""); ele_map_type = Rast_get_map_type(ele_fd); ele_size = Rast_cell_size(ele_map_type); elebuf = Rast_allocate_buf(ele_map_type); afbuf = G_malloc(ncols * sizeof(ASP_FLAG)); if (ele_map_type == FCELL_TYPE || ele_map_type == DCELL_TYPE) ele_scale = 1000; /* should be enough to do the trick */ /* initial flow accumulation */ if (run_flag) { wat_fd = Rast_open_old(run_name, ""); wat_map_type = Rast_get_map_type(ele_fd); wat_size = Rast_cell_size(ele_map_type); watbuf = Rast_allocate_buf(ele_map_type); } else { watbuf = watptr = NULL; wat_fd = wat_size = wat_map_type = -1; } wabuf = G_malloc(ncols * sizeof(WAT_ALT)); alt_value_buf = Rast_allocate_buf(CELL_TYPE); /* read elevation input and mark NULL/masked cells */ G_message("SECTION 1a: Mark masked and NULL cells"); MASK_flag = 0; do_points = (GW_LARGE_INT) nrows * ncols; for (r = 0; r < nrows; r++) { G_percent(r, nrows, 1); Rast_get_row(ele_fd, elebuf, r, ele_map_type); ptr = elebuf; if (run_flag) { Rast_get_row(wat_fd, watbuf, r, wat_map_type); watptr = watbuf; } for (c = 0; c < ncols; c++) { afbuf[c].flag = 0; afbuf[c].asp = 0; /* check for masked and NULL cells */ if (Rast_is_null_value(ptr, ele_map_type)) { FLAG_SET(afbuf[c].flag, NULLFLAG); FLAG_SET(afbuf[c].flag, INLISTFLAG); FLAG_SET(afbuf[c].flag, WORKEDFLAG); Rast_set_c_null_value(&alt_value, 1); /* flow accumulation */ Rast_set_d_null_value(&wat_value, 1); do_points--; } else { if (ele_map_type == CELL_TYPE) { alt_value = *((CELL *)ptr); } else if (ele_map_type == FCELL_TYPE) { dvalue = *((FCELL *)ptr); dvalue *= ele_scale; alt_value = ele_round(dvalue); } else if (ele_map_type == DCELL_TYPE) { dvalue = *((DCELL *)ptr); dvalue *= ele_scale; alt_value = ele_round(dvalue); } /* flow accumulation */ if (run_flag) { if (Rast_is_null_value(watptr, wat_map_type)) { wat_value = 0; /* ok ? */ } else { if (wat_map_type == CELL_TYPE) { wat_value = *((CELL *)watptr); } else if (wat_map_type == FCELL_TYPE) { wat_value = *((FCELL *)watptr); } else if (wat_map_type == DCELL_TYPE) { wat_value = *((DCELL *)watptr); } } } else { wat_value = 1; } } wabuf[c].wat = wat_value; wabuf[c].ele = alt_value; alt_value_buf[c] = alt_value; ptr = G_incr_void_ptr(ptr, ele_size); if (run_flag) { watptr = G_incr_void_ptr(watptr, wat_size); } } seg_put_row(&watalt, (char *) wabuf, r); seg_put_row(&aspflag, (char *)afbuf, r); if (er_flag) { cseg_put_row(&r_h, alt_value_buf, r); } } G_percent(nrows, nrows, 1); /* finish it */ Rast_close(ele_fd); G_free(wabuf); G_free(afbuf); if (run_flag) { Rast_close(wat_fd); G_free(watbuf); } MASK_flag = (do_points < nrows * ncols); /* do RUSLE */ if (er_flag) { if (ob_flag) { fd = Rast_open_old(ob_name, ""); buf = Rast_allocate_c_buf(); for (r = 0; r < nrows; r++) { G_percent(r, nrows, 1); Rast_get_c_row(fd, buf, r); for (c = 0; c < ncols; c++) { block_value = buf[c]; if (!Rast_is_c_null_value(&block_value) && block_value) { seg_get(&aspflag, (char *)&af, r, c); FLAG_SET(af.flag, RUSLEBLOCKFLAG); seg_put(&aspflag, (char *)&af, r, c); } } } G_percent(nrows, nrows, 1); /* finish it */ Rast_close(fd); G_free(buf); } if (ril_flag) { dseg_open(&ril, seg_rows, seg_cols, num_open_segs); dseg_read_cell(&ril, ril_name, ""); } /* dseg_open(&slp, SROW, SCOL, num_open_segs); */ dseg_open(&s_l, seg_rows, seg_cols, num_open_segs); if (sg_flag) dseg_open(&s_g, seg_rows, seg_cols, num_open_segs); if (ls_flag) dseg_open(&l_s, seg_rows, seg_cols, num_open_segs); } G_debug(1, "open segments for A* points"); /* columns per segment */ seg_cols = seg_rows * seg_rows; num_cseg_total = do_points / seg_cols; if (do_points % seg_cols > 0) num_cseg_total++; /* no need to have more segments open than exist */ num_open_array_segs = num_open_segs / 16.; if (num_open_array_segs > num_cseg_total) num_open_array_segs = num_cseg_total; if (num_open_array_segs < 1) num_open_array_segs = 1; seg_open(&astar_pts, 1, do_points, 1, seg_cols, num_open_array_segs, sizeof(POINT)); /* one-based d-ary search_heap with astar_pts */ G_debug(1, "open segments for A* search heap"); G_debug(1, "heap memory %.2f MB", heap_mem); /* columns per segment */ /* larger is faster */ seg_cols = seg_rows * seg_rows; num_cseg_total = do_points / seg_cols; if (do_points % seg_cols > 0) num_cseg_total++; /* no need to have more segments open than exist */ num_open_array_segs = (1 << 20) * heap_mem / (seg_cols * sizeof(HEAP_PNT)); if (num_open_array_segs > num_cseg_total) num_open_array_segs = num_cseg_total; if (num_open_array_segs < 2) num_open_array_segs = 2; G_debug(1, "A* search heap open segments %d, total %d", num_open_array_segs, num_cseg_total); /* the search heap will not hold more than 5% of all points at any given time ? */ /* chances are good that the heap will fit into one large segment */ seg_open(&search_heap, 1, do_points + 1, 1, seg_cols, num_open_array_segs, sizeof(HEAP_PNT)); G_message(_("SECTION 1b: Determining Offmap Flow.")); /* heap is empty */ heap_size = 0; if (pit_flag) { buf = Rast_allocate_c_buf(); fd = Rast_open_old(pit_name, ""); } else buf = NULL; first_astar = first_cum = -1; for (r = 0; r < nrows; r++) { G_percent(r, nrows, 1); if (pit_flag) Rast_get_c_row(fd, buf, r); for (c = 0; c < ncols; c++) { seg_get(&aspflag, (char *)&af, r, c); if (!FLAG_GET(af.flag, NULLFLAG)) { if (er_flag) dseg_put(&s_l, &half_res, r, c); asp_value = af.asp; if (r == 0 || c == 0 || r == nrows - 1 || c == ncols - 1) { /* dseg_get(&wat, &wat_value, r, c); */ seg_get(&watalt, (char *)&wa, r, c); wat_value = wa.wat; if (wat_value > 0) { wat_value = -wat_value; /* dseg_put(&wat, &wat_value, r, c); */ wa.wat = wat_value; seg_put(&watalt, (char *)&wa, r, c); } if (r == 0) asp_value = -2; else if (c == 0) asp_value = -4; else if (r == nrows - 1) asp_value = -6; else if (c == ncols - 1) asp_value = -8; /* cseg_get(&alt, &alt_value, r, c); */ alt_value = wa.ele; add_pt(r, c, alt_value); FLAG_SET(af.flag, INLISTFLAG); FLAG_SET(af.flag, EDGEFLAG); af.asp = asp_value; seg_put(&aspflag, (char *)&af, r, c); } else { seg_get(&watalt, (char *)&wa, r, c); for (ct_dir = 0; ct_dir < sides; ct_dir++) { /* get r, c (r_nbr, c_nbr) for neighbours */ r_nbr = r + nextdr[ct_dir]; c_nbr = c + nextdc[ct_dir]; seg_get(&aspflag, (char *)&af_nbr, r_nbr, c_nbr); if (FLAG_GET(af_nbr.flag, NULLFLAG)) { af.asp = -1 * drain[r - r_nbr + 1][c - c_nbr + 1]; add_pt(r, c, wa.ele); FLAG_SET(af.flag, INLISTFLAG); FLAG_SET(af.flag, EDGEFLAG); seg_put(&aspflag, (char *)&af, r, c); wat_value = wa.wat; if (wat_value > 0) { wa.wat = -wat_value; seg_put(&watalt, (char *)&wa, r, c); } break; } } } /* real depression ? */ if (pit_flag && asp_value == 0) { if (!Rast_is_c_null_value(&buf[c]) && buf[c] != 0) { seg_get(&watalt, (char *)&wa, r, c); add_pt(r, c, wa.ele); FLAG_SET(af.flag, INLISTFLAG); FLAG_SET(af.flag, EDGEFLAG); seg_put(&aspflag, (char *)&af, r, c); wat_value = wa.wat; if (wat_value > 0) { wa.wat = -wat_value; seg_put(&watalt, (char *)&wa, r, c); } } } } /* end non-NULL cell */ } /* end column */ } G_percent(r, nrows, 1); /* finish it */ return 0; }
static int load_files(void) { void *voidc; int rtype; register int i, rowoff, row, col, vxoff, vyoff, offset; int cnt, fd, size, tsiz, coff; int vnum; int y_rows, y_cols; char *pr, *pg, *pb; unsigned char *tr, *tg, *tb, *tset; char *mpfilename, *name; char *yfiles[MAXIMAGES]; struct Colors colors; int ret; size = nrows * ncols; pr = G_malloc(size); pg = G_malloc(size); pb = G_malloc(size); tsiz = Rast_window_cols(); tr = (unsigned char *)G_malloc(tsiz); tg = (unsigned char *)G_malloc(tsiz); tb = (unsigned char *)G_malloc(tsiz); tset = (unsigned char *)G_malloc(tsiz); for (cnt = 0; cnt < frames; cnt++) { if (cnt > MAXIMAGES) { cnt--; break; } for (i = 0; i < size; i++) pr[i] = pg[i] = pb[i] = 0; for (vnum = 0; vnum < numviews; vnum++) { if (icols == vcols) { vxoff = BORDER_W; vyoff = (irows == vrows) ? BORDER_W : BORDER_W + vnum * (BORDER_W + vrows); } else if (irows == vrows) { vxoff = (icols == vcols) ? BORDER_W : BORDER_W + vnum * (BORDER_W + vcols); vyoff = BORDER_W; } else { /* 4 views */ /* assumes we want: view1 view2 view3 view4 */ vxoff = vnum % 2 ? BORDER_W : vcols + 2 * BORDER_W; vyoff = vnum > 1 ? vrows + 2 * BORDER_W : BORDER_W; } name = vfiles[vnum][cnt]; G_message(_("Reading raster map <%s>..."), name); fd = Rast_open_old(name, ""); if (Rast_read_colors(name, "", &colors) < 0) G_fatal_error(_("Unable to read color table for <%s>"), name); rtype = Rast_get_map_type(fd); voidc = Rast_allocate_buf(rtype); for (row = 0; row < vrows; row++) { Rast_get_row(fd, voidc, (int)(row / vscale), rtype); rowoff = (vyoff + row) * ncols; Rast_lookup_colors(voidc, tr, tg, tb, tset, tsiz, &colors, rtype); for (col = 0; col < vcols; col++) { coff = (int)(col / vscale); offset = rowoff + col + vxoff; if (!tset[coff]) pr[offset] = pg[offset] = pb[offset] = (char)255; else { pr[offset] = (char)tr[coff]; pg[offset] = (char)tg[coff]; pb[offset] = (char)tb[coff]; } } } Rast_close(fd); } yfiles[cnt] = G_tempfile(); #ifdef USE_PPM write_ppm(pr, pg, pb, nrows, ncols, &y_rows, &y_cols, yfiles[cnt]); #else write_ycc(pr, pg, pb, nrows, ncols, &y_rows, &y_cols, yfiles[cnt]); #endif } mpfilename = G_tempfile(); write_params(mpfilename, yfiles, outfile, cnt, quality, y_rows, y_cols, 0); if (G_verbose() <= G_verbose_min()) ret = G_spawn(encoder, encoder, mpfilename, SF_REDIRECT_FILE, SF_STDOUT, SF_MODE_OUT, G_DEV_NULL, SF_REDIRECT_FILE, SF_STDERR, SF_MODE_OUT, G_DEV_NULL, NULL); else ret = G_spawn(encoder, encoder, mpfilename, NULL); if (ret != 0) G_warning(_("mpeg_encode ERROR")); clean_files(mpfilename, yfiles, cnt); G_free(voidc); G_free(tset); G_free(tr); G_free(tg); G_free(tb); G_free(pr); G_free(pg); G_free(pb); return (cnt); }
int main(int argc, char *argv[]) { struct Cell_head cellhd; char *name, *result; char **mapname; FCELL **fbuf; int n_measures, n_outputs, *measure_idx; int nrows, ncols; int row, col, first_row, last_row, first_col, last_col; int i, j; CELL **data; /* Data structure containing image */ DCELL *dcell_row; struct FPRange range; DCELL min, max, inscale; FCELL measure; /* Containing measure done */ int dist, size; /* dist = value of distance, size = s. of moving window */ int offset; int have_px, have_py, have_sentr, have_pxpys, have_pxpyd; int infd, *outfd; RASTER_MAP_TYPE data_type, out_data_type; struct GModule *module; struct Option *opt_input, *opt_output, *opt_size, *opt_dist, *opt_measure; struct Flag *flag_ind, *flag_all; struct History history; char p[1024]; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("algebra")); G_add_keyword(_("statistics")); G_add_keyword(_("texture")); module->description = _("Generate images with textural features from a raster map."); module->overwrite = 1; /* Define the different options */ opt_input = G_define_standard_option(G_OPT_R_INPUT); opt_output = G_define_standard_option(G_OPT_R_BASENAME_OUTPUT); opt_size = G_define_option(); opt_size->key = "size"; opt_size->key_desc = "value"; opt_size->type = TYPE_INTEGER; opt_size->required = NO; opt_size->description = _("The size of moving window (odd and >= 3)"); opt_size->answer = "3"; /* Textural character is in direct relation of the spatial size of the texture primitives. */ opt_dist = G_define_option(); opt_dist->key = "distance"; opt_dist->key_desc = "value"; opt_dist->type = TYPE_INTEGER; opt_dist->required = NO; opt_dist->description = _("The distance between two samples (>= 1)"); opt_dist->answer = "1"; for (i = 0; menu[i].name; i++) { if (i) strcat(p, ","); else *p = 0; strcat(p, menu[i].name); } opt_measure = G_define_option(); opt_measure->key = "method"; opt_measure->type = TYPE_STRING; opt_measure->required = NO; opt_measure->multiple = YES; opt_measure->options = p; opt_measure->description = _("Textural measurement method"); flag_ind = G_define_flag(); flag_ind->key = 's'; flag_ind->description = _("Separate output for each angle (0, 45, 90, 135)"); flag_all = G_define_flag(); flag_all->key = 'a'; flag_all->description = _("Calculate all textural measurements"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); name = opt_input->answer; result = opt_output->answer; size = atoi(opt_size->answer); if (size <= 0) G_fatal_error(_("Size of the moving window must be > 0")); if (size % 2 != 1) G_fatal_error(_("Size of the moving window must be odd")); dist = atoi(opt_dist->answer); if (dist <= 0) G_fatal_error(_("The distance between two samples must be > 0")); n_measures = 0; if (flag_all->answer) { for (i = 0; menu[i].name; i++) { menu[i].useme = 1; } n_measures = i; } else { for (i = 0; opt_measure->answers[i]; i++) { if (opt_measure->answers[i]) { const char *measure_name = opt_measure->answers[i]; int n = find_measure(measure_name); menu[n].useme = 1; n_measures++; } } } if (!n_measures) G_fatal_error(_("Nothing to compute. Use at least one textural measure.")); measure_idx = G_malloc(n_measures * sizeof(int)); j = 0; for (i = 0; menu[i].name; i++) { if (menu[i].useme == 1) { measure_idx[j] = menu[i].idx; j++; } } /* variables needed */ if (menu[2].useme || menu[11].useme || menu[12].useme) have_px = 1; else have_px = 0; if (menu[11].useme || menu[12].useme) have_py = 1; else have_py = 0; if (menu[6].useme || menu[7].useme) have_sentr = 1; else have_sentr = 0; if (menu[5].useme || menu[6].useme || menu[7].useme) have_pxpys = 1; else have_pxpys = 0; if (menu[9].useme || menu[10].useme) have_pxpyd = 1; else have_pxpyd = 0; infd = Rast_open_old(name, ""); /* determine the inputmap type (CELL/FCELL/DCELL) */ data_type = Rast_get_map_type(infd); Rast_get_cellhd(name, "", &cellhd); out_data_type = FCELL_TYPE; /* Allocate output buffers, use FCELL data_type */ n_outputs = n_measures; if (flag_ind->answer) { n_outputs = n_measures * 4; } fbuf = G_malloc(n_outputs * sizeof(FCELL *)); mapname = G_malloc(n_outputs * sizeof(char *)); for (i = 0; i < n_outputs; i++) { mapname[i] = G_malloc(GNAME_MAX * sizeof(char)); fbuf[i] = Rast_allocate_buf(out_data_type); } /* open output maps */ outfd = G_malloc(n_outputs * sizeof(int)); for (i = 0; i < n_measures; i++) { if (flag_ind->answer) { for (j = 0; j < 4; j++) { sprintf(mapname[i * 4 + j], "%s%s_%d", result, menu[measure_idx[i]].suffix, j * 45); outfd[i * 4 + j] = Rast_open_new(mapname[i * 4 + j], out_data_type); } } else { sprintf(mapname[i], "%s%s", result, menu[measure_idx[i]].suffix); outfd[i] = Rast_open_new(mapname[i], out_data_type); } } nrows = Rast_window_rows(); ncols = Rast_window_cols(); /* Load raster map. */ /* allocate the space for one row of cell map data *A* */ dcell_row = Rast_allocate_d_buf(); /* Allocate appropriate memory for the structure containing the image */ data = (int **)G_malloc(nrows * sizeof(int *)); for (i = 0; i < nrows; i++) { data[i] = (int *)G_malloc(ncols * sizeof(int)); } /* read input range */ Rast_init_fp_range(&range); Rast_read_fp_range(name, "", &range); Rast_get_fp_range_min_max(&range, &min, &max); inscale = 0; if (min < 0 || max > 255) { inscale = 255. / (max - min); } /* input has 0 - 1 range */ else if (max <= 1.) { inscale = 255. / (max - min); } /* Read in cell map values */ /* TODO: use r.proj cache */ G_important_message(_("Reading raster map...")); for (j = 0; j < nrows; j++) { Rast_get_row(infd, dcell_row, j, DCELL_TYPE); for (i = 0; i < ncols; i++) { if (Rast_is_d_null_value(&(dcell_row[i]))) data[j][i] = -1; else if (inscale) { data[j][i] = (CELL)((dcell_row[i] - min) * inscale); } else data[j][i] = (CELL)dcell_row[i]; } } /* close input cell map and release the row buffer */ Rast_close(infd); G_free(dcell_row); /* Now raster map is loaded to memory. */ /* ************************************************************************************************* * * Compute of the matrix S.G.L.D. (Spatial Gray-Level Dependence Matrices) or co-occurrence matrix. * The image is analized for piece, every piece is naming moving window (s.w.). The s.w. must be * square with number of size's samples odd, that because we want the sample at the center of matrix. * ***************************************************************************************************/ offset = size / 2; first_row = first_col = offset; last_row = nrows - offset; last_col = ncols - offset; Rast_set_f_null_value(fbuf[0], ncols); for (row = 0; row < first_row; row++) { for (i = 0; i < n_outputs; i++) { Rast_put_row(outfd[i], fbuf[0], out_data_type); } } if (n_measures > 1) G_message(n_("Calculating %d texture measure", "Calculating %d texture measures", n_measures), n_measures); else G_message(_("Calculating %s"), menu[measure_idx[0]].desc); alloc_vars(size, dist); for (row = first_row; row < last_row; row++) { G_percent(row, nrows, 2); for (i = 0; i < n_outputs; i++) Rast_set_f_null_value(fbuf[i], ncols); /*process the data */ for (col = first_col; col < last_col; col++) { if (!set_vars(data, row, col, size, offset, dist)) { for (i = 0; i < n_outputs; i++) Rast_set_f_null_value(&(fbuf[i][col]), 1); continue; } /* for all angles (0, 45, 90, 135) */ for (i = 0; i < 4; i++) { set_angle_vars(i, have_px, have_py, have_sentr, have_pxpys, have_pxpyd); /* for all requested textural measures */ for (j = 0; j < n_measures; j++) { measure = (FCELL) h_measure(measure_idx[j]); if (flag_ind->answer) { /* output for each angle separately */ fbuf[j * 4 + i][col] = measure; } else { /* use average over all angles for each measure */ if (i == 0) fbuf[j][col] = measure; else if (i < 3) fbuf[j][col] += measure; else fbuf[j][col] = (fbuf[j][col] + measure) / 4.0; } } } } for (i = 0; i < n_outputs; i++) { Rast_put_row(outfd[i], fbuf[i], out_data_type); } } Rast_set_f_null_value(fbuf[0], ncols); for (row = last_row; row < nrows; row++) { for (i = 0; i < n_outputs; i++) { Rast_put_row(outfd[i], fbuf[0], out_data_type); } } G_percent(nrows, nrows, 1); for (i = 0; i < n_outputs; i++) { Rast_close(outfd[i]); Rast_short_history(mapname[i], "raster", &history); Rast_command_history(&history); Rast_write_history(mapname[i], &history); G_free(fbuf[i]); } G_free(fbuf); G_free(data); exit(EXIT_SUCCESS); }