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);
}
