static void load_input_raster3d_maps(struct Option *scalar_opt,
struct Option *vector_opt,
struct Gradient_info *gradient_info,
RASTER3D_Region * region)
{
int i;
if (scalar_opt->answer) {
gradient_info->scalar_map =
Rast3d_open_cell_old(scalar_opt->answer,
G_find_raster3d(scalar_opt->answer, ""),
region, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (!gradient_info->scalar_map)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
scalar_opt->answer);
gradient_info->compute_gradient = TRUE;
}
else {
for (i = 0; i < 3; i++) {
gradient_info->velocity_maps[i] =
Rast3d_open_cell_old(vector_opt->answers[i],
G_find_raster3d(vector_opt->answers[i],
""), region,
RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (!gradient_info->velocity_maps[i])
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
vector_opt->answers[i]);
}
gradient_info->compute_gradient = FALSE;
}
}
static void makeMask(char *name, d_Mask * maskRules)
{
void *map, *mask;
RASTER3D_Region region;
int tileX, tileY, tileZ, x, y, z, cacheSize;
double value;
float floatNull;
cacheSize = Rast3d_cache_size_encode(RASTER3D_USE_CACHE_XY, 1);
if (NULL == G_find_raster3d(name, ""))
Rast3d_fatal_error(_("3D raster map <%s> not found"), name);
map = Rast3d_open_cell_old(name, G_mapset(), RASTER3D_DEFAULT_WINDOW,
DCELL_TYPE, cacheSize);
if (map == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"), name);
Rast3d_get_region_struct_map(map, ®ion);
Rast3d_get_tile_dimensions_map(map, &tileX, &tileY, &tileZ);
mask = Rast3d_open_new_param(Rast3d_mask_file(), FCELL_TYPE, cacheSize,
®ion, FCELL_TYPE, RASTER3D_COMPRESSION, 0,
tileX, tileY, tileZ);
if (mask == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster mask file"));
Rast3d_min_unlocked(map, RASTER3D_USE_CACHE_X);
Rast3d_autolock_on(map);
Rast3d_unlock_all(map);
Rast3d_min_unlocked(mask, RASTER3D_USE_CACHE_X);
Rast3d_autolock_on(mask);
Rast3d_unlock_all(mask);
Rast3d_set_null_value(&floatNull, 1, FCELL_TYPE);
for (z = 0; z < region.depths; z++) {
if ((z % tileZ) == 0) {
Rast3d_unlock_all(map);
Rast3d_unlock_all(mask);
}
for (y = 0; y < region.rows; y++) /* We count from north to south in the cube coordinate system */
for (x = 0; x < region.cols; x++) {
value = Rast3d_get_double_region(map, x, y, z);
if (Rast3d_mask_d_select((DCELL *) & value, maskRules))
Rast3d_put_float(mask, x, y, z, (float)floatNull); /* mask-out value */
else
Rast3d_put_float(mask, x, y, z, (float)0.0); /* not mask-out value */
}
if ((z % tileZ) == 0) {
if (!Rast3d_flush_tiles_in_cube
(mask, 0, 0, MAX(0, z - tileZ), region.rows - 1,
region.cols - 1, z))
Rast3d_fatal_error(_("makeMask: error flushing tiles in cube"));
}
}
if (!Rast3d_flush_all_tiles(mask))
Rast3d_fatal_error(_("makeMask: error flushing all tiles"));
Rast3d_autolock_off(map);
Rast3d_unlock_all(map);
Rast3d_autolock_off(mask);
Rast3d_unlock_all(mask);
if (!Rast3d_close(mask))
Rast3d_fatal_error(_("Unable to close 3D raster mask file"));
if (!Rast3d_close(map))
Rast3d_fatal_error(_("Unable to close raster map <%s>"), name);
}
/* ************************************************************************* */
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(_("conversion"));
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(_("Unable to open 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(_("Unable to open 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[])
{
struct Option *vector_opt, *seed_opt, *flowlines_opt, *flowacc_opt, *sampled_opt,
*scalar_opt, *unit_opt, *step_opt, *limit_opt, *skip_opt, *dir_opt,
*error_opt;
struct Flag *table_fl;
struct GModule *module;
RASTER3D_Region region;
RASTER3D_Map *flowacc, *sampled;
struct Integration integration;
struct Seed seed;
struct Gradient_info gradient_info;
struct Map_info seed_Map;
struct line_pnts *seed_points;
struct line_cats *seed_cats;
struct Map_info fl_map;
struct line_cats *fl_cats; /* for flowlines */
struct line_pnts *fl_points; /* for flowlines */
struct field_info *finfo;
dbDriver *driver;
int cat; /* cat of flowlines */
int if_table;
int i, r, c, d;
char *desc;
int n_seeds, seed_count, ltype;
int skip[3];
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("hydrology"));
G_add_keyword(_("voxel"));
module->description =
_("Computes 3D flow lines and 3D flow accumulation.");
scalar_opt = G_define_standard_option(G_OPT_R3_INPUT);
scalar_opt->required = NO;
scalar_opt->guisection = _("Input");
vector_opt = G_define_standard_option(G_OPT_R3_INPUTS);
vector_opt->key = "vector_field";
vector_opt->required = NO;
vector_opt->description = _("Names of three 3D raster maps describing "
"x, y, z components of vector field");
vector_opt->guisection = _("Input");
seed_opt = G_define_standard_option(G_OPT_V_INPUT);
seed_opt->required = NO;
seed_opt->key = "seed_points";
seed_opt->description = _("If no map is provided, "
"flow lines are generated "
"from each cell of the input 3D raster");
seed_opt->label = _("Name of vector map with points "
"from which flow lines are generated");
seed_opt->guisection = _("Input");
flowlines_opt = G_define_standard_option(G_OPT_V_OUTPUT);
flowlines_opt->key = "flowline";
flowlines_opt->required = NO;
flowlines_opt->description = _("Name for vector map of flow lines");
flowlines_opt->guisection = _("Output");
flowacc_opt = G_define_standard_option(G_OPT_R3_OUTPUT);
flowacc_opt->key = "flowaccumulation";
flowacc_opt->required = NO;
flowacc_opt->description =
_("Name for output flowaccumulation 3D raster");
flowacc_opt->guisection = _("Output");
sampled_opt = G_define_standard_option(G_OPT_R3_INPUT);
sampled_opt->key = "sampled";
sampled_opt->required = NO;
sampled_opt->label =
_("Name for 3D raster sampled by flowlines");
sampled_opt->description =
_("Values of this 3D raster will be stored "
"as attributes of flowlines segments");
unit_opt = G_define_option();
unit_opt->key = "unit";
unit_opt->type = TYPE_STRING;
unit_opt->required = NO;
unit_opt->answer = "cell";
unit_opt->options = "time,length,cell";
desc = NULL;
G_asprintf(&desc,
"time;%s;"
"length;%s;"
"cell;%s",
_("elapsed time"),
_("length in map units"), _("length in cells (voxels)"));
unit_opt->descriptions = desc;
unit_opt->label = _("Unit of integration step");
unit_opt->description = _("Default unit is cell");
unit_opt->guisection = _("Integration");
step_opt = G_define_option();
step_opt->key = "step";
step_opt->type = TYPE_DOUBLE;
step_opt->required = NO;
step_opt->answer = "0.25";
step_opt->label = _("Integration step in selected unit");
step_opt->description = _("Default step is 0.25 cell");
step_opt->guisection = _("Integration");
limit_opt = G_define_option();
limit_opt->key = "limit";
limit_opt->type = TYPE_INTEGER;
limit_opt->required = NO;
limit_opt->answer = "2000";
limit_opt->description = _("Maximum number of steps");
limit_opt->guisection = _("Integration");
error_opt = G_define_option();
error_opt->key = "max_error";
error_opt->type = TYPE_DOUBLE;
error_opt->required = NO;
error_opt->answer = "1e-5";
error_opt->label = _("Maximum error of integration");
error_opt->description = _("Influences step, increase maximum error "
"to allow bigger steps");
error_opt->guisection = _("Integration");
skip_opt = G_define_option();
skip_opt->key = "skip";
skip_opt->type = TYPE_INTEGER;
skip_opt->required = NO;
skip_opt->multiple = YES;
skip_opt->description =
_("Number of cells between flow lines in x, y and z direction");
dir_opt = G_define_option();
dir_opt->key = "direction";
dir_opt->type = TYPE_STRING;
dir_opt->required = NO;
dir_opt->multiple = NO;
dir_opt->options = "up,down,both";
dir_opt->answer = "down";
dir_opt->description = _("Compute flowlines upstream, "
"downstream or in both direction.");
table_fl = G_define_flag();
table_fl->key = 'a';
table_fl->description = _("Create and fill attribute table");
G_option_required(scalar_opt, vector_opt, NULL);
G_option_exclusive(scalar_opt, vector_opt, NULL);
G_option_required(flowlines_opt, flowacc_opt, NULL);
G_option_requires(seed_opt, flowlines_opt, NULL);
G_option_requires(table_fl, flowlines_opt, NULL);
G_option_requires(sampled_opt, table_fl, NULL);
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
driver = NULL;
finfo = NULL;
if_table = table_fl->answer ? TRUE : FALSE;
check_vector_input_maps(vector_opt, seed_opt);
Rast3d_init_defaults();
Rast3d_get_window(®ion);
/* set up integration variables */
if (step_opt->answer) {
integration.step = atof(step_opt->answer);
integration.unit = unit_opt->answer;
}
else {
integration.unit = "cell";
integration.step = 0.25;
}
integration.max_error = atof(error_opt->answer);
integration.max_step = 5 * integration.step;
integration.min_step = integration.step / 5;
integration.limit = atof(limit_opt->answer);
if (strcmp(dir_opt->answer, "up") == 0)
integration.direction_type = FLOWDIR_UP;
else if (strcmp(dir_opt->answer, "down") == 0)
integration.direction_type = FLOWDIR_DOWN;
else
integration.direction_type = FLOWDIR_BOTH;
/* cell size is the diagonal */
integration.cell_size = sqrt(region.ns_res * region.ns_res +
region.ew_res * region.ew_res +
region.tb_res * region.tb_res);
/* set default skip if needed */
if (skip_opt->answers) {
for (i = 0; i < 3; i++) {
if (skip_opt->answers[i] != NULL) {
skip[i] = atoi(skip_opt->answers[i]);
}
else {
G_fatal_error(_("Please provide 3 integer values for skip option."));
}
}
}
else {
skip[0] = fmax(1, region.cols / 10);
skip[1] = fmax(1, region.rows / 10);
skip[2] = fmax(1, region.depths / 10);
}
/* open raster 3D maps of velocity components */
gradient_info.initialized = FALSE;
load_input_raster3d_maps(scalar_opt, vector_opt, &gradient_info, ®ion);
/* open new 3D raster map of flowacumulation */
if (flowacc_opt->answer) {
flowacc = Rast3d_open_new_opt_tile_size(flowacc_opt->answer,
RASTER3D_USE_CACHE_DEFAULT,
®ion, FCELL_TYPE, 32);
if (!flowacc)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
flowacc_opt->answer);
init_flowaccum(®ion, flowacc);
}
/* open 3D raster map used for sampling */
if (sampled_opt->answer) {
sampled = Rast3d_open_cell_old(sampled_opt->answer,
G_find_raster3d(sampled_opt->answer, ""),
®ion, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (!sampled)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
sampled_opt->answer);
}
else
sampled = NULL;
/* open new vector map of flowlines */
if (flowlines_opt->answer) {
fl_cats = Vect_new_cats_struct();
fl_points = Vect_new_line_struct();
if (Vect_open_new(&fl_map, flowlines_opt->answer, TRUE) < 0)
G_fatal_error(_("Unable to create vector map <%s>"),
flowlines_opt->answer);
Vect_hist_command(&fl_map);
if (if_table) {
create_table(&fl_map, &finfo, &driver,
gradient_info.compute_gradient, sampled ? 1 : 0);
}
}
n_seeds = 0;
/* open vector map of seeds */
if (seed_opt->answer) {
if (Vect_open_old2(&seed_Map, seed_opt->answer, "", "1") < 0)
G_fatal_error(_("Unable to open vector map <%s>"),
seed_opt->answer);
if (!Vect_is_3d(&seed_Map))
G_fatal_error(_("Vector map <%s> is not 3D"), seed_opt->answer);
n_seeds = Vect_get_num_primitives(&seed_Map, GV_POINT);
}
if (flowacc_opt->answer || (!seed_opt->answer && flowlines_opt->answer)) {
if (flowacc_opt->answer)
n_seeds += region.cols * region.rows * region.depths;
else {
n_seeds += ceil(region.cols / (double)skip[0]) *
ceil(region.rows / (double)skip[1]) *
ceil(region.depths / (double)skip[2]);
}
}
G_debug(1, "Number of seeds is %d", n_seeds);
seed_count = 0;
cat = 1;
if (seed_opt->answer) {
seed_points = Vect_new_line_struct();
seed_cats = Vect_new_cats_struct();
/* compute flowlines from vector seed map */
while (TRUE) {
ltype = Vect_read_next_line(&seed_Map, seed_points, seed_cats);
if (ltype == -1) {
Vect_close(&seed_Map);
G_fatal_error(_("Error during reading seed vector map"));
}
else if (ltype == -2) {
break;
}
else if (ltype == GV_POINT) {
seed.x = seed_points->x[0];
seed.y = seed_points->y[0];
seed.z = seed_points->z[0];
seed.flowline = TRUE;
seed.flowaccum = FALSE;
}
G_percent(seed_count, n_seeds, 1);
if (integration.direction_type == FLOWDIR_UP ||
integration.direction_type == FLOWDIR_BOTH) {
integration.actual_direction = FLOWDIR_UP;
compute_flowline(®ion, &seed, &gradient_info, flowacc, sampled,
&integration, &fl_map, fl_cats, fl_points,
&cat, if_table, finfo, driver);
}
if (integration.direction_type == FLOWDIR_DOWN ||
integration.direction_type == FLOWDIR_BOTH) {
integration.actual_direction = FLOWDIR_DOWN;
compute_flowline(®ion, &seed, &gradient_info, flowacc, sampled,
&integration, &fl_map, fl_cats, fl_points,
&cat, if_table, finfo, driver);
}
seed_count++;
}
Vect_destroy_line_struct(seed_points);
Vect_destroy_cats_struct(seed_cats);
Vect_close(&seed_Map);
}
if (flowacc_opt->answer || (!seed_opt->answer && flowlines_opt->answer)) {
/* compute flowlines from points on grid */
for (r = region.rows; r > 0; r--) {
for (c = 0; c < region.cols; c++) {
for (d = 0; d < region.depths; d++) {
seed.x =
region.west + c * region.ew_res + region.ew_res / 2;
seed.y =
region.south + r * region.ns_res - region.ns_res / 2;
seed.z =
region.bottom + d * region.tb_res + region.tb_res / 2;
seed.flowline = FALSE;
seed.flowaccum = FALSE;
if (flowacc_opt->answer)
seed.flowaccum = TRUE;
if (flowlines_opt->answer && !seed_opt->answer &&
(c % skip[0] == 0) && (r % skip[1] == 0) && (d % skip[2] == 0))
seed.flowline = TRUE;
if (seed.flowaccum || seed.flowline) {
G_percent(seed_count, n_seeds, 1);
if (integration.direction_type == FLOWDIR_UP ||
integration.direction_type == FLOWDIR_BOTH) {
integration.actual_direction = FLOWDIR_UP;
compute_flowline(®ion, &seed, &gradient_info,
flowacc, sampled, &integration, &fl_map,
fl_cats, fl_points, &cat,
if_table, finfo, driver);
}
if (integration.direction_type == FLOWDIR_DOWN ||
integration.direction_type == FLOWDIR_BOTH) {
integration.actual_direction = FLOWDIR_DOWN;
compute_flowline(®ion, &seed, &gradient_info,
flowacc, sampled, &integration, &fl_map,
fl_cats, fl_points, &cat,
if_table, finfo, driver);
}
seed_count++;
}
}
}
}
}
G_percent(1, 1, 1);
if (flowlines_opt->answer) {
if (if_table) {
db_commit_transaction(driver);
db_close_database_shutdown_driver(driver);
}
Vect_destroy_line_struct(fl_points);
Vect_destroy_cats_struct(fl_cats);
Vect_build(&fl_map);
Vect_close(&fl_map);
}
if (flowacc_opt->answer)
Rast3d_close(flowacc);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
RASTER3D_Map *input;
RASTER3D_Map *output;
RASTER3D_Region region;
struct GModule *module;
stat_func *method_fn;
double quantile;
int x, y, z;
/* Initialize GRASS */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("neighbor"));
G_add_keyword(_("aggregation"));
G_add_keyword(_("statistics"));
G_add_keyword(_("filter"));
module->description =
_("Makes each voxel value a "
"function of the values assigned to the voxels "
"around it, and stores new voxel values in an output 3D raster map");
/* Get parameters from user */
set_params();
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (NULL == G_find_raster3d(param.input->answer, ""))
Rast3d_fatal_error(_("3D raster map <%s> not found"),
param.input->answer);
Rast3d_init_defaults();
Rast3d_get_window(®ion);
nx = region.cols;
ny = region.rows;
nz = region.depths;
/* Size fo the moving window */
x_size = atoi(param.window->answers[0]);
y_size = atoi(param.window->answers[1]);
z_size = atoi(param.window->answers[2]);
/* Distances in all directions */
x_dist = x_size / 2;
y_dist = y_size / 2;
z_dist = z_size / 2;
/* Maximum size of the buffer */
size = x_size * y_size * z_size;
/* Set the computation method */
method_fn = menu[find_method(param.method->answer)].method;
if (param.quantile->answer)
quantile = atof(param.quantile->answer);
else
quantile = 0.0;
input = Rast3d_open_cell_old(param.input->answer,
G_find_raster3d(param.input->answer, ""),
®ion, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (input == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
param.input->answer);
output =
Rast3d_open_new_opt_tile_size(param.output->answer,
RASTER3D_USE_CACHE_X, ®ion,
DCELL_TYPE, 32);
if (output == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
param.output->answer);
Rast3d_min_unlocked(output, RASTER3D_USE_CACHE_X);
Rast3d_autolock_on(output);
Rast3d_unlock_all(output);
DCELL *buff = NULL, value;
buff = (DCELL *) calloc(size, sizeof(DCELL));
if (buff == NULL)
Rast3d_fatal_error(_("Unable to allocate buffer"));
for (z = 0; z < nz; z++) {
for (y = 0; y < ny; y++) {
for (x = 0; x < nx; x++) {
/* Gather values in moving window */
int num = gather_values(input, buff, x, y, z);
/* Compute the resulting value */
if (num > 0)
(*method_fn) (&value, buff, num, &quantile);
else
Rast_set_d_null_value(&value, 1);
/* Write the value */
Rast3d_put_double(output, x, y, z, value);
}
}
}
free(buff);
if (!Rast3d_flush_all_tiles(output))
G_fatal_error(_("Error flushing tiles"));
Rast3d_autolock_off(output);
Rast3d_unlock_all(output);
Rast3d_close(input);
Rast3d_close(output);
return 0;
}
/* ************************************************************************* */
int main(int argc, char *argv[])
{
RASTER3D_Region region;
struct Cell_head window2d;
struct GModule *module;
void *map = NULL; /*The 3D Rastermap */
int changemask = 0;
int elevfd = -1, outfd = -1; /*file descriptors */
int output_type, cols, rows;
/* Initialize GRASS */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("profile"));
G_add_keyword(_("raster"));
G_add_keyword(_("voxel"));
module->description =
_("Creates cross section 2D raster map from 3D raster map based on 2D elevation map");
/* Get parameters from user */
set_params();
/* Have GRASS get inputs */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_debug(3, "Open 3D raster map %s", param.input->answer);
if (NULL == G_find_raster3d(param.input->answer, ""))
Rast3d_fatal_error(_("3D raster map <%s> not found"),
param.input->answer);
/* Figure out the region from the map */
Rast3d_init_defaults();
Rast3d_get_window(®ion);
/*Check if the g3d-region is equal to the 2d rows and cols */
rows = Rast_window_rows();
cols = Rast_window_cols();
/*If not equal, set the 2D windows correct */
if (rows != region.rows || cols != region.cols) {
G_message
(_("The 2D and 3D region settings are different. Using the 3D raster map settings to adjust the 2D region."));
G_get_set_window(&window2d);
window2d.ns_res = region.ns_res;
window2d.ew_res = region.ew_res;
window2d.rows = region.rows;
window2d.cols = region.cols;
Rast_set_window(&window2d);
}
/*******************/
/*Open the 3d raster map */
/*******************/
map = Rast3d_open_cell_old(param.input->answer,
G_find_raster3d(param.input->answer, ""),
®ion, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (map == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"),
param.input->answer);
/*Get the output type */
output_type = Rast3d_file_type_map(map);
if (output_type == FCELL_TYPE || output_type == DCELL_TYPE) {
/********************************/
/*Open the elevation raster map */
/********************************/
elevfd = Rast_open_old(param.elevation->answer, "");
globalElevMapType = Rast_get_map_type(elevfd);
/**********************/
/*Open the Outputmap */
/**********************/
if (G_find_raster2(param.output->answer, ""))
G_message(_("Output map already exists. Will be overwritten!"));
if (output_type == FCELL_TYPE)
outfd = Rast_open_new(param.output->answer, FCELL_TYPE);
else if (output_type == DCELL_TYPE)
outfd = Rast_open_new(param.output->answer, DCELL_TYPE);
/*if requested set the Mask on */
if (param.mask->answer) {
if (Rast3d_mask_file_exists()) {
changemask = 0;
if (Rast3d_mask_is_off(map)) {
Rast3d_mask_on(map);
changemask = 1;
}
}
}
/************************/
/*Create the Rastermaps */
/************************/
rast3d_cross_section(map, region, elevfd, outfd);
/*We set the Mask off, if it was off before */
if (param.mask->answer) {
if (Rast3d_mask_file_exists())
if (Rast3d_mask_is_on(map) && changemask)
Rast3d_mask_off(map);
}
Rast_close(outfd);
Rast_close(elevfd);
} else {
fatal_error(map, -1, -1,
_("Wrong 3D raster datatype! Cannot create raster map"));
}
/* Close files and exit */
if (!Rast3d_close(map))
Rast3d_fatal_error(_("Unable to close 3D raster map <%s>"),
param.input->answer);
return (EXIT_SUCCESS);
}
/* ************************************************************************* */
void open_write_vector_maps(input_maps * in, RASTER3D_Region region, FILE * fp,
int dp)
{
int i, changemask[3] = {0, 0, 0};
void *mapvect = NULL;
if (param.vectormaps->answers != NULL) {
/*Loop over all input maps! */
for (i = 0; i < 3; i++) {
G_debug(3, "Open vector 3D raster map <%s>",
param.vectormaps->answers[i]);
mapvect = NULL;
/*Open the map */
mapvect =
Rast3d_open_cell_old(param.vectormaps->answers[i],
G_find_raster3d(param.vectormaps->answers[i],
""), ®ion,
RASTER3D_TILE_SAME_AS_FILE, RASTER3D_USE_CACHE_DEFAULT);
if (mapvect == NULL) {
G_warning(_("Unable to open 3D raster map <%s>"),
param.vectormaps->answers[i]);
fatal_error(_("No vector data will be created."), in);
}
/*if requested set the Mask on */
if (param.mask->answer) {
if (Rast3d_mask_file_exists()) {
changemask[i] = 0;
if (Rast3d_mask_is_off(mapvect)) {
Rast3d_mask_on(mapvect);
changemask[i] = 1;
}
}
}
if (i == 0)
in->map_x = mapvect;
if (i == 1)
in->map_y = mapvect;
if (i == 2)
in->map_z = mapvect;
}
G_debug(3, "Writing VTK Vector Data");
write_vtk_vector_data(in->map_x, in->map_y, in->map_z, fp,
"Vector_Data", region, dp);
for (i = 0; i < 3; i++) {
if (i == 0)
mapvect = in->map_x;
if (i == 1)
mapvect = in->map_y;
if (i == 2)
mapvect = in->map_z;
/*We set the Mask off, if it was off before */
if (param.mask->answer) {
if (Rast3d_mask_file_exists())
if (Rast3d_mask_is_on(mapvect) && changemask[i])
Rast3d_mask_off(mapvect);
}
/* Close the 3d raster map */
if (!Rast3d_close(mapvect)) {
fatal_error(_("Unable to close 3D raster map"), in);
}
/*Set the pointer to null so we know later that these files are already closed */
if (i == 0)
in->map_x = NULL;
if (i == 1)
in->map_y = NULL;
if (i == 2)
in->map_z = NULL;
}
}
return;
}
/* ************************************************************************* */
int main(int argc, char *argv[])
{
char *output = NULL;
RASTER3D_Region region;
struct Cell_head window2d;
struct Cell_head default_region;
FILE *fp = NULL;
struct GModule *module;
int dp, i, changemask = 0;
int rows, cols;
const char *mapset, *name;
double scale = 1.0, llscale = 1.0;
input_maps *in;
/* Initialize GRASS */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("export"));
G_add_keyword(_("voxel"));
G_add_keyword("VTK");
module->description =
_("Converts 3D raster maps into the VTK-ASCII format.");
/* Get parameters from user */
set_params();
/* Have GRASS get inputs */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/*The precision of the output */
if (param.decimals->answer) {
if (sscanf(param.decimals->answer, "%d", &dp) != 1)
G_fatal_error(_("failed to interpret dp as an integer"));
if (dp > 20 || dp < 0)
G_fatal_error(_("dp has to be from 0 to 20"));
} else {
dp = 8; /*This value is taken from the lib settings in G_format_easting */
}
/*Check the input */
check_input_maps();
/*Correct the coordinates, so the precision of VTK is not hurt :( */
if (param.coorcorr->answer) {
/*Get the default region for coordiante correction */
G_get_default_window(&default_region);
/*Use the center of the current region as extent */
y_extent = (default_region.north + default_region.south) / 2;
x_extent = (default_region.west + default_region.east) / 2;
} else {
x_extent = 0;
y_extent = 0;
}
/*open the output */
if (param.output->answer) {
fp = fopen(param.output->answer, "w");
if (fp == NULL) {
perror(param.output->answer);
G_usage();
exit(EXIT_FAILURE);
}
} else
fp = stdout;
/* Figure out the region from the map */
Rast3d_init_defaults();
Rast3d_get_window(®ion);
/*initiate the input mpas structure */
in = create_input_maps_struct();
/* read and compute the scale factor */
sscanf(param.elevscale->answer, "%lf", &scale);
/*if LL projection, convert the elevation values to degrees */
if (param.scalell->answer && region.proj == PROJECTION_LL) {
llscale = M_PI / (180) * 6378137;
scale /= llscale;
}
/*Open the top and bottom file */
if (param.structgrid->answer) {
/*Check if the g3d-region is equal to the 2d rows and cols */
rows = Rast_window_rows();
cols = Rast_window_cols();
/*If not equal, set the 2D windows correct */
if (rows != region.rows || cols != region.cols) {
G_message(_("The 2D and 3D region settings are different. "
"Using the 2D window settings to adjust the 2D part of the 3D region."));
G_get_set_window(&window2d);
window2d.ns_res = region.ns_res;
window2d.ew_res = region.ew_res;
window2d.rows = region.rows;
window2d.cols = region.cols;
Rast_set_window(&window2d);
}
/*open top */
mapset = NULL;
name = NULL;
name = param.top->answer;
mapset = G_find_raster2(name, "");
in->top = open_input_map(name, mapset);
in->topMapType = Rast_get_map_type(in->top);
/*open bottom */
mapset = NULL;
name = NULL;
name = param.bottom->answer;
mapset = G_find_raster2(name, "");
in->bottom = open_input_map(name, mapset);
in->bottomMapType = Rast_get_map_type(in->bottom);
/* Write the vtk-header and the points */
if (param.point->answer) {
write_vtk_structured_grid_header(fp, output, region);
write_vtk_points(in, fp, region, dp, 1, scale);
} else {
write_vtk_unstructured_grid_header(fp, output, region);
write_vtk_points(in, fp, region, dp, 0, scale);
write_vtk_unstructured_grid_cells(fp, region);
}
Rast_close(in->top);
in->top = -1;
Rast_close(in->bottom);
in->bottom = -1;
} else {
/* Write the structured point vtk-header */
write_vtk_structured_point_header(fp, output, region, dp, scale);
}
/*Write the normal VTK data (cell or point data) */
/*Loop over all 3d input maps! */
if (param.input->answers != NULL) {
for (i = 0; param.input->answers[i] != NULL; i++) {
G_debug(3, "Open 3D raster map <%s>", param.input->answers[i]);
/*Open the map */
in->map =
Rast3d_open_cell_old(param.input->answers[i],
G_find_raster3d(param.input->answers[i], ""),
®ion, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (in->map == NULL) {
G_warning(_("Unable to open 3D raster map <%s>"),
param.input->answers[i]);
fatal_error(" ", in);
}
/*if requested set the Mask on */
if (param.mask->answer) {
if (Rast3d_mask_file_exists()) {
changemask = 0;
if (Rast3d_mask_is_off(in->map)) {
Rast3d_mask_on(in->map);
changemask = 1;
}
}
}
/* Write the point or cell data */
write_vtk_data(fp, in->map, region, param.input->answers[i], dp);
/*We set the Mask off, if it was off before */
if (param.mask->answer) {
if (Rast3d_mask_file_exists())
if (Rast3d_mask_is_on(in->map) && changemask)
Rast3d_mask_off(in->map);
}
/* Close the 3d raster map */
if (!Rast3d_close(in->map)) {
in->map = NULL;
fatal_error(_("Unable to close 3D raster map, the VTK file may be incomplete"),
in);
}
in->map = NULL;
}
}
/*Write the RGB voxel data */
open_write_rgb_maps(in, region, fp, dp);
open_write_vector_maps(in, region, fp, dp);
/*Close the output file */
if (param.output->answer && fp != NULL)
if (fclose(fp))
fatal_error(_("Unable to close VTK-ASCII file"), in);
/*close all open maps and free memory */
release_input_maps_struct(in);
return 0;
}
int test_large_file_sparse_random(int depths, int rows, int cols, int tile_size)
{
int sum = 0;
int x, y, z, i;
DCELL value, random_value;
DCELL *random_value_vector = G_calloc(RAND_VALUE_VECTOR_SIZE, sizeof(DCELL));
G_message("Testing DCELL put function for large files filled with sparse random values");
RASTER3D_Region region;
RASTER3D_Map *map = NULL;
/* We need to set up a specific region for the new raster3d map.
* First we safe the default region. */
Rast3d_get_window(®ion);
region.bottom = -365.5;
region.top = 365.5;
region.south = -90;
region.north = 90;
region.west = -180;
region.east = 180;
region.rows = rows;
region.cols = cols;
region.depths = depths;
Rast3d_adjust_region(®ion);
G_message("Creating 3D raster map filled with sparse random values");
map = Rast3d_open_new_opt_tile_size("test_put_get_value_dcell_large_sparse_random",
RASTER3D_USE_CACHE_XY, ®ion, DCELL_TYPE, tile_size);
/* The window is the same as the map region ... of course */
Rast3d_set_window_map(map, ®ion);
srand(1);
/* We fill the random value vector */
for(i = 0; i < RAND_VALUE_VECTOR_SIZE; i++) {
/* Put the counter as cell value */
value = (DCELL)rand();
value /= RAND_MAX;
if(value <= 0.7)
value = 0.0;
else if(value <= 0.8)
value = 1.0;
else if(value <= 0.9)
value = 2.0;
else if(value <= 1.0)
value = 3.0;
else
value = 4.0;
random_value_vector[i] = value;
}
i = 0;
for(z = 0; z < region.depths; z++) {
G_percent(z, region.depths, 1);
for(y = 0; y < region.rows; y++) {
for(x = 0; x < region.cols; x++) {
/* Put the counter as cell value */
value = random_value_vector[i];
Rast3d_put_value(map, x, y, z, &value, DCELL_TYPE);
i++;
if(i == RAND_VALUE_VECTOR_SIZE)
i = 0;
}
}
}
G_percent(1, 1, 1);
/* Write everything to the disk */
Rast3d_flush_all_tiles(map);
Rast3d_close(map);
G_message("Verifying 3D raster map filled with sparse random values");
map = Rast3d_open_cell_old("test_put_get_value_dcell_large_sparse_random",
G_mapset(), ®ion, DCELL_TYPE, RASTER3D_USE_CACHE_XY);
i = 0;
for(z = 0; z < region.depths; z++) {
G_percent(z, region.depths, 1);
for(y = 0; y < region.rows; y++) {
for(x = 0; x < region.cols; x++) {
/* Check the counter as cell value */
Rast3d_get_value(map, x, y, z, &value, DCELL_TYPE);
if(fabs(value - random_value_vector[i]) > EPSILON) {
G_message("At: z %i y %i x %i -- value %.14lf != %.14lf\n",
z, y, x, value, random_value);
sum++;
}
i++;
if(i == RAND_VALUE_VECTOR_SIZE)
i = 0;
}
}
}
G_percent(1, 1, 1);
Rast3d_close(map);
G_free(random_value_vector);
G_remove("grid3", "test_put_get_value_dcell_large_sparse_random");
return sum;
}
/* ************************************************************************* */
void open_write_rgb_maps(input_maps * in, RASTER3D_Region region, FILE * fp,
int dp)
{
int i, changemask[3] = {0, 0, 0};
void *maprgb = NULL;
if (param.rgbmaps->answers != NULL) {
/*Loop over all input maps! */
for (i = 0; i < 3; i++) {
G_debug(3, "Open RGB 3D raster map <%s>",
param.rgbmaps->answers[i]);
maprgb = NULL;
/*Open the map */
maprgb =
Rast3d_open_cell_old(param.rgbmaps->answers[i],
G_find_raster3d(param.rgbmaps->answers[i], ""),
®ion, RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (maprgb == NULL) {
G_warning(_("Unable to open 3D raster map <%s>"),
param.rgbmaps->answers[i]);
fatal_error(_("No RGB Data will be created."), in);
}
/*if requested set the Mask on */
if (param.mask->answer) {
if (Rast3d_mask_file_exists()) {
changemask[i] = 0;
if (Rast3d_mask_is_off(maprgb)) {
Rast3d_mask_on(maprgb);
changemask[i] = 1;
}
}
}
if (i == 0)
in->map_r = maprgb;
if (i == 1)
in->map_g = maprgb;
if (i == 2)
in->map_b = maprgb;
}
G_debug(3, "Writing VTK VoxelData");
write_vtk_rgb_data(in->map_r, in->map_g, in->map_b, fp, "RGB_Voxel",
region, dp);
for (i = 0; i < 3; i++) {
if (i == 0)
maprgb = in->map_r;
if (i == 1)
maprgb = in->map_g;
if (i == 2)
maprgb = in->map_b;
/*We set the Mask off, if it was off before */
if (param.mask->answer) {
if (Rast3d_mask_file_exists())
if (Rast3d_mask_is_on(maprgb) && changemask[i])
Rast3d_mask_off(maprgb);
}
/* Close the 3d raster map */
if (!Rast3d_close(maprgb)) {
fatal_error(_("Unable to close 3D raster map"), in);
}
/*Set the pointer to null so we noe later that these files are already closed */
if (i == 0)
in->map_r = NULL;
if (i == 1)
in->map_g = NULL;
if (i == 2)
in->map_b = NULL;
}
}
return;
}
int test_large_file_zeros(int depths, int rows, int cols, int tile_size)
{
int sum = 0;
int x, y, z;
DCELL value;
G_message("Testing DCELL put function for large files filled with zeros");
RASTER3D_Region region;
RASTER3D_Map *map = NULL;
/* We need to set up a specific region for the new raster3d map.
* First we safe the default region. */
Rast3d_get_window(®ion);
region.bottom = -365.5;
region.top = 365.5;
region.south = -90;
region.north = 90;
region.west = -180;
region.east = 180;
region.rows = rows;
region.cols = cols;
region.depths = depths;
Rast3d_adjust_region(®ion);
G_message("Creating 3D raster map filled with zeros");
map = Rast3d_open_new_opt_tile_size("test_put_get_value_dcell_large_zeros",
RASTER3D_USE_CACHE_XY, ®ion, DCELL_TYPE, tile_size);
/* The window is the same as the map region ... of course */
Rast3d_set_window_map(map, ®ion);
for(z = 0; z < region.depths; z++) {
G_percent(z, region.depths, 1);
for(y = 0; y < region.rows; y++) {
for(x = 0; x < region.cols; x++) {
/* Put the counter as cell value */
value = 0.0;
Rast3d_put_value(map, x, y, z, &value, DCELL_TYPE);
}
}
}
G_percent(1, 1, 1);
/* Write everything to the disk */
Rast3d_flush_all_tiles(map);
Rast3d_close(map);
G_message("Verifying 3D raster map filled with zeros");
map = Rast3d_open_cell_old("test_put_get_value_dcell_large_zeros",
G_mapset(), ®ion, DCELL_TYPE, RASTER3D_USE_CACHE_XY);
for(z = 0; z < region.depths; z++) {
G_percent(z, region.depths, 1);
for(y = 0; y < region.rows; y++) {
for(x = 0; x < region.cols; x++) {
/* Check the counter as cell value */
Rast3d_get_value(map, x, y, z, &value, DCELL_TYPE);
if(value > EPSILON) {
G_message("At: z %i y %i x %i -- value %.14lf != 0.0\n",
z, y, x, value);
sum++;
}
}
}
}
G_percent(1, 1, 1);
Rast3d_close(map);
G_remove("grid3", "test_put_get_value_dcell_large_zeros");
return sum;
}
/* *************************************************************** */
int main(int argc, char *argv[])
{
FCELL val_f; /* for misc use */
DCELL val_d; /* for misc use */
int map_type, zmap_type;
univar_stat *stats;
char *infile, *zonemap;
void *map, *zmap = NULL;
RASTER3D_Region region;
unsigned int i;
unsigned int rows, cols, depths;
unsigned int x, y, z;
double dmin, dmax;
int zone, n_zones, use_zone = 0;
char *mapset, *name;
struct GModule *module;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("statistics"));
module->description =
_("Calculates univariate statistics from the non-null 3d cells of a raster3d map.");
/* Define the different options */
set_params();
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* Set the defaults */
Rast3d_init_defaults();
/* get the current region */
Rast3d_get_window(®ion);
cols = region.cols;
rows = region.rows;
depths = region.depths;
name = param.output_file->answer;
if (name != NULL && strcmp(name, "-") != 0) {
if (NULL == freopen(name, "w", stdout)) {
G_fatal_error(_("Unable to open file <%s> for writing"), name);
}
}
/* table field separator */
zone_info.sep = param.separator->answer;
if (strcmp(zone_info.sep, "\\t") == 0)
zone_info.sep = "\t";
if (strcmp(zone_info.sep, "tab") == 0)
zone_info.sep = "\t";
if (strcmp(zone_info.sep, "space") == 0)
zone_info.sep = " ";
if (strcmp(zone_info.sep, "comma") == 0)
zone_info.sep = ",";
dmin = 0.0 / 0.0; /* set to nan as default */
dmax = 0.0 / 0.0; /* set to nan as default */
zone_info.min = 0.0 / 0.0; /* set to nan as default */
zone_info.max = 0.0 / 0.0; /* set to nan as default */
zone_info.n_zones = 0;
/* open 3D zoning raster with default region */
if ((zonemap = param.zonefile->answer) != NULL) {
if (NULL == (mapset = G_find_raster3d(zonemap, "")))
Rast3d_fatal_error(_("3D raster map <%s> not found"), zonemap);
zmap =
Rast3d_open_cell_old(zonemap, G_find_raster3d(zonemap, ""), ®ion,
RASTER3D_TILE_SAME_AS_FILE, RASTER3D_USE_CACHE_DEFAULT);
if (zmap == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"), zonemap);
zmap_type = Rast3d_tile_type_map(zmap);
if (Rast3d_read_cats(zonemap, mapset, &(zone_info.cats)))
G_warning("No category support for zoning raster");
Rast3d_range_init(zmap);
Rast3d_range_load(zmap);
Rast3d_range_min_max(zmap, &dmin, &dmax);
/* properly round dmin and dmax */
if (dmin < 0)
zone_info.min = dmin - 0.5;
else
zone_info.min = dmin + 0.5;
if (dmax < 0)
zone_info.max = dmax - 0.5;
else
zone_info.max = dmax + 0.5;
G_debug(1, "min: %d, max: %d", zone_info.min, zone_info.max);
zone_info.n_zones = zone_info.max - zone_info.min + 1;
use_zone = 1;
}
/* Open 3D input raster with default region */
infile = param.inputfile->answer;
if (NULL == G_find_raster3d(infile, ""))
Rast3d_fatal_error(_("3D raster map <%s> not found"), infile);
map =
Rast3d_open_cell_old(infile, G_find_raster3d(infile, ""), ®ion,
RASTER3D_TILE_SAME_AS_FILE, RASTER3D_USE_CACHE_DEFAULT);
if (map == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"), infile);
map_type = Rast3d_tile_type_map(map);
i = 0;
while (param.percentile->answers[i])
i++;
n_zones = zone_info.n_zones;
if (n_zones == 0)
n_zones = 1;
stats = create_univar_stat_struct(map_type, i);
for (i = 0; i < n_zones; i++) {
unsigned int j;
for (j = 0; j < stats[i].n_perc; j++) {
sscanf(param.percentile->answers[j], "%lf", &(stats[i].perc[j]));
}
}
for (z = 0; z < depths; z++) { /* From the bottom to the top */
if (!(param.shell_style->answer))
G_percent(z, depths - 1, 10);
for (y = 0; y < rows; y++) {
for (x = 0; x < cols; x++) {
zone = 0;
if (zone_info.n_zones) {
if (zmap_type == FCELL_TYPE) {
Rast3d_get_value(zmap, x, y, z, &val_f, FCELL_TYPE);
if (Rast3d_is_null_value_num(&val_f, FCELL_TYPE))
continue;
if (val_f < 0)
zone = val_f - 0.5;
else
zone = val_f + 0.5;
}
else if (zmap_type == DCELL_TYPE) {
Rast3d_get_value(zmap, x, y, z, &val_d, DCELL_TYPE);
if (Rast3d_is_null_value_num(&val_d, DCELL_TYPE))
continue;
if (val_d < 0)
zone = val_d - 0.5;
else
zone = val_d + 0.5;
}
zone -= zone_info.min;
}
if (map_type == FCELL_TYPE) {
Rast3d_get_value(map, x, y, z, &val_f, map_type);
if (!Rast3d_is_null_value_num(&val_f, map_type)) {
if (param.extended->answer) {
if (stats[zone].n >= stats[zone].n_alloc) {
size_t msize;
stats[zone].n_alloc += 1000;
msize = stats[zone].n_alloc * sizeof(FCELL);
stats[zone].fcell_array =
(FCELL *)G_realloc((void *)stats[zone].fcell_array, msize);
}
stats[zone].fcell_array[stats[zone].n] = val_f;
}
stats[zone].sum += val_f;
stats[zone].sumsq += (val_f * val_f);
stats[zone].sum_abs += fabs(val_f);
if (stats[zone].first) {
stats[zone].max = val_f;
stats[zone].min = val_f;
stats[zone].first = FALSE;
}
else {
if (val_f > stats[zone].max)
stats[zone].max = val_f;
if (val_f < stats[zone].min)
stats[zone].min = val_f;
}
stats[zone].n++;
}
stats[zone].size++;
}
else if (map_type == DCELL_TYPE) {
Rast3d_get_value(map, x, y, z, &val_d, map_type);
if (!Rast3d_is_null_value_num(&val_d, map_type)) {
if (param.extended->answer) {
if (stats[zone].n >= stats[zone].n_alloc) {
size_t msize;
stats[zone].n_alloc += 1000;
msize = stats[zone].n_alloc * sizeof(DCELL);
stats[zone].dcell_array =
(DCELL *)G_realloc((void *)stats[zone].dcell_array, msize);
}
stats[zone].dcell_array[stats[zone].n] = val_d;
}
stats[zone].sum += val_d;
stats[zone].sumsq += val_d * val_d;
stats[zone].sum_abs += fabs(val_d);
if (stats[zone].first) {
stats[zone].max = val_d;
stats[zone].min = val_d;
stats[zone].first = FALSE;
}
else {
if (val_d > stats[zone].max)
stats[zone].max = val_d;
if (val_d < stats[zone].min)
stats[zone].min = val_d;
}
stats[zone].n++;
}
stats[zone].size++;
}
}
}
}
/* close maps */
Rast3d_close(map);
if (zone_info.n_zones)
Rast3d_close(zmap);
/* create the output */
if (param.table->answer)
print_stats_table(stats);
else
print_stats(stats);
/* release memory */
free_univar_stat_struct(stats);
exit(EXIT_SUCCESS);
}
static void
modifyNull(char *name, d_Mask * maskRules, int changeNull, double newNullVal)
{
void *map, *mapOut;
RASTER3D_Region region;
int tileX, tileY, tileZ, x, y, z;
double value;
int doCompress, doLzw, doRle, precision;
int cacheSize;
cacheSize = Rast3d_cache_size_encode(RASTER3D_USE_CACHE_XY, 1);
if (NULL == G_find_raster3d(name, ""))
Rast3d_fatal_error(_("3D raster map <%s> not found"), name);
fprintf(stderr, "name %s Mapset %s \n", name, G_mapset());
map = Rast3d_open_cell_old(name, G_mapset(), RASTER3D_DEFAULT_WINDOW,
DCELL_TYPE, cacheSize);
if (map == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"), name);
Rast3d_get_region_struct_map(map, ®ion);
Rast3d_get_tile_dimensions_map(map, &tileX, &tileY, &tileZ);
Rast3d_get_compression_mode(&doCompress, &doLzw, &doRle, &precision);
mapOut = Rast3d_open_new_param(name, DCELL_TYPE, RASTER3D_USE_CACHE_XY,
®ion, Rast3d_file_type_map(map),
doLzw, doRle, Rast3d_tile_precision_map(map), tileX,
tileY, tileZ);
if (mapOut == NULL)
Rast3d_fatal_error(_("modifyNull: error opening tmp file"));
Rast3d_min_unlocked(map, RASTER3D_USE_CACHE_X);
Rast3d_autolock_on(map);
Rast3d_unlock_all(map);
Rast3d_min_unlocked(mapOut, RASTER3D_USE_CACHE_X);
Rast3d_autolock_on(mapOut);
Rast3d_unlock_all(mapOut);
for (z = 0; z < region.depths; z++) {
if ((z % tileZ) == 0) {
Rast3d_unlock_all(map);
Rast3d_unlock_all(mapOut);
}
for (y = 0; y < region.rows; y++)
for (x = 0; x < region.cols; x++) {
value = Rast3d_get_double_region(map, x, y, z);
if (Rast3d_is_null_value_num(&value, DCELL_TYPE)) {
if (changeNull) {
value = newNullVal;
}
}
else if (Rast3d_mask_d_select((DCELL *) & value, maskRules)) {
Rast3d_set_null_value(&value, 1, DCELL_TYPE);
}
Rast3d_put_double(mapOut, x, y, z, value);
}
if ((z % tileZ) == 0) {
if (!Rast3d_flush_tiles_in_cube
(mapOut, 0, 0, MAX(0, z - tileZ), region.rows - 1,
region.cols - 1, z))
Rast3d_fatal_error(_("modifyNull: error flushing tiles in cube"));
}
}
if (!Rast3d_flush_all_tiles(mapOut))
Rast3d_fatal_error(_("modifyNull: error flushing all tiles"));
Rast3d_autolock_off(map);
Rast3d_unlock_all(map);
Rast3d_autolock_off(mapOut);
Rast3d_unlock_all(mapOut);
if (!Rast3d_close(map))
Rast3d_fatal_error(_("Unable to close raster map"));
if (!Rast3d_close(mapOut))
Rast3d_fatal_error(_("modifyNull: Unable to close tmp file"));
}
int main(int argc, char *argv[])
{
float val_f; /* for misc use */
double val_d; /* for misc use */
stat_table *stats = NULL;
double min, max;
equal_val_array *eqvals = NULL;
unsigned int n = 0, nsteps;
int map_type;
char *infile = NULL;
void *map = NULL;
RASTER3D_Region region;
unsigned int rows, cols, depths;
unsigned int x, y, z;
struct Option *inputfile, *steps;
struct Flag *equal, *counts_only;
struct GModule *module;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("statistics"));
module->description = _("Generates volume statistics for 3D raster maps.");
/* Define the different options */
inputfile = G_define_standard_option(G_OPT_R3_INPUT);
steps = G_define_option();
steps->key = "nsteps";
steps->type = TYPE_INTEGER;
steps->required = NO;
steps->answer = "20";
steps->description = _("Number of subranges to collect stats from");
equal = G_define_flag();
equal->key = 'e';
equal->description =
_("Calculate statistics based on equal value groups");
counts_only = G_define_flag();
counts_only->key = 'c';
counts_only->description = _("Only print cell counts");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/*Set the defaults */
Rast3d_init_defaults();
/*get the current region */
Rast3d_get_window(®ion);
cols = region.cols;
rows = region.rows;
depths = region.depths;
sscanf(steps->answer, "%i", &nsteps);
/* break if the wrong number of subranges are given */
if (nsteps <= 0)
G_fatal_error(_("The number of subranges has to be equal or greater than 1"));
infile = inputfile->answer;
if (NULL == G_find_raster3d(infile, ""))
Rast3d_fatal_error(_("3D raster map <%s> not found"), infile);
map =
Rast3d_open_cell_old(infile, G_find_raster3d(infile, ""), ®ion,
RASTER3D_TILE_SAME_AS_FILE, RASTER3D_USE_CACHE_DEFAULT);
if (map == NULL)
Rast3d_fatal_error(_("Unable to open 3D raster map <%s>"), infile);
map_type = Rast3d_tile_type_map(map);
/* calculate statistics for groups of equal values */
if ((equal->answer)) {
/*search for equal values */
eqvals = NULL;
n = 0;
for (z = 0; z < depths; z++) {
G_percent(z, depths - 1, 2);
for (y = 0; y < rows; y++) {
for (x = 0; x < cols; x++) {
if (map_type == FCELL_TYPE) {
Rast3d_get_value(map, x, y, z, &val_f, map_type);
if (!Rast3d_is_null_value_num(&val_f, map_type)) {
/*the first entry */
if (eqvals == NULL)
eqvals =
add_equal_val_to_array(eqvals,
(double)val_f);
else
check_equal_value(eqvals, (double)val_f);
n++; /*count non null cells */
}
}
else if (map_type == DCELL_TYPE) {
Rast3d_get_value(map, x, y, z, &val_d, map_type);
if (!Rast3d_is_null_value_num(&val_d, map_type)) {
/*the first entry */
if (eqvals == NULL)
eqvals =
add_equal_val_to_array(eqvals, val_d);
else
check_equal_value(eqvals, val_d);
n++; /*count non null cells */
}
}
}
}
}
if (eqvals) {
/* sort the equal values array */
G_message(_("Sort non-null values"));
heapsort_eqvals(eqvals, eqvals->count);
/* create the statistic table with equal values */
stats = create_stat_table(eqvals->count, eqvals, 0, 0);
/* compute the number of null values */
stats->null->count = rows * cols * depths - n;
free_equal_val_array(eqvals);
}
}
else {
/* create the statistic table based on value ranges */
/* get the range of the map */
Rast3d_range_load(map);
Rast3d_range_min_max(map, &min, &max);
stats = create_stat_table(nsteps, NULL, min, max);
n = 0;
for (z = 0; z < depths; z++) {
G_percent(z, depths - 1, 2);
for (y = 0; y < rows; y++) {
for (x = 0; x < cols; x++) {
if (map_type == FCELL_TYPE) {
Rast3d_get_value(map, x, y, z, &val_f, map_type);
if (!Rast3d_is_null_value_num(&val_f, map_type)) {
check_range_value(stats, (double)val_f);
n++;
}
}
else if (map_type == DCELL_TYPE) {
Rast3d_get_value(map, x, y, z, &val_d, map_type);
if (!Rast3d_is_null_value_num(&val_d, map_type)) {
check_range_value(stats, val_d);
n++;
}
}
}
}
}
/* compute the number of null values */
stats->null->count = rows * cols * depths - n;
}
if(stats) {
/* Compute the volume and percentage */
update_stat_table(stats, ®ion);
/* Print the statistics to stdout */
print_stat_table(stats, counts_only->answer);
free_stat_table(stats);
}
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
const char *mapset;
struct GModule *module;
struct Option *raster, *title_opt, *history_opt;
struct Option *datasrc1_opt, *datasrc2_opt, *datadesc_opt;
struct Option *map_opt, *units_opt, *vunits_opt;
struct Option *load_opt, *save_opt;
struct Flag *stats_flag;
const char *infile;
char title[MAX_TITLE_LEN + 1];
struct History hist;
/* Initialize GIS engine */
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("metadata"));
G_add_keyword(_("voxel"));
module->description = _("Allows creation and/or modification of "
"3D raster map layer support files.");
raster = G_define_standard_option(G_OPT_R3_MAP);
title_opt = G_define_option();
title_opt->key = "title";
title_opt->key_desc = "phrase";
title_opt->type = TYPE_STRING;
title_opt->required = NO;
title_opt->description = _("Text to use for map title");
history_opt = G_define_option();
history_opt->key = "history";
history_opt->key_desc = "phrase";
history_opt->type = TYPE_STRING;
history_opt->required = NO;
history_opt->description =
_("Text to append to the next line of the map's metadata file");
units_opt = G_define_option();
units_opt->key = "unit";
units_opt->type = TYPE_STRING;
units_opt->required = NO;
units_opt->description = _("The map data unit");
vunits_opt = G_define_option();
vunits_opt->key = "vunit";
vunits_opt->type = TYPE_STRING;
vunits_opt->required = NO;
vunits_opt->description = _("The vertical unit of the map");
datasrc1_opt = G_define_option();
datasrc1_opt->key = "source1";
datasrc1_opt->key_desc = "phrase";
datasrc1_opt->type = TYPE_STRING;
datasrc1_opt->required = NO;
datasrc1_opt->description = _("Text to use for data source, line 1");
datasrc2_opt = G_define_option();
datasrc2_opt->key = "source2";
datasrc2_opt->key_desc = "phrase";
datasrc2_opt->type = TYPE_STRING;
datasrc2_opt->required = NO;
datasrc2_opt->description = _("Text to use for data source, line 2");
datadesc_opt = G_define_option();
datadesc_opt->key = "description";
datadesc_opt->key_desc = "phrase";
datadesc_opt->type = TYPE_STRING;
datadesc_opt->required = NO;
datadesc_opt->description =
_("Text to use for data description or keyword(s)");
map_opt = G_define_option();
map_opt->key = "raster";
map_opt->type = TYPE_STRING;
map_opt->required = NO;
map_opt->gisprompt = "old,cell,raster";
map_opt->description = _("Raster map from which to copy category table");
load_opt = G_define_standard_option(G_OPT_F_INPUT);
load_opt->key = "loadhistory";
load_opt->required = NO;
load_opt->description = _("Text file from which to load history");
save_opt = G_define_standard_option(G_OPT_F_OUTPUT);
save_opt->key = "savehistory";
save_opt->required = NO;
save_opt->description = _("Text file in which to save history");
stats_flag = G_define_flag();
stats_flag->key = 's';
stats_flag->description = _("Update range");
/* Parse command-line options */
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
/* Make sure raster exists and set mapset */
infile = raster->answer;
mapset = G_find_raster3d(infile, G_mapset()); /* current mapset only for editing */
if (!mapset || strcmp(mapset, G_mapset()) != 0)
G_fatal_error(_("3D raster map <%s> not found"), infile);
if (title_opt->answer) {
strncpy(title, title_opt->answer, MAX_TITLE_LEN);
title[MAX_TITLE_LEN - 1] = '\0'; /* strncpy doesn't null terminate over-sized input */
G_strip(title);
G_debug(3, "map title= [%s] (%d chars)", title, (int)strlen(title));
Rast3d_read_history(raster->answer, "", &hist);
Rast_set_history(&hist, HIST_TITLE, title);
Rast3d_write_history(raster->answer, &hist);
}
if (save_opt->answer) {
FILE *fp = fopen(save_opt->answer, "w");
int i;
if (!fp)
G_fatal_error(_("Unable to open output file <%s>"), save_opt->answer);
Rast3d_read_history(raster->answer, "", &hist);
for (i = 0; i < Rast_history_length(&hist); i++)
fprintf(fp, "%s\n", Rast_history_line(&hist, i));
fclose(fp);
}
if (load_opt->answer) {
FILE *fp = fopen(load_opt->answer, "r");
if (!fp)
G_fatal_error(_("Unable to open input file <%s>"), load_opt->answer);
Rast3d_read_history(raster->answer, "", &hist);
Rast_clear_history(&hist);
for (;;) {
char buf[80];
if (!G_getl2(buf, sizeof(buf), fp))
break;
Rast_append_history(&hist, buf);
}
fclose(fp);
Rast3d_write_history(raster->answer, &hist);
}
if (history_opt->answer) {
Rast3d_read_history(raster->answer, "", &hist);
/* two less than defined as if only one less a newline gets appended in the hist file. bug? */
/* Should be RECORD_LEN, but r.info truncates at > 71 chars */
if (strlen(history_opt->answer) > 71) {
int i;
for (i = 0; i < strlen(history_opt->answer); i += 71) {
char buf[72];
strncpy(buf, &history_opt->answer[i], sizeof(buf)-1);
buf[sizeof(buf)-1] = '\0';
Rast_append_history(&hist, buf);
}
}
else
Rast_append_history(&hist, history_opt->answer);
Rast3d_write_history(raster->answer, &hist);
}
if(units_opt->answer || vunits_opt->answer) {
RASTER3D_Map *map;
map = Rast3d_open_cell_old(raster->answer, G_mapset(), \
RASTER3D_DEFAULT_WINDOW, RASTER3D_TILE_SAME_AS_FILE, RASTER3D_USE_CACHE_DEFAULT);
/* Modify the units */
if (units_opt->answer)
Rast3d_set_unit(map, units_opt->answer);
if (vunits_opt->answer)
Rast3d_set_vertical_unit(map, vunits_opt->answer);
Rast3d_rewrite_header(map);
Rast3d_close(map);
}
if (datasrc1_opt->answer || datasrc2_opt->answer || datadesc_opt->answer) {
Rast3d_read_history(raster->answer, "", &hist);
if (datasrc1_opt->answer)
Rast_set_history(&hist, HIST_DATSRC_1, datasrc1_opt->answer);
if (datasrc2_opt->answer)
Rast_set_history(&hist, HIST_DATSRC_2, datasrc2_opt->answer);
if (datadesc_opt->answer)
Rast_set_history(&hist, HIST_KEYWRD, datadesc_opt->answer);
Rast3d_write_history(raster->answer, &hist);
}
if (map_opt->answer) { /* use cats from another map */
int fd;
struct Categories cats;
fd = Rast_open_old(infile, "");
Rast_init_cats("", &cats);
if (Rast3d_read_cats(map_opt->answer, "", &cats) < 0)
G_fatal_error(_("Unable to read category file of raster map <%s>"),
map_opt->answer);
Rast3d_write_cats(infile, &cats);
G_message(_("cats table for [%s] set to %s"),
infile, map_opt->answer);
Rast_close(fd);
Rast_free_cats(&cats);
}
/* Check the histogram and range */
if (stats_flag->answer)
check_stats(raster->answer);
return EXIT_SUCCESS;
}