int main(int argc, char *argv[]) { struct GModule *module; struct Option *in_dir_opt, /* options */ *in_stm_opt, *in_elev_opt, *opt_swapsize, *opt_output; struct Flag *flag_segmentation, *flag_catchment_total, *flag_orders_summary; char *filename; int number_of_segs; int order_max; int segmentation, catchment_total, orders_summary; /*flags */ /* initialize GIS environment */ G_gisinit(argv[0]); /* initialize module */ module = G_define_module(); module->description = _("Calculates Horton's statistics for Strahler and Horton ordered networks created with r.stream.order."); G_add_keyword(_("raster")); G_add_keyword(_("hydrology")); G_add_keyword(_("stream network")); G_add_keyword(_("Horton's statistics")); in_stm_opt = G_define_standard_option(G_OPT_R_INPUT); in_stm_opt->key = "stream_rast"; in_stm_opt->description = _("Name of input raster map with stream network"); in_dir_opt = G_define_standard_option(G_OPT_R_INPUT); in_dir_opt->key = "direction"; in_dir_opt->description = _("Name of input flow direction raster map"); in_elev_opt = G_define_standard_option(G_OPT_R_ELEV); opt_swapsize = G_define_option(); opt_swapsize->key = "memory"; opt_swapsize->type = TYPE_INTEGER; opt_swapsize->answer = "300"; opt_swapsize->description = _("Max memory used in memory swap mode (MB)"); opt_swapsize->guisection = _("Memory settings"); opt_output = G_define_standard_option(G_OPT_F_OUTPUT); opt_output->required = NO; opt_output->description = _("Name for output file (if omitted output to stdout)"); flag_segmentation = G_define_flag(); flag_segmentation->key = 'm'; flag_segmentation->description = _("Use memory swap (operation is slow)"); flag_segmentation->guisection = _("Memory settings"); flag_catchment_total = G_define_flag(); flag_catchment_total->key = 'c'; flag_catchment_total->description = _("Print only catchment's statistics"); flag_catchment_total->guisection = _("Print"); flag_orders_summary = G_define_flag(); flag_orders_summary->key = 'o'; flag_orders_summary->description = _("Print only orders' statistics"); flag_orders_summary->guisection = _("Print"); if (G_parser(argc, argv)) /* parser */ exit(EXIT_FAILURE); segmentation = (flag_segmentation->answer != 0); catchment_total = (flag_catchment_total->answer != 0); orders_summary = (flag_orders_summary->answer != 0); filename = opt_output->answer; if (filename != NULL) if (NULL == freopen(filename, "w", stdout)) G_fatal_error(_("Unable to open file '%s' for writing"), filename); nrows = Rast_window_rows(); ncols = Rast_window_cols(); if (!segmentation) { MAP map_dirs, map_streams, map_elevation; CELL **streams, **dirs; FCELL **elevation; G_message(_("All in RAM calculation...")); ram_create_map(&map_streams, CELL_TYPE); ram_read_map(&map_streams, in_stm_opt->answer, 1, CELL_TYPE); ram_create_map(&map_dirs, CELL_TYPE); ram_read_map(&map_dirs, in_dir_opt->answer, 1, CELL_TYPE); ram_create_map(&map_elevation, FCELL_TYPE); ram_read_map(&map_elevation, in_elev_opt->answer, 0, -1); streams = (CELL **) map_streams.map; dirs = (CELL **) map_dirs.map; elevation = (FCELL **) map_elevation.map; order_max = (int)map_streams.max; ram_init_streams(streams, dirs, elevation); ram_calculate_streams(streams, dirs, elevation); ram_calculate_basins(dirs); stats(order_max); if (!catchment_total && !orders_summary) print_stats(order_max); if (catchment_total) print_stats_total(); if (orders_summary) print_stats_orders(order_max); G_free(stat_streams); G_free(ord_stats); ram_release_map(&map_streams); ram_release_map(&map_dirs); ram_release_map(&map_elevation); } if (segmentation) { SEG map_dirs, map_streams, map_elevation; SEGMENT *streams, *dirs, *elevation; G_message(_("Memory swap calculation (may take some time)...")); number_of_segs = (int)atof(opt_swapsize->answer); number_of_segs = number_of_segs < 32 ? (int)(32 / 0.18) : number_of_segs / 0.18; seg_create_map(&map_streams, SROWS, SCOLS, number_of_segs, CELL_TYPE); seg_read_map(&map_streams, in_stm_opt->answer, 1, CELL_TYPE); seg_create_map(&map_dirs, SROWS, SCOLS, number_of_segs, CELL_TYPE); seg_read_map(&map_dirs, in_dir_opt->answer, 1, CELL_TYPE); seg_create_map(&map_elevation, SROWS, SCOLS, number_of_segs, FCELL_TYPE); seg_read_map(&map_elevation, in_elev_opt->answer, 0, -1); streams = &map_streams.seg; dirs = &map_dirs.seg; elevation = &map_elevation.seg; order_max = (int)map_streams.max; seg_init_streams(streams, dirs, elevation); seg_calculate_streams(streams, dirs, elevation); seg_calculate_basins(dirs); stats(order_max); if (!catchment_total && !orders_summary) print_stats(order_max); if (catchment_total) print_stats_total(); if (orders_summary) print_stats_orders(order_max); G_free(stat_streams); G_free(ord_stats); seg_release_map(&map_streams); seg_release_map(&map_dirs); seg_release_map(&map_elevation); } exit(EXIT_SUCCESS); }
/* ************************************************************************* */ 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; }
/* Process the raster and do atmospheric corrections. Params: * INPUT FILE ifd: input file descriptor iref: input file has radiance values (default is reflectance) ? iscale: input file's range (default is min = 0, max = 255) ialt_fd: height map file descriptor, negative if global value is used ivis_fd: visibility map file descriptor, negative if global value is used * OUTPUT FILE ofd: output file descriptor oflt: if true use FCELL_TYPE for output oscale: output file's range (default is min = 0, max = 255) */ static void process_raster(int ifd, InputMask imask, ScaleRange iscale, int ialt_fd, int ivis_fd, int ofd, bool oint, ScaleRange oscale) { FCELL *buf; /* buffer for the input values */ FCELL *alt = NULL; /* buffer for the elevation values */ FCELL *vis = NULL; /* buffer for the visibility values */ FCELL prev_alt = -1.f; FCELL prev_vis = -1.f; int row, col, nrows, ncols; /* switch on optimization automatically if elevation and/or visibility map is given */ bool optimize = (ialt_fd >= 0 || ivis_fd >= 0); #ifdef _NO_OPTIMIZE_ optimize = false; #endif /* do initial computation with global elevation and visibility values */ TransformInput ti; ti = compute(); /* use a cache to increase computation speed when an elevation map * and/or a visibility map is given */ TICache ticache; /* allocate memory for buffers */ buf = (FCELL *) Rast_allocate_buf(FCELL_TYPE); if (ialt_fd >= 0) alt = (FCELL *) Rast_allocate_buf(FCELL_TYPE); if (ivis_fd >= 0) vis = (FCELL *) Rast_allocate_buf(FCELL_TYPE); nrows = Rast_window_rows(); ncols = Rast_window_cols(); for (row = 0; row < nrows; row++) { G_percent(row, nrows, 1); /* keep the user informed of our progress */ /* read the next row */ Rast_get_row(ifd, buf, row, FCELL_TYPE); /* read the next row of elevation values */ if (ialt_fd >= 0) Rast_get_row(ialt_fd, alt, row, FCELL_TYPE); /* read the next row of elevation values */ if (ivis_fd >= 0) Rast_get_row(ivis_fd, vis, row, FCELL_TYPE); /* loop over all the values in the row */ for (col = 0; col < ncols; col++) { if ((vis && Rast_is_f_null_value(&vis[col])) || (alt && Rast_is_f_null_value(&alt[col])) || Rast_is_f_null_value(&buf[col])) { Rast_set_f_null_value(&buf[col], 1); continue; } if (ialt_fd >= 0) { if (alt[col] < 0) alt[col] = 0; /* on or below sea level, all the same for 6S */ else alt[col] /= 1000.0f; /* converting to km from input which should be in meter */ /* round to nearest altitude bin */ /* rounding result: watch out for fp representation error */ alt[col] = ((int) (alt[col] * BIN_ALT + 0.5)) / BIN_ALT; } if (ivis_fd >= 0) { if (vis[col] < 0) vis[col] = 0; /* negative visibility is invalid, print a WARNING ? */ /* round to nearest visibility bin */ /* rounding result: watch out for fp representation error */ vis[col] = ((int) (vis[col] + 0.5)); } /* check if both maps are active and if whether any value has changed */ if ((ialt_fd >= 0) && (ivis_fd >= 0) && ((prev_vis != vis[col]) || (prev_alt != alt[col]))) { prev_alt = alt[col]; /* update new values */ prev_vis = vis[col]; if (optimize) { int in_cache = ticache.search(alt[col], vis[col], &ti); if (!in_cache) { pre_compute_hv(alt[col], vis[col]); /* re-compute transformation inputs */ ti = compute(); /* ... */ ticache.add(ti, alt[col], vis[col]); } } else { pre_compute_hv(alt[col], vis[col]); /* re-compute transformation inputs */ ti = compute(); /* ... */ } } else { /* only one of the maps is being used */ if ((ivis_fd >= 0) && (prev_vis != vis[col])) { prev_vis = vis[col]; /* keep track of previous visibility */ if (optimize) { int in_cache = ticache.search(0, vis[col], &ti); if (!in_cache) { pre_compute_v(vis[col]); /* re-compute transformation inputs */ ti = compute(); /* ... */ ticache.add(ti, 0, vis[col]); } } else { pre_compute_v(vis[col]); /* re-compute transformation inputs */ ti = compute(); /* ... */ } } if ((ialt_fd >= 0) && (prev_alt != alt[col])) { prev_alt = alt[col]; /* keep track of previous altitude */ if (optimize) { int in_cache = ticache.search(alt[col], 0, &ti); if (!in_cache) { pre_compute_h(alt[col]); /* re-compute transformation inputs */ ti = compute(); /* ... */ ticache.add(ti, alt[col], 0); } } else { pre_compute_h(alt[col]); /* re-compute transformation inputs */ ti = compute(); /* ... */ } } } G_debug(3, "Computed r%d (%d), c%d (%d)", row, nrows, col, ncols); /* transform from iscale.[min,max] to [0,1] */ buf[col] = (buf[col] - iscale.min) / ((float)iscale.max - (float)iscale.min); buf[col] = transform(ti, imask, buf[col]); /* transform from [0,1] to oscale.[min,max] */ buf[col] = buf[col] * ((float)oscale.max - (float)oscale.min) + oscale.min; if (oint && (buf[col] > (float)oscale.max)) G_warning(_("The output data will overflow. Reflectance > 100%%")); } /* write output */ if (oint) write_fp_to_cell(ofd, buf); else Rast_put_row(ofd, buf, FCELL_TYPE); } G_percent(1, 1, 1); /* free allocated memory */ G_free(buf); if (ialt_fd >= 0) G_free(alt); if (ivis_fd >= 0) G_free(vis); }
int centroids(int fd, /* File descriptor of map layer to process */ /* This file is assumed to be opened before calling */ /* centroids. */ unsigned long *e, unsigned long *n, /* Pointers to arrays at least max+1 long */ int method, /* 0, 1, or 2; see above. */ int max) { /* Highest positive cat number in map layer */ CELL *cell_buf, v; int i, adjusted, numb, left, right; long int *count; int row, col, rows, cols; adjusted = 0; cell_buf = Rast_allocate_c_buf(); /* space to accumulate counts */ count = (long int *)G_malloc((max + 1) * sizeof(long int)); /* zero the count totals */ for (i = 1; i <= max; i++) { count[i] = 0; e[i] = 0; n[i] = 0; } /* do rows and columns through window and mask */ /* to do counting */ rows = Rast_window_rows(); cols = Rast_window_cols(); for (row = 0; row < rows; row++) { Rast_get_c_row(fd, cell_buf, row); /* get a row */ for (col = 0; col < cols; col++) { v = cell_buf[col]; /* next cell value in row */ if (v < 1) continue; /* can't handle 0 or - values */ count[v]++; if (method > 0) { /* acccumulate row, col weights */ e[v] += col; n[v] += row; } } } /* compute averages */ if (method > 0) for (i = 0; i <= max; i++) { if (count[i]) { numb = count[i]; e[i] /= numb; n[i] /= numb; } } /* substitute 'count' centroids for 'weighted' ones, if necessary */ if (method == 1) { for (i = 1; i <= max; i++) { if (count[i]) { row = n[i]; col = e[i]; /* get cell at row,col */ Rast_get_c_row(fd, cell_buf, row); v = cell_buf[col]; if (v > 0) { if (v == i) count[i] = 0; /* weighted is acceptable */ else adjusted++; } } } } /* compute middle cell; zeros will remain zeros */ for (i = 1; i <= max; i++) count[i] = (count[i] + 1) / 2; /* go through map again */ for (row = 0; row < rows; row++) { Rast_get_c_row(fd, cell_buf, row); for (col = 0; col < cols; col++) { v = cell_buf[col]; if (v < 1) continue; if (count[v] == 0) continue; if ((--count[v]) == 0) { /* then this is middle cell */ n[v] = row; /* find row-center in this clump */ left = right = col; /* left edge first */ while (left > 0) if (cell_buf[--left] != v) { left++; break; } /* then right edge */ while (right < cols) if (cell_buf[++right] != v) { right--; break; } e[v] = (left + right) / 2; } } } G_free(cell_buf); G_free(count); return (adjusted); } /* end of centroids() */
int main(int argc, char *argv[]) { struct Cell_head cellhd; /* buffer for in out raster */ DCELL *inrast_T, *inrast_RH, *inrast_u2; DCELL *inrast_Rn, *inrast_DEM, *inrast_hc, *outrast; char *EPo; int nrows, ncols; int row, col; int infd_T, infd_RH, infd_u2, infd_Rn, infd_DEM, infd_hc; int outfd; char *T, *RH, *u2, *Rn, *DEM, *hc; DCELL d_T, d_RH, d_u2, d_Rn, d_Z, d_hc; DCELL d_EPo; int d_night; struct History history; struct GModule *module; struct Option *input_DEM, *input_T, *input_RH; struct Option *input_u2, *input_Rn, *input_hc, *output; struct Flag *day, *zero; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("imagery")); G_add_keyword(_("evapotranspiration")); module->description = _("Computes potential evapotranspiration calculation with hourly Penman-Monteith."); /* Define different options */ input_DEM = G_define_standard_option(G_OPT_R_ELEV); input_DEM->description = _("Name of input elevation raster map [m a.s.l.]"); input_T = G_define_standard_option(G_OPT_R_INPUT); input_T->key = "temperature"; input_T->description = _("Name of input temperature raster map [C]"); input_RH = G_define_standard_option(G_OPT_R_INPUT); input_RH->key = "relativehumidity"; input_RH->description = _("Name of input relative humidity raster map [%]"); input_u2 = G_define_standard_option(G_OPT_R_INPUT); input_u2->key = "windspeed"; input_u2->description = _("Name of input wind speed raster map [m/s]"); input_Rn = G_define_standard_option(G_OPT_R_INPUT); input_Rn->key = "netradiation"; input_Rn->description = _("Name of input net solar radiation raster map [MJ/m2/h]"); input_hc = G_define_standard_option(G_OPT_R_INPUT); input_hc->key = "cropheight"; input_hc->description = _("Name of input crop height raster map [m]"); output = G_define_standard_option(G_OPT_R_OUTPUT); _("Name for output raster map [mm/h]"); zero = G_define_flag(); zero->key = 'z'; zero->description = _("Set negative evapotranspiration to zero"); day = G_define_flag(); day->key = 'n'; day->description = _("Use Night-time"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); /* get entered parameters */ T = input_T->answer; RH = input_RH->answer; u2 = input_u2->answer; Rn = input_Rn->answer; EPo = output->answer; DEM = input_DEM->answer; hc = input_hc->answer; if (day->answer) { d_night = TRUE; } else { d_night = FALSE; } infd_T = Rast_open_old(T, ""); infd_RH = Rast_open_old(RH, ""); infd_u2 = Rast_open_old(u2, ""); infd_Rn = Rast_open_old(Rn, ""); infd_DEM = Rast_open_old(DEM, ""); infd_hc = Rast_open_old(hc, ""); Rast_get_cellhd(T, "", &cellhd); Rast_get_cellhd(RH, "", &cellhd); Rast_get_cellhd(u2, "", &cellhd); Rast_get_cellhd(Rn, "", &cellhd); Rast_get_cellhd(DEM, "", &cellhd); Rast_get_cellhd(hc, "", &cellhd); /* Allocate input buffer */ inrast_T = Rast_allocate_d_buf(); inrast_RH = Rast_allocate_d_buf(); inrast_u2 = Rast_allocate_d_buf(); inrast_Rn = Rast_allocate_d_buf(); inrast_DEM = Rast_allocate_d_buf(); inrast_hc = Rast_allocate_d_buf(); /* Allocate output buffer */ nrows = Rast_window_rows(); ncols = Rast_window_cols(); outrast = Rast_allocate_d_buf(); outfd = Rast_open_new(EPo, DCELL_TYPE); for (row = 0; row < nrows; row++) { /* read a line input maps into buffers */ Rast_get_d_row(infd_T, inrast_T, row); Rast_get_d_row(infd_RH, inrast_RH, row); Rast_get_d_row(infd_u2, inrast_u2, row); Rast_get_d_row(infd_Rn, inrast_Rn, row); Rast_get_d_row(infd_DEM, inrast_DEM, row); Rast_get_d_row(infd_hc, inrast_hc, row); /* read every cell in the line buffers */ for (col = 0; col < ncols; col++) { d_T = ((DCELL *) inrast_T)[col]; d_RH = ((DCELL *) inrast_RH)[col]; d_u2 = ((DCELL *) inrast_u2)[col]; d_Rn = ((DCELL *) inrast_Rn)[col]; d_Z = ((DCELL *) inrast_DEM)[col]; d_hc = ((DCELL *) inrast_hc)[col]; /* calculate evapotranspiration */ if (d_hc < 0) { /* calculate evaporation */ d_EPo = calc_openwaterETp(d_T, d_Z, d_u2, d_Rn, d_night, d_RH, d_hc); } else { /* calculate evapotranspiration */ d_EPo = calc_ETp(d_T, d_Z, d_u2, d_Rn, d_night, d_RH, d_hc); } if (zero->answer && d_EPo < 0) d_EPo = 0; ((DCELL *) outrast)[col] = d_EPo; } Rast_put_d_row(outfd, outrast); } G_free(inrast_T); G_free(inrast_RH); G_free(inrast_u2); G_free(inrast_Rn); G_free(inrast_DEM); G_free(inrast_hc); G_free(outrast); Rast_close(infd_T); Rast_close(infd_RH); Rast_close(infd_u2); Rast_close(infd_Rn); Rast_close(infd_DEM); Rast_close(infd_hc); Rast_close(outfd); /* add command line incantation to history file */ Rast_short_history(EPo, "raster", &history); Rast_command_history(&history); Rast_write_history(EPo, &history); exit(EXIT_SUCCESS); }
/* ---------------------------------------------------------------------- */ int main(int argc, char *argv[]) { struct GModule *module; Rtimer rtTotal; char buf[BUFSIZ]; /* initialize GIS library */ G_gisinit(argv[0]); module = G_define_module(); #ifdef ELEV_SHORT module->description = _("Flow computation for massive grids (integer version)."); #endif #ifdef ELEV_FLOAT module->description = _("Flow computation for massive grids (float version)."); #endif G_add_keyword(_("raster")); G_add_keyword(_("hydrology")); /* read user options; fill in global <opt> */ opt = (userOptions*)malloc(sizeof(userOptions)); assert(opt); region = (struct Cell_head*)malloc(sizeof(struct Cell_head)); assert(region); parse_args(argc, argv); /* get the current region and dimensions */ G_get_set_window(region); check_args(); int nr = Rast_window_rows(); int nc = Rast_window_cols(); if ((nr > dimension_type_max) || (nc > dimension_type_max)) { G_fatal_error(_("[nrows=%d, ncols=%d] dimension_type overflow -- " "change dimension_type and recompile"), nr, nc); } else { nrows = (dimension_type)nr; ncols = (dimension_type)nc; } G_verbose_message( _("Region size is %d x %d"), nrows, ncols); /* check STREAM path (the place where intermediate STREAMs are placed) */ sprintf(buf, "%s=%s",STREAM_TMPDIR, opt->streamdir); /* don't pass an automatic variable; putenv() isn't guaranteed to make a copy */ putenv(G_store(buf)); if (getenv(STREAM_TMPDIR) == NULL) { fprintf(stderr, "%s:", STREAM_TMPDIR); G_fatal_error("not set"); } else { fprintf(stderr, "STREAM temporary files in %s ", getenv(STREAM_TMPDIR)); fprintf(stderr, "(THESE INTERMEDIATE STREAMS WILL NOT BE DELETED IN CASE OF ABNORMAL TERMINATION OF THE PROGRAM. TO SAVE SPACE PLEASE DELETE THESE FILES MANUALLY!)\n"); } /* open the stats file */ stats = new statsRecorder(opt->stats); record_args(argc, argv); { char buf[BUFSIZ]; long grid_size = nrows * ncols; *stats << "region size = " << formatNumber(buf, grid_size) << " elts " << "(" << nrows << " rows x " << ncols << " cols)\n"; stats->flush(); } /* set up STREAM memory manager */ size_t mm_size = (size_t) opt->mem << 20; /* opt->mem is in MB */ MM_manager.set_memory_limit(mm_size); if (opt->verbose) { MM_manager.warn_memory_limit(); } else { MM_manager.ignore_memory_limit(); } MM_manager.print_limit_mode(); /* initialize nodata */ nodataType::init(); *stats << "internal nodata value: " << nodataType::ELEVATION_NODATA << endl; /* start timing -- after parse_args, which are interactive */ rt_start(rtTotal); #ifndef JUMP2FLOW /* read elevation into a stream */ AMI_STREAM<elevation_type> *elstr=NULL; long nodata_count; elstr = cell2stream<elevation_type>(opt->elev_grid, elevation_type_max, &nodata_count); /* print the largest interm file that will be generated */ printMaxSortSize(nodata_count); /* -------------------------------------------------- */ /* compute flow direction and filled elevation (and watersheds) */ AMI_STREAM<direction_type> *dirstr=NULL; AMI_STREAM<elevation_type> *filledstr=NULL; AMI_STREAM<waterWindowBaseType> *flowStream=NULL; AMI_STREAM<labelElevType> *labeledWater = NULL; flowStream=computeFlowDirections(elstr, filledstr, dirstr, labeledWater); delete elstr; /* write streams to GRASS raster maps */ stream2_CELL(dirstr, nrows, ncols, opt->dir_grid); delete dirstr; #ifdef ELEV_SHORT stream2_CELL(filledstr, nrows, ncols, opt->filled_grid); #else stream2_CELL(filledstr, nrows, ncols, opt->filled_grid,true); #endif delete filledstr; stream2_CELL(labeledWater, nrows, ncols, labelElevTypePrintLabel(), opt->watershed_grid); setSinkWatershedColorTable(opt->watershed_grid); delete labeledWater; #else AMI_STREAM<waterWindowBaseType> *flowStream; char path[GPATH_MAX]; sprintf(path, "%s/flowStream", streamdir->answer); flowStream = new AMI_STREAM<waterWindowBaseType>(path); fprintf(stderr, "flowStream opened: len=%d\n", flowStream->stream_len()); fprintf(stderr, "jumping to flow accumulation computation\n"); #endif /* -------------------------------------------------- */ /* compute flow accumulation (and tci) */ AMI_STREAM<sweepOutput> *outstr=NULL; computeFlowAccumulation(flowStream, outstr); /* delete flowStream -- deleted inside */ /* write output stream to GRASS raster maps */ #ifdef OUTPUT_TCI stream2_FCELL(outstr, nrows, ncols, printAccumulation(), printTci(), opt->flowaccu_grid, opt->tci_grid); #else stream2_FCELL(outstr, nrows, ncols, printAccumulation(), opt->flowaccu_grid); #endif setFlowAccuColorTable(opt->flowaccu_grid); delete outstr; rt_stop(rtTotal); stats->recordTime("Total running time: ", rtTotal); stats->timestamp("end"); G_done_msg(" "); /* free the globals */ free(region); free(opt); delete stats; return 0; }
/* ************************************************************************* */ int main(int argc, char *argv[]) { RASTER3D_Region region, inputmap_bounds; struct Cell_head region2d; struct GModule *module; struct History history; void *map = NULL; /*The 3D Rastermap */ int i = 0, changemask = 0; int *fd = NULL, output_type, cols, rows; char *RasterFileName; int overwrite = 0; /* Initialize GRASS */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster3d")); G_add_keyword(_("raster")); G_add_keyword(_("voxel")); module->description = _("Converts 3D raster maps to 2D raster maps"); /* 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); /*Set the defaults */ Rast3d_init_defaults(); /*Set the resolution of the output maps */ if (param.res->answer) { /*Open the map with current region */ map = Rast3d_open_cell_old(param.input->answer, G_find_raster3d(param.input->answer, ""), RASTER3D_DEFAULT_WINDOW, RASTER3D_TILE_SAME_AS_FILE, RASTER3D_USE_CACHE_DEFAULT); if (map == NULL) Rast3d_fatal_error(_("Error opening 3D raster map <%s>"), param.input->answer); /*Get the region of the map */ Rast3d_get_region_struct_map(map, ®ion); /*set this region as current 3D window for map */ Rast3d_set_window_map(map, ®ion); /*Set the 2d region appropriate */ Rast3d_extract2d_region(®ion, ®ion2d); /*Make the new 2d region the default */ Rast_set_window(®ion2d); } else { /* Figure out the region from the map */ Rast3d_get_window(®ion); /*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(_("Error opening 3D raster map <%s>"), param.input->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 3D window 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(®ion2d); region.ns_res = region2d.ns_res; region.ew_res = region2d.ew_res; region.rows = region2d.rows; region.cols = region2d.cols; Rast3d_adjust_region(®ion); Rast3d_set_window_map(map, ®ion); } /* save the input map region for later use (history meta-data) */ Rast3d_get_region_struct_map(map, &inputmap_bounds); /*Get the output type */ output_type = Rast3d_file_type_map(map); /*prepare the filehandler */ fd = (int *) G_malloc(region.depths * sizeof (int)); if (fd == NULL) fatal_error(map, NULL, 0, _("Out of memory")); G_message(_("Creating %i raster maps"), region.depths); /*Loop over all output maps! open */ for (i = 0; i < region.depths; i++) { /*Create the outputmaps */ G_asprintf(&RasterFileName, "%s_%05d", param.output->answer, i + 1); G_message(_("Raster map %i Filename: %s"), i + 1, RasterFileName); overwrite = G_check_overwrite(argc, argv); if (G_find_raster2(RasterFileName, "") && !overwrite) G_fatal_error(_("Raster map %d Filename: %s already exists. Use the flag --o to overwrite."), i + 1, RasterFileName); if (output_type == FCELL_TYPE) fd[i] = open_output_map(RasterFileName, FCELL_TYPE); else if (output_type == DCELL_TYPE) fd[i] = open_output_map(RasterFileName, 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 */ g3d_to_raster(map, region, fd); /*Loop over all output maps! close */ for (i = 0; i < region.depths; i++) { close_output_map(fd[i]); /* write history */ G_asprintf(&RasterFileName, "%s_%i", param.output->answer, i + 1); G_debug(4, "Raster map %d Filename: %s", i + 1, RasterFileName); Rast_short_history(RasterFileName, "raster", &history); Rast_set_history(&history, HIST_DATSRC_1, "3D Raster map:"); Rast_set_history(&history, HIST_DATSRC_2, param.input->answer); Rast_append_format_history(&history, "Level %d of %d", i + 1, region.depths); Rast_append_format_history(&history, "Level z-range: %f to %f", region.bottom + (i * region.tb_res), region.bottom + (i + 1 * region.tb_res)); Rast_append_format_history(&history, "Input map full z-range: %f to %f", inputmap_bounds.bottom, inputmap_bounds.top); Rast_append_format_history(&history, "Input map z-resolution: %f", inputmap_bounds.tb_res); if (!param.res->answer) { Rast_append_format_history(&history, "GIS region full z-range: %f to %f", region.bottom, region.top); Rast_append_format_history(&history, "GIS region z-resolution: %f", region.tb_res); } Rast_command_history(&history); Rast_write_history(RasterFileName, &history); } /*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); } /*Cleaning */ if (RasterFileName) G_free(RasterFileName); if (fd) G_free(fd); /* Close files and exit */ if (!Rast3d_close(map)) fatal_error(map, NULL, 0, _("Unable to close 3D raster map")); map = NULL; return (EXIT_SUCCESS); }
int main(int argc, char *argv[]) { char *input; char *output; char *title; char *temp; FILE *fd, *ft; int cf, direction, sz; struct Cell_head cellhd; struct History history; void *rast, *rast_ptr; int row, col; int nrows, ncols; double x; char y[128]; struct GModule *module; struct { struct Option *input, *output, *title, *mult, *nv, *type; } parm; struct { struct Flag *s; } flag; char *null_val_str; DCELL mult; RASTER_MAP_TYPE data_type; double atof(); G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("import")); G_add_keyword(_("conversion")); G_add_keyword("ASCII"); module->description = _("Converts a GRASS ASCII raster file to binary raster map."); parm.input = G_define_standard_option(G_OPT_F_INPUT); parm.input->label = _("Name of input file to be imported"); parm.input->description = _("'-' for standard input"); parm.output = G_define_standard_option(G_OPT_R_OUTPUT); parm.type = G_define_option(); parm.type->key = "type"; parm.type->type = TYPE_STRING; parm.type->required = NO; parm.type->options = "CELL,FCELL,DCELL"; parm.type->label = _("Storage type for resultant raster map"); parm.type->description = _("Default: CELL for integer values, DCELL for floating-point values"); 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 for resultant raster map"); parm.mult = G_define_option(); parm.mult->key = "multiplier"; parm.mult->type = TYPE_DOUBLE; parm.mult->description = _("Default: read from header"); parm.mult->required = NO; parm.mult->label = _("Multiplier for ASCII data"); parm.nv = G_define_standard_option(G_OPT_M_NULL_VALUE); parm.nv->description = _("Default: read from header"); parm.nv->label = _("String representing NULL value data cell"); parm.nv->guisection = _("NULL data"); flag.s = G_define_flag(); flag.s->key = 's'; flag.s->description = _("SURFER (Golden Software) ASCII file will be imported"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); input = parm.input->answer; output = parm.output->answer; temp = G_tempfile(); ft = fopen(temp, "w+"); if (ft == NULL) G_fatal_error(_("Unable to open temporary file <%s>"), temp); if ((title = parm.title->answer)) G_strip(title); if (!parm.mult->answer) Rast_set_d_null_value(&mult, 1); else if ((sscanf(parm.mult->answer, "%lf", &mult)) != 1) G_fatal_error(_("Wrong entry for multiplier: %s"), parm.mult->answer); null_val_str = parm.nv->answer; data_type = -1; if (parm.type->answer) { switch(parm.type->answer[0]) { case 'C': data_type = CELL_TYPE; break; case 'F': data_type = FCELL_TYPE; break; case 'D': data_type = DCELL_TYPE; break; } } if (strcmp(input, "-") == 0) { Tmp_file = G_tempfile(); if (NULL == (Tmp_fd = fopen(Tmp_file, "w+"))) G_fatal_error(_("Unable to open temporary file <%s>"), Tmp_file); unlink(Tmp_file); if (0 > file_cpy(stdin, Tmp_fd)) G_fatal_error(_("Unable to read input from stdin")); fd = Tmp_fd; } else fd = fopen(input, "r"); if (fd == NULL) { G_fatal_error(_("Unable to read input from <%s>"), input); } direction = 1; sz = 0; if (flag.s->answer) { sz = getgrdhead(fd, &cellhd); /* for Surfer files, the data type is always FCELL_TYPE, the multiplier and the null_val_str are never used */ data_type = FCELL_TYPE; mult = 1.; null_val_str = ""; /* rows in surfer files are ordered from bottom to top, opposite of normal GRASS ordering */ direction = -1; } else sz = gethead(fd, &cellhd, &data_type, &mult, &null_val_str); if (!sz) G_fatal_error(_("Can't get cell header")); nrows = cellhd.rows; ncols = cellhd.cols; Rast_set_window(&cellhd); if (nrows != Rast_window_rows()) G_fatal_error(_("OOPS: rows changed from %d to %d"), nrows, Rast_window_rows()); if (ncols != Rast_window_cols()) G_fatal_error(_("OOPS: cols changed from %d to %d"), ncols, Rast_window_cols()); rast_ptr = Rast_allocate_buf(data_type); rast = rast_ptr; cf = Rast_open_new(output, data_type); for (row = 0; row < nrows; row++) { G_percent(row, nrows, 2); for (col = 0; col < ncols; col++) { if (fscanf(fd, "%s", y) != 1) { Rast_unopen(cf); G_fatal_error(_("Data conversion failed at row %d, col %d"), row + 1, col + 1); } if (strcmp(y, null_val_str)) { x = atof(y); if ((float)x == GS_BLANK) { Rast_set_null_value(rast_ptr, 1, data_type); } else { Rast_set_d_value(rast_ptr, (DCELL) (x * mult), data_type); } } else { Rast_set_null_value(rast_ptr, 1, data_type); } rast_ptr = G_incr_void_ptr(rast_ptr, Rast_cell_size(data_type)); } fwrite(rast, Rast_cell_size(data_type), ncols, ft); rast_ptr = rast; } G_percent(nrows, nrows, 2); G_debug(1, "Creating support files for %s", output); sz = 0; if (direction < 0) { sz = -ncols * Rast_cell_size(data_type); G_fseek(ft, sz, SEEK_END); sz *= 2; } else { G_fseek(ft, 0L, SEEK_SET); } for (row = 0; row < nrows; row += 1) { fread(rast, Rast_cell_size(data_type), ncols, ft); Rast_put_row(cf, rast, data_type); G_fseek(ft, sz, SEEK_CUR); } fclose(ft); unlink(temp); Rast_close(cf); if (title) Rast_put_cell_title(output, title); 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[]) { int nrows, ncols; int row, col; int makin = 0; /*Makin Flag for root zone soil moisture output */ struct GModule *module; struct Option *input1, *input2, *input3, *output1, *output2; struct Flag *flag1; struct History history; /*metadata */ char *result1, *result2; /*output raster name */ int infd_rnet, infd_g0, infd_h0; int outfd1, outfd2; char *rnet, *g0, *h0; void *inrast_rnet, *inrast_g0, *inrast_h0; DCELL * outrast1, *outrast2; /************************************/ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("imagery")); G_add_keyword(_("energy balance")); G_add_keyword(_("soil moisture")); G_add_keyword(_("evaporative fraction")); G_add_keyword(_("SEBAL")); module->description = _("Computes evaporative fraction (Bastiaanssen, 1995) and " "root zone soil moisture (Makin, Molden and Bastiaanssen, 2001)."); /* Define the different options */ input1 = G_define_standard_option(G_OPT_R_INPUT); input1->key = "netradiation"; input1->description = _("Name of Net Radiation raster map [W/m2]"); input2 = G_define_standard_option(G_OPT_R_INPUT); input2->key = "soilheatflux"; input2->description = _("Name of soil heat flux raster map [W/m2]"); input3 = G_define_standard_option(G_OPT_R_INPUT); input3->key = "sensibleheatflux"; input3->description = _("Name of sensible heat flux raster map [W/m2]"); output1 = G_define_standard_option(G_OPT_R_OUTPUT); output1->key = "evaporativefraction"; output1->description = _("Name for output evaporative fraction raster map"); output2 = G_define_standard_option(G_OPT_R_OUTPUT); output2->key = "soilmoisture"; output2->required = NO; output2->description = _("Name for output root zone soil moisture raster map"); flag1 = G_define_flag(); flag1->key = 'm'; flag1->description = _("Root zone soil moisture output (Makin, Molden and Bastiaanssen, 2001)"); /********************/ if (G_parser(argc, argv)) exit(EXIT_FAILURE); rnet = input1->answer; g0 = input2->answer; h0 = input3->answer; result1 = output1->answer; result2 = output2->answer; makin = flag1->answer; /***************************************************/ infd_rnet = Rast_open_old(rnet, ""); inrast_rnet = Rast_allocate_d_buf(); /***************************************************/ infd_g0 = Rast_open_old(g0, ""); inrast_g0 = Rast_allocate_d_buf(); /***************************************************/ infd_h0 = Rast_open_old(h0, ""); inrast_h0 = Rast_allocate_d_buf(); /***************************************************/ nrows = Rast_window_rows(); ncols = Rast_window_cols(); outrast1 = Rast_allocate_d_buf(); if (makin) outrast2 = Rast_allocate_d_buf(); /* Create New raster files */ outfd1 = Rast_open_new(result1, DCELL_TYPE); if (makin) outfd2 = Rast_open_new(result2, DCELL_TYPE); /* Process pixels */ for (row = 0; row < nrows; row++) { DCELL d; DCELL d_rnet; DCELL d_g0; DCELL d_h0; G_percent(row, nrows, 2); /* read input maps */ Rast_get_d_row(infd_rnet, inrast_rnet, row); Rast_get_d_row(infd_g0, inrast_g0, row); Rast_get_d_row(infd_h0, inrast_h0, row); /*process the data */ for (col = 0; col < ncols; col++) { d_rnet = ((DCELL *) inrast_rnet)[col]; d_g0 = ((DCELL *) inrast_g0)[col]; d_h0 = ((DCELL *) inrast_h0)[col]; if (Rast_is_d_null_value(&d_rnet) || Rast_is_d_null_value(&d_g0) || Rast_is_d_null_value(&d_h0)) { Rast_set_d_null_value(&outrast1[col], 1); if (makin) Rast_set_d_null_value(&outrast2[col], 1); } else { /* calculate evaporative fraction */ d = evap_fr(d_rnet, d_g0, d_h0); outrast1[col] = d; /* calculate soil moisture */ if (makin) { d = soilmoisture(d); outrast2[col] = d; } } } Rast_put_d_row(outfd1, outrast1); if (makin) Rast_put_d_row(outfd2, outrast2); } G_free(inrast_rnet); G_free(inrast_g0); G_free(inrast_h0); Rast_close(infd_rnet); Rast_close(infd_g0); Rast_close(infd_h0); G_free(outrast1); Rast_close(outfd1); if (makin) { G_free(outrast2); Rast_close(outfd2); } Rast_short_history(result1, "raster", &history); Rast_command_history(&history); Rast_write_history(result1, &history); if (makin) { Rast_short_history(result2, "raster", &history); Rast_command_history(&history); Rast_write_history(result2, &history); } exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { struct Cell_head cellhd; /*region+header info */ char *mapset; /*mapset name */ int nrows, ncols; int row, col; struct GModule *module; struct Option *input, *output; struct Option *input1, *input2; struct Flag *flag0, *flag1, *flag2; struct Flag *flag3, *flag4, *flag5; struct History history; /*metadata */ /************************************/ char *name; /*input raster name */ char *result; /*output raster name */ /*Prepare new names for output files */ char result0[GNAME_MAX], result1[GNAME_MAX]; char result2[GNAME_MAX], result3[GNAME_MAX]; char result4[GNAME_MAX], result5[GNAME_MAX]; char result6[GNAME_MAX], result7[GNAME_MAX]; char result8[GNAME_MAX], result9[GNAME_MAX]; char result10[GNAME_MAX], result11[GNAME_MAX]; char result12[GNAME_MAX], result13[GNAME_MAX]; char result14[GNAME_MAX]; /*File Descriptors */ int infd[MAXFILES]; int outfd[MAXFILES]; char **names, **ptr; /* For some strange reason infd[0] cannot be used later */ /* So nfiles is initialized with nfiles = 1 */ int nfiles = 1; int i = 0, j = 0; int radiance = 0; void *inrast[MAXFILES]; DCELL *outrast[MAXFILES]; RASTER_MAP_TYPE in_data_type[MAXFILES]; RASTER_MAP_TYPE out_data_type = DCELL_TYPE; /* 0=numbers 1=text */ double gain[MAXFILES], offset[MAXFILES]; double kexo[MAXFILES]; double doy, sun_elevation; /************************************/ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("imagery")); G_add_keyword(_("radiometric conversion")); G_add_keyword(_("radiance")); G_add_keyword(_("reflectance")); G_add_keyword(_("brightness temperature")); G_add_keyword(_("satellite")); G_add_keyword(_("ASTER")); module->description = _("Calculates Top of Atmosphere Radiance/Reflectance/Brightness Temperature from ASTER DN.\n"); /* Define the different options */ input = G_define_standard_option(G_OPT_R_INPUTS); input->description = _("Names of ASTER DN layers (15 layers)"); input1 = G_define_option(); input1->key = "dayofyear"; input1->type = TYPE_DOUBLE; input1->required = YES; input1->gisprompt = "value"; input1->description = _("Day of Year of satellite overpass [0-366]"); input2 = G_define_option(); input2->key = "sun_elevation"; input2->type = TYPE_DOUBLE; input2->required = YES; input2->gisprompt = "value"; input2->description = _("Sun elevation angle (degrees, < 90.0)"); output = G_define_standard_option(G_OPT_R_OUTPUT); output->description = _("Base name of the output layers (will add .x)"); /* Define the different flags */ flag0 = G_define_flag(); flag0->key = 'r'; flag0->description = _("Output is radiance (W/m2)"); flag1 = G_define_flag(); flag1->key = 'a'; flag1->description = _("VNIR is High Gain"); flag2 = G_define_flag(); flag2->key = 'b'; flag2->description = _("SWIR is High Gain"); flag3 = G_define_flag(); flag3->key = 'c'; flag3->description = _("VNIR is Low Gain 1"); flag4 = G_define_flag(); flag4->key = 'd'; flag4->description = _("SWIR is Low Gain 1"); flag5 = G_define_flag(); flag5->key = 'e'; flag5->description = _("SWIR is Low Gain 2"); /********************/ if (G_parser(argc, argv)) exit(EXIT_FAILURE); names = input->answers; ptr = input->answers; doy = atof(input1->answer); sun_elevation = atof(input2->answer); result = output->answer; radiance = (flag0->answer); /********************/ /*Prepare the output file names */ /********************/ sprintf(result0,"%s%s", result, ".1"); sprintf(result1,"%s%s", result, ".2"); sprintf(result2,"%s%s", result, ".3N"); sprintf(result3,"%s%s", result, ".3B"); sprintf(result4,"%s%s", result, ".4"); sprintf(result5,"%s%s", result, ".5"); sprintf(result6,"%s%s", result, ".6"); sprintf(result7,"%s%s", result, ".7"); sprintf(result8,"%s%s", result, ".8"); sprintf(result9,"%s%s", result, ".9"); sprintf(result10,"%s%s", result, ".10"); sprintf(result11,"%s%s", result, ".11"); sprintf(result12,"%s%s", result, ".12"); sprintf(result13,"%s%s", result, ".13"); sprintf(result14,"%s%s", result, ".14"); /********************/ /*Prepare radiance boundaries */ /********************/ int gain_code = 1; for (i = 0; i < MAXFILES; i++) { /*0 - High (Not Applicable for band 10-14: TIR) */ /*1 - Normal */ /*2 - Low 1(Not Applicable for band 10-14: TIR) */ /*3 - Low 2(Not Applicable for Band 1-3N/B & 10-14) */ if (flag1->answer && i <= 3) gain_code = 0; if (flag2->answer && i >= 4 && i <= 9) gain_code = 0; if (flag3->answer && i <= 3) gain_code = 2; if (flag4->answer && i >= 4 && i <= 9) gain_code = 2; if (flag5->answer && i >= 4 && i <= 9) gain_code = 3; gain[i] = gain_aster(i, gain_code); /* Reset to NORMAL GAIN */ gain_code = 1; } /********************/ /*Prepare sun exo-atm irradiance */ /********************/ kexo[0] = KEXO1; kexo[1] = KEXO2; kexo[2] = KEXO3; kexo[3] = KEXO3; kexo[4] = KEXO4; kexo[5] = KEXO5; kexo[6] = KEXO6; kexo[7] = KEXO7; kexo[8] = KEXO8; kexo[9] = KEXO9; /********************/ /********************/ for (; *ptr != NULL; ptr++) { if (nfiles > MAXFILES) G_fatal_error(_("Too many input maps. Only %d allowed."), MAXFILES); name = *ptr; /* Allocate input buffer */ in_data_type[nfiles-1] = Rast_map_type(name, ""); /* For some strange reason infd[0] cannot be used later */ /* So nfiles is initialized with nfiles = 1 */ infd[nfiles] = Rast_open_old(name, ""); Rast_get_cellhd(name, "", &cellhd); inrast[nfiles-1] = Rast_allocate_buf(in_data_type[nfiles-1]); nfiles++; } nfiles--; if (nfiles < MAXFILES) G_fatal_error(_("The input band number should be 15")); /***************************************************/ /* Allocate output buffer, use input map data_type */ nrows = Rast_window_rows(); ncols = Rast_window_cols(); out_data_type = DCELL_TYPE; for (i = 0; i < MAXFILES; i++) outrast[i] = Rast_allocate_buf(out_data_type); outfd[1] = Rast_open_new(result0, 1); outfd[2] = Rast_open_new(result1, 1); outfd[3] = Rast_open_new(result2, 1); outfd[4] = Rast_open_new(result3, 1); outfd[5] = Rast_open_new(result4, 1); outfd[6] = Rast_open_new(result5, 1); outfd[7] = Rast_open_new(result6, 1); outfd[8] = Rast_open_new(result7, 1); outfd[9] = Rast_open_new(result8, 1); outfd[10] = Rast_open_new(result9, 1); outfd[11] = Rast_open_new(result10, 1); outfd[12] = Rast_open_new(result11, 1); outfd[13] = Rast_open_new(result12, 1); outfd[14] = Rast_open_new(result13, 1); outfd[15] = Rast_open_new(result14, 1); /* Process pixels */ DCELL dout[MAXFILES]; DCELL d[MAXFILES]; for (row = 0; row < nrows; row++) { G_percent(row, nrows, 2); /* read input map */ for (i = 1; i <= MAXFILES; i++) Rast_get_row(infd[i], inrast[i-1], row, in_data_type[i-1]); /*process the data */ for (col = 0; col < ncols; col++) { for (i = 0; i < MAXFILES; i++) { switch (in_data_type[i]) { case CELL_TYPE: d[i] = (double)((CELL *) inrast[i])[col]; break; case FCELL_TYPE: d[i] = (double)((FCELL *) inrast[i])[col]; break; case DCELL_TYPE: d[i] = (double)((DCELL *) inrast[i])[col]; break; } /* if radiance mode or Thermal band */ if (radiance || i >= 10) { dout[i] = gain[i] * (d[i] - 1.0); } /* if reflectance default mode and Not Thermal Band */ else { dout[i] = gain[i] * (d[i] - 1.0); dout[i] = rad2ref_aster(dout[i], doy, sun_elevation, kexo[i]); } outrast[i][col] = dout[i]; } } for (i = 1; i <= MAXFILES; i++) Rast_put_row(outfd[i], outrast[i-1], out_data_type); } for (i = 1; i <= MAXFILES; i++) { G_free(inrast[i-1]); Rast_close(infd[i]); G_free(outrast[i-1]); Rast_close(outfd[i]); } exit(EXIT_SUCCESS); }
int main(int argc, char **argv) { long i; int band, rows, cols; CELL *rowbuffer[3]; struct Option *opt_hue, *opt_red; struct Option *opt_inten, *opt_green; struct Option *opt_sat, *opt_blue; struct GModule *module; int fd_input[3]; int fd_output[3]; /* Initialize GIS engine */ G_gisinit(argv[0]); /* Set description */ module = G_define_module(); G_add_keyword(_("imagery")); G_add_keyword(_("color transformation")); G_add_keyword(_("RGB")); G_add_keyword(_("HIS")); module->description = _("Transforms raster maps from RGB (Red-Green-Blue) color space to " "HIS (Hue-Intensity-Saturation) color space."); /* Define the different options */ opt_red = G_define_standard_option(G_OPT_R_INPUT); opt_red->key = "red_input"; opt_red->description = _("Name of input raster map (red)"); opt_green = G_define_standard_option(G_OPT_R_INPUT); opt_green->key = "green_input"; opt_green->description = _("Name of input raster map (green)"); opt_blue = G_define_standard_option(G_OPT_R_INPUT); opt_blue->key = "blue_input"; opt_blue->description = _("Name of input raster map (blue)"); opt_hue = G_define_standard_option(G_OPT_R_OUTPUT); opt_hue->key = "hue_output"; opt_hue->description = _("Name for output raster map (hue)"); opt_inten = G_define_standard_option(G_OPT_R_OUTPUT); opt_inten->key = "intensity_output"; opt_inten->description = _("Name for output raster map (intensity)"); opt_sat = G_define_standard_option(G_OPT_R_OUTPUT); opt_sat->key = "saturation_output"; opt_sat->description = _("Name for output raster map (saturation)"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); /* get dimension of the image */ rows = Rast_window_rows(); cols = Rast_window_cols(); openfiles(opt_red->answer, opt_green->answer, opt_blue->answer, opt_hue->answer, opt_inten->answer, opt_sat->answer, fd_input, fd_output, rowbuffer); for (i = 0; i < rows; i++) { /* read in a row from each cell map */ G_percent(i, rows, 2); for (band = 0; band < 3; band++) Rast_get_c_row(fd_input[band], rowbuffer[band], i); /* process this row of the map */ rgb2his(rowbuffer, cols); /* write out the new row for each cell map */ for (band = 0; band < 3; band++) Rast_put_row(fd_output[band], rowbuffer[band], CELL_TYPE); } G_percent(i, rows, 2); closefiles(opt_hue->answer, opt_inten->answer, opt_sat->answer, fd_output, rowbuffer); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { struct Cell_head cellhd; /* buffer for in, tmp and out raster */ void *inrast_Rn, *inrast_g0; void *inrast_z0m, *inrast_t0dem; DCELL *outrast; int nrows, ncols; int row, col; int row_wet, col_wet; int row_dry, col_dry; double m_row_wet, m_col_wet; double m_row_dry, m_col_dry; int infd_Rn, infd_g0; int infd_z0m, infd_t0dem; int outfd; char *Rn, *g0; char *z0m, *t0dem; char *h0; double ustar, ea; struct History history; struct GModule *module; struct Option *input_Rn, *input_g0; struct Option *input_z0m, *input_t0dem, *input_ustar; struct Option *input_ea, *output; struct Option *input_row_wet, *input_col_wet; struct Option *input_row_dry, *input_col_dry; struct Flag *flag2, *flag3; /********************************/ double xp, yp; double xmin, ymin; double xmax, ymax; double stepx, stepy; double latitude, longitude; int rowDry, colDry, rowWet, colWet; /********************************/ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("imagery")); G_add_keyword(_("energy balance")); G_add_keyword(_("soil moisture")); G_add_keyword(_("evaporative fraction")); G_add_keyword(_("SEBAL")); module->description = _("Computes sensible heat flux iteration SEBAL 01."); /* Define different options */ input_Rn = G_define_standard_option(G_OPT_R_INPUT); input_Rn->key = "netradiation"; input_Rn->description = _("Name of instantaneous net radiation raster map [W/m2]"); input_g0 = G_define_standard_option(G_OPT_R_INPUT); input_g0->key = "soilheatflux"; input_g0->description = _("Name of instantaneous soil heat flux raster map [W/m2]"); input_z0m = G_define_standard_option(G_OPT_R_INPUT); input_z0m->key = "aerodynresistance"; input_z0m->description = _("Name of aerodynamic resistance to heat momentum raster map [s/m]"); input_t0dem = G_define_standard_option(G_OPT_R_INPUT); input_t0dem->key = "temperaturemeansealevel"; input_t0dem->description = _("Name of altitude corrected surface temperature raster map [K]"); input_ustar = G_define_option(); input_ustar->key = "frictionvelocitystar"; input_ustar->type = TYPE_DOUBLE; input_ustar->required = YES; input_ustar->gisprompt = "old,value"; input_ustar->answer = "0.32407"; input_ustar->description = _("Value of the height independent friction velocity (u*) [m/s]"); input_ustar->guisection = _("Parameters"); input_ea = G_define_option(); input_ea->key = "vapourpressureactual"; input_ea->type = TYPE_DOUBLE; input_ea->required = YES; input_ea->answer = "1.511"; input_ea->description = _("Value of the actual vapour pressure (e_act) [KPa]"); input_ea->guisection = _("Parameters"); input_row_wet = G_define_option(); input_row_wet->key = "row_wet_pixel"; input_row_wet->type = TYPE_DOUBLE; input_row_wet->required = NO; input_row_wet->description = _("Row value of the wet pixel"); input_row_wet->guisection = _("Parameters"); input_col_wet = G_define_option(); input_col_wet->key = "column_wet_pixel"; input_col_wet->type = TYPE_DOUBLE; input_col_wet->required = NO; input_col_wet->description = _("Column value of the wet pixel"); input_col_wet->guisection = _("Parameters"); input_row_dry = G_define_option(); input_row_dry->key = "row_dry_pixel"; input_row_dry->type = TYPE_DOUBLE; input_row_dry->required = NO; input_row_dry->description = _("Row value of the dry pixel"); input_row_dry->guisection = _("Parameters"); input_col_dry = G_define_option(); input_col_dry->key = "column_dry_pixel"; input_col_dry->type = TYPE_DOUBLE; input_col_dry->required = NO; input_col_dry->description = _("Column value of the dry pixel"); input_col_dry->guisection = _("Parameters"); output = G_define_standard_option(G_OPT_R_OUTPUT); output->description = _("Name for output sensible heat flux raster map [W/m2]"); /* Define the different flags */ flag2 = G_define_flag(); flag2->key = 'a'; flag2->description = _("Automatic wet/dry pixel (careful!)"); flag3 = G_define_flag(); flag3->key = 'c'; flag3->description = _("Dry/Wet pixels coordinates are in image projection, not row/col"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); /* get entered parameters */ Rn = input_Rn->answer; g0 = input_g0->answer; z0m = input_z0m->answer; t0dem = input_t0dem->answer; h0 = output->answer; ustar = atof(input_ustar->answer); ea = atof(input_ea->answer); if(input_row_wet->answer&& input_col_wet->answer&& input_row_dry->answer&& input_col_dry->answer){ m_row_wet = atof(input_row_wet->answer); m_col_wet = atof(input_col_wet->answer); m_row_dry = atof(input_row_dry->answer); m_col_dry = atof(input_col_dry->answer); } if ((!input_row_wet->answer || !input_col_wet->answer || !input_row_dry->answer || !input_col_dry->answer) && !flag2->answer) { G_fatal_error(_("Either auto-mode either wet/dry pixels coordinates should be provided!")); } if (flag3->answer) { G_message(_("Manual wet/dry pixels in image coordinates")); G_message(_("Wet Pixel=> x:%f y:%f"), m_col_wet, m_row_wet); G_message(_("Dry Pixel=> x:%f y:%f"), m_col_dry, m_row_dry); } else { if(flag2->answer) G_message(_("Automatic mode selected")); else { G_message(_("Wet Pixel=> row:%.0f col:%.0f"), m_row_wet, m_col_wet); G_message(_("Dry Pixel=> row:%.0f col:%.0f"), m_row_dry, m_col_dry); } } /* check legal output name */ if (G_legal_filename(h0) < 0) G_fatal_error(_("<%s> is an illegal name"), h0); infd_Rn = Rast_open_old(Rn, ""); infd_g0 = Rast_open_old(g0, ""); infd_z0m = Rast_open_old(z0m, ""); infd_t0dem = Rast_open_old(t0dem, ""); Rast_get_cellhd(Rn, "", &cellhd); Rast_get_cellhd(g0, "", &cellhd); Rast_get_cellhd(z0m, "", &cellhd); Rast_get_cellhd(t0dem, "", &cellhd); /* Allocate input buffer */ inrast_Rn = Rast_allocate_d_buf(); inrast_g0 = Rast_allocate_d_buf(); inrast_z0m = Rast_allocate_d_buf(); inrast_t0dem = Rast_allocate_d_buf(); /***************************************************/ /* Setup pixel location variables */ /***************************************************/ stepx = cellhd.ew_res; stepy = cellhd.ns_res; xmin = cellhd.west; xmax = cellhd.east; ymin = cellhd.south; ymax = cellhd.north; nrows = Rast_window_rows(); ncols = Rast_window_cols(); /***************************************************/ /* Allocate output buffer */ /***************************************************/ outrast = Rast_allocate_d_buf(); outfd = Rast_open_new(h0, DCELL_TYPE); /***************************************************/ /* Allocate memory for temporary images */ double **d_Roh, **d_Rah; if ((d_Roh = G_alloc_matrix(nrows, ncols)) == NULL) G_message("Unable to allocate memory for temporary d_Roh image"); if ((d_Rah = G_alloc_matrix(nrows, ncols)) == NULL) G_message("Unable to allocate memory for temporary d_Rah image"); /***************************************************/ /* MANUAL T0DEM WET/DRY PIXELS */ DCELL d_Rn_dry,d_g0_dry; DCELL d_t0dem_dry,d_t0dem_wet; if (flag2->answer) { /* Process tempk min / max pixels */ /* Internal use only */ DCELL d_Rn_wet,d_g0_wet; DCELL d_Rn,d_g0,d_h0; DCELL t0dem_min,t0dem_max; /*********************/ for (row = 0; row < nrows; row++) { DCELL d_t0dem; G_percent(row, nrows, 2); Rast_get_d_row(infd_t0dem,inrast_t0dem,row); Rast_get_d_row(infd_Rn,inrast_Rn,row); Rast_get_d_row(infd_g0,inrast_g0,row); /*process the data */ for (col = 0; col < ncols; col++) { d_t0dem = ((DCELL *) inrast_t0dem)[col]; d_Rn = ((DCELL *) inrast_Rn)[col]; d_g0 = ((DCELL *) inrast_g0)[col]; if (Rast_is_d_null_value(&d_t0dem) || Rast_is_d_null_value(&d_Rn) || Rast_is_d_null_value(&d_g0)) { /* do nothing */ } else { if (d_t0dem <= 250.0) { /* do nothing */ } else { d_h0 = d_Rn - d_g0; if (d_t0dem < t0dem_min && d_Rn > 0.0 && d_g0 > 0.0 && d_h0 > 0.0 && d_h0 < 100.0) { t0dem_min = d_t0dem; d_t0dem_wet = d_t0dem; d_Rn_wet = d_Rn; d_g0_wet = d_g0; m_col_wet = col; m_row_wet = row; } if (d_t0dem > t0dem_max && d_Rn > 0.0 && d_g0 > 0.0 && d_h0 > 100.0 && d_h0 < 500.0) { t0dem_max = d_t0dem; d_t0dem_dry = d_t0dem; d_Rn_dry = d_Rn; d_g0_dry = d_g0; m_col_dry = col; m_row_dry = row; } } } } } G_message("row_wet=%d\tcol_wet=%d", row_wet, col_wet); G_message("row_dry=%d\tcol_dry=%d", row_dry, col_dry); G_message("g0_wet=%f", d_g0_wet); G_message("Rn_wet=%f", d_Rn_wet); G_message("LE_wet=%f", d_Rn_wet - d_g0_wet); G_message("t0dem_dry=%f", d_t0dem_dry); G_message("rnet_dry=%f", d_Rn_dry); G_message("g0_dry=%f", d_g0_dry); G_message("h0_dry=%f", d_Rn_dry - d_g0_dry); }/* END OF FLAG2 */ G_message("Passed here"); /* MANUAL T0DEM WET/DRY PIXELS */ /*DRY PIXEL */ if (flag3->answer) { /*Calculate coordinates of row/col from projected ones */ row = (int)((ymax - m_row_dry) / (double)stepy); col = (int)((m_col_dry - xmin) / (double)stepx); G_message("Dry Pixel | row:%i col:%i", row, col); } else { row = (int)m_row_dry; col = (int)m_col_dry; G_message("Dry Pixel | row:%i col:%i", row, col); } rowDry = row; colDry = col; Rast_get_d_row(infd_Rn, inrast_Rn, row); Rast_get_d_row(infd_g0, inrast_g0, row); Rast_get_d_row(infd_t0dem, inrast_t0dem, row); d_Rn_dry = ((DCELL *) inrast_Rn)[col]; d_g0_dry = ((DCELL *) inrast_g0)[col]; d_t0dem_dry = ((DCELL *) inrast_t0dem)[col]; /*WET PIXEL */ if (flag3->answer) { /*Calculate coordinates of row/col from projected ones */ row = (int)((ymax - m_row_wet) / (double)stepy); col = (int)((m_col_wet - xmin) / (double)stepx); G_message("Wet Pixel | row:%i col:%i", row, col); } else { row = m_row_wet; col = m_col_wet; G_message("Wet Pixel | row:%i col:%i", row, col); } rowWet = row; colWet = col; Rast_get_d_row(infd_t0dem, inrast_t0dem, row); d_t0dem_wet = ((DCELL *) inrast_t0dem)[col]; /* END OF MANUAL WET/DRY PIXELS */ double h_dry; h_dry = d_Rn_dry - d_g0_dry; G_message("h_dry = %f", h_dry); G_message("t0dem_dry = %f", d_t0dem_dry); G_message("t0dem_wet = %f", d_t0dem_wet); DCELL d_rah_dry; DCELL d_roh_dry; /* INITIALIZATION */ for (row = 0; row < nrows; row++) { DCELL d_t0dem,d_z0m; DCELL d_rah1,d_roh1; DCELL d_u5; G_percent(row, nrows, 2); /* read a line input maps into buffers */ Rast_get_d_row(infd_z0m, inrast_z0m, row); Rast_get_d_row(infd_t0dem, inrast_t0dem,row); /* read every cell in the line buffers */ for (col = 0; col < ncols; col++) { d_z0m = ((DCELL *) inrast_z0m)[col]; d_t0dem = ((DCELL *) inrast_t0dem)[col]; if (Rast_is_d_null_value(&d_t0dem) || Rast_is_d_null_value(&d_z0m)) { /* do nothing */ d_Roh[row][col] = -999.9; d_Rah[row][col] = -999.9; } else { d_u5 = (ustar / 0.41) * log(5 / d_z0m); d_rah1=(1/(d_u5*pow(0.41,2)))*log(5/d_z0m)*log(5/(d_z0m*0.1)); d_roh1=((998-ea)/(d_t0dem*2.87))+(ea/(d_t0dem*4.61)); if (d_roh1 > 5) d_roh1 = 1.0; else d_roh1=((1000-4.65)/(d_t0dem*2.87))+(4.65/(d_t0dem*4.61)); if (row == rowDry && col == colDry) { /*collect dry pix info */ d_rah_dry = d_rah1; d_roh_dry = d_roh1; G_message("d_rah_dry=%f d_roh_dry=%f",d_rah_dry,d_roh_dry); } d_Roh[row][col] = d_roh1; d_Rah[row][col] = d_rah1; } } } DCELL d_dT_dry; /*Calculate dT_dry */ d_dT_dry = (h_dry * d_rah_dry) / (1004 * d_roh_dry); double a, b; /*Calculate coefficients for next dT equation */ /*a = 1.0/ ((d_dT_dry-0.0) / (d_t0dem_dry-d_t0dem_wet)); */ /*b = ( a * d_t0dem_wet ) * (-1.0); */ double sumx = d_t0dem_wet + d_t0dem_dry; double sumy = d_dT_dry + 0.0; double sumx2 = pow(d_t0dem_wet, 2) + pow(d_t0dem_dry, 2); double sumxy = (d_t0dem_wet * 0.0) + (d_t0dem_dry * d_dT_dry); a = (sumxy - ((sumx * sumy) / 2.0)) / (sumx2 - (pow(sumx, 2) / 2.0)); b = (sumy - (a * sumx)) / 2.0; G_message("d_dT_dry=%f", d_dT_dry); G_message("dT1=%f * t0dem + (%f)", a, b); DCELL d_h_dry; /* ITERATION 1 */ for (row = 0; row < nrows; row++) { DCELL d_t0dem,d_z0m; DCELL d_h1,d_rah1,d_rah2,d_roh1; DCELL d_L,d_x,d_psih,d_psim; DCELL d_u5; G_percent(row, nrows, 2); /* read a line input maps into buffers */ Rast_get_d_row(infd_z0m, inrast_z0m, row); Rast_get_d_row(infd_t0dem, inrast_t0dem,row); /* read every cell in the line buffers */ for (col = 0; col < ncols; col++) { d_z0m = ((DCELL *) inrast_z0m)[col]; d_t0dem = ((DCELL *) inrast_t0dem)[col]; d_rah1 = d_Rah[row][col]; d_roh1 = d_Roh[row][col]; if (Rast_is_d_null_value(&d_t0dem) || Rast_is_d_null_value(&d_z0m)) { /* do nothing */ } else { if (d_rah1 < 1.0) d_h1 = 0.0; else d_h1 = (1004 * d_roh1) * (a * d_t0dem + b) / d_rah1; d_L =-1004*d_roh1*pow(ustar,3)*d_t0dem/(d_h1*9.81*0.41); d_x = pow((1-16*(5/d_L)),0.25); d_psim =2*log((1+d_x)/2)+log((1+pow(d_x,2))/2)-2*atan(d_x)+0.5*M_PI; d_psih =2*log((1+pow(d_x,2))/2); d_u5 =(ustar/0.41)*log(5/d_z0m); d_rah2 = (1/(d_u5*pow(0.41,2)))*log((5/d_z0m)-d_psim) *log((5/(d_z0m*0.1))-d_psih); if (row == rowDry && col == colDry) {/*collect dry pix info */ d_rah_dry = d_rah2; d_h_dry = d_h1; } d_Rah[row][col] = d_rah1; } } } /*Calculate dT_dry */ d_dT_dry = (d_h_dry * d_rah_dry) / (1004 * d_roh_dry); /*Calculate coefficients for next dT equation */ /* a = (d_dT_dry-0)/(d_t0dem_dry-d_t0dem_wet); */ /* b = (-1.0) * ( a * d_t0dem_wet ); */ /* G_message("d_dT_dry=%f",d_dT_dry); */ /* G_message("dT2=%f * t0dem + (%f)", a, b); */ sumx = d_t0dem_wet + d_t0dem_dry; sumy = d_dT_dry + 0.0; sumx2 = pow(d_t0dem_wet, 2) + pow(d_t0dem_dry, 2); sumxy = (d_t0dem_wet * 0.0) + (d_t0dem_dry * d_dT_dry); a = (sumxy - ((sumx * sumy) / 2.0)) / (sumx2 - (pow(sumx, 2) / 2.0)); b = (sumy - (a * sumx)) / 2.0; G_message("d_dT_dry=%f", d_dT_dry); G_message("dT1=%f * t0dem + (%f)", a, b); /* ITERATION 2 */ /***************************************************/ /***************************************************/ for (row = 0; row < nrows; row++) { DCELL d_t0dem; DCELL d_z0m; DCELL d_rah2; DCELL d_rah3; DCELL d_roh1; DCELL d_h2; DCELL d_L; DCELL d_x; DCELL d_psih; DCELL d_psim; DCELL d_u5; G_percent(row, nrows, 2); /* read a line input maps into buffers */ Rast_get_d_row(infd_z0m,inrast_z0m,row); Rast_get_d_row(infd_t0dem,inrast_t0dem,row); /* read every cell in the line buffers */ for (col = 0; col < ncols; col++) { d_z0m = ((DCELL *) inrast_z0m)[col]; d_t0dem = ((DCELL *) inrast_t0dem)[col]; d_rah2 = d_Rah[row][col]; d_roh1 = d_Roh[row][col]; if (Rast_is_d_null_value(&d_t0dem) || Rast_is_d_null_value(&d_z0m)) { /* do nothing */ } else { if (d_rah2 < 1.0) { d_h2 = 0.0; } else { d_h2 =(1004*d_roh1)*(a*d_t0dem+b)/d_rah2; } d_L =-1004*d_roh1*pow(ustar,3)*d_t0dem/(d_h2*9.81*0.41); d_x = pow((1 - 16 * (5 / d_L)), 0.25); d_psim =2*log((1+d_x)/2)+log((1+pow(d_x,2))/2)- 2*atan(d_x)+0.5*M_PI; d_psih =2*log((1+pow(d_x,2))/2); d_u5 =(ustar/0.41)*log(5/d_z0m); d_rah3=(1/(d_u5*pow(0.41,2)))*log((5/d_z0m)-d_psim)* log((5/(d_z0m*0.1))-d_psih); if (row == rowDry && col == colDry) {/*collect dry pix info */ d_rah_dry = d_rah2; d_h_dry = d_h2; } d_Rah[row][col] = d_rah2; } } } /*Calculate dT_dry */ d_dT_dry = (d_h_dry * d_rah_dry) / (1004 * d_roh_dry); /*Calculate coefficients for next dT equation */ /* a = (d_dT_dry-0)/(d_t0dem_dry-d_t0dem_wet); */ /* b = (-1.0) * ( a * d_t0dem_wet ); */ /* G_message("d_dT_dry=%f",d_dT_dry); */ /* G_message("dT3=%f * t0dem + (%f)", a, b); */ sumx = d_t0dem_wet + d_t0dem_dry; sumy = d_dT_dry + 0.0; sumx2 = pow(d_t0dem_wet, 2) + pow(d_t0dem_dry, 2); sumxy = (d_t0dem_wet * 0.0) + (d_t0dem_dry * d_dT_dry); a = (sumxy - ((sumx * sumy) / 2.0)) / (sumx2 - (pow(sumx, 2) / 2.0)); b = (sumy - (a * sumx)) / 2.0; G_message("d_dT_dry=%f", d_dT_dry); G_message("dT1=%f * t0dem + (%f)", a, b); /* ITERATION 3 */ /***************************************************/ /***************************************************/ for (row = 0; row < nrows; row++) { DCELL d_t0dem; DCELL d_z0m; DCELL d_rah3; DCELL d_roh1; DCELL d_h3; DCELL d_L; DCELL d_x; DCELL d_psih; DCELL d_psim; DCELL d; /* Output pixel */ G_percent(row, nrows, 2); /* read a line input maps into buffers */ Rast_get_d_row(infd_z0m, inrast_z0m, row); Rast_get_d_row(infd_t0dem,inrast_t0dem,row); /* read every cell in the line buffers */ for (col = 0; col < ncols; col++) { d_z0m = ((DCELL *) inrast_z0m)[col]; d_t0dem = ((DCELL *) inrast_t0dem)[col]; d_rah3 = d_Rah[row][col]; d_roh1 = d_Roh[row][col]; if (Rast_is_d_null_value(&d_t0dem) || Rast_is_d_null_value(&d_z0m)) { Rast_set_d_null_value(&outrast[col], 1); } else { if (d_rah3 < 1.0) { d_h3 = 0.0; } else { d_h3 = (1004 * d_roh1) * (a * d_t0dem + b) / d_rah3; } if (d_h3 < 0 && d_h3 > -50) { d_h3 = 0.0; } if (d_h3 < -50 || d_h3 > 1000) { Rast_set_d_null_value(&outrast[col], 1); } outrast[col] = d_h3; } } Rast_put_d_row(outfd, outrast); } G_free(inrast_z0m); Rast_close(infd_z0m); G_free(inrast_t0dem); Rast_close(infd_t0dem); G_free(outrast); Rast_close(outfd); /* add command line incantation to history file */ Rast_short_history(h0, "raster", &history); Rast_command_history(&history); Rast_write_history(h0, &history); exit(EXIT_SUCCESS); }
int null_distance(const char *name1, const char *name2, int *zerro_row, int *zerro_col) { RASTER_MAP_TYPE maptype1, maptype2; const char *mapset; int mapd1, mapd2; void *inrast1, *inrast2; int nrows, ncols, row, col; void *cell1, *cell2; /* NOTE: no need to controll, if the map exists. it should be checked in edge.c */ mapset = G_find_raster2(name1, ""); maptype1 = Rast_map_type(name1, mapset); mapd1 = Rast_open_old(name1, mapset); inrast1 = Rast_allocate_buf(maptype1); mapset = G_find_raster2(name2, ""); maptype2 = Rast_map_type(name2, mapset); mapd2 = Rast_open_old(name2, mapset); inrast2 = Rast_allocate_buf(maptype2); G_message(_("Reading maps <%s,%s> while finding 0 distance ..."), name1, name2); ncols = Rast_window_cols(); nrows = Rast_window_rows(); for (row = 0; row < nrows; row++) { G_percent(row, nrows, 2); Rast_get_row(mapd1, inrast1, row, maptype1); Rast_get_row(mapd2, inrast2, row, maptype2); for (col = 0; col < ncols; col++) { /* first raster */ switch (maptype1) { case CELL_TYPE: cell1 = ((CELL **) inrast1)[col]; break; case FCELL_TYPE: cell1 = ((FCELL **) inrast1)[col]; break; case DCELL_TYPE: cell1 = ((DCELL **) inrast1)[col]; break; } /* second raster */ switch (maptype2) { case CELL_TYPE: cell2 = ((CELL **) inrast2)[col]; break; case FCELL_TYPE: cell2 = ((FCELL **) inrast2)[col]; break; case DCELL_TYPE: cell2 = ((DCELL **) inrast2)[col]; break; } if (!Rast_is_null_value(&cell1, maptype1) && !Rast_is_null_value(&cell2, maptype2)) { *zerro_row = row; *zerro_col = col; /* memory cleanup */ G_free(inrast1); G_free(inrast2); /* closing raster maps */ Rast_close(mapd1); Rast_close(mapd2); return 1; } } } /* memory cleanup */ G_free(inrast1); G_free(inrast2); /* closing raster maps */ Rast_close(mapd1); Rast_close(mapd2); return 0; }
int main(int argc, char *argv[]) { /* buffer for input-output rasters */ void *inrast_TEMPKA, *inrast_PATM, *inrast_RNET, *inrast_G0; DCELL *outrast; /* pointers to input-output raster files */ int infd_TEMPKA, infd_PATM, infd_RNET, infd_G0; int outfd; /* names of input-output raster files */ char *RNET, *TEMPKA, *PATM, *G0; char *ETa; /* input-output cell values */ DCELL d_tempka, d_pt_patm, d_rnet, d_g0; DCELL d_pt_alpha, d_pt_delta, d_pt_ghamma, d_daily_et; /* region informations and handler */ struct Cell_head cellhd; int nrows, ncols; int row, col; /* parser stuctures definition */ struct GModule *module; struct Option *input_RNET, *input_TEMPKA, *input_PATM, *input_G0, *input_PT; struct Option *output; struct Flag *zero; struct Colors color; struct History history; /* Initialize the GIS calls */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("imagery")); G_add_keyword(_("evapotranspiration")); module->description = _("Computes evapotranspiration calculation " "Prestley and Taylor formulation, 1972."); /* Define different options */ input_RNET = G_define_standard_option(G_OPT_R_INPUT); input_RNET->key = "netradiation"; input_RNET->description = _("Name of input net radiation raster map [W/m2]"); input_G0 = G_define_standard_option(G_OPT_R_INPUT); input_G0->key = "soilheatflux"; input_G0->description = _("Name of input soil heat flux raster map [W/m2]"); input_TEMPKA = G_define_standard_option(G_OPT_R_INPUT); input_TEMPKA->key = "airtemperature"; input_TEMPKA->description = _("Name of input air temperature raster map [K]"); input_PATM = G_define_standard_option(G_OPT_R_INPUT); input_PATM->key = "atmosphericpressure"; input_PATM->description = _("Name of input atmospheric pressure raster map [millibars]"); input_PT = G_define_option(); input_PT->key = "priestleytaylorcoef"; input_PT->type = TYPE_DOUBLE; input_PT->required = YES; input_PT->description = _("Prestley-Taylor coefficient"); input_PT->answer = "1.26"; output = G_define_standard_option(G_OPT_R_OUTPUT); output->description = _("Name of output evapotranspiration raster map [mm/d]"); /* Define the different flags */ zero = G_define_flag(); zero->key = 'z'; zero->description = _("Set negative ETa to zero"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); /* get entered parameters */ RNET = input_RNET->answer; TEMPKA = input_TEMPKA->answer; PATM = input_PATM->answer; G0 = input_G0->answer; d_pt_alpha = atof(input_PT->answer); ETa = output->answer; /* open pointers to input raster files */ infd_RNET = Rast_open_old(RNET, ""); infd_TEMPKA = Rast_open_old(TEMPKA, ""); infd_PATM = Rast_open_old(PATM, ""); infd_G0 = Rast_open_old(G0, ""); /* read headers of raster files */ Rast_get_cellhd(RNET, "", &cellhd); Rast_get_cellhd(TEMPKA, "", &cellhd); Rast_get_cellhd(PATM, "", &cellhd); Rast_get_cellhd(G0, "", &cellhd); /* Allocate input buffer */ inrast_RNET = Rast_allocate_d_buf(); inrast_TEMPKA = Rast_allocate_d_buf(); inrast_PATM = Rast_allocate_d_buf(); inrast_G0 = Rast_allocate_d_buf(); /* get rows and columns number of the current region */ nrows = Rast_window_rows(); ncols = Rast_window_cols(); /* allocate output buffer */ outrast = Rast_allocate_d_buf(); /* open pointers to output raster files */ outfd = Rast_open_new(ETa, DCELL_TYPE); /* start the loop through cells */ for (row = 0; row < nrows; row++) { G_percent(row, nrows, 2); /* read input raster row into line buffer */ Rast_get_d_row(infd_RNET, inrast_RNET, row); Rast_get_d_row(infd_TEMPKA, inrast_TEMPKA, row); Rast_get_d_row(infd_PATM, inrast_PATM, row); Rast_get_d_row(infd_G0, inrast_G0, row); for (col = 0; col < ncols; col++) { /* read current cell from line buffer */ d_rnet = ((DCELL *) inrast_RNET)[col]; d_tempka = ((DCELL *) inrast_TEMPKA)[col]; d_pt_patm = ((DCELL *) inrast_PATM)[col]; d_g0 = ((DCELL *) inrast_G0)[col]; /*Delta_pt and Ghamma_pt */ d_pt_delta = pt_delta(d_tempka); d_pt_ghamma = pt_ghamma(d_tempka, d_pt_patm); /*Calculate ET */ d_daily_et = pt_daily_et(d_pt_alpha, d_pt_delta, d_pt_ghamma, d_rnet, d_g0, d_tempka); if (zero->answer && d_daily_et < 0) d_daily_et = 0.0; /* write calculated ETP to output line buffer */ outrast[col] = d_daily_et; } /* write output line buffer to output raster file */ Rast_put_d_row(outfd, outrast); } /* free buffers and close input maps */ G_free(inrast_RNET); G_free(inrast_TEMPKA); G_free(inrast_PATM); G_free(inrast_G0); Rast_close(infd_RNET); Rast_close(infd_TEMPKA); Rast_close(infd_PATM); Rast_close(infd_G0); /* generate color table between -20 and 20 */ Rast_make_rainbow_colors(&color, -20, 20); Rast_write_colors(ETa, G_mapset(), &color); Rast_short_history(ETa, "raster", &history); Rast_command_history(&history); Rast_write_history(ETa, &history); /* free buffers and close output map */ G_free(outrast); Rast_close(outfd); return (EXIT_SUCCESS); }
int main(int argc, char *argv[]) { int i, j; /* Loop control variables */ int bands; /* Number of image bands */ double *mu; /* Mean vector for image bands */ double **covar; /* Covariance Matrix */ double *eigval; double **eigmat; int *inp_fd; int scale, scale_max, scale_min; struct GModule *module; struct Option *opt_in, *opt_out, *opt_scale; /* initialize GIS engine */ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("imagery")); G_add_keyword(_("image transformation")); G_add_keyword(_("PCA")); module->description = _("Principal components analysis (PCA) " "for image processing."); /* Define options */ opt_in = G_define_standard_option(G_OPT_R_INPUTS); opt_in->description = _("Name of two or more input raster maps"); opt_out = G_define_option(); opt_out->label = _("Base name for output raster maps"); opt_out->description = _("A numerical suffix will be added for each component map"); opt_out->key = "output_prefix"; opt_out->type = TYPE_STRING; opt_out->key_desc = "string"; opt_out->required = YES; opt_scale = G_define_option(); opt_scale->key = "rescale"; opt_scale->type = TYPE_INTEGER; opt_scale->key_desc = "min,max"; opt_scale->required = NO; opt_scale->answer = "0,255"; opt_scale->label = _("Rescaling range for output maps"); opt_scale->description = _("For no rescaling use 0,0"); opt_scale->guisection = _("Rescale"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); /* determine number of bands passed in */ for (bands = 0; opt_in->answers[bands] != NULL; bands++) ; if (bands < 2) G_fatal_error(_("Sorry, at least 2 input bands must be provided")); /* default values */ scale = 1; scale_min = 0; scale_max = 255; /* get scale parameters */ set_output_scale(opt_scale, &scale, &scale_min, &scale_max); /* allocate memory */ covar = G_alloc_matrix(bands, bands); mu = G_alloc_vector(bands); inp_fd = G_alloc_ivector(bands); eigmat = G_alloc_matrix(bands, bands); eigval = G_alloc_vector(bands); /* open and check input/output files */ for (i = 0; i < bands; i++) { char tmpbuf[128]; sprintf(tmpbuf, "%s.%d", opt_out->answer, i + 1); G_check_input_output_name(opt_in->answers[i], tmpbuf, GR_FATAL_EXIT); inp_fd[i] = Rast_open_old(opt_in->answers[i], ""); } G_verbose_message(_("Calculating covariance matrix...")); calc_mu(inp_fd, mu, bands); calc_covariance(inp_fd, covar, mu, bands); for (i = 0; i < bands; i++) { for (j = 0; j < bands; j++) { covar[i][j] = covar[i][j] / ((double)((Rast_window_rows() * Rast_window_cols()) - 1)); G_debug(3, "covar[%d][%d] = %f", i, j, covar[i][j]); } } G_math_d_copy(covar[0], eigmat[0], bands*bands); G_debug(1, "Calculating eigenvalues and eigenvectors..."); G_math_eigen(eigmat, eigval, bands); #ifdef PCA_DEBUG /* dump eigen matrix and eigen values */ dump_eigen(bands, eigmat, eigval); #endif G_debug(1, "Ordering eigenvalues in descending order..."); G_math_egvorder(eigval, eigmat, bands); G_debug(1, "Transposing eigen matrix..."); G_math_d_A_T(eigmat, bands); /* write output images */ write_pca(eigmat, inp_fd, opt_out->answer, bands, scale, scale_min, scale_max); /* write colors and history to output */ for (i = 0; i < bands; i++) { char outname[80]; sprintf(outname, "%s.%d", opt_out->answer, i + 1); /* write colors and history to file */ write_support(bands, outname, eigmat, eigval); /* close output file */ Rast_unopen(inp_fd[i]); } /* free memory */ G_free_matrix(covar); G_free_vector(mu); G_free_ivector(inp_fd); G_free_matrix(eigmat); G_free_vector(eigval); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { struct 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 execute_random(struct rr_state *theState) { long nt; long nc; struct Cell_head window; int nrows, ncols, row, col; int infd, cinfd, outfd; struct Map_info Out; struct field_info *fi; dbTable *table; dbColumn *column; dbString sql; dbDriver *driver; struct line_pnts *Points; struct line_cats *Cats; int cat; RASTER_MAP_TYPE type; G_get_window(&window); nrows = Rast_window_rows(); ncols = Rast_window_cols(); /* open the data files, input raster should be set-up already */ if ((infd = theState->fd_old) < 0) G_fatal_error(_("Unable to open raster map <%s>"), theState->inraster); if (theState->docover == TRUE) { if ((cinfd = theState->fd_cold) < 0) G_fatal_error(_("Unable to open raster map <%s>"), theState->inrcover); } if (theState->outraster != NULL) { if (theState->docover == TRUE) type = theState->cover.type; else type = theState->buf.type; outfd = Rast_open_new(theState->outraster, type); theState->fd_new = outfd; } if (theState->outvector) { if (theState->z_geometry) Vect_open_new(&Out, theState->outvector, 1); else Vect_open_new(&Out, theState->outvector, 0); Vect_hist_command(&Out); fi = Vect_default_field_info(&Out, 1, NULL, GV_1TABLE); driver = db_start_driver_open_database(fi->driver, Vect_subst_var(fi->database, &Out)); if (!driver) G_fatal_error(_("Unable to open database <%s> by driver <%s>"), Vect_subst_var(fi->database, &Out), fi->driver); Vect_map_add_dblink(&Out, 1, NULL, fi->table, GV_KEY_COLUMN, fi->database, fi->driver); if (theState->docover == TRUE) table = db_alloc_table(3); else table = db_alloc_table(2); db_set_table_name(table, fi->table); column = db_get_table_column(table, 0); db_set_column_name(column, GV_KEY_COLUMN); db_set_column_sqltype(column, DB_SQL_TYPE_INTEGER); column = db_get_table_column(table, 1); db_set_column_name(column, "value"); db_set_column_sqltype(column, DB_SQL_TYPE_DOUBLE_PRECISION); if (theState->docover == TRUE) { column = db_get_table_column(table, 2); db_set_column_name(column, "covervalue"); db_set_column_sqltype(column, DB_SQL_TYPE_DOUBLE_PRECISION); } if (db_create_table(driver, table) != DB_OK) G_warning(_("Cannot create new table")); db_begin_transaction(driver); Points = Vect_new_line_struct(); Cats = Vect_new_cats_struct(); db_init_string(&sql); } if (theState->outvector && theState->outraster) G_message(_("Writing raster map <%s> and vector map <%s> ..."), theState->outraster, theState->outvector); else if (theState->outraster) G_message(_("Writing raster map <%s> ..."), theState->outraster); else if (theState->outvector) G_message(_("Writing vector map <%s> ..."), theState->outvector); G_percent(0, theState->nRand, 2); init_rand(); nc = (theState->use_nulls) ? theState->nCells : theState->nCells - theState->nNulls; nt = theState->nRand; /* Number of points to generate */ cat = 1; /* Execute for loop for every row if nt>1 */ for (row = 0; row < nrows && nt; row++) { Rast_get_row(infd, theState->buf.data.v, row, theState->buf.type); if (theState->docover == TRUE) { Rast_get_row(cinfd, theState->cover.data.v, row, theState->cover.type); } for (col = 0; col < ncols && nt; col++) { if ((theState->use_nulls || !is_null_value(theState->buf, col)) && (!theState->docover || theState->use_nulls || !is_null_value(theState->cover, col)) && (make_rand() % nc < nt)) { nt--; if (is_null_value(theState->buf, col)) cpvalue(&theState->nulls, 0, &theState->buf, col); if (theState->docover == TRUE) { if (is_null_value(theState->cover, col)) cpvalue(&theState->cnulls, 0, &theState->cover, col); } if (theState->outvector) { double x, y, val, coverval; char buf[500]; Vect_reset_line(Points); Vect_reset_cats(Cats); x = window.west + (col + .5) * window.ew_res; y = window.north - (row + .5) * window.ns_res; val = cell_as_dbl(&theState->buf, col); if (theState->docover == 1) coverval = cell_as_dbl(&theState->cover, col); if (theState->z_geometry) Vect_append_point(Points, x, y, val); else Vect_append_point(Points, x, y, 0.0); Vect_cat_set(Cats, 1, cat); Vect_write_line(&Out, GV_POINT, Points, Cats); if (theState->docover == 1) if (is_null_value(theState->cover, col)) sprintf(buf, "insert into %s values ( %d, %f, NULL )", fi->table, cat, val); else sprintf(buf, "insert into %s values ( %d, %f, %f )", fi->table, cat, val, coverval); else sprintf(buf, "insert into %s values ( %d, %f )", fi->table, cat, val); db_set_string(&sql, buf); if (db_execute_immediate(driver, &sql) != DB_OK) G_fatal_error(_("Cannot insert new record: %s"), db_get_string(&sql)); cat++; } G_percent((theState->nRand - nt), theState->nRand, 2); nc--; } else { set_to_null(&theState->buf, col); if (theState->docover == 1) set_to_null(&theState->cover, col); } } while (col < ncols) { set_to_null(&theState->buf, col); if (theState->docover == 1) set_to_null(&theState->cover, col); col++; } if (theState->outraster) { if (theState->docover == 1) Rast_put_row(outfd, theState->cover.data.v, theState->cover.type); else Rast_put_row(outfd, theState->buf.data.v, theState->buf.type); } } /* Catch any remaining rows in the window */ if (theState->outraster && row < nrows) { for (col = 0; col < ncols; col++) { if (theState->docover == 1) set_to_null(&theState->cover, col); else set_to_null(&theState->buf, col); } for (; row < nrows; row++) { if (theState->docover == 1) Rast_put_row(outfd, theState->cover.data.v, theState->cover.type); else Rast_put_row(outfd, theState->buf.data.v, theState->buf.type); } } if (nt > 0) G_warning(_("Only [%ld] random points created"), theState->nRand - nt); /* close files */ Rast_close(infd); if (theState->docover == TRUE) Rast_close(cinfd); if (theState->outvector) { db_commit_transaction(driver); db_close_database_shutdown_driver(driver); if (theState->notopol != 1) Vect_build(&Out); Vect_close(&Out); } if (theState->outraster) Rast_close(outfd); return 0; } /* execute_random() */
int main(int argc, char *argv[]) { int nrows, ncols; int row, col; char *viflag; /*Switch for particular index */ char *desc; struct GModule *module; struct { struct Option *viname, *red, *nir, *green, *blue, *chan5, *chan7, *sl_slope, *sl_int, *sl_red, *bits, *output; } opt; struct History history; /*metadata */ struct Colors colors; /*Color rules */ char *result; /*output raster name */ int infd_redchan, infd_nirchan, infd_greenchan; int infd_bluechan, infd_chan5chan, infd_chan7chan; int outfd; char *bluechan, *greenchan, *redchan, *nirchan, *chan5chan, *chan7chan; DCELL *inrast_redchan, *inrast_nirchan, *inrast_greenchan; DCELL *inrast_bluechan, *inrast_chan5chan, *inrast_chan7chan; DCELL *outrast; RASTER_MAP_TYPE data_type_redchan; RASTER_MAP_TYPE data_type_nirchan, data_type_greenchan; RASTER_MAP_TYPE data_type_bluechan; RASTER_MAP_TYPE data_type_chan5chan, data_type_chan7chan; DCELL msavip1, msavip2, msavip3, dnbits; CELL val1, val2; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("imagery")); G_add_keyword(_("vegetation index")); G_add_keyword(_("biophysical parameters")); module->label = _("Calculates different types of vegetation indices."); module->description = _("Uses red and nir bands mostly, " "and some indices require additional bands."); /* Define the different options */ opt.red = G_define_standard_option(G_OPT_R_INPUT); opt.red->key = "red"; opt.red->label = _("Name of input red channel surface reflectance map"); opt.red->description = _("Range: [0.0;1.0]"); opt.output = G_define_standard_option(G_OPT_R_OUTPUT); opt.viname = G_define_option(); opt.viname->key = "viname"; opt.viname->type = TYPE_STRING; opt.viname->required = YES; opt.viname->description = _("Type of vegetation index"); desc = NULL; G_asprintf(&desc, "arvi;%s;dvi;%s;evi;%s;evi2;%s;gvi;%s;gari;%s;gemi;%s;ipvi;%s;msavi;%s;" "msavi2;%s;ndvi;%s;pvi;%s;savi;%s;sr;%s;vari;%s;wdvi;%s", _("Atmospherically Resistant Vegetation Index"), _("Difference Vegetation Index"), _("Enhanced Vegetation Index"), _("Enhanced Vegetation Index 2"), _("Green Vegetation Index"), _("Green Atmospherically Resistant Vegetation Index"), _("Global Environmental Monitoring Index"), _("Infrared Percentage Vegetation Index"), _("Modified Soil Adjusted Vegetation Index"), _("second Modified Soil Adjusted Vegetation Index"), _("Normalized Difference Vegetation Index"), _("Perpendicular Vegetation Index"), _("Soil Adjusted Vegetation Index"), _("Simple Ratio"), _("Visible Atmospherically Resistant Index"), _("Weighted Difference Vegetation Index")); opt.viname->descriptions = desc; opt.viname->options = "arvi,dvi,evi,evi2,gvi,gari,gemi,ipvi,msavi,msavi2,ndvi,pvi,savi,sr,vari,wdvi"; opt.viname->answer = "ndvi"; opt.viname->key_desc = _("type"); opt.nir = G_define_standard_option(G_OPT_R_INPUT); opt.nir->key = "nir"; opt.nir->required = NO; opt.nir->label = _("Name of input nir channel surface reflectance map"); opt.nir->description = _("Range: [0.0;1.0]"); opt.nir->guisection = _("Optional inputs"); opt.green = G_define_standard_option(G_OPT_R_INPUT); opt.green->key = "green"; opt.green->required = NO; opt.green->label = _("Name of input green channel surface reflectance map"); opt.green->description = _("Range: [0.0;1.0]"); opt.green->guisection = _("Optional inputs"); opt.blue = G_define_standard_option(G_OPT_R_INPUT); opt.blue->key = "blue"; opt.blue->required = NO; opt.blue->label = _("Name of input blue channel surface reflectance map"); opt.blue->description = _("Range: [0.0;1.0]"); opt.blue->guisection = _("Optional inputs"); opt.chan5 = G_define_standard_option(G_OPT_R_INPUT); opt.chan5->key = "band5"; opt.chan5->required = NO; opt.chan5->label = _("Name of input 5th channel surface reflectance map"); opt.chan5->description = _("Range: [0.0;1.0]"); opt.chan5->guisection = _("Optional inputs"); opt.chan7 = G_define_standard_option(G_OPT_R_INPUT); opt.chan7->key = "band7"; opt.chan7->required = NO; opt.chan7->label = _("Name of input 7th channel surface reflectance map"); opt.chan7->description = _("Range: [0.0;1.0]"); opt.chan7->guisection = _("Optional inputs"); opt.sl_slope = G_define_option(); opt.sl_slope->key = "soil_line_slope"; opt.sl_slope->type = TYPE_DOUBLE; opt.sl_slope->required = NO; opt.sl_slope->description = _("Value of the slope of the soil line (MSAVI only)"); opt.sl_slope->guisection = _("MSAVI settings"); opt.sl_int = G_define_option(); opt.sl_int->key = "soil_line_intercept"; opt.sl_int->type = TYPE_DOUBLE; opt.sl_int->required = NO; opt.sl_int->description = _("Value of the intercept of the soil line (MSAVI only)"); opt.sl_int->guisection = _("MSAVI settings"); opt.sl_red = G_define_option(); opt.sl_red->key = "soil_noise_reduction"; opt.sl_red->type = TYPE_DOUBLE; opt.sl_red->required = NO; opt.sl_red->description = _("Value of the factor of reduction of soil noise (MSAVI only)"); opt.sl_red->guisection = _("MSAVI settings"); opt.bits = G_define_option(); opt.bits->key = "storage_bit"; opt.bits->type = TYPE_INTEGER; opt.bits->required = NO; opt.bits->label = _("Maximum bits for digital numbers"); opt.bits->description = _("If data is in Digital Numbers (i.e. integer type), give the max bits (i.e. 8 for Landsat -> [0-255])"); opt.bits->options = "7,8,10,16"; opt.bits->answer = "8"; if (G_parser(argc, argv)) exit(EXIT_FAILURE); viflag = opt.viname->answer; redchan = opt.red->answer; nirchan = opt.nir->answer; greenchan = opt.green->answer; bluechan = opt.blue->answer; chan5chan = opt.chan5->answer; chan7chan = opt.chan7->answer; if(opt.sl_slope->answer) msavip1 = atof(opt.sl_slope->answer); if(opt.sl_int->answer) msavip2 = atof(opt.sl_int->answer); if(opt.sl_red->answer) msavip3 = atof(opt.sl_red->answer); if(opt.bits->answer) dnbits = atof(opt.bits->answer); result = opt.output->answer; G_verbose_message(_("Calculating %s..."), viflag); if (!strcasecmp(viflag, "sr") && (!(opt.red->answer) || !(opt.nir->answer)) ) G_fatal_error(_("sr index requires red and nir maps")); if (!strcasecmp(viflag, "ndvi") && (!(opt.red->answer) || !(opt.nir->answer)) ) G_fatal_error(_("ndvi index requires red and nir maps")); if (!strcasecmp(viflag, "ipvi") && (!(opt.red->answer) || !(opt.nir->answer)) ) G_fatal_error(_("ipvi index requires red and nir maps")); if (!strcasecmp(viflag, "dvi") && (!(opt.red->answer) || !(opt.nir->answer)) ) G_fatal_error(_("dvi index requires red and nir maps")); if (!strcasecmp(viflag, "pvi") && (!(opt.red->answer) || !(opt.nir->answer)) ) G_fatal_error(_("pvi index requires red and nir maps")); if (!strcasecmp(viflag, "wdvi") && (!(opt.red->answer) || !(opt.nir->answer)) ) G_fatal_error(_("wdvi index requires red and nir maps")); if (!strcasecmp(viflag, "savi") && (!(opt.red->answer) || !(opt.nir->answer)) ) G_fatal_error(_("savi index requires red and nir maps")); if (!strcasecmp(viflag, "msavi") && (!(opt.red->answer) || !(opt.nir->answer) || !(opt.sl_slope->answer) || !(opt.sl_int->answer) || !(opt.sl_red->answer)) ) G_fatal_error(_("msavi index requires red and nir maps, and 3 parameters related to soil line")); if (!strcasecmp(viflag, "msavi2") && (!(opt.red->answer) || !(opt.nir->answer)) ) G_fatal_error(_("msavi2 index requires red and nir maps")); if (!strcasecmp(viflag, "gemi") && (!(opt.red->answer) || !(opt.nir->answer)) ) G_fatal_error(_("gemi index requires red and nir maps")); if (!strcasecmp(viflag, "arvi") && (!(opt.red->answer) || !(opt.nir->answer) || !(opt.blue->answer)) ) G_fatal_error(_("arvi index requires blue, red and nir maps")); if (!strcasecmp(viflag, "evi") && (!(opt.red->answer) || !(opt.nir->answer) || !(opt.blue->answer)) ) G_fatal_error(_("evi index requires blue, red and nir maps")); if (!strcasecmp(viflag, "evi2") && (!(opt.red->answer) || !(opt.nir->answer) ) ) G_fatal_error(_("evi2 index requires red and nir maps")); if (!strcasecmp(viflag, "vari") && (!(opt.red->answer) || !(opt.green->answer) || !(opt.blue->answer)) ) G_fatal_error(_("vari index requires blue, green and red maps")); if (!strcasecmp(viflag, "gari") && (!(opt.red->answer) || !(opt.nir->answer) || !(opt.green->answer) || !(opt.blue->answer)) ) G_fatal_error(_("gari index requires blue, green, red and nir maps")); if (!strcasecmp(viflag, "gvi") && (!(opt.red->answer) || !(opt.nir->answer) || !(opt.green->answer) || !(opt.blue->answer) || !(opt.chan5->answer) || !(opt.chan7->answer)) ) G_fatal_error(_("gvi index requires blue, green, red, nir, chan5 and chan7 maps")); infd_redchan = Rast_open_old(redchan, ""); data_type_redchan = Rast_map_type(redchan, ""); inrast_redchan = Rast_allocate_buf(data_type_redchan); if (nirchan) { infd_nirchan = Rast_open_old(nirchan, ""); data_type_nirchan = Rast_map_type(nirchan, ""); inrast_nirchan = Rast_allocate_buf(data_type_nirchan); } if (greenchan) { infd_greenchan = Rast_open_old(greenchan, ""); data_type_greenchan = Rast_map_type(greenchan, ""); inrast_greenchan = Rast_allocate_buf(data_type_greenchan); } if (bluechan) { infd_bluechan = Rast_open_old(bluechan, ""); data_type_bluechan = Rast_map_type(bluechan, ""); inrast_bluechan = Rast_allocate_buf(data_type_bluechan); } if (chan5chan) { infd_chan5chan = Rast_open_old(chan5chan, ""); data_type_chan5chan = Rast_map_type(chan5chan, ""); inrast_chan5chan = Rast_allocate_buf(data_type_chan5chan); } if (chan7chan) { infd_chan7chan = Rast_open_old(chan7chan, ""); data_type_chan7chan = Rast_map_type(chan7chan, ""); inrast_chan7chan = Rast_allocate_buf(data_type_chan7chan); } nrows = Rast_window_rows(); ncols = Rast_window_cols(); /* Create New raster files */ outfd = Rast_open_new(result, DCELL_TYPE); outrast = Rast_allocate_d_buf(); /* Process pixels */ for (row = 0; row < nrows; row++) { DCELL d_bluechan; DCELL d_greenchan; DCELL d_redchan; DCELL d_nirchan; DCELL d_chan5chan; DCELL d_chan7chan; G_percent(row, nrows, 2); /* read input maps */ Rast_get_row(infd_redchan,inrast_redchan,row,data_type_redchan); if (nirchan) { Rast_get_row(infd_nirchan,inrast_nirchan,row,data_type_nirchan); } if (bluechan) { Rast_get_row(infd_bluechan,inrast_bluechan,row,data_type_bluechan); } if (greenchan) { Rast_get_row(infd_greenchan,inrast_greenchan,row,data_type_greenchan); } if (chan5chan) { Rast_get_row(infd_chan5chan,inrast_chan5chan,row,data_type_chan5chan); } if (chan7chan) { Rast_get_row(infd_chan7chan,inrast_chan7chan,row,data_type_chan7chan); } /* process the data */ for (col = 0; col < ncols; col++) { switch(data_type_redchan){ case CELL_TYPE: d_redchan = (double) ((CELL *) inrast_redchan)[col]; if(opt.bits->answer) d_redchan *= 1.0/(pow(2,dnbits)-1); break; case FCELL_TYPE: d_redchan = (double) ((FCELL *) inrast_redchan)[col]; break; case DCELL_TYPE: d_redchan = ((DCELL *) inrast_redchan)[col]; break; } if (nirchan) { switch(data_type_nirchan){ case CELL_TYPE: d_nirchan = (double) ((CELL *) inrast_nirchan)[col]; if(opt.bits->answer) d_nirchan *= 1.0/(pow(2,dnbits)-1); break; case FCELL_TYPE: d_nirchan = (double) ((FCELL *) inrast_nirchan)[col]; break; case DCELL_TYPE: d_nirchan = ((DCELL *) inrast_nirchan)[col]; break; } } if (greenchan) { switch(data_type_greenchan){ case CELL_TYPE: d_greenchan = (double) ((CELL *) inrast_greenchan)[col]; if(opt.bits->answer) d_greenchan *= 1.0/(pow(2,dnbits)-1); break; case FCELL_TYPE: d_greenchan = (double) ((FCELL *) inrast_greenchan)[col]; break; case DCELL_TYPE: d_greenchan = ((DCELL *) inrast_greenchan)[col]; break; } } if (bluechan) { switch(data_type_bluechan){ case CELL_TYPE: d_bluechan = (double) ((CELL *) inrast_bluechan)[col]; if(opt.bits->answer) d_bluechan *= 1.0/(pow(2,dnbits)-1); break; case FCELL_TYPE: d_bluechan = (double) ((FCELL *) inrast_bluechan)[col]; break; case DCELL_TYPE: d_bluechan = ((DCELL *) inrast_bluechan)[col]; break; } } if (chan5chan) { switch(data_type_chan5chan){ case CELL_TYPE: d_chan5chan = (double) ((CELL *) inrast_chan5chan)[col]; if(opt.bits->answer) d_chan5chan *= 1.0/(pow(2,dnbits)-1); break; case FCELL_TYPE: d_chan5chan = (double) ((FCELL *) inrast_chan5chan)[col]; break; case DCELL_TYPE: d_chan5chan = ((DCELL *) inrast_chan5chan)[col]; break; } } if (chan7chan) { switch(data_type_chan7chan){ case CELL_TYPE: d_chan7chan = (double) ((CELL *) inrast_chan7chan)[col]; if(opt.bits->answer) d_chan7chan *= 1.0/(pow(2,dnbits)-1); break; case FCELL_TYPE: d_chan7chan = (double) ((FCELL *) inrast_chan7chan)[col]; break; case DCELL_TYPE: d_chan7chan = ((DCELL *) inrast_chan7chan)[col]; break; } } if (Rast_is_d_null_value(&d_redchan) || ((nirchan) && Rast_is_d_null_value(&d_nirchan)) || ((greenchan) && Rast_is_d_null_value(&d_greenchan)) || ((bluechan) && Rast_is_d_null_value(&d_bluechan)) || ((chan5chan) && Rast_is_d_null_value(&d_chan5chan)) || ((chan7chan) && Rast_is_d_null_value(&d_chan7chan))) { Rast_set_d_null_value(&outrast[col], 1); } else { /* calculate simple_ratio */ if (!strcasecmp(viflag, "sr")) outrast[col] = s_r(d_redchan, d_nirchan); /* calculate ndvi */ if (!strcasecmp(viflag, "ndvi")) { if (d_redchan + d_nirchan < 0.001) Rast_set_d_null_value(&outrast[col], 1); else outrast[col] = nd_vi(d_redchan, d_nirchan); } if (!strcasecmp(viflag, "ipvi")) outrast[col] = ip_vi(d_redchan, d_nirchan); if (!strcasecmp(viflag, "dvi")) outrast[col] = d_vi(d_redchan, d_nirchan); if (!strcasecmp(viflag, "evi")) outrast[col] = e_vi(d_bluechan, d_redchan, d_nirchan); if (!strcasecmp(viflag, "evi2")) outrast[col] = e_vi2(d_redchan, d_nirchan); if (!strcasecmp(viflag, "pvi")) outrast[col] = p_vi(d_redchan, d_nirchan); if (!strcasecmp(viflag, "wdvi")) outrast[col] = wd_vi(d_redchan, d_nirchan); if (!strcasecmp(viflag, "savi")) outrast[col] = sa_vi(d_redchan, d_nirchan); if (!strcasecmp(viflag, "msavi")) outrast[col] = msa_vi(d_redchan, d_nirchan, msavip1, msavip2, msavip3); if (!strcasecmp(viflag, "msavi2")) outrast[col] = msa_vi2(d_redchan, d_nirchan); if (!strcasecmp(viflag, "gemi")) outrast[col] = ge_mi(d_redchan, d_nirchan); if (!strcasecmp(viflag, "arvi")) outrast[col] = ar_vi(d_redchan, d_nirchan, d_bluechan); if (!strcasecmp(viflag, "gvi")) outrast[col] = g_vi(d_bluechan, d_greenchan, d_redchan, d_nirchan, d_chan5chan, d_chan7chan); if (!strcasecmp(viflag, "gari")) outrast[col] = ga_ri(d_redchan, d_nirchan, d_bluechan, d_greenchan); if (!strcasecmp(viflag, "vari")) outrast[col] = va_ri(d_redchan, d_greenchan, d_bluechan); } } Rast_put_d_row(outfd, outrast); } G_percent(1, 1, 1); G_free(inrast_redchan); Rast_close(infd_redchan); if (nirchan) { G_free(inrast_nirchan); Rast_close(infd_nirchan); } if (greenchan) { G_free(inrast_greenchan); Rast_close(infd_greenchan); } if (bluechan) { G_free(inrast_bluechan); Rast_close(infd_bluechan); } if (chan5chan) { G_free(inrast_chan5chan); Rast_close(infd_chan5chan); } if (chan7chan) { G_free(inrast_chan7chan); Rast_close(infd_chan7chan); } G_free(outrast); Rast_close(outfd); if (!strcasecmp(viflag, "ndvi")) { /* apply predefined NDVI color table */ const char *style = "ndvi"; if (G_find_color_rule("ndvi")) { Rast_make_fp_colors(&colors, style, -1.0, 1.0); } else G_fatal_error(_("Unknown color request '%s'"), style); } else { /* Color from -1.0 to +1.0 in grey */ Rast_init_colors(&colors); val1 = -1; val2 = 1; Rast_add_c_color_rule(&val1, 0, 0, 0, &val2, 255, 255, 255, &colors); } Rast_write_colors(result, G_mapset(), &colors); Rast_short_history(result, "raster", &history); Rast_command_history(&history); Rast_write_history(result, &history); exit(EXIT_SUCCESS); }
void Init() { struct Cell_head Region; int Count; int FD, row, col; double MinRes; G_debug(2, "Init()"); Rs = Rast_window_rows(); Cs = Rast_window_cols(); G_get_set_window(&Region); EW = Region.ew_res; NS = Region.ns_res; if (EW < NS) MinRes = EW; else MinRes = NS; CellBuffer = Rast_allocate_c_buf(); /* Out = FlagCreate( Rs, Cs); */ Out = (CELL **) G_malloc(sizeof(CELL *) * Rs); for (row = 0; row < Rs; row++) { Out[row] = Rast_allocate_c_buf(); Rast_zero_buf(Out[row], CELL_TYPE); } Cells = FlagCreate(Rs, Cs); CellCount = 0; if (G_find_raster2("MASK", G_mapset())) { FD = Rast_open_old("MASK", G_mapset()); { for (row = 0; row < Rs; row++) { Rast_get_c_row_nomask(FD, CellBuffer, row); for (col = 0; col < Cs; col++) { if (CellBuffer[col]) { FLAG_SET(Cells, row, col); CellCount++; } } } Rast_close(FD); } } else { for (row = 0; row < Rs; row++) { for (col = 0; col < Cs; col++) { FLAG_SET(Cells, row, col); } } CellCount = Rs * Cs; } sscanf(Distance->answer, "%lf", &MaxDist); if (MaxDist < 0.0) G_fatal_error(_("Distance must be >= 0.0")); G_debug(3, "(MaxDist):%.12lf", MaxDist); MaxDistSq = MaxDist * MaxDist; if (!SeedStuff->answer) { Seed = (int)getpid(); } else { sscanf(SeedStuff->answer, "%d", &(Seed)); } if (Seed > SEED_MAX) { Seed = Seed % SEED_MAX; } else if (Seed < SEED_MIN) { while (Seed < SEED_MIN) Seed += SEED_MAX - SEED_MIN; } G_message(_("Generating raster map <%s>..."), Output->answer); DoNext = (CELLSORTER *) G_malloc(CellCount * sizeof(CELLSORTER)); Count = 0; for (row = 0; row < Rs; row++) { G_percent(row, Rs, 2); for (col = 0; col < Cs; col++) { if (0 != FlagGet(Cells, row, col)) { DoNext[Count].R = row; DoNext[Count].C = col; DoNext[Count].Value = GasDev(); if (++Count == CellCount) { row = Rs; col = Cs; } } } } G_percent(1, 1, 1); qsort(DoNext, CellCount, sizeof(CELLSORTER), comp_array); }
int main(int argc, char *argv[]) { int partfd; int nrows, ncols; const char *drain_name; const char *ridge_name; const char *part_name; CELL *drain, *ridge; struct Cell_head window; int row, col, npass, tpass; struct GModule *module; struct Option *num_opt, *drain_opt, *ridge_opt, *part_opt; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("hydrology")); G_add_keyword(_("watershed")); module->description = _("Generates watershed subbasins raster map."); drain_opt = G_define_standard_option(G_OPT_R_INPUT); drain_opt->key = "cnetwork"; drain_opt->description = _("Name of input coded stream network raster map"); ridge_opt = G_define_standard_option(G_OPT_R_INPUT); ridge_opt->key = "tnetwork"; ridge_opt->description = _("Name of input thinned ridge network raster map"); part_opt = G_define_standard_option(G_OPT_R_OUTPUT); num_opt = G_define_option(); num_opt->key = "number"; num_opt->type = TYPE_INTEGER; num_opt->required = YES; num_opt->description = _("Number of passes through the dataset"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); sscanf(num_opt->answer, "%d", &tpass); drain_name = drain_opt->answer; /* this isn't a nice thing to do. Rast_align_window() should be used first */ Rast_get_cellhd(drain_name, "", &window); Rast_set_window(&window); nrows = Rast_window_rows(); ncols = Rast_window_cols(); ridge_name = ridge_opt->answer; part_name = part_opt->answer; drain = read_map(drain_name, NOMASK, nrows, ncols); ridge = read_map(ridge_name, NOMASK, nrows, ncols); partfd = Rast_open_c_new(part_name); /* run through file and set streams to zero at locations where ridges exist */ for (row = 0; row < nrows; row++) { for (col = 0; col < ncols; col++) if (ridge[row * ncols + col] != 0) drain[row * ncols + col] = 0; } for (npass = 1; npass <= tpass; npass++) { for (row = 1; row < nrows - 1; row++) { for (col = 1; col < ncols - 1; col++) { if (drain[row * ncols + col] == 0 && ridge[row * ncols + col] == 0) { if (drain[(row - 1) * ncols + col] != 0 && ridge[(row - 1) * ncols + col] == 0) drain[row * ncols + col] = drain[(row - 1) * ncols + col]; if (drain[row * ncols + (col - 1)] != 0 && ridge[row * ncols + (col - 1)] == 0) drain[row * ncols + col] = drain[row * ncols + (col - 1)]; } } } G_message(_("Forward sweep complete")); for (row = nrows - 3; row > 1; --row) { for (col = ncols - 3; col > 1; --col) { if (drain[row * ncols + col] == 0 && ridge[row * ncols + col] == 0) { if (drain[(row + 1) * ncols + col] != 0 && ridge[(row + 1) * ncols + col] == 0) drain[row * ncols + col] = drain[(row + 1) * ncols + col]; if (drain[row * ncols + (col + 1)] != 0 && ridge[row * ncols + (col + 1)] == 0) drain[row * ncols + col] = drain[row * ncols + (col + 1)]; } } } G_message(_("Reverse sweep complete")); } /* write out partitioned watershed map */ for (row = 0; row < nrows; row++) Rast_put_row(partfd, drain + (row * ncols), CELL_TYPE); G_message(_("Creating support files for <%s>..."), part_name); Rast_close(partfd); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { int r, c; DCELL con1, con2; double d1, d2; DCELL *alt_row; const char *con_name, *alt_name; int file_fd; DCELL value; struct History history; struct GModule *module; struct Option *opt1, *opt2; G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("surface")); G_add_keyword(_("interpolation")); module->description = _("Generates surface raster map from rasterized contours."); opt1 = G_define_standard_option(G_OPT_R_INPUT); opt1->description = _("Name of input raster map containing contours"); opt2 = G_define_standard_option(G_OPT_R_OUTPUT); if (G_parser(argc, argv)) exit(EXIT_FAILURE); con_name = opt1->answer; alt_name = opt2->answer; nrows = Rast_window_rows(); ncols = Rast_window_cols(); i_val_l_f = nrows + ncols; con = read_cell(con_name); alt_row = (DCELL *) G_malloc(ncols * sizeof(DCELL)); seen = flag_create(nrows, ncols); mask = flag_create(nrows, ncols); if (NULL != G_find_file("cell", "MASK", G_mapset())) { file_fd = Rast_open_old("MASK", G_mapset()); for (r = 0; r < nrows; r++) { Rast_get_d_row_nomask(file_fd, alt_row, r); for (c = 0; c < ncols; c++) if (Rast_is_d_null_value(&(alt_row[c])) || alt_row[c] == 0) FLAG_SET(mask, r, c); } Rast_close(file_fd); } zero = (NODE *) G_malloc(INIT_AR * sizeof(NODE)); minc = minr = 0; maxc = ncols - 1; maxr = nrows - 1; array_size = INIT_AR; file_fd = Rast_open_new(alt_name, DCELL_TYPE); for (r = 0; r < nrows; r++) { G_percent(r, nrows, 1); Rast_set_d_null_value(alt_row, ncols); for (c = 0; c < ncols; c++) { if (FLAG_GET(mask, r, c)) continue; value = con[r][c]; if (!Rast_is_d_null_value(&value)) { alt_row[c] = value; continue; } find_con(r, c, &d1, &d2, &con1, &con2); if (!Rast_is_d_null_value(&con2)) alt_row[c] = d2 * con1 / (d1 + d2) + d1 * con2 / (d1 + d2); else alt_row[c] = con1; } Rast_put_row(file_fd, alt_row, DCELL_TYPE); } G_percent(1, 1, 1); free_cell(con); flag_destroy(seen); flag_destroy(mask); Rast_close(file_fd); Rast_short_history(alt_name, "raster", &history); Rast_command_history(&history); Rast_write_history(alt_name, &history); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { struct Cell_head cellhd; /*region+header info */ char *mapset; /*mapset name */ int nrows, ncols; int row, col; struct GModule *module; struct Option *input, *input1, *input2, *input3, *input4, *input5, *output; struct History history; /*metadata */ struct Colors colors; /*Color rules */ /************************************/ char *name, *name1, *name2; /*input raster name */ char *result; /*output raster name */ /*File Descriptors */ int nfiles, nfiles1, nfiles2; int infd[MAXFILES], infd1[MAXFILES], infd2[MAXFILES]; int outfd; /****************************************/ /* Pointers for file names */ char **names; char **ptr; char **names1; char **ptr1; char **names2; char **ptr2; /****************************************/ int DOYbeforeETa[MAXFILES], DOYafterETa[MAXFILES]; int bfr, aft; /****************************************/ int ok; int i = 0, j = 0; double etodoy; /*minimum ETo DOY */ double startperiod, endperiod; /*first and last days (DOYs) of the period studied */ void *inrast[MAXFILES], *inrast1[MAXFILES], *inrast2[MAXFILES]; DCELL *outrast; CELL val1, val2; RASTER_MAP_TYPE in_data_type[MAXFILES]; /* ETa */ RASTER_MAP_TYPE in_data_type1[MAXFILES]; /* DOY of ETa */ RASTER_MAP_TYPE in_data_type2[MAXFILES]; /* ETo */ RASTER_MAP_TYPE out_data_type = DCELL_TYPE; /************************************/ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("imagery")); G_add_keyword(_("evapotranspiration")); module->description =_("Computes temporal integration of satellite " "ET actual (ETa) following the daily ET reference " "(ETo) from meteorological station(s)."); /* Define the different options */ input = G_define_standard_option(G_OPT_R_INPUTS); input->key = "eta"; input->description = _("Names of satellite ETa raster maps [mm/d or cm/d]"); input1 = G_define_standard_option(G_OPT_R_INPUTS); input1->key = "eta_doy"; input1->description = _("Names of satellite ETa Day of Year (DOY) raster maps [0-400] [-]"); input2 = G_define_standard_option(G_OPT_R_INPUTS); input2->key = "eto"; input2->description = _("Names of meteorological station ETo raster maps [0-400] [mm/d or cm/d]"); input3 = G_define_option(); input3->key = "eto_doy_min"; input3->type = TYPE_DOUBLE; input3->required = YES; input3->description = _("Value of DOY for ETo first day"); input4 = G_define_option(); input4->key = "start_period"; input4->type = TYPE_DOUBLE; input4->required = YES; input4->description = _("Value of DOY for the first day of the period studied"); input5 = G_define_option(); input5->key = "end_period"; input5->type = TYPE_DOUBLE; input5->required = YES; input5->description = _("Value of DOY for the last day of the period studied"); output = G_define_standard_option(G_OPT_R_OUTPUT); /* init nfiles */ nfiles = 1; nfiles1 = 1; nfiles2 = 1; /********************/ if (G_parser(argc, argv)) exit(EXIT_FAILURE); ok = 1; names = input->answers; ptr = input->answers; names1 = input1->answers; ptr1 = input1->answers; names2 = input2->answers; ptr2 = input2->answers; etodoy = atof(input3->answer); startperiod = atof(input4->answer); endperiod = atof(input5->answer); result = output->answer; /****************************************/ if (endperiod<startperiod) { G_fatal_error(_("The DOY for end_period can not be smaller than start_period")); ok = 0; } if (etodoy>startperiod) { G_fatal_error(_("The DOY for start_period can not be smaller than eto_doy_min")); ok = 0; } for (; *ptr != NULL; ptr++) { if (nfiles > MAXFILES) G_fatal_error(_("Too many ETa files. Only %d allowed."), MAXFILES); name = *ptr; /* Allocate input buffer */ infd[nfiles] = Rast_open_old(name, ""); Rast_get_cellhd(name, "", &cellhd); inrast[nfiles] = Rast_allocate_d_buf(); nfiles++; } nfiles--; if (nfiles <= 1) G_fatal_error(_("The min specified input map is two")); /****************************************/ for (; *ptr1 != NULL; ptr1++) { if (nfiles1 > MAXFILES) G_fatal_error(_("Too many ETa_doy files. Only %d allowed."), MAXFILES); name1 = *ptr1; /* Allocate input buffer */ infd1[nfiles1] = Rast_open_old(name1, ""); Rast_get_cellhd(name1, "", &cellhd); inrast1[nfiles1] = Rast_allocate_d_buf(); nfiles1++; } nfiles1--; if (nfiles1 <= 1) G_fatal_error(_("The min specified input map is two")); /****************************************/ if (nfiles != nfiles1) G_fatal_error(_("ETa and ETa_DOY file numbers are not equal!")); /****************************************/ for (; *ptr2 != NULL; ptr2++) { if (nfiles > MAXFILES) G_fatal_error(_("Too many ETo files. Only %d allowed."), MAXFILES); name2 = *ptr2; /* Allocate input buffer */ infd2[nfiles2] = Rast_open_old(name2, ""); Rast_get_cellhd(name2, "", &cellhd); inrast2[nfiles2] = Rast_allocate_d_buf(); nfiles2++; } nfiles2--; if (nfiles2 <= 1) G_fatal_error(_("The min specified input map is two")); /* Allocate output buffer, use input map data_type */ nrows = Rast_window_rows(); ncols = Rast_window_cols(); outrast = Rast_allocate_d_buf(); /* Create New raster files */ outfd = Rast_open_new(result, 1); /*******************/ /* Process pixels */ double doy[MAXFILES]; double sum[MAXFILES]; for (row = 0; row < nrows; row++) { DCELL d_out; DCELL d_ETrF[MAXFILES]; DCELL d[MAXFILES]; DCELL d1[MAXFILES]; DCELL d2[MAXFILES]; G_percent(row, nrows, 2); /* read input map */ for (i = 1; i <= nfiles; i++) Rast_get_d_row(infd[i], inrast[i], row); for (i = 1; i <= nfiles1; i++) Rast_get_d_row(infd1[i], inrast1[i], row); for (i = 1; i <= nfiles2; i++) Rast_get_d_row (infd2[i], inrast2[i], row); /*process the data */ for (col = 0; col < ncols; col++) { int d1_null=0; int d_null=0; for (i = 1; i <= nfiles; i++) { if (Rast_is_d_null_value(&((DCELL *) inrast[i])[col])) d_null=1; else d[i] = ((DCELL *) inrast[i])[col]; } for (i = 1; i <= nfiles1; i++) { if (Rast_is_d_null_value(&((DCELL *) inrast1[i])[col])) d1_null=1; else d1[i] = ((DCELL *) inrast1[i])[col]; } for (i = 1; i <= nfiles2; i++) d2[i] = ((DCELL *) inrast2[i])[col]; /* Find out the DOY of the eto image */ for (i = 1; i <= nfiles1; i++) { if ( d_null==1 || d1_null==1 ) Rast_set_d_null_value(&outrast[col],1); else { doy[i] = d1[i] - etodoy+1; if (Rast_is_d_null_value(&d2[(int)doy[i]]) || d2[(int)doy[i]]==0 ) Rast_set_d_null_value(&outrast[col],1); else d_ETrF[i] = d[i] / d2[(int)doy[i]]; } } for (i = 1; i <= nfiles1; i++) { /* do nothing */ if ( d_null==1 || d1_null==1) { /*G_message(" null value ");*/ } else { DOYbeforeETa[i]=0; DOYafterETa[i]=0; if (i == 1) DOYbeforeETa[i] = startperiod; else { int k=i-1; while (d1[k]>=startperiod ) { if (d1[k]<0) // case were d1[k] is null k=k-1; else { DOYbeforeETa[i] = 1+((d1[i] + d1[k])/2.0); break; } } } if (i == nfiles1) DOYafterETa[i] = endperiod; else { int k=i+1; while (d1[k]<=endperiod) { if (d1[k]<0) // case were d1[k] is null k=k+1; else { DOYafterETa[i] = (d1[i] + d1[k]) / 2.0; break; } } } } } sum[MAXFILES] = 0.0; for (i = 1; i <= nfiles1; i++) { if(d_null==1 || d1_null==1) { /* do nothing */ } else { if (DOYbeforeETa[i]==0 || DOYbeforeETa[i]==0 ) Rast_set_d_null_value(&outrast[col],1); else { bfr = (int)DOYbeforeETa[i]; aft = (int)DOYafterETa[i]; sum[i]=0.0; for (j = bfr; j < aft; j++) sum[i] += d2[(int)(j-etodoy+1)]; } } } d_out = 0.0; for (i = 1; i <= nfiles1; i++) { if(d_null==1 || d_null==1) Rast_set_d_null_value(&outrast[col],1); else { d_out += d_ETrF[i] * sum[i]; outrast[col] = d_out; } } } Rast_put_row(outfd, outrast, out_data_type); } for (i = 1; i <= nfiles; i++) { G_free(inrast[i]); Rast_close(infd[i]); } for (i = 1; i <= nfiles1; i++) { G_free(inrast1[i]); Rast_close(infd1[i]); } for (i = 1; i <= nfiles2; i++) { G_free(inrast2[i]); Rast_close(infd2[i]); } G_free(outrast); Rast_close(outfd); /* Color table from 0.0 to 10.0 */ Rast_init_colors(&colors); val1 = 0; val2 = 10; Rast_add_c_color_rule(&val1, 0, 0, 0, &val2, 255, 255, 255, &colors); /* Metadata */ Rast_short_history(result, "raster", &history); Rast_command_history(&history); Rast_write_history(result, &history); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { 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[]) { struct Cell_head cellhd; /*region+header info */ char *mapset; /*mapset name */ int nrows, ncols; int row, col; struct GModule *module; struct Option *input1, *input2, *input3, *input4, *input5; struct Option *input6, *input7, *input8, *input9, *output1; struct Flag *flag1; struct History history; /*metadata */ struct Colors colors; /*Color rules */ char *name; /*input raster name */ char *result; /*output raster name */ int infd_albedo, infd_ndvi, infd_tempk, infd_time, infd_dtair; int infd_emissivity, infd_tsw, infd_doy, infd_sunzangle; int outfd; char *albedo, *ndvi, *tempk, *time, *dtair, *emissivity; char *tsw, *doy, *sunzangle; int i = 0, j = 0; void *inrast_albedo, *inrast_ndvi, *inrast_tempk, *inrast_rnet; void *inrast_time, *inrast_dtair, *inrast_emissivity, *inrast_tsw; void *inrast_doy, *inrast_sunzangle; DCELL * outrast; CELL val1,val2; /*For color range*/ G_gisinit(argv[0]); module = G_define_module(); G_add_keyword(_("imagery")); G_add_keyword(_("energy balance")); G_add_keyword(_("net radiation")); G_add_keyword(_("SEBAL")); module->description = _("Net radiation approximation (Bastiaanssen, 1995)."); /* Define the different options */ input1 = G_define_standard_option(G_OPT_R_INPUT); input1->key = "albedo"; input1->description = _("Name of albedo raster map [0.0;1.0]"); input2 = G_define_standard_option(G_OPT_R_INPUT); input2->key = "ndvi"; input2->description = _("Name of NDVI raster map [-1.0;+1.0]"); input3 = G_define_standard_option(G_OPT_R_INPUT); input3->key = "temperature"; input3->description = _("Name of surface temperature raster map [K]"); input4 = G_define_standard_option(G_OPT_R_INPUT); input4->key = "localutctime"; input4->description = _("Name of time of satellite overpass raster map [local time in UTC]"); input5 = G_define_standard_option(G_OPT_R_INPUT); input5->key = "temperaturedifference2m"; input5->description = _("Name of the difference map of temperature from surface skin to about 2 m height [K]"); input6 = G_define_standard_option(G_OPT_R_INPUT); input6->key = "emissivity"; input6->description = _("Name of the emissivity map [-]"); input7 = G_define_standard_option(G_OPT_R_INPUT); input7->key = "transmissivity_singleway"; input7->description = _("Name of the single-way atmospheric transmissivitymap [-]"); input8 = G_define_standard_option(G_OPT_R_INPUT); input8->key = "dayofyear"; input8->description = _("Name of the Day Of Year (DOY) map [-]"); input9 = G_define_standard_option(G_OPT_R_INPUT); input9->key = "sunzenithangle"; input9->description = _("Name of the sun zenith angle map [degrees]"); output1 = G_define_standard_option(G_OPT_R_OUTPUT); output1->description = _("Name of the output net radiation layer"); /********************/ if (G_parser(argc, argv)) exit(EXIT_FAILURE); albedo = input1->answer; ndvi = input2->answer; tempk = input3->answer; time = input4->answer; dtair = input5->answer; emissivity = input6->answer; tsw = input7->answer; doy = input8->answer; sunzangle = input9->answer; result = output1->answer; /* Open access to image files and allocate row access memory */ infd_albedo = Rast_open_old(albedo, ""); inrast_albedo = Rast_allocate_d_buf(); infd_ndvi = Rast_open_old(ndvi, ""); inrast_ndvi = Rast_allocate_d_buf(); infd_tempk = Rast_open_old(tempk, ""); inrast_tempk = Rast_allocate_d_buf(); infd_dtair = Rast_open_old(dtair, ""); inrast_dtair = Rast_allocate_d_buf(); infd_time = Rast_open_old(time, ""); inrast_time = Rast_allocate_d_buf(); infd_emissivity = Rast_open_old(emissivity, ""); inrast_emissivity = Rast_allocate_d_buf(); infd_tsw = Rast_open_old(tsw, ""); inrast_tsw = Rast_allocate_d_buf(); infd_doy = Rast_open_old(doy, ""); inrast_doy = Rast_allocate_d_buf(); infd_sunzangle = Rast_open_old(sunzangle, ""); inrast_sunzangle = Rast_allocate_d_buf(); nrows = Rast_window_rows(); ncols = Rast_window_cols(); outfd = Rast_open_new(result, DCELL_TYPE); outrast = Rast_allocate_d_buf(); /* Process pixels */ for (row = 0; row < nrows; row++) { DCELL d; DCELL d_albedo; DCELL d_ndvi; DCELL d_tempk; DCELL d_dtair; DCELL d_time; DCELL d_emissivity; DCELL d_tsw; DCELL d_doy; DCELL d_sunzangle; /* Display row process percentage */ G_percent(row, nrows, 2); /* Load rows for each input image */ Rast_get_d_row(infd_albedo, inrast_albedo, row); Rast_get_d_row(infd_ndvi, inrast_ndvi, row); Rast_get_d_row(infd_tempk, inrast_tempk, row); Rast_get_d_row(infd_dtair, inrast_dtair, row); Rast_get_d_row(infd_time, inrast_time, row); Rast_get_d_row(infd_emissivity, inrast_emissivity, row); Rast_get_d_row(infd_tsw, inrast_tsw, row); Rast_get_d_row(infd_doy, inrast_doy, row); Rast_get_d_row(infd_sunzangle, inrast_sunzangle, row); /*process the data */ for (col = 0; col < ncols; col++) { d_albedo = (double)((DCELL *) inrast_albedo)[col]; d_ndvi = (double)((DCELL *) inrast_ndvi)[col]; d_tempk = (double)((DCELL *) inrast_tempk)[col]; d_dtair = (double)((DCELL *) inrast_dtair)[col]; d_time = (double)((DCELL *) inrast_time)[col]; d_emissivity = (double)((DCELL *) inrast_emissivity)[col]; d_tsw = (double)((DCELL *) inrast_tsw)[col]; d_doy = (double)((DCELL *) inrast_doy)[col]; d_sunzangle = (double)((DCELL *) inrast_sunzangle)[col]; /* process NULL Values */ if (Rast_is_d_null_value(&d_albedo) || Rast_is_d_null_value(&d_ndvi) || Rast_is_d_null_value(&d_tempk) || Rast_is_d_null_value(&d_dtair) || Rast_is_d_null_value(&d_time) || Rast_is_d_null_value(&d_emissivity) || Rast_is_d_null_value(&d_tsw) || Rast_is_d_null_value(&d_doy) || Rast_is_d_null_value(&d_sunzangle)) { Rast_set_d_null_value(&outrast[col], 1); } else { /************************************/ /* calculate the net radiation */ d = r_net(d_albedo, d_ndvi, d_tempk, d_dtair, d_emissivity, d_tsw, d_doy, d_time, d_sunzangle); outrast[col] = d; } } Rast_put_d_row(outfd, outrast); } G_free(inrast_albedo); G_free(inrast_ndvi); G_free(inrast_tempk); G_free(inrast_dtair); G_free(inrast_time); G_free(inrast_emissivity); G_free(inrast_tsw); G_free(inrast_doy); G_free(inrast_sunzangle); Rast_close(infd_albedo); Rast_close(infd_ndvi); Rast_close(infd_tempk); Rast_close(infd_dtair); Rast_close(infd_time); Rast_close(infd_emissivity); Rast_close(infd_tsw); Rast_close(infd_doy); Rast_close(infd_sunzangle); G_free(outrast); Rast_close(outfd); /* Colors in grey shade */ Rast_init_colors(&colors); val1=0; val2=900; Rast_add_c_color_rule(&val1, 0, 0, 0, &val2, 255, 255, 255, &colors); /* Metadata */ Rast_short_history(result, "raster", &history); Rast_command_history(&history); Rast_write_history(result, &history); exit(EXIT_SUCCESS); }
int main(int argc, char *argv[]) { struct GModule *module; struct Option *in_dir_opt, *in_stm_opt, *in_elev_opt, *in_method_opt, *opt_swapsize, *out_dist_opt, *out_diff_opt; struct Flag *flag_outs, *flag_sub, *flag_near, *flag_segmentation; char *method_name[] = { "UPSTREAM", "DOWNSTREAM" }; int method; int number_of_segs; int outlets_num; int number_of_streams; int outs, subs, near, segmentation; /*flags */ int j; G_gisinit(argv[0]); module = G_define_module(); module->label = _("Calculates distance to and elevation above streams and outlet."); module->description = _("The module can work in stream mode where target are streams and " "outlets mode where targets are outlets."); G_add_keyword(_("raster")); G_add_keyword(_("hydrology")); G_add_keyword(_("stream network")); G_add_keyword(_("watercourse distance")); in_stm_opt = G_define_standard_option(G_OPT_R_INPUT); in_stm_opt->key = "stream_rast"; in_stm_opt->description = _("Name of input raster map with stream network " "(in outlet mode is the name for outlet raster map)"); in_dir_opt = G_define_standard_option(G_OPT_R_INPUT); in_dir_opt->key = "direction"; in_dir_opt->description = _("Name of input raster map with flow direction"); in_elev_opt = G_define_standard_option(G_OPT_R_ELEV); in_elev_opt->required = NO; in_elev_opt->guisection = _("Input maps"); in_method_opt = G_define_option(); in_method_opt->key = "method"; in_method_opt->description = _("Calculation method"); in_method_opt->type = TYPE_STRING; in_method_opt->required = YES; in_method_opt->options = "upstream,downstream"; in_method_opt->answer = "downstream"; out_dist_opt = G_define_standard_option(G_OPT_R_OUTPUT); out_dist_opt->key = "distance"; out_dist_opt->required = NO; out_dist_opt->description = _("Name for output distance raster map"); out_dist_opt->guisection = _("Output maps"); out_diff_opt = G_define_standard_option(G_OPT_R_OUTPUT); out_diff_opt->key = "difference"; out_diff_opt->required = NO; out_diff_opt->description = _("Name for output elevation difference raster map"); out_diff_opt->guisection = _("Output maps"); opt_swapsize = G_define_option(); opt_swapsize->key = "memory"; opt_swapsize->type = TYPE_INTEGER; opt_swapsize->answer = "300"; opt_swapsize->description = _("Max memory used in memory swap mode (MB)"); opt_swapsize->guisection = _("Memory settings"); flag_outs = G_define_flag(); flag_outs->key = 'o'; flag_outs->description = _("Calculate parameters for outlets (outlet mode) instead of (default) streams"); flag_sub = G_define_flag(); flag_sub->key = 's'; flag_sub->description = _("Calculate parameters for subbasins (ignored in stream mode)"); flag_near = G_define_flag(); flag_near->key = 'n'; flag_near->description = _("Calculate nearest local maximum (ignored in downstream calculation)"); flag_segmentation = G_define_flag(); flag_segmentation->key = 'm'; flag_segmentation->description = _("Use memory swap (operation is slow)"); flag_segmentation->guisection = _("Memory settings"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); if (!out_diff_opt->answer && !out_dist_opt->answer) G_fatal_error(_("You must select at least one output raster map")); if (out_diff_opt->answer && !in_elev_opt->answer) G_fatal_error(_("Output elevation difference raster map requires " "input elevation raster map to be specified")); if (!strcmp(in_method_opt->answer, "upstream")) method = UPSTREAM; else if (!strcmp(in_method_opt->answer, "downstream")) method = DOWNSTREAM; outs = (flag_outs->answer != 0); subs = (flag_sub->answer != 0); near = (flag_near->answer != 0); segmentation = (flag_segmentation->answer != 0); nrows = Rast_window_rows(); ncols = Rast_window_cols(); G_begin_distance_calculations(); fifo_max = 4 * (nrows + ncols); fifo_points = (POINT *) G_malloc((fifo_max + 1) * sizeof(POINT)); if (!segmentation) { G_message(_("All in RAM calculation - method <%s>..."), method_name[method]); MAP map_dirs, map_streams, map_distance, map_elevation, map_tmp_elevation; CELL **streams, **dirs; DCELL **distance; DCELL **elevation = NULL; DCELL **tmp_elevation = NULL; ram_create_map(&map_streams, CELL_TYPE); ram_read_map(&map_streams, in_stm_opt->answer, 1, CELL_TYPE); ram_create_map(&map_dirs, CELL_TYPE); ram_read_map(&map_dirs, in_dir_opt->answer, 1, CELL_TYPE); ram_create_map(&map_distance, DCELL_TYPE); streams = (CELL **) map_streams.map; dirs = (CELL **) map_dirs.map; distance = (DCELL **) map_distance.map; number_of_streams = (int)map_streams.max + 1; outlets_num = ram_find_outlets(streams, number_of_streams, dirs, subs, outs); ram_init_distance(streams, distance, outlets_num, outs); ram_release_map(&map_streams); if (in_elev_opt->answer) { ram_create_map(&map_elevation, DCELL_TYPE); ram_read_map(&map_elevation, in_elev_opt->answer, 0, -1); elevation = (DCELL **) map_elevation.map; } /* map elevation will be replaced by elevation difference map */ if (method == DOWNSTREAM) { G_message(_("Calculate downstream parameters...")); for (j = 0; j < outlets_num; ++j) { G_percent(j, outlets_num, 1); ram_calculate_downstream(dirs, distance, elevation, outlets[j], outs); } G_percent(j, outlets_num, 1); } else if (method == UPSTREAM) { if (out_diff_opt->answer) { ram_create_map(&map_tmp_elevation, DCELL_TYPE); tmp_elevation = (DCELL **) map_tmp_elevation.map; } for (j = 0; j < outlets_num; ++j) ram_fill_basins(outlets[j], distance, dirs); ram_calculate_upstream(distance, dirs, elevation, tmp_elevation, near); } else { G_fatal_error(_("Unrecognised method of processing")); } /* end methods */ if (out_diff_opt->answer) { ram_prep_null_elevation(distance, elevation); ram_write_map(&map_elevation, out_diff_opt->answer, DCELL_TYPE, 1, -1); } if (out_dist_opt->answer) ram_write_map(&map_distance, out_dist_opt->answer, DCELL_TYPE, 1, -1); ram_release_map(&map_dirs); ram_release_map(&map_distance); if (in_elev_opt->answer) ram_release_map(&map_elevation); if (in_elev_opt->answer && method == UPSTREAM) ram_release_map(&map_tmp_elevation); } if (segmentation) { G_message(_("Calculating segments in direction <%s> (may take some time)..."), method_name[method]); SEG map_dirs, map_streams, map_distance, map_elevation, map_tmp_elevation; SEGMENT *streams, *dirs, *distance; SEGMENT *elevation = NULL; SEGMENT *tmp_elevation = NULL; number_of_segs = (int)atof(opt_swapsize->answer); if (method == DOWNSTREAM) number_of_segs = number_of_segs < 32 ? (int)(32 / 0.18) : number_of_segs / 0.18; else /* two elevation maps */ number_of_segs = number_of_segs < 32 ? (int)(32 / 0.24) : number_of_segs / 0.24; seg_create_map(&map_streams, SROWS, SCOLS, number_of_segs, CELL_TYPE); seg_read_map(&map_streams, in_stm_opt->answer, 1, CELL_TYPE); seg_create_map(&map_dirs, SROWS, SCOLS, number_of_segs, CELL_TYPE); seg_read_map(&map_dirs, in_dir_opt->answer, 1, CELL_TYPE); seg_create_map(&map_distance, SROWS, SCOLS, number_of_segs, DCELL_TYPE); streams = &map_streams.seg; dirs = &map_dirs.seg; distance = &map_distance.seg; number_of_streams = (int)map_streams.max + 1; outlets_num = seg_find_outlets(streams, number_of_streams, dirs, subs, outs); seg_init_distance(streams, distance, outlets_num, outs); seg_release_map(&map_streams); if (in_elev_opt->answer) { seg_create_map(&map_elevation, SROWS, SCOLS, number_of_segs, DCELL_TYPE); seg_read_map(&map_elevation, in_elev_opt->answer, 0, -1); elevation = &map_elevation.seg; } /* map elevation will be replaced by elevation difference map */ if (method == DOWNSTREAM) { G_message(_("Calculate downstream parameters...")); for (j = 0; j < outlets_num; ++j) { G_percent(j, outlets_num, 1); seg_calculate_downstream(dirs, distance, elevation, outlets[j], outs); } G_percent(j, outlets_num, 1); } else if (method == UPSTREAM) { if (out_diff_opt->answer) { seg_create_map(&map_tmp_elevation, SROWS, SCOLS, number_of_segs, DCELL_TYPE); tmp_elevation = &map_tmp_elevation.seg; } for (j = 0; j < outlets_num; ++j) seg_fill_basins(outlets[j], distance, dirs); seg_calculate_upstream(distance, dirs, elevation, tmp_elevation, near); } else { G_fatal_error(_("Unrecognised method of processing")); } /* end methods */ if (out_dist_opt->answer) seg_write_map(&map_distance, out_dist_opt->answer, DCELL_TYPE, 1, -1); if (out_diff_opt->answer) { seg_prep_null_elevation(distance, elevation); seg_write_map(&map_elevation, out_diff_opt->answer, DCELL_TYPE, 1, -1); } seg_release_map(&map_dirs); seg_release_map(&map_distance); if (in_elev_opt->answer) seg_release_map(&map_elevation); if (in_elev_opt->answer && method == UPSTREAM) seg_release_map(&map_tmp_elevation); } G_free(fifo_points); exit(EXIT_SUCCESS); }
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[]) { 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); }
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; }
CELL clump(int in_fd, int out_fd, int diag, int print) { register int col; register int n; CELL NEW, OLD; CELL *temp_cell, *temp_clump; CELL *prev_in, *cur_in, *out_cell; CELL *prev_clump, *cur_clump; CELL X, LEFT; CELL *index, *renumber; CELL label; int nrows, ncols; int row; int len; int nalloc; long cur_time; char *cname; int cfd, csize; CELL cat; nrows = Rast_window_rows(); ncols = Rast_window_cols(); /* allocate clump index */ nalloc = INCR; index = (CELL *) G_malloc(nalloc * sizeof(CELL)); index[0] = 0; renumber = NULL; /* allocate CELL buffers two columns larger than current window */ len = (ncols + 2) * sizeof(CELL); prev_in = (CELL *) G_malloc(len); cur_in = (CELL *) G_malloc(len); prev_clump = (CELL *) G_malloc(len); cur_clump = (CELL *) G_malloc(len); out_cell = (CELL *) G_malloc(len); /* temp file for initial clump IDs */ cname = G_tempfile(); if ((cfd = open(cname, O_RDWR | O_CREAT | O_EXCL, 0600)) < 0) G_fatal_error(_("Unable to open temp file")); csize = ncols * sizeof(CELL); time(&cur_time); /* fake a previous row which is all NULL */ Rast_set_c_null_value(prev_in, ncols + 2); /* set left and right edge to NULL */ Rast_set_c_null_value(&cur_in[0], 1); Rast_set_c_null_value(&cur_in[ncols + 1], 1); /* initialize clump labels */ G_zero(cur_clump, len); G_zero(prev_clump, len); label = 0; /**************************************************** * PASS 1 * * pass thru the input, create initial clump labels * ****************************************************/ G_message(_("Pass 1 of 2...")); for (row = 0; row < nrows; row++) { Rast_get_c_row(in_fd, cur_in + 1, row); G_percent(row, nrows, 4); Rast_set_c_null_value(&X, 1); for (col = 1; col <= ncols; col++) { LEFT = X; X = cur_in[col]; if (Rast_is_c_null_value(&X)) { /* don't clump NULL data */ cur_clump[col] = 0; continue; } /* * if the cell value is different to the left and above * (diagonal: and above left and above right) * then we must start a new clump * * this new clump may eventually collide with another * clump and will have to be merged */ /* try to connect the current cell to an existing clump */ OLD = NEW = 0; /* same clump as to the left */ if (X == LEFT) { OLD = cur_clump[col] = cur_clump[col - 1]; } if (diag) { /* check above right, center, left, in that order */ n = 2; temp_clump = prev_clump + col + 1; temp_cell = prev_in + col + 1; do { if (X == *temp_cell) { cur_clump[col] = *temp_clump; if (OLD == 0) { OLD = *temp_clump; } else { NEW = *temp_clump; break; } } temp_cell--; temp_clump--; } while (n-- > 0); } else { /* check above */ if (X == prev_in[col]) { temp_clump = prev_clump + col; cur_clump[col] = *temp_clump; if (OLD == 0) { OLD = *temp_clump; } else { NEW = *temp_clump; } } } if (NEW == 0 || OLD == NEW) { /* ok */ if (OLD == 0) { /* start a new clump */ label++; cur_clump[col] = label; if (label >= nalloc) { nalloc += INCR; index = (CELL *) G_realloc(index, nalloc * sizeof(CELL)); } index[label] = label; } continue; } /* conflict! preserve NEW clump ID and change OLD clump ID. * Must go back to the left in the current row and to the right * in the previous row to change all the clump values as well. */ /* left of the current row from 1 to col - 1 */ temp_clump = cur_clump; n = col - 1; while (n-- > 0) { temp_clump++; /* skip left edge */ if (*temp_clump == OLD) *temp_clump = NEW; } /* right of previous row from col + 1 to ncols */ temp_clump = prev_clump; temp_clump += col; n = ncols - col; while (n-- > 0) { temp_clump++; /* skip col */ if (*temp_clump == OLD) *temp_clump = NEW; } /* modify the OLD index */ index[OLD] = NEW; } /* write initial clump IDs */ /* this works also with writing out cur_clump, but only * prev_clump is complete and will not change any more */ if (row > 0) { if (write(cfd, prev_clump + 1, csize) != csize) G_fatal_error(_("Unable to write to temp file")); } /* switch the buffers so that the current buffer becomes the previous */ temp_cell = cur_in; cur_in = prev_in; prev_in = temp_cell; temp_clump = cur_clump; cur_clump = prev_clump; prev_clump = temp_clump; } /* write last row with initial clump IDs */ if (write(cfd, prev_clump + 1, csize) != csize) G_fatal_error(_("Unable to write to temp file")); G_percent(1, 1, 1); /* generate a renumbering scheme */ G_message(_("Generating renumbering scheme...")); G_debug(1, "%d initial labels", label); /* allocate final clump ID */ renumber = (CELL *) G_malloc((label + 1) * sizeof(CELL)); renumber[0] = 0; cat = 1; G_percent(0, label, 1); for (n = 1; n <= label; n++) { G_percent(n, label, 1); OLD = n; NEW = index[n]; if (OLD != NEW) { renumber[n] = 0; /* find valid clump ID */ while (OLD != NEW) { OLD = NEW; NEW = index[OLD]; } index[n] = NEW; } else /* set final clump id */ renumber[n] = cat++; } /* rewind temp file */ lseek(cfd, 0, SEEK_SET); if (print) { fprintf(stdout, "clumps=%d\n", cat - 1); } else { /**************************************************** * PASS 2 * * apply renumbering scheme to initial clump labels * ****************************************************/ /* the input raster is no longer needed, * using instead the temp file with initial clump labels */ G_message(_("Pass 2 of 2...")); for (row = 0; row < nrows; row++) { G_percent(row, nrows, 4); if (read(cfd, cur_clump, csize) != csize) G_fatal_error(_("Unable to read from temp file")); temp_clump = cur_clump; temp_cell = out_cell; for (col = 0; col < ncols; col++) { *temp_cell = renumber[index[*temp_clump]]; if (*temp_cell == 0) Rast_set_c_null_value(temp_cell, 1); temp_clump++; temp_cell++; } Rast_put_row(out_fd, out_cell, CELL_TYPE); } G_percent(1, 1, 1); } close(cfd); unlink(cname); print_time(&cur_time); return 0; }
int main(int argc, char *argv[]) { int fd[NFILES]; int outfd; int i; const char *name; const char *output; const char *mapset; int non_zero; struct Range range; CELL ncats, max_cats; int primary; struct Categories pcats; struct Colors pcolr; char buf[1024]; CELL result; struct GModule *module; struct { struct Option *input, *output; } parm; struct { struct Flag *z; } flag; G_gisinit(argv[0]); /* Define the different options */ module = G_define_module(); G_add_keyword(_("raster")); G_add_keyword(_("statistics")); module->description = _("Creates a cross product of the category values from " "multiple raster map layers."); parm.input = G_define_option(); parm.input->key = "input"; parm.input->type = TYPE_STRING; parm.input->required = YES; parm.input->multiple = YES; parm.input->gisprompt = "old,cell,raster"; sprintf(buf, _("Names of 2-%d input raster maps"), NFILES); parm.input->description = G_store(buf); parm.output = G_define_standard_option(G_OPT_R_OUTPUT); /* Define the different flags */ flag.z = G_define_flag(); flag.z->key = 'z'; flag.z->description = _("Non-zero data only"); if (G_parser(argc, argv)) exit(EXIT_FAILURE); nrows = Rast_window_rows(); ncols = Rast_window_cols(); nfiles = 0; non_zero = flag.z->answer; for (nfiles = 0; (name = parm.input->answers[nfiles]); nfiles++) { if (nfiles >= NFILES) G_fatal_error(_("More than %d files not allowed"), NFILES); mapset = G_find_raster2(name, ""); if (!mapset) G_fatal_error(_("Raster map <%s> not found"), name); names[nfiles] = name; fd[nfiles] = Rast_open_old(name, mapset); Rast_read_range(name, mapset, &range); ncats = range.max - range.min; if (nfiles == 0 || ncats > max_cats) { primary = nfiles; max_cats = ncats; } } if (nfiles <= 1) G_fatal_error(_("Must specify 2 or more input maps")); output = parm.output->answer; outfd = Rast_open_c_new(output); sprintf(buf, "Cross of %s", names[0]); for (i = 1; i < nfiles - 1; i++) { strcat(buf, ", "); strcat(buf, names[i]); } strcat(buf, " and "); strcat(buf, names[i]); Rast_init_cats(buf, &pcats); /* first step is cross product, but un-ordered */ result = cross(fd, non_zero, primary, outfd); /* print message STEP mesage */ G_message(_("%s: STEP 2 ..."), G_program_name()); /* now close all files */ for (i = 0; i < nfiles; i++) Rast_close(fd[i]); Rast_close(outfd); if (result <= 0) exit(0); /* build the renumbering/reclass and the new cats file */ qsort(reclass, result + 1, sizeof(RECLASS), cmp); table = (CELL *) G_calloc(result + 1, sizeof(CELL)); for (i = 0; i < nfiles; i++) { mapset = G_find_raster2(names[i], ""); Rast_read_cats(names[i], mapset, &labels[i]); } for (ncats = 0; ncats <= result; ncats++) { table[reclass[ncats].result] = ncats; set_cat(ncats, reclass[ncats].cat, &pcats); } for (i = 0; i < nfiles; i++) Rast_free_cats(&labels[i]); /* reopen the output cell for reading and for writing */ fd[0] = Rast_open_old(output, G_mapset()); outfd = Rast_open_c_new(output); renumber(fd[0], outfd); G_message(_("Creating support files for <%s>..."), output); Rast_close(fd[0]); Rast_close(outfd); Rast_write_cats(output, &pcats); Rast_free_cats(&pcats); if (result > 0) { Rast_make_random_colors(&pcolr, (CELL) 1, result); Rast_write_colors(output, G_mapset(), &pcolr); } G_message(_("%ld categories"), (long)result); exit(EXIT_SUCCESS); }