int get_range(const char *name, long *min, long *max) { struct Range range; int nrows, ncols, row, col; CELL *cell; int fd; CELL cmin, cmax; struct Cell_head cellhd; if (Rast_read_range(name, "", &range) < 0) { Rast_init_range(&range); /* read the file to get the range */ Rast_get_cellhd(name, "", &cellhd); Rast_set_window(&cellhd); cell = Rast_allocate_c_buf(); fd = Rast_open_old(name, ""); nrows = Rast_window_rows(); ncols = Rast_window_cols(); G_message(_("Reading %s ..."), name); for (row = 0; row < nrows; row++) { G_percent(row, nrows, 2); Rast_get_c_row_nomask(fd, cell, row); for (col = 0; col < ncols; col++) Rast_update_range(cell[col], &range); } G_percent(row, nrows, 2); Rast_close(fd); G_free(cell); } Rast_get_range_min_max(&range, &cmin, &cmax); *min = cmin; *max = cmax; return 0; }
int get_stats(const char *name, struct Cell_stats *statf) { int fd; CELL *cell; int row, nrows, ncols; fd = Rast_open_old(name, ""); nrows = Rast_window_rows(); ncols = Rast_window_cols(); cell = Rast_allocate_c_buf(); Rast_init_cell_stats(statf); G_message(_("Reading %s ..."), name); for (row = 0; row < nrows; row++) { G_percent(row, nrows, 2); Rast_get_c_row(fd, cell, row); Rast_update_cell_stats(cell, ncols, statf); } if (row < nrows) exit(1); Rast_close(fd); G_free(cell); G_percent(row, nrows, 2); return 0; }
int cseg_read_cell(CSEG * cseg, char *map_name, char *mapset) { GW_LARGE_INT row, nrows; int map_fd; CELL *buffer; cseg->name = NULL; cseg->mapset = NULL; map_fd = Rast_open_old(map_name, mapset); nrows = Rast_window_rows(); buffer = Rast_allocate_c_buf(); for (row = 0; row < nrows; row++) { Rast_get_c_row(map_fd, buffer, row); if (Segment_put_row(&(cseg->seg), buffer, row) < 0) { G_free(buffer); Rast_close(map_fd); G_warning("%s(): unable to segment put row for [%s] in [%s]", me, map_name, mapset); return (-1); } } Rast_close(map_fd); G_free(buffer); cseg->name = G_store(map_name); cseg->mapset = G_store(mapset); return 0; }
void openfiles(char *r_name, char *g_name, char *b_name, char *h_name, char *i_name, char *s_name, int fd_input[3], int fd_output[3], CELL * rowbuf[3]) { fd_input[0] = Rast_open_old(r_name, ""); fd_input[1] = Rast_open_old(g_name, ""); fd_input[2] = Rast_open_old(b_name, ""); /* open output files */ fd_output[0] = Rast_open_c_new(h_name); fd_output[1] = Rast_open_c_new(i_name); fd_output[2] = Rast_open_c_new(s_name); /* allocate the cell row buffer */ rowbuf[0] = Rast_allocate_c_buf(); rowbuf[1] = Rast_allocate_c_buf(); rowbuf[2] = Rast_allocate_c_buf(); }
void openfiles(char *h_name, char *i_name, char *s_name, char *r_name, char *g_name, char *b_name, int fd_input[3], int fd_output[3], CELL * rowbuf[3]) { /* open output files */ fd_output[0] = Rast_open_c_new(r_name); fd_output[1] = Rast_open_c_new(g_name); fd_output[2] = Rast_open_c_new(b_name); /* allocate the cell row buffer */ rowbuf[0] = Rast_allocate_c_buf(); rowbuf[1] = Rast_allocate_c_buf(); rowbuf[2] = Rast_allocate_c_buf(); /* open input files (maps can be in different mapsets) */ fd_input[0] = Rast_open_old(h_name, ""); fd_input[1] = Rast_open_old(i_name, ""); fd_input[2] = Rast_open_old(s_name, ""); }
int randsurf(char *out, /* Name of raster maps to be opened. */ int min, int max, /* Minimum and maximum cell values. */ int int_map) { /* if map is to be written as a CELL map */ int nrows, ncols; /* Number of cell rows and columns */ DCELL *row_out_D; /* Buffer just large enough to hold one */ CELL *row_out_C; /* row of the raster map layer. */ int fd_out; /* File descriptor - used to identify */ /* open raster maps. */ int row_count, col_count; /****** INITIALISE RANDOM NUMBER GENERATOR ******/ G_math_rand(-1 * getpid()); /****** OPEN CELL FILES AND GET CELL DETAILS ******/ fd_out = Rast_open_new(out, int_map ? CELL_TYPE : DCELL_TYPE); nrows = Rast_window_rows(); ncols = Rast_window_cols(); if (int_map) row_out_C = Rast_allocate_c_buf(); else row_out_D = Rast_allocate_d_buf(); /****** PASS THROUGH EACH CELL ASSIGNING RANDOM VALUE ******/ for (row_count = 0; row_count < nrows; row_count++) { G_percent(row_count, nrows, 2); for (col_count = 0; col_count < ncols; col_count++) { if (int_map) *(row_out_C + col_count) = (CELL) (G_math_rand(2742) * (max + 1 - min) + min); /* under represents first and last bin */ /* *(row_out_C + col_count) = (CELL) floor(rand1(2742)*(max-min)+min +0.5); */ else *(row_out_D + col_count) = (DCELL) (G_math_rand(2742) * (max - min) + min); } /* Write contents row by row */ if (int_map) Rast_put_c_row(fd_out, (CELL *) row_out_C); else Rast_put_d_row(fd_out, (DCELL *) row_out_D); } G_percent(1, 1, 1); Rast_close(fd_out); return 0; }
int transform(int *datafds, int *outfds, int rows, int cols, double **eigmat, int bands, CELL *mins, CELL *maxs) { int i, j, k, l; double *sum; CELL **rowbufs; sum = G_alloc_vector(bands); rowbufs = (CELL**)G_calloc(bands, sizeof(CELL*)); /* allocate row buffers for each band */ for (i = 0; i < bands; i++) if ((rowbufs[i] = Rast_allocate_c_buf()) == NULL) G_fatal_error(_("Unable to allocate cell buffers.")); for (i = 0; i < rows; i++) { /* get one row of data */ for (j = 0; j < bands; j++) Rast_get_c_row(datafds[j], rowbufs[j], i); /* transform each cell in the row */ for (l = 0; l < cols; l++) { for (j = 0; j < bands; j++) { sum[j] = 0.0; for (k = 0; k < bands; k++) { sum[j] += eigmat[j][k] * (double)rowbufs[k][l]; } } for (j = 0; j < bands; j++) { rowbufs[j][l] = (CELL) (sum[j] + 0.5); if (rowbufs[j][l] > maxs[j]) maxs[j] = rowbufs[j][l]; if (rowbufs[j][l] < mins[j]) mins[j] = rowbufs[j][l]; } } /* output the row of data */ for (j = 0; j < bands; j++) Rast_put_row(outfds[j], rowbufs[j], CELL_TYPE); } for (i = 0; i < bands; i++) G_free(rowbufs[i]); G_free(rowbufs); G_free_vector(sum); G_message(_("Transform completed.\n")); return 0; }
int sg_factor(void) { int r, c; CELL low_elev, hih_elev; double height, length, S, sin_theta; G_message(_("SECTION 4: RUSLE LS and/or S factor determination.")); if (ril_flag) ril_buf = Rast_allocate_c_buf(); for (r = 0; r < nrows; r++) { G_percent(r, nrows, 3); if (ril_flag) { Rast_get_c_row(ril_fd, ril_buf, r); } for (c = 0; c < ncols; c++) { low_elev = alt[SEG_INDEX(alt_seg, r, c)]; hih_elev = r_h[SEG_INDEX(r_h_seg, r, c)]; length = s_l[SEG_INDEX(s_l_seg, r, c)]; height = 1.0 * (hih_elev - low_elev) / ele_scale; if (length > max_length) { height *= max_length / length; length = max_length; } sin_theta = height / sqrt(height * height + length * length); if (height / length < .09) S = 10.8 * sin_theta + .03; else S = 16.8 * sin_theta - .50; if (sg_flag) s_g[SEG_INDEX(s_g_seg, r, c)] = S; if (ls_flag) { length *= METER_TO_FOOT; len_slp_equ(length, sin_theta, S, r, c); } } } G_percent(nrows, nrows, 1); /* finish it */ if (ril_flag) { G_free(ril_buf); Rast_close(ril_fd); } return 0; }
static void init_channel(channel *c) { sprintf(c->name, "%s%s", output, c->suffix); if (Float) { c->fd = Rast_open_fp_new(c->name); c->fbuf = Rast_allocate_f_buf(); } else { c->fd = Rast_open_c_new(c->name); c->buf = Rast_allocate_c_buf(); } c->active = 1; }
static void do_output(int base_fd, char **outputs, const char *covermap) { int *out_fd = G_malloc(num_quants * sizeof(int)); CELL *base_buf = Rast_allocate_c_buf(); DCELL *out_buf = Rast_allocate_d_buf(); const char *mapset = G_mapset(); struct Colors colors; int have_colors; int quant; int row, col; G_message(_("Writing output maps")); for (quant = 0; quant < num_quants; quant++) { const char *output = outputs[quant]; out_fd[quant] = Rast_open_fp_new(output); } have_colors = Rast_read_colors(covermap, "", &colors) > 0; for (row = 0; row < rows; row++) { Rast_get_c_row(base_fd, base_buf, row); for (quant = 0; quant < num_quants; quant++) { for (col = 0; col < cols; col++) if (Rast_is_c_null_value(&base_buf[col])) Rast_set_d_null_value(&out_buf[col], 1); else out_buf[col] = basecats[base_buf[col] - min].quants[quant]; Rast_put_d_row(out_fd[quant], out_buf); } G_percent(row, rows, 2); } G_percent(row, rows, 2); for (quant = 0; quant < num_quants; quant++) { Rast_close(out_fd[quant]); if (have_colors) Rast_write_colors(outputs[quant], mapset, &colors); } }
int cseg_write_cellfile(CSEG * cseg, char *map_name) { int map_fd; GW_LARGE_INT row, nrows; CELL *buffer; map_fd = Rast_open_c_new(map_name); nrows = Rast_window_rows(); buffer = Rast_allocate_c_buf(); Segment_flush(&(cseg->seg)); for (row = 0; row < nrows; row++) { G_percent(row, nrows, 1); Segment_get_row(&(cseg->seg), buffer, row); Rast_put_row(map_fd, buffer, CELL_TYPE); } G_percent(row, nrows, 1); /* finish it */ G_free(buffer); Rast_close(map_fd); return 0; }
/*! \brief Open and allocate space for the group band files. \param refer pointer to band files structure \param[out] band_buffer buffer to read one row of each band \param[out] band_fd band files descriptors */ void open_band_files(struct Ref *refer, CELL *** band_buffer, int **band_fd) { int n, nbands; char *name, *mapset; G_debug(3, "open_band_files()"); /* allocate row buffers and open raster maps */ nbands = refer->nfiles; *band_buffer = (CELL **) G_malloc(nbands * sizeof(CELL *)); *band_fd = (int *)G_malloc(nbands * sizeof(int)); for (n = 0; n < nbands; n++) { (*band_buffer)[n] = Rast_allocate_c_buf(); name = refer->file[n].name; mapset = refer->file[n].mapset; (*band_fd)[n] = Rast_open_old(name, mapset); } }
static void fill_bins(int basefile, int coverfile) { CELL *basebuf = Rast_allocate_c_buf(); DCELL *coverbuf = Rast_allocate_d_buf(); int row, col; G_message(_("Binning data")); for (row = 0; row < rows; row++) { Rast_get_c_row(basefile, basebuf, row); Rast_get_d_row(coverfile, coverbuf, row); for (col = 0; col < cols; col++) { struct basecat *bc; int i, bin; struct bin *b; if (Rast_is_c_null_value(&basebuf[col])) continue; if (Rast_is_d_null_value(&coverbuf[col])) continue; i = get_slot(coverbuf[col]); bc = &basecats[basebuf[col] - min]; if (!bc->slot_bins[i]) continue; bin = bc->slot_bins[i] - 1; b = &bc->bins[bin]; bc->values[b->base + b->count++] = coverbuf[col]; } G_percent(row, rows, 2); } G_percent(rows, rows, 2); G_free(basebuf); G_free(coverbuf); }
int openfiles(struct parms *parms, struct files *files) { struct Ref Ref; /* subgroup reference list */ int n; if (!I_get_subgroup_ref(parms->group, parms->subgroup, &Ref)) G_fatal_error(_("Unable to read REF file for subgroup <%s> in group <%s>"), parms->subgroup, parms->group); if (Ref.nfiles <= 0) G_fatal_error(_("Subgroup <%s> in group <%s> contains no raster maps"), parms->subgroup, parms->group); /* allocate file descriptors, and io buffer */ files->cellbuf = Rast_allocate_d_buf(); files->outbuf = Rast_allocate_c_buf(); files->isdata = G_malloc(Rast_window_cols()); files->nbands = Ref.nfiles; files->band_fd = (int *)G_calloc(Ref.nfiles, sizeof(int)); /* open all group maps for reading */ for (n = 0; n < Ref.nfiles; n++) files->band_fd[n] = open_cell_old(Ref.file[n].name, Ref.file[n].mapset); /* open output map */ files->output_fd = open_cell_new(parms->output_map); if (parms->goodness_map) files->goodness_fd = Rast_open_new(parms->goodness_map, FCELL_TYPE); else files->goodness_fd = -1; return 0; }
int renumber(int in, int out) { CELL *cell, *c; int row, col; cell = Rast_allocate_c_buf(); G_message(_("%s: STEP 3 ... "), G_program_name()); for (row = 0; row < nrows; row++) { G_percent(row, nrows, 5); Rast_get_c_row(in, c = cell, row); col = ncols; while (col-- > 0) { if (!Rast_is_c_null_value(c)) *c = table[*c]; c++; } Rast_put_row(out, cell, CELL_TYPE); } G_percent(row, nrows, 10); G_free(cell); return 0; }
int get_cats(const char *name, const char *mapset) { int fd; int row, nrows, ncols; CELL *cell; struct Cell_head cellhd; /* set the window to the cell header */ Rast_get_cellhd(name, mapset, &cellhd); Rast_set_window(&cellhd); /* open the raster map */ fd = Rast_open_old(name, mapset); nrows = Rast_window_rows(); ncols = Rast_window_cols(); cell = Rast_allocate_c_buf(); Rast_init_cell_stats(&statf); /* read the raster map */ G_verbose_message(_("Reading <%s> in <%s>"), name, mapset); for (row = 0; row < nrows; row++) { if (G_verbose() > G_verbose_std()) G_percent(row, nrows, 2); Rast_get_c_row_nomask(fd, cell, row); Rast_update_cell_stats(cell, ncols, &statf); } /* done */ if (G_verbose() > G_verbose_std()) G_percent(row, nrows, 2); Rast_close(fd); G_free(cell); Rast_rewind_cell_stats(&statf); return 0; }
static void get_slot_counts(int basefile, int coverfile) { CELL *basebuf = Rast_allocate_c_buf(); DCELL *coverbuf = Rast_allocate_d_buf(); int row, col; G_message(_("Computing histograms")); for (row = 0; row < rows; row++) { Rast_get_c_row(basefile, basebuf, row); Rast_get_d_row(coverfile, coverbuf, row); for (col = 0; col < cols; col++) { struct basecat *bc; int i; if (Rast_is_c_null_value(&basebuf[col])) continue; if (Rast_is_d_null_value(&coverbuf[col])) continue; i = get_slot(coverbuf[col]); bc = &basecats[basebuf[col] - min]; bc->slots[i]++; bc->total++; } G_percent(row, rows, 2); } G_percent(rows, rows, 2); G_free(basebuf); G_free(coverbuf); }
/* * do_histogram() - Creates histogram for CELL * * RETURN: EXIT_SUCCESS / EXIT_FAILURE */ int do_histogram(const char *name) { CELL *cell; struct Cell_head cellhd; struct Cell_stats statf; int nrows, ncols; int row; int fd; Rast_get_cellhd(name, "", &cellhd); Rast_set_window(&cellhd); fd = Rast_open_old(name, ""); nrows = Rast_window_rows(); ncols = Rast_window_cols(); cell = Rast_allocate_c_buf(); Rast_init_cell_stats(&statf); for (row = 0; row < nrows; row++) { Rast_get_c_row_nomask(fd, cell, row); Rast_update_cell_stats(cell, ncols, &statf); } if (row == nrows) Rast_write_histogram_cs(name, &statf); Rast_free_cell_stats(&statf); Rast_close(fd); G_free(cell); if (row < nrows) return -1; return 0; }
int close_maps(char *stream_rast, char *stream_vect, char *dir_rast) { int stream_fd, dir_fd, r, c, i; CELL *cell_buf1, *cell_buf2; struct History history; CELL stream_id; ASP_FLAG af; /* cheating... */ stream_fd = dir_fd = -1; cell_buf1 = cell_buf2 = NULL; G_message(_("Writing output raster maps...")); /* write requested output rasters */ if (stream_rast) { stream_fd = Rast_open_new(stream_rast, CELL_TYPE); cell_buf1 = Rast_allocate_c_buf(); } if (dir_rast) { dir_fd = Rast_open_new(dir_rast, CELL_TYPE); cell_buf2 = Rast_allocate_c_buf(); } for (r = 0; r < nrows; r++) { G_percent(r, nrows, 2); if (stream_rast) Rast_set_c_null_value(cell_buf1, ncols); /* reset row to all NULL */ if (dir_rast) Rast_set_c_null_value(cell_buf2, ncols); /* reset row to all NULL */ for (c = 0; c < ncols; c++) { if (stream_rast) { cseg_get(&stream, &stream_id, r, c); if (stream_id) cell_buf1[c] = stream_id; } if (dir_rast) { seg_get(&aspflag, (char *)&af, r, c); if (!FLAG_GET(af.flag, NULLFLAG)) { cell_buf2[c] = af.asp; } } } if (stream_rast) Rast_put_row(stream_fd, cell_buf1, CELL_TYPE); if (dir_rast) Rast_put_row(dir_fd, cell_buf2, CELL_TYPE); } G_percent(nrows, nrows, 2); /* finish it */ if (stream_rast) { Rast_close(stream_fd); G_free(cell_buf1); Rast_short_history(stream_rast, "raster", &history); Rast_command_history(&history); Rast_write_history(stream_rast, &history); } if (dir_rast) { struct Colors colors; Rast_close(dir_fd); G_free(cell_buf2); Rast_short_history(dir_rast, "raster", &history); Rast_command_history(&history); Rast_write_history(dir_rast, &history); Rast_init_colors(&colors); Rast_make_aspect_colors(&colors, -8, 8); Rast_write_colors(dir_rast, G_mapset(), &colors); } /* close stream vector */ if (stream_vect) { if (close_streamvect(stream_vect) < 0) G_fatal_error(_("Unable to write vector map <%s>"), stream_vect); } /* rearranging desk chairs on the Titanic... */ G_free(outlets); /* free stream nodes */ for (i = 1; i <= n_stream_nodes; i++) { if (stream_node[i].n_alloc > 0) { G_free(stream_node[i].trib); } } G_free(stream_node); return 1; }
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); }
/* CALCULATE THE COORDINATES OF THE TOP LEFT CORNER OF THE SAMPLING UNITS */ static int calc_unit_loc(double radius, int top, int bot, int left, int right, double ratio, int u_w, int u_l, int method, double intv, int num, int h_d, int v_d, double *ux, double *uy, int *sites, double startx, int starty, int fmask, double nx, double x, double y) { char *sites_mapset, sites_file_name[GNAME_MAX], *cmd; struct Map_info Map; struct Cell_head region; double D_u_to_a_col(), D_u_to_a_row(); int i, j, k, cnt = 0, w_w = right - left, w_l = bot - top, exp1, exp2, dx = w_w, dy = w_l, l, t, left1 = left, top1 = top, n, tmp, ulrow, ulcol, *row_buf, lap = 0; static struct line_pnts *Points; struct line_cats *Cats; int ltype; /* VARIABLES: UNITS FOR ALL DIMENSION VARIABLES IN THIS ROUTINE ARE IN PIXELS top = sampling frame top row in pixels bot = sampling frame bottom row in pixels left = sampling frame left in pixels right = sampling frame right in pixels left1 = col of left side of sampling frame or each stratum top1 = row of top side of sampling frame or each stratum l = random # cols to be added to left1 r = random # rows to be added to top1 ratio = u_w = sampling unit width in pixels u_l = sampling unit length in pixels method = method of sampling unit distribution (1-5) intv = interval between sampling units when method=3 num = number of sampling units h_d = number of horizontal strata v_d = number of vertical strata ux = uy = sites = startx = col of UL corner starting pt for strata starty = row of UL corner starting pt for strata dx = number of cols per stratum dy = number of rows per stratum w_w = width of sampling frame in cols w_l = length of sampling frame in rows */ /* if user hits Ctrl+C, abort this calculation */ setjmp(jmp); if (tag) { tag = 0; return 0; } /* for syst. noncontig. distribution */ if (method == 3) { u_w += intv; u_l += intv; } /* for stratified random distribution */ if (method == 4) { dx = (int)((double)(w_w - startx) / (double)(h_d)); dy = (int)((double)(w_l - starty) / (double)(v_d)); } /* for syst. contig. and noncontig. distribution */ else if (method == 2 || method == 3) { if (nx >= num) dx = (w_w - startx) - (num - 1) * u_w; else { dx = (w_w - startx) - (nx - 1) * u_w; dy = (w_l - starty) - (num / nx - 1) * u_l; } } if (10 > (exp1 = (int)pow(10.0, ceil(log10((double)(dx - u_w + 10)))))) exp1 = 10; if (10 > (exp2 = (int)pow(10.0, ceil(log10((double)(dy - u_l + 10)))))) exp2 = 10; /* for random nonoverlapping and stratified random */ if (method == 1 || method == 4) { fprintf(stderr, "\n 'Ctrl+C' and choose fewer units if the requested number"); fprintf(stderr, " is not reached\n"); for (i = 0; i < num; i++) { /* if Cntl+C */ if (signal(SIGINT, SIG_IGN) != SIG_IGN) signal(SIGINT, f); /* for stratified random distribution */ if (method == 4) { j = 0; if (n = i % h_d) left1 += dx; else { left1 = left + startx; if (i < h_d) top1 = top + starty; else top1 += dy; } get_rd(exp1, exp2, dx, dy, u_w, u_l, &l, &t); } /* for random nonoverlapping distribution */ if (method == 1) { /* get random numbers */ back: get_rd(exp1, exp2, dx, dy, u_w, u_l, &l, &t); if (left1 + l + u_w > right || top1 + t + u_l > bot || left1 + l < left || top1 + t < top) goto back; /* if there is a mask, check to see that the unit will be within the mask area */ if (fmask > 0) { row_buf = Rast_allocate_c_buf(); Rast_get_c_row_nomask(fmask, row_buf, t + top1); if (! (*(row_buf + l + left1) && *(row_buf + l + left1 + u_w - 1))) goto back; Rast_zero_c_buf(row_buf); Rast_get_c_row_nomask(fmask, row_buf, t + top1 + u_l - 1); if (! (*(row_buf + l + left1) && *(row_buf + l + left1 + u_w - 1))) goto back; G_free(row_buf); } /* check for sampling unit overlap */ lap = 0; for (j = 0; j < cnt; j++) { if (overlap (l + left1, t + top1, (int)ux[j], (int)uy[j], u_w, u_l)) lap = 1; } if (lap) goto back; cnt++; } /* fill the array of upper left coordinates for the sampling units */ *(ux + i) = l + left1; *(uy + i) = t + top1; /* draw the sampling units on the screen */ R_open_driver(); R_standard_color(D_translate_color("red")); if (radius) draw_circle((int)((double)(ux[i]) / x), (int)((double)(uy[i]) / y), (int)((double)(ux[i] + u_w) / x), (int)((double)(uy[i] + u_l) / y), 3); else draw_box((int)((double)(ux[i]) / x), (int)((double)(uy[i]) / y), (int)((double)(ux[i] + u_w) / x), (int)((double)(uy[i] + u_l) / y), 1); R_close_driver(); fprintf(stderr, " Distributed unit %4d of %4d requested\r", i + 1, num); } } /* for syst. contig. & syst. noncontig. */ else if (method == 2 || method == 3) { for (i = 0; i < num; i++) { *(ux + i) = left + startx + u_w * (i - nx * floor((double)i / nx)); *(uy + i) = top + starty + u_l * floor((double)i / nx); } } /* for centered over sites */ else if (method == 5) { sites_mapset = G_ask_vector_old(" Enter name of vector points map", sites_file_name); if (sites_mapset == NULL) { G_system("d.frame -e"); exit(0); } if (Vect_open_old(&Map, sites_file_name, sites_mapset) < 0) G_fatal_error(_("Unable to open vector map <%s>"), sites_file_name); /* fprintf(stderr, "\n Can't open vector points file %s\n", sites_file_name); */ *sites = 0; i = 0; n = 0; Points = Vect_new_line_struct(); /* init line_pnts struct */ Cats = Vect_new_cats_struct(); while (1) { ltype = Vect_read_next_line(&Map, Points, Cats); if (ltype == -1) G_fatal_error(_("Cannot read vector")); if (ltype == -2) break; /* EOF */ /* point features only. (GV_POINTS is pts AND centroids, GV_POINT is just pts) */ if (!(ltype & GV_POINT)) continue; ulcol = ((int)(D_u_to_a_col(Points->x[0]))) + 1 - u_w / 2; ulrow = ((int)(D_u_to_a_row(Points->y[0]))) + 1 - u_l / 2; if (ulcol <= left || ulrow <= top || ulcol + u_w - 1 > right || ulrow + u_l - 1 > bot) { fprintf(stderr, " No sampling unit over site %d at east=%8.1f north=%8.1f\n", n + 1, Points->x[0], Points->y[0]); fprintf(stderr, " as it would extend outside the map\n"); } else { *(ux + i) = ulcol - 1; *(uy + i) = ulrow - 1; i++; } n++; if (n > 250) G_fatal_error ("There are more than the maximum of 250 sites\n"); } fprintf(stderr, " Total sites with sampling units = %d\n", i); *sites = i; cmd = G_malloc(100); sprintf(cmd, "d.vect %s color=black", sites_file_name); G_system(cmd); G_free(cmd); Vect_close(&Map); G_free(Points); G_free(Cats); } return 1; }
static void graph_unit(int t, int b, int l, int r, char *n1, char *n2, char *n3, double *mx, int fmask) { int x0 = 0, y0 = 0, xp, yp, ux[250], uy[250], u_w, u_l, btn = 0, k = 0, w_w = 0, w_l = 0, *row_buf, at, ab, al, ar, circle = 0, tmpw, tmpl, au_w, au_l, lap = 0, l0 = 0, r0 = 0, t0 = 0, b0 = 0; FILE *fp; double tmp, radius = 0.0; register int i, j; /* VARIABLES: COORDINATES IN THIS ROUTINE ARE IN CELLS t = top row of sampling frame b = bottom row of sampling frame l = left col of sampling frame r = right col of sampling frame n1 = n2 = n3 = mx[0] = cols of region/width of screen mx[1] = rows of region/height of screen xp = mouse x location in screen coordinates (col) yp = mouse y location in screen coordinates (row) ar = mouse x location in map coordinates (col) al = mouse y location in map coordinates (row) */ l0 = l; r0 = r; t0 = t; b0 = b; l = (int)((double)(l * mx[0]) + 0.5); r = (int)((double)(r * mx[0]) + 0.5); t = (int)((double)(t * mx[1]) + 0.5); b = (int)((double)(b * mx[1]) + 0.5); w_w = r - l; w_l = b - t; /* draw the sampling frame */ R_open_driver(); R_standard_color(D_translate_color("grey")); draw_box((int)(l / mx[0]), (int)(t / mx[1]), (int)(r / mx[0]), (int)(b / mx[1]), 1); R_close_driver(); fp = fopen0("r.le.para/units", "w"); G_sleep_on_error(0); /* get the number of scales */ do { fprintf(stderr, "\n How many different SCALES do you want? (1-15) "); numtrap(1, &tmp); if (tmp < 1 || tmp > 15) fprintf(stderr, " Too many (>15) or too few scales, try again.\n"); } while (tmp < 1 || tmp > 15); fprintf(fp, "%10d # of scales\n", (int)(tmp)); /* for each scale */ for (i = 0; i < tmp; i++) { G_system("clear"); radius = 0.0; circle = 0; /* if sampling using circles */ fprintf(stderr, "\n SCALE %d\n", i + 1); fprintf(stderr, "\n Do you want to sample using rectangles"); if (!G_yes("\n (including squares) (y) or circles (n)? ", 1)) { circle = 1; fprintf(stderr, "\n Draw a rectangular area to contain a standard circular"); fprintf(stderr, "\n sampling unit of scale %d. First select upper left", i + 1); fprintf(stderr, "\n corner, then lower right:\n"); fprintf(stderr, " Left button: Check unit size\n"); fprintf(stderr, " Middle button: Upper left corner of area here\n"); fprintf(stderr, " Right button: Lower right corner of area here\n"); } else { fprintf(stderr, "\n Draw a standard rectangular unit of scale %d.", i + 1); fprintf(stderr, "\n First select upper left corner, then lower right:\n"); fprintf(stderr, " Left button: Check unit size\n"); fprintf(stderr, " Middle button: Upper left corner of unit here\n"); fprintf(stderr, " Right button: Lower right corner of unit here\n"); } R_open_driver(); do { back1: R_get_location_with_box(x0, y0, &xp, &yp, &btn); /* convert the upper left screen coordinate (x0, y0) and the mouse position (xp, yp) on the screen to the nearest row and column; do the same for the sampling unit width (u_w) and height (u_l); then convert back */ ar = (int)((double)(xp) * mx[0] + 0.5); xp = (int)((double)(ar) / mx[0] + 0.5); al = (int)((double)(x0) * mx[0] + 0.5); x0 = (int)((double)(al) / mx[0] + 0.5); au_w = ar - al; u_w = (int)((double)(au_w) / mx[0] + 0.5); ab = (int)((double)(yp) * mx[1] + 0.5); yp = (int)((double)(ab) / mx[1] + 0.5); at = (int)((double)(y0) * mx[1] + 0.5); y0 = (int)((double)(at) / mx[1] + 0.5); au_l = ab - at; u_l = (int)((double)(au_l) / mx[1] + 0.5); /* left button, check the size of the rubber box in array system */ if (btn == 1) { if (ar > r || ab > b || ar < l || ab < t) { fprintf(stderr, "\n This point is not in the sampling frame; try again\n"); goto back1; } if (x0 < l || y0 < t) { fprintf(stderr, "\n Use the middle button to first put the upper left"); fprintf(stderr, "\n corner inside the sampling frame\n"); goto back1; } if (ar <= al || ab <= at) { fprintf(stderr, "\n Please put the lower right corner down and to"); fprintf(stderr, "\n the right of the upper left corner\n"); goto back1; } else { fprintf(stderr, "\n Unit would be %d columns wide by %d rows long\n", abs(au_w), abs(au_l)); fprintf(stderr, " Width/length would be %5.2f and size %d pixels\n", (double)abs((au_w)) / (double)abs((au_l)), abs(au_w) * abs(au_l)); } } /* mid button, move the start point of the rubber box */ else if (btn == 2) { if (ar > r || ab > b || ar < l || ab < t) { fprintf(stderr, "\n Point is not in the sampling frame; try again\n"); goto back1; } else { R_move_abs(xp, yp); x0 = xp; y0 = yp; } } /* right button, outline the unit */ else if (btn == 3) { if (circle) { if (u_w > u_l) { al = al + ((ar - al) - (ab - at)) / 2; ar = al + (ab - at); x0 = (int)((double)(al) / mx[0] + 0.5); xp = (int)((double)(ar) / mx[0] + 0.5); au_w = ar - al; u_w = u_l = (int)((double)(au_w) / mx[0] + 0.5); } if (u_l > u_w) { at = at + ((ab - at) - (ar - al)) / 2; ab = at + (ar - al); y0 = (int)((double)(at) / mx[1] + 0.5); yp = (int)((double)(ab) / mx[1] + 0.5); au_l = ab - at; u_w = u_l = (int)((double)(au_l) / mx[1] + 0.5); } } if (ar > r || ab > b || al < l || at < t) { fprintf(stderr, "\n The unit extends outside the sampling frame or map;"); fprintf(stderr, "\n try again\n"); goto back1; } if (au_w > w_w || au_l > w_l) { fprintf(stderr, "\n The unit is too big for the sampling frame; "); fprintf(stderr, "try again\n"); goto back1; } /* if there is a mask, check to see that the unit will be within the mask area, by checking to see whether the four corners of the unit are in the mask */ if (fmask > 0) { row_buf = Rast_allocate_c_buf(); Rast_get_c_row_nomask(fmask, row_buf, at); if (!(*(row_buf + al) && *(row_buf + ar - 1))) { fprintf(stderr, "\n The unit would be outside the mask; "); fprintf(stderr, "try again\n"); G_free(row_buf); goto back1; } Rast_zero_c_buf(row_buf); Rast_get_c_row_nomask(fmask, row_buf, ab - 1); if (!(*(row_buf + al) && *(row_buf + ar - 1))) { fprintf(stderr, "\n The unit would be outside the mask; "); fprintf(stderr, "try again\n"); G_free(row_buf); goto back1; } G_free(row_buf); } if (xp - x0 > 0 && yp - y0 > 0) { R_standard_color(D_translate_color("red")); if (circle) draw_circle(x0, y0, xp, yp, 3); else draw_box(x0, y0, xp, yp, 1); G_system("clear"); if (circle) { fprintf(stderr, "\n\n The standard circular sampling unit has:\n"); fprintf(stderr, " radius = %f pixels\n", (double)(ar - al) / 2.0); } else { fprintf(stderr, "\n\n The standard sampling unit has:\n"); fprintf(stderr, " columns=%d rows=%d\n", abs(ar - al), abs(ab - at)); fprintf(stderr, " width/length ratio=%5.2f\n", (double)abs(ar - al) / (double)abs(ab - at)); fprintf(stderr, " size=%d pixels\n", abs(ar - al) * abs(ab - at)); } k = 0; ux[0] = al; uy[0] = at; } else if (xp - x0 == 0 || yp - y0 == 0) { fprintf(stderr, "\n Unit has 0 rows and/or 0 columns; try again\n"); goto back1; } else { fprintf(stderr, "\n You did not put the lower right corner below"); fprintf(stderr, "\n and to the right of the upper left corner. Please try again"); goto back1; } } } while (btn != 3); R_close_driver(); /* use the size and shape of the standard unit to outline more units in that scale */ fprintf(stderr, "\n Outline more sampling units of scale %d?\n", i + 1); fprintf(stderr, " Left button: Exit\n"); fprintf(stderr, " Middle button: Check unit position\n"); fprintf(stderr, " Right button: Lower right corner of next unit here\n"); R_open_driver(); /* if not the left button (to exit) */ back2: while (btn != 1) { R_get_location_with_box(xp - u_w, yp - u_l, &xp, &yp, &btn); /* convert the left (x0), right (y0), top (y0), bottom (yp) coordinates in screen pixels to the nearest row and column; do the same for the sampling unit width (u_w) and height (u_l); then convert back */ ar = (int)((double)(xp) * mx[0] + 0.5); ab = (int)((double)(yp) * mx[1] + 0.5); xp = (int)((double)(ar) / mx[0] + 0.5); yp = (int)((double)(ab) / mx[1] + 0.5); al = (int)((double)(xp - u_w) * mx[0] + 0.5); at = (int)((double)(yp - u_l) * mx[0] + 0.5); x0 = (int)((double)(al) / mx[0] + 0.5); y0 = (int)((double)(at) / mx[1] + 0.5); /* if right button, outline the unit */ if (btn == 3) { if (ar > r || ab > b || al < l || at < t) { fprintf(stderr, "\n The unit would be outside the map; try again"); goto back2; } /* if there is a mask, check to see that the unit will be within the mask area */ if (fmask > 0) { row_buf = Rast_allocate_c_buf(); Rast_get_c_row_nomask(fmask, row_buf, at); if (!(*(row_buf + al) && *(row_buf + ar - 1))) { fprintf(stderr, "\n The unit would be outside the mask; "); fprintf(stderr, "try again"); G_free(row_buf); goto back2; } Rast_zero_c_buf(row_buf); Rast_get_c_row_nomask(fmask, row_buf, ab - 1); if (!(*(row_buf + al) && *(row_buf + ar - 1))) { fprintf(stderr, "\n The unit would be outside the mask; "); fprintf(stderr, "try again"); G_free(row_buf); goto back2; } G_free(row_buf); } /* check for sampling unit overlap */ lap = 0; for (j = 0; j < k + 1; j++) { if (overlap(al, at, ux[j], uy[j], au_w, au_l)) { fprintf(stderr, "\n The unit would overlap a previously drawn "); fprintf(stderr, "unit; try again"); lap = 1; } } if (lap) goto back2; k++; fprintf(stderr, "\n %d sampling units have been placed", (k + 1)); ux[k] = al; uy[k] = at; R_standard_color(D_translate_color("red")); if (circle) draw_circle(x0, y0, xp, yp, 3); else draw_box(x0, y0, xp, yp, 1); } } R_close_driver(); /* save the sampling units in the r.le.para/units file */ if (circle) radius = (double)(ar - al) / 2.0; else radius = 0.0; fprintf(fp, "%10d # of units of scale %d\n", k + 1, i + 1); fprintf(fp, "%10d%10d u_w, u_l of units in scale %d\n", (int)(u_w * mx[0]), (int)(u_l * mx[1]), i + 1); fprintf(fp, "%10.1f radius of circles in scale %d\n", radius, (i + 1)); for (j = 0; j < k + 1; j++) fprintf(fp, "%10d%10d left, top of unit[%d]\n", ux[j], uy[j], j + 1); if (i < tmp - 1 && G_yes("\n Refresh the screen? ", 1)) { paint_map(n1, n2, n3); R_open_driver(); R_standard_color(D_translate_color("red")); R_close_driver(); } } fclose(fp); return; }
int open_files(void) { char *name, *mapset; FILE *fd; int n; I_init_group_ref(&Ref); if (!I_find_group(group)) G_fatal_error(_("Group <%s> not found"), group); if (!I_find_subgroup(group, subgroup)) G_fatal_error(_("Subgroup <%s> in group <%s> not found"), subgroup, group); I_get_subgroup_ref(group, subgroup, &Ref); if (Ref.nfiles <= 1) { if (Ref.nfiles <= 0) G_fatal_error(_("Subgroup <%s> of group <%s> doesn't have any raster maps. " "The subgroup must have at least 2 raster maps.")); else G_fatal_error(_("Subgroup <%s> of group <%s> only has 1 raster map. " "The subgroup must have at least 2 raster maps.")); } cell = (DCELL **) G_malloc(Ref.nfiles * sizeof(DCELL *)); cellfd = (int *)G_malloc(Ref.nfiles * sizeof(int)); P = (double *)G_malloc(Ref.nfiles * sizeof(double)); for (n = 0; n < Ref.nfiles; n++) { cell[n] = Rast_allocate_d_buf(); name = Ref.file[n].name; mapset = Ref.file[n].mapset; cellfd[n] = Rast_open_old(name, mapset); } I_init_signatures(&S, Ref.nfiles); fd = I_fopen_signature_file_old(group, subgroup, sigfile); if (fd == NULL) G_fatal_error(_("Unable to open signature file <%s>"), sigfile); n = I_read_signatures(fd, &S); fclose(fd); if (n < 0) G_fatal_error(_("Unable to read signature file <%s>"), sigfile); if (S.nsigs > 255) G_fatal_error(_("<%s> has too many signatures (limit is 255)"), sigfile); B = (double *)G_malloc(S.nsigs * sizeof(double)); invert_signatures(); class_fd = Rast_open_c_new(class_name); class_cell = Rast_allocate_c_buf(); reject_cell = NULL; if (reject_name) { reject_fd = Rast_open_c_new(reject_name); reject_cell = Rast_allocate_c_buf(); } return 0; }
int main(int argc, char **argv) { MELEMENT *rowlist; SHORT nrows, ncols; SHORT datarows; int npoints; struct GModule *module; struct History history; struct { struct Option *input, *output, *npoints; } parm; struct { struct Flag *e; } flag; int n, fd, maskfd; /* Initialize the GIS calls */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("surface")); G_add_keyword(_("interpolation")); G_add_keyword(_("IDW")); module->description = _("Surface interpolation utility for raster map."); parm.input = G_define_standard_option(G_OPT_R_INPUT); parm.output = G_define_standard_option(G_OPT_R_OUTPUT); parm.npoints = G_define_option(); parm.npoints->key = "npoints"; parm.npoints->type = TYPE_INTEGER; parm.npoints->required = NO; parm.npoints->description = _("Number of interpolation points"); parm.npoints->answer = "12"; flag.e = G_define_flag(); flag.e->key = 'e'; flag.e->description = _("Output is the interpolation error"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); if (sscanf(parm.npoints->answer, "%d", &n) != 1 || n <= 0) G_fatal_error(_("Illegal value for '%s' (%s)"), parm.npoints->key, parm.npoints->answer); npoints = n; error_flag = flag.e->answer; input = parm.input->answer; output = parm.output->answer; /* Get database window parameters */ G_get_window(&window); /* find number of rows and columns in window */ nrows = Rast_window_rows(); ncols = Rast_window_cols(); /* create distance squared or latitude lookup tables */ /* initialize function pointers */ lookup_and_function_ptrs(nrows, ncols); /* allocate buffers for row i/o */ cell = Rast_allocate_c_buf(); if ((maskfd = Rast_maskfd()) >= 0 || error_flag) { /* apply mask to output */ if (error_flag) /* use input as mask when -e option chosen */ maskfd = Rast_open_old(input, ""); mask = Rast_allocate_c_buf(); } else mask = NULL; /* Open input cell layer for reading */ fd = Rast_open_old(input, ""); /* Store input data in array-indexed doubly-linked lists and close input file */ rowlist = row_lists(nrows, ncols, &datarows, &n, fd, cell); Rast_close(fd); if (npoints > n) npoints = n; /* open cell layer for writing output */ fd = Rast_open_c_new(output); /* call the interpolation function */ interpolate(rowlist, nrows, ncols, datarows, npoints, fd, maskfd); /* free allocated memory */ free_row_lists(rowlist, nrows); G_free(rowlook); G_free(collook); if (ll) free_dist_params(); Rast_close(fd); /* writing history file */ Rast_short_history(output, "raster", &history); Rast_command_history(&history); Rast_write_history(output, &history); G_done_msg(" "); exit(EXIT_SUCCESS); }
int main(int argc, char **argv) { static DCELL *count, *sum, *mean, *sumu, *sum2, *sum3, *sum4, *min, *max; DCELL *result; struct GModule *module; struct { struct Option *method, *basemap, *covermap, *output; } opt; struct { struct Flag *c, *r; } flag; char methods[2048]; const char *basemap, *covermap, *output; int usecats; int reclass; int base_fd, cover_fd; struct Categories cats; CELL *base_buf; DCELL *cover_buf; struct Range range; CELL mincat, ncats; int method; int rows, cols; int row, col, i; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("statistics")); module->description = _("Calculates category or object oriented statistics (accumulator-based statistics)."); opt.basemap = G_define_standard_option(G_OPT_R_BASE); opt.covermap = G_define_standard_option(G_OPT_R_COVER); opt.method = G_define_option(); opt.method->key = "method"; opt.method->type = TYPE_STRING; opt.method->required = YES; opt.method->description = _("Method of object-based statistic"); for (i = 0; menu[i].name; i++) { if (i) strcat(methods, ","); else *(methods) = 0; strcat(methods, menu[i].name); } opt.method->options = G_store(methods); for (i = 0; menu[i].name; i++) { if (i) strcat(methods, ";"); else *(methods) = 0; strcat(methods, menu[i].name); strcat(methods, ";"); strcat(methods, menu[i].text); } opt.method->descriptions = G_store(methods); opt.output = G_define_standard_option(G_OPT_R_OUTPUT); opt.output->description = _("Resultant raster map"); opt.output->required = YES; flag.c = G_define_flag(); flag.c->key = 'c'; flag.c->description = _("Cover values extracted from the category labels of the cover map"); flag.r = G_define_flag(); flag.r->key = 'r'; flag.r->description = _("Create reclass map with statistics as category labels"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); basemap = opt.basemap->answer; covermap = opt.covermap->answer; output = opt.output->answer; usecats = flag.c->answer; reclass = flag.r->answer; for (i = 0; menu[i].name; i++) if (strcmp(menu[i].name, opt.method->answer) == 0) break; if (!menu[i].name) { G_warning(_("<%s=%s> unknown %s"), opt.method->key, opt.method->answer, opt.method->key); G_usage(); exit(EXIT_FAILURE); } method = menu[i].val; base_fd = Rast_open_old(basemap, ""); cover_fd = Rast_open_old(covermap, ""); if (usecats && Rast_read_cats(covermap, "", &cats) < 0) G_fatal_error(_("Unable to read category file of cover map <%s>"), covermap); if (Rast_map_is_fp(basemap, "") != 0) G_fatal_error(_("The base map must be an integer (CELL) map")); if (Rast_read_range(basemap, "", &range) < 0) G_fatal_error(_("Unable to read range of base map <%s>"), basemap); mincat = range.min; ncats = range.max - range.min + 1; rows = Rast_window_rows(); cols = Rast_window_cols(); switch (method) { case COUNT: count = G_calloc(ncats, sizeof(DCELL)); break; case SUM: sum = G_calloc(ncats, sizeof(DCELL)); break; case MIN: min = G_malloc(ncats * sizeof(DCELL)); break; case MAX: max = G_malloc(ncats * sizeof(DCELL)); break; case RANGE: min = G_malloc(ncats * sizeof(DCELL)); max = G_malloc(ncats * sizeof(DCELL)); break; case AVERAGE: case ADEV: case VARIANCE2: case STDDEV2: case SKEWNESS2: case KURTOSIS2: count = G_calloc(ncats, sizeof(DCELL)); sum = G_calloc(ncats, sizeof(DCELL)); break; case VARIANCE1: case STDDEV1: count = G_calloc(ncats, sizeof(DCELL)); sum = G_calloc(ncats, sizeof(DCELL)); sum2 = G_calloc(ncats, sizeof(DCELL)); break; case SKEWNESS1: count = G_calloc(ncats, sizeof(DCELL)); sum = G_calloc(ncats, sizeof(DCELL)); sum2 = G_calloc(ncats, sizeof(DCELL)); sum3 = G_calloc(ncats, sizeof(DCELL)); break; case KURTOSIS1: count = G_calloc(ncats, sizeof(DCELL)); sum = G_calloc(ncats, sizeof(DCELL)); sum2 = G_calloc(ncats, sizeof(DCELL)); sum4 = G_calloc(ncats, sizeof(DCELL)); break; } if (min) for (i = 0; i < ncats; i++) min[i] = 1e300; if (max) for (i = 0; i < ncats; i++) max[i] = -1e300; base_buf = Rast_allocate_c_buf(); cover_buf = Rast_allocate_d_buf(); G_message(_("First pass")); for (row = 0; row < rows; row++) { Rast_get_c_row(base_fd, base_buf, row); Rast_get_d_row(cover_fd, cover_buf, row); for (col = 0; col < cols; col++) { int n; DCELL v; if (Rast_is_c_null_value(&base_buf[col])) continue; if (Rast_is_d_null_value(&cover_buf[col])) continue; n = base_buf[col] - mincat; if (n < 0 || n >= ncats) continue; v = cover_buf[col]; if (usecats) sscanf(Rast_get_c_cat((CELL *) &v, &cats), "%lf", &v); if (count) count[n]++; if (sum) sum[n] += v; if (sum2) sum2[n] += v * v; if (sum3) sum3[n] += v * v * v; if (sum4) sum4[n] += v * v * v * v; if (min && min[n] > v) min[n] = v; if (max && max[n] < v) max[n] = v; } G_percent(row, rows, 2); } G_percent(row, rows, 2); result = G_calloc(ncats, sizeof(DCELL)); switch (method) { case ADEV: case VARIANCE2: case STDDEV2: case SKEWNESS2: case KURTOSIS2: mean = G_calloc(ncats, sizeof(DCELL)); for (i = 0; i < ncats; i++) mean[i] = sum[i] / count[i]; G_free(sum); break; } switch (method) { case ADEV: sumu = G_calloc(ncats, sizeof(DCELL)); break; case VARIANCE2: case STDDEV2: sum2 = G_calloc(ncats, sizeof(DCELL)); break; case SKEWNESS2: sum2 = G_calloc(ncats, sizeof(DCELL)); sum3 = G_calloc(ncats, sizeof(DCELL)); break; case KURTOSIS2: sum2 = G_calloc(ncats, sizeof(DCELL)); sum4 = G_calloc(ncats, sizeof(DCELL)); break; } if (mean) { G_message(_("Second pass")); for (row = 0; row < rows; row++) { Rast_get_c_row(base_fd, base_buf, row); Rast_get_d_row(cover_fd, cover_buf, row); for (col = 0; col < cols; col++) { int n; DCELL v, d; if (Rast_is_c_null_value(&base_buf[col])) continue; if (Rast_is_d_null_value(&cover_buf[col])) continue; n = base_buf[col] - mincat; if (n < 0 || n >= ncats) continue; v = cover_buf[col]; if (usecats) sscanf(Rast_get_c_cat((CELL *) &v, &cats), "%lf", &v); d = v - mean[n]; if (sumu) sumu[n] += fabs(d); if (sum2) sum2[n] += d * d; if (sum3) sum3[n] += d * d * d; if (sum4) sum4[n] += d * d * d * d; } G_percent(row, rows, 2); } G_percent(row, rows, 2); G_free(mean); G_free(cover_buf); } switch (method) { case COUNT: for (i = 0; i < ncats; i++) result[i] = count[i]; break; case SUM: for (i = 0; i < ncats; i++) result[i] = sum[i]; break; case AVERAGE: for (i = 0; i < ncats; i++) result[i] = sum[i] / count[i]; break; case MIN: for (i = 0; i < ncats; i++) result[i] = min[i]; break; case MAX: for (i = 0; i < ncats; i++) result[i] = max[i]; break; case RANGE: for (i = 0; i < ncats; i++) result[i] = max[i] - min[i]; break; case VARIANCE1: for (i = 0; i < ncats; i++) { double n = count[i]; double var = (sum2[i] - sum[i] * sum[i] / n) / (n - 1); result[i] = var; } break; case STDDEV1: for (i = 0; i < ncats; i++) { double n = count[i]; double var = (sum2[i] - sum[i] * sum[i] / n) / (n - 1); result[i] = sqrt(var); } break; case SKEWNESS1: for (i = 0; i < ncats; i++) { double n = count[i]; double var = (sum2[i] - sum[i] * sum[i] / n) / (n - 1); double skew = (sum3[i] / n - 3 * sum[i] * sum2[i] / (n * n) + 2 * sum[i] * sum[i] * sum[i] / (n * n * n)) / (pow(var, 1.5)); result[i] = skew; } break; case KURTOSIS1: for (i = 0; i < ncats; i++) { double n = count[i]; double var = (sum2[i] - sum[i] * sum[i] / n) / (n - 1); double kurt = (sum4[i] / n - 4 * sum[i] * sum3[i] / (n * n) + 6 * sum[i] * sum[i] * sum2[i] / (n * n * n) - 3 * sum[i] * sum[i] * sum[i] * sum[i] / (n * n * n * n)) / (var * var) - 3; result[i] = kurt; } break; case ADEV: for (i = 0; i < ncats; i++) result[i] = sumu[i] / count[i]; break; case VARIANCE2: for (i = 0; i < ncats; i++) result[i] = sum2[i] / (count[i] - 1); break; case STDDEV2: for (i = 0; i < ncats; i++) result[i] = sqrt(sum2[i] / (count[i] - 1)); break; case SKEWNESS2: for (i = 0; i < ncats; i++) { double n = count[i]; double var = sum2[i] / (n - 1); double sdev = sqrt(var); result[i] = sum3[i] / (sdev * sdev * sdev) / n; } G_free(count); G_free(sum2); G_free(sum3); break; case KURTOSIS2: for (i = 0; i < ncats; i++) { double n = count[i]; double var = sum2[i] / (n - 1); result[i] = sum4[i] / (var * var) / n - 3; } G_free(count); G_free(sum2); G_free(sum4); break; } if (reclass) { const char *tempfile = G_tempfile(); char *input_arg = G_malloc(strlen(basemap) + 7); char *output_arg = G_malloc(strlen(output) + 8); char *rules_arg = G_malloc(strlen(tempfile) + 7); FILE *fp; G_message(_("Generating reclass map")); sprintf(input_arg, "input=%s", basemap); sprintf(output_arg, "output=%s", output); sprintf(rules_arg, "rules=%s", tempfile); fp = fopen(tempfile, "w"); if (!fp) G_fatal_error(_("Unable to open temporary file")); for (i = 0; i < ncats; i++) fprintf(fp, "%d = %d %f\n", mincat + i, mincat + i, result[i]); fclose(fp); G_spawn("r.reclass", "r.reclass", input_arg, output_arg, rules_arg, NULL); } else { int out_fd; DCELL *out_buf; struct Colors colors; G_message(_("Writing output map")); out_fd = Rast_open_fp_new(output); out_buf = Rast_allocate_d_buf(); for (row = 0; row < rows; row++) { Rast_get_c_row(base_fd, base_buf, row); for (col = 0; col < cols; col++) if (Rast_is_c_null_value(&base_buf[col])) Rast_set_d_null_value(&out_buf[col], 1); else out_buf[col] = result[base_buf[col] - mincat]; Rast_put_d_row(out_fd, out_buf); G_percent(row, rows, 2); } G_percent(row, rows, 2); Rast_close(out_fd); if (Rast_read_colors(covermap, "", &colors) > 0) Rast_write_colors(output, G_mapset(), &colors); } return 0; }
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 cell_stats(int fd[], int with_percents, int with_counts, int with_areas, int do_sort, int with_labels, char *fmt) { CELL **cell; int i; int row; double unit_area; int planimetric = 0; int compute_areas; double G_area_of_cell_at_row(); /* allocate i/o buffers for each raster map */ cell = (CELL **) G_calloc(nfiles, sizeof(CELL *)); for (i = 0; i < nfiles; i++) cell[i] = Rast_allocate_c_buf(); /* if we want area totals, set this up. * distinguish projections which are planimetric (all cells same size) * from those which are not (e.g., lat-long) */ unit_area = 0.0; if (with_areas) { switch (G_begin_cell_area_calculations()) { case 0: /* areas don't make sense, but ignore this for now */ case 1: planimetric = 1; unit_area = G_area_of_cell_at_row(0); break; default: planimetric = 0; break; } } compute_areas = with_areas && !planimetric; /* here we go */ initialize_cell_stats(nfiles); for (row = 0; row < nrows; row++) { if (compute_areas) unit_area = G_area_of_cell_at_row(row); G_percent(row, nrows, 2); for (i = 0; i < nfiles; i++) { Rast_get_c_row(fd[i], cell[i], row); /* include max FP value in nsteps'th bin */ if(is_fp[i]) fix_max_fp_val(cell[i], ncols); /* we can't compute hash on null values, so we change all nulls to max+1, set NULL_CELL to max+1, and later compare with NULL_CELL to chack for nulls */ reset_null_vals(cell[i], ncols); } update_cell_stats(cell, ncols, unit_area); } G_percent(row, nrows, 2); sort_cell_stats(do_sort); print_cell_stats(fmt, with_percents, with_counts, with_areas, with_labels, fs); return 0; }
int calculate(int fd, struct area_entry *ad, double *result) { CELL *buf, *buf_sup, *buf_null; CELL corrCell, precCell, supCell; long npatch, area; long pid, old_pid, new_pid, *pid_corr, *pid_sup, *ltmp; struct pst *pst; long nalloc, incr; int i, j, k; int connected; int mask_fd, *mask_buf, *mask_sup, *mask_tmp, masked; struct Cell_head hd; Rast_get_window(&hd); buf_null = Rast_allocate_c_buf(); Rast_set_c_null_value(buf_null, Rast_window_cols()); buf_sup = buf_null; /* initialize patch ids */ pid_corr = G_malloc(Rast_window_cols() * sizeof(long)); pid_sup = G_malloc(Rast_window_cols() * sizeof(long)); for (j = 0; j < Rast_window_cols(); j++) { pid_corr[j] = 0; pid_sup[j] = 0; } /* open mask if needed */ mask_fd = -1; mask_buf = mask_sup = NULL; masked = FALSE; if (ad->mask == 1) { if ((mask_fd = open(ad->mask_name, O_RDONLY, 0755)) < 0) return RLI_ERRORE; mask_buf = G_malloc(ad->cl * sizeof(int)); if (mask_buf == NULL) { G_fatal_error("malloc mask_buf failed"); return RLI_ERRORE; } mask_sup = G_malloc(ad->cl * sizeof(int)); if (mask_sup == NULL) { G_fatal_error("malloc mask_buf failed"); return RLI_ERRORE; } for (j = 0; j < ad->cl; j++) mask_buf[j] = 0; masked = TRUE; } /* calculate number of patches */ npatch = 0; area = 0; pid = 0; /* patch size and type */ incr = 1024; if (incr > ad->rl) incr = ad->rl; if (incr > ad->cl) incr = ad->cl; if (incr < 2) incr = 2; nalloc = incr; pst = G_malloc(nalloc * sizeof(struct pst)); for (k = 0; k < nalloc; k++) { pst[k].count = 0; } for (i = 0; i < ad->rl; i++) { buf = RLI_get_cell_raster_row(fd, i + ad->y, ad); if (i > 0) { buf_sup = RLI_get_cell_raster_row(fd, i - 1 + ad->y, ad); } if (masked) { mask_tmp = mask_sup; mask_sup = mask_buf; mask_buf = mask_tmp; if (read(mask_fd, mask_buf, (ad->cl * sizeof(int))) < 0) return 0; } ltmp = pid_sup; pid_sup = pid_corr; pid_corr = ltmp; Rast_set_c_null_value(&precCell, 1); connected = 0; for (j = 0; j < ad->cl; j++) { pid_corr[j + ad->x] = 0; corrCell = buf[j + ad->x]; if (masked && (mask_buf[j] == 0)) { Rast_set_c_null_value(&corrCell, 1); } if (Rast_is_c_null_value(&corrCell)) { connected = 0; precCell = corrCell; continue; } area++; supCell = buf_sup[j + ad->x]; if (masked && (mask_sup[j] == 0)) { Rast_set_c_null_value(&supCell, 1); } if (!Rast_is_c_null_value(&precCell) && corrCell == precCell) { pid_corr[j + ad->x] = pid_corr[j - 1 + ad->x]; connected = 1; pst[pid_corr[j + ad->x]].count++; } else { connected = 0; } if (!Rast_is_c_null_value(&supCell) && corrCell == supCell) { if (pid_corr[j + ad->x] != pid_sup[j + ad->x]) { /* connect or merge */ /* after r.clump */ if (connected) { npatch--; if (npatch == 0) { G_fatal_error("npatch == 0 at row %d, col %d", i, j); } } old_pid = pid_corr[j + ad->x]; new_pid = pid_sup[j + ad->x]; pid_corr[j + ad->x] = new_pid; if (old_pid > 0) { /* merge */ /* update left side of the current row */ for (k = 0; k < j; k++) { if (pid_corr[k + ad->x] == old_pid) pid_corr[k + ad->x] = new_pid; } /* update right side of the previous row */ for (k = j + 1; k < ad->cl; k++) { if (pid_sup[k + ad->x] == old_pid) pid_sup[k + ad->x] = new_pid; } pst[new_pid].count += pst[old_pid].count; pst[old_pid].count = 0; if (old_pid == pid) pid--; } else { pst[new_pid].count++; } } connected = 1; } if (!connected) { /* start new patch */ npatch++; pid++; pid_corr[j + ad->x] = pid; if (pid >= nalloc) { pst = (struct pst *)G_realloc(pst, (pid + incr) * sizeof(struct pst)); for (k = nalloc; k < pid + incr; k++) pst[k].count = 0; nalloc = pid + incr; } pst[pid].count = 1; pst[pid].type.t = CELL_TYPE; pst[pid].type.val.c = corrCell; } precCell = corrCell; } } if (npatch > 0) { double EW_DIST1, EW_DIST2, NS_DIST1, NS_DIST2; double area_p; double cell_size_m; double min, max; /* calculate distance */ G_begin_distance_calculations(); /* EW Dist at North edge */ EW_DIST1 = G_distance(hd.east, hd.north, hd.west, hd.north); /* EW Dist at South Edge */ EW_DIST2 = G_distance(hd.east, hd.south, hd.west, hd.south); /* NS Dist at East edge */ NS_DIST1 = G_distance(hd.east, hd.north, hd.east, hd.south); /* NS Dist at West edge */ NS_DIST2 = G_distance(hd.west, hd.north, hd.west, hd.south); cell_size_m = (((EW_DIST1 + EW_DIST2) / 2) / hd.cols) * (((NS_DIST1 + NS_DIST2) / 2) / hd.rows); /* get min and max patch size */ min = 1.0 / 0.0; /* inf */ max = -1.0 / 0.0; /* -inf */ for (old_pid = 1; old_pid <= pid; old_pid++) { if (pst[old_pid].count > 0) { area_p = cell_size_m * pst[old_pid].count / 10000; if (min > area_p) min = area_p; if (max < area_p) max = area_p; } } *result = max - min; } else Rast_set_d_null_value(result, 1); if (masked) { close(mask_fd); G_free(mask_buf); G_free(mask_sup); } G_free(buf_null); G_free(pid_corr); G_free(pid_sup); G_free(pst); return RLI_OK; }
int read_input_map(char *input, char *mapset, int ZEROFLAG) { int fd; int row; int hit; register int col; register CELL *cell; register MAPTYPE *ptr; map = (MAPTYPE *) G_malloc((size_t) window.rows * window.cols * sizeof(MAPTYPE)); fd = Rast_open_old(input, mapset); cell = Rast_allocate_c_buf(); ptr = map; minrow = -1; maxrow = -1; mincol = window.cols; maxcol = 0; G_message(_("Reading input raster map <%s>..."), G_fully_qualified_name(input, mapset)); count_rows_with_data = 0; for (row = 0; row < window.rows; row++) { hit = 0; G_percent(row, window.rows, 2); Rast_get_c_row(fd, cell, row); for (col = 0; col < window.cols; col++) { if (ZEROFLAG) { if ((*ptr++ = (*cell++ != 0))) { if (minrow < 0) minrow = row; maxrow = row; if (col < mincol) mincol = col; if (col > maxcol) maxcol = col; if (!hit) { count_rows_with_data++; hit = 1; } } } else { /* use NULL */ if ((*ptr++ = !Rast_is_c_null_value(cell++))) { if (minrow < 0) minrow = row; maxrow = row; if (col < mincol) mincol = col; if (col > maxcol) maxcol = col; if (!hit) { count_rows_with_data++; hit = 1; } } } } cell -= window.cols; } G_percent(row, window.rows, 2); Rast_close(fd); G_free(cell); return 0; }
int main(int argc, char *argv[]) { /* Global variable & function declarations */ struct GModule *module; struct { struct Option *orig, *real, *imag; } opt; const char *Cellmap_real, *Cellmap_imag; const char *Cellmap_orig; int realfd, imagfd, outputfd, maskfd; /* the input and output file descriptors */ struct Cell_head realhead, imaghead; DCELL *cell_real, *cell_imag; CELL *maskbuf; int i, j; /* Loop control variables */ int rows, cols; /* number of rows & columns */ long totsize; /* Total number of data points */ double (*data)[2]; /* Data structure containing real & complex values of FFT */ G_gisinit(argv[0]); /* Set description */ module = G_define_module(); G_add_keyword(_("imagery")); G_add_keyword(_("transformation")); G_add_keyword(_("Fast Fourier Transform")); module->description = _("Inverse Fast Fourier Transform (IFFT) for image processing."); /* define options */ opt.real = G_define_standard_option(G_OPT_R_INPUT); opt.real->key = "real"; opt.real->description = _("Name of input raster map (image fft, real part)"); opt.imag = G_define_standard_option(G_OPT_R_INPUT); opt.imag->key = "imaginary"; opt.imag->description = _("Name of input raster map (image fft, imaginary part"); opt.orig = G_define_standard_option(G_OPT_R_OUTPUT); opt.orig->description = _("Name for output raster map"); /*call parser */ if (G_parser(argc, argv)) exit(EXIT_FAILURE); Cellmap_real = opt.real->answer; Cellmap_imag = opt.imag->answer; Cellmap_orig = opt.orig->answer; /* get and compare the original window data */ Rast_get_cellhd(Cellmap_real, "", &realhead); Rast_get_cellhd(Cellmap_imag, "", &imaghead); if (realhead.proj != imaghead.proj || realhead.zone != imaghead.zone || realhead.north != imaghead.north || realhead.south != imaghead.south || realhead.east != imaghead.east || realhead.west != imaghead.west || realhead.ew_res != imaghead.ew_res || realhead.ns_res != imaghead.ns_res) G_fatal_error(_("The real and imaginary original windows did not match")); Rast_set_window(&realhead); /* set the window to the whole cell map */ /* open input raster map */ realfd = Rast_open_old(Cellmap_real, ""); imagfd = Rast_open_old(Cellmap_imag, ""); /* get the rows and columns in the current window */ rows = Rast_window_rows(); cols = Rast_window_cols(); totsize = rows * cols; /* Allocate appropriate memory for the structure containing the real and complex components of the FFT. DATA[0] will contain the real, and DATA[1] the complex component. */ data = G_malloc(rows * cols * 2 * sizeof(double)); /* allocate the space for one row of cell map data */ cell_real = Rast_allocate_d_buf(); cell_imag = Rast_allocate_d_buf(); #define C(i, j) ((i) * cols + (j)) /* Read in cell map values */ G_message(_("Reading raster maps...")); for (i = 0; i < rows; i++) { Rast_get_d_row(realfd, cell_real, i); Rast_get_d_row(imagfd, cell_imag, i); for (j = 0; j < cols; j++) { data[C(i, j)][0] = cell_real[j]; data[C(i, j)][1] = cell_imag[j]; } G_percent(i+1, rows, 2); } /* close input cell maps */ Rast_close(realfd); Rast_close(imagfd); /* Read in cell map values */ G_message(_("Masking raster maps...")); maskfd = Rast_maskfd(); if (maskfd >= 0) { maskbuf = Rast_allocate_c_buf(); for (i = 0; i < rows; i++) { Rast_get_c_row(maskfd, maskbuf, i); for (j = 0; j < cols; j++) { if (maskbuf[j] == 0) { data[C(i, j)][0] = 0.0; data[C(i, j)][1] = 0.0; } } G_percent(i+1, rows, 2); } Rast_close(maskfd); G_free(maskbuf); } #define SWAP1(a, b) \ do { \ double temp = (a); \ (a) = (b); \ (b) = temp; \ } while (0) #define SWAP2(a, b) \ do { \ SWAP1(data[(a)][0], data[(b)][0]); \ SWAP1(data[(a)][1], data[(b)][1]); \ } while (0) /* rotate the data array for standard display */ G_message(_("Rotating data...")); for (i = 0; i < rows; i++) for (j = 0; j < cols / 2; j++) SWAP2(C(i, j), C(i, j + cols / 2)); for (i = 0; i < rows / 2; i++) for (j = 0; j < cols; j++) SWAP2(C(i, j), C(i + rows / 2, j)); /* perform inverse FFT */ G_message(_("Starting Inverse FFT...")); fft2(1, data, totsize, cols, rows); /* open the output cell map */ outputfd = Rast_open_fp_new(Cellmap_orig); /* Write out result to a new cell map */ G_message(_("Writing raster map <%s>..."), Cellmap_orig); for (i = 0; i < rows; i++) { for (j = 0; j < cols; j++) cell_real[j] = data[C(i, j)][0]; Rast_put_d_row(outputfd, cell_real); G_percent(i+1, rows, 2); } Rast_close(outputfd); G_free(cell_real); G_free(cell_imag); fft_colors(Cellmap_orig); /* Release memory resources */ G_free(data); G_done_msg(" "); exit(EXIT_SUCCESS); }