/* ************************************************************************* */
double get_g3d_raster_value_as_double(void *map, int x, int y, int z,
int type, double nullval)
{
double val = 0;
float fvalue;
double dvalue;
if (type == FCELL_TYPE) {
Rast3d_get_value(map, x, y, z, &fvalue, type);
if (Rast3d_is_null_value_num(&fvalue, FCELL_TYPE))
val = nullval;
else
val = (double) fvalue;
} else {
Rast3d_get_value(map, x, y, z, &dvalue, type);
if (Rast3d_is_null_value_num(&dvalue, DCELL_TYPE))
val = nullval;
else
val = dvalue;
}
return val;
}
int Rast3d_copy_to_xdr(const void *src, int nofNum)
{
int i;
if (useXdr == RASTER3D_NO_XDR) {
Rast3d_copy_values(src, 0, srcType, xdrTmp, 0, type, nofNum);
xdrTmp = G_incr_void_ptr(xdrTmp, nofNum * Rast3d_extern_length(type));
return 1;
}
for (i = 0; i < nofNum; i++, src = G_incr_void_ptr(src, eltLength)) {
if (Rast3d_is_null_value_num(src, srcType)) {
Rast3d_set_xdr_null_num(xdrTmp, isFloat);
if (!xdr_setpos(xdrs, xdr_getpos(xdrs) + externLength)) {
Rast3d_error("Rast3d_copy_to_xdr: positioning xdr failed");
return 0;
}
}
else {
if (type == srcType) {
if (xdrFun(xdrs, src) < 0) {
Rast3d_error("Rast3d_copy_to_xdr: writing xdr failed");
return 0;
}
}
else {
if (type == FCELL_TYPE)
*((float *)tmp) = (float)*((double *)src);
else
*((double *)tmp) = (double)*((float *)src);
if (xdrFun(xdrs, tmp) < 0) {
Rast3d_error("Rast3d_copy_to_xdr: writing xdr failed");
return 0;
}
}
}
xdrTmp = G_incr_void_ptr(xdrTmp, externLength);
}
return 1;
}
/* ************************************************************************* */
void g3d_to_raster(void *map, RASTER3D_Region region, int *fd)
{
DCELL d1 = 0;
FCELL f1 = 0;
int x, y, z;
int rows, cols, depths, typeIntern, pos = 0;
FCELL *fcell = NULL;
DCELL *dcell = NULL;
rows = region.rows;
cols = region.cols;
depths = region.depths;
G_debug(2, "g3d_to_raster: Writing %i raster maps with %i rows %i cols.",
depths, rows, cols);
typeIntern = Rast3d_tile_type_map(map);
if (typeIntern == FCELL_TYPE)
fcell = Rast_allocate_f_buf();
else if (typeIntern == DCELL_TYPE)
dcell = Rast_allocate_d_buf();
pos = 0;
/*Every Rastermap */
for (z = 0; z < depths; z++) { /*From the bottom to the top */
G_debug(2, "Writing raster map %d of %d", z + 1, depths);
for (y = 0; y < rows; y++) {
G_percent(y, rows - 1, 10);
for (x = 0; x < cols; x++) {
if (typeIntern == FCELL_TYPE) {
Rast3d_get_value(map, x, y, z, &f1, typeIntern);
if (Rast3d_is_null_value_num(&f1, FCELL_TYPE))
Rast_set_null_value(&fcell[x], 1, FCELL_TYPE);
else
fcell[x] = f1;
} else {
Rast3d_get_value(map, x, y, z, &d1, typeIntern);
if (Rast3d_is_null_value_num(&d1, DCELL_TYPE))
Rast_set_null_value(&dcell[x], 1, DCELL_TYPE);
else
dcell[x] = d1;
}
}
if (typeIntern == FCELL_TYPE)
Rast_put_f_row(fd[pos], fcell);
if (typeIntern == DCELL_TYPE)
Rast_put_d_row(fd[pos], dcell);
}
G_debug(2, "Finished writing map %d.", z + 1);
pos++;
}
if (dcell)
G_free(dcell);
if (fcell)
G_free(fcell);
}
/*!
* \brief This function returns 1 if value of N_array_3d data at position col, row, depth
* is of type null, otherwise 0
*
* This function checks automatically the type of the array and checks for the
* data type null value.
*
* \param data N_array_3d *
* \param col int
* \param row int
* \param depth int
* \return void
* */
int N_is_array_3d_value_null(N_array_3d * data, int col, int row, int depth)
{
if (data->offset == 0) {
if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
G_debug(6,
"N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
depth, row, col);
return Rast3d_is_null_value_num((void *)
&(data->
fcell_array[depth *
(data->rows_intern *
data->cols_intern) +
row * data->cols_intern +
col]), FCELL_TYPE);
}
else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
G_debug(6,
"N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
depth, row, col);
return Rast3d_is_null_value_num((void *)
&(data->
dcell_array[depth *
(data->rows_intern *
data->cols_intern) +
row * data->cols_intern +
col]), DCELL_TYPE);
}
}
else {
if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
G_debug(6,
"N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
depth, row, col);
return Rast3d_is_null_value_num((void *)
&(data->
fcell_array[(depth +
data->offset) *
(data->rows_intern *
data->cols_intern) +
(row + data->offset)
* data->cols_intern +
(col + data->offset)]),
FCELL_TYPE);
}
else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
G_debug(6,
"N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
depth, row, col);
return Rast3d_is_null_value_num((void *)
&(data->
dcell_array[(depth +
data->offset) *
(data->rows_intern *
data->cols_intern) +
(row +
data->offset) *
data->cols_intern + (col +
data->
offset)]),
DCELL_TYPE);
}
}
return 0;
}
/* *************************************************************** */
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);
}
