void Rast3d_change_precision(void *map, int precision, const char *nameOut) { void *map2; int x, y, z, savePrecision, saveCompression; char *data; RASTER3D_Region region; int typeIntern; int nx, ny, nz; int tileXsave, tileYsave, tileZsave, tileX, tileY, tileZ, saveType; saveType = Rast3d_get_file_type(); /* Rast3d_set_file_type (Rast3d_file_type_map (map)); */ Rast3d_get_compression_mode(&saveCompression, &savePrecision); Rast3d_set_compression_mode(RASTER3D_COMPRESSION, precision); Rast3d_get_tile_dimension(&tileXsave, &tileYsave, &tileZsave); Rast3d_get_tile_dimensions_map(map, &tileX, &tileY, &tileZ); Rast3d_set_tile_dimension(tileX, tileY, tileZ); typeIntern = Rast3d_tile_type_map(map); Rast3d_get_region_struct_map(map, ®ion); map2 = Rast3d_open_cell_new(nameOut, typeIntern, RASTER3D_USE_CACHE_DEFAULT, ®ion); if (map2 == NULL) Rast3d_fatal_error("Rast3d_change_precision: error in Rast3d_open_cell_new"); Rast3d_set_file_type(saveType); Rast3d_set_compression_mode(saveCompression, savePrecision); Rast3d_set_tile_dimension(tileXsave, tileYsave, tileZsave); data = Rast3d_alloc_tiles(map, 1); if (data == NULL) Rast3d_fatal_error("Rast3d_change_precision: error in Rast3d_alloc_tiles"); Rast3d_get_nof_tiles_map(map2, &nx, &ny, &nz); for (z = 0; z < nz; z++) for (y = 0; y < ny; y++) for (x = 0; x < nx; x++) { if (!Rast3d_read_tile(map, Rast3d_tile2tile_index(map, x, y, z), data, typeIntern)) Rast3d_fatal_error ("Rast3d_change_precision: error in Rast3d_read_tile"); if (!Rast3d_write_tile (map2, Rast3d_tile2tile_index(map2, x, y, z), data, typeIntern)) Rast3d_fatal_error ("Rast3d_change_precision: error in Rast3d_write_tile"); } Rast3d_free_tiles(data); if (!Rast3d_close(map2)) Rast3d_fatal_error("Rast3d_change_precision: error in Rast3d_close"); }
static void retileNocache(void *map, const char *nameOut, int tileX, int tileY, int tileZ) { void *map2; int x, y, z, saveType, nx, ny, nz; int typeIntern; void *data; int tileXsave, tileYsave, tileZsave; RASTER3D_Region region; saveType = Rast3d_get_file_type(); Rast3d_set_file_type(Rast3d_file_type_map(map)); Rast3d_get_tile_dimension(&tileXsave, &tileYsave, &tileZsave); Rast3d_set_tile_dimension(tileX, tileY, tileZ); typeIntern = Rast3d_tile_type_map(map); Rast3d_get_region_struct_map(map, ®ion); map2 = Rast3d_open_cell_new(nameOut, typeIntern, RASTER3D_NO_CACHE, ®ion); if (map2 == NULL) Rast3d_fatal_error("Rast3d_retile: error in Rast3d_open_cell_new"); Rast3d_set_file_type(saveType); Rast3d_set_tile_dimension(tileXsave, tileYsave, tileZsave); data = Rast3d_alloc_tiles(map2, 1); if (data == NULL) Rast3d_fatal_error("Rast3d_retile: error in Rast3d_alloc_tiles"); Rast3d_get_nof_tiles_map(map2, &nx, &ny, &nz); for (z = 0; z < nz; z++) { G_percent(z, nz, 1); for (y = 0; y < ny; y++) for (x = 0; x < nx; x++) { Rast3d_get_block(map, x * tileX, y * tileY, z * tileZ, tileX, tileY, tileZ, data, typeIntern); if (!Rast3d_write_tile (map2, Rast3d_tile2tile_index(map2, x, y, z), data, typeIntern)) Rast3d_fatal_error ("Rast3d_retileNocache: error in Rast3d_write_tile"); } } G_percent(1, 1, 1); Rast3d_free_tiles(data); Rast3d_close(map2); }
/* ************************************************************************* */ 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); }
void Rast3d_retile(void *map, const char *nameOut, int tileX, int tileY, int tileZ) { void *map2; double value; int x, y, z, saveType; int rows, cols, depths, typeIntern; int xTile, yTile, zTile; int xOffs, yOffs, zOffs, prev; int tileXsave, tileYsave, tileZsave; RASTER3D_Region region; if (!Rast3d_tile_use_cache_map(map)) { retileNocache(map, nameOut, tileX, tileY, tileZ); return; } saveType = Rast3d_get_file_type(); Rast3d_set_file_type(Rast3d_file_type_map(map)); Rast3d_get_tile_dimension(&tileXsave, &tileYsave, &tileZsave); Rast3d_set_tile_dimension(tileX, tileY, tileZ); typeIntern = Rast3d_tile_type_map(map); Rast3d_get_region_struct_map(map, ®ion); map2 = Rast3d_open_cell_new(nameOut, typeIntern, RASTER3D_USE_CACHE_DEFAULT, ®ion); if (map2 == NULL) Rast3d_fatal_error("Rast3d_retile: error in Rast3d_open_cell_new"); Rast3d_set_file_type(saveType); Rast3d_set_tile_dimension(tileXsave, tileYsave, tileZsave); Rast3d_coord2tile_coord(map2, 0, 0, 0, &xTile, &yTile, &zTile, &xOffs, &yOffs, &zOffs); prev = zTile; x = 0; y = 0; Rast3d_get_coords_map(map, &rows, &cols, &depths); for (z = 0; z < depths; z++) { G_percent(z, depths, 1); Rast3d_coord2tile_coord(map2, x, y, z, &xTile, &yTile, &zTile, &xOffs, &yOffs, &zOffs); if (zTile > prev) { if (!Rast3d_flush_all_tiles(map2)) Rast3d_fatal_error("Rast3d_retile: error in Rast3d_flush_all_tiles"); prev++; } for (y = 0; y < rows; y++) for (x = 0; x < cols; x++) { Rast3d_get_value_region(map, x, y, z, &value, typeIntern); if (!Rast3d_put_value(map2, x, y, z, &value, typeIntern)) Rast3d_fatal_error("Rast3d_retile: error in Rast3d_put_value"); } } G_percent(1, 1, 1); if (!Rast3d_flush_all_tiles(map2)) Rast3d_fatal_error("Rast3d_retile: error in Rast3d_flush_all_tiles"); if (!Rast3d_close(map2)) Rast3d_fatal_error("Rast3d_retile: error in Rast3d_close"); }
/* ************************************************************************* */ void rast3d_cross_section(void *map,RASTER3D_Region region, int elevfd, int outfd) { int col, row; int rows, cols, depths, typeIntern; FCELL *fcell = NULL; DCELL *dcell = NULL; void *elevrast; void *ptr; int intvalue; float fvalue; double dvalue; double elevation = 0; double north, east; struct Cell_head window; Rast_get_window(&window); rows = region.rows; cols = region.cols; depths = region.depths; /*Typ of the RASTER3D Tile */ typeIntern = Rast3d_tile_type_map(map); /*Allocate mem for the output maps row */ if (typeIntern == FCELL_TYPE) fcell = Rast_allocate_f_buf(); else if (typeIntern == DCELL_TYPE) dcell = Rast_allocate_d_buf(); /*Mem for the input map row */ elevrast = Rast_allocate_buf(globalElevMapType); for (row = 0; row < rows; row++) { G_percent(row, rows - 1, 10); /*Read the input map row */ Rast_get_row(elevfd, elevrast, row, globalElevMapType); for (col = 0, ptr = elevrast; col < cols; col++, ptr = G_incr_void_ptr(ptr, Rast_cell_size(globalElevMapType))) { if (Rast_is_null_value(ptr, globalElevMapType)) { if (typeIntern == FCELL_TYPE) Rast_set_null_value(&fcell[col], 1, FCELL_TYPE); else if (typeIntern == DCELL_TYPE) Rast_set_null_value(&dcell[col], 1, DCELL_TYPE); continue; } /*Read the elevation value */ if (globalElevMapType == CELL_TYPE) { intvalue = *(CELL *) ptr; elevation = intvalue; } else if (globalElevMapType == FCELL_TYPE) { fvalue = *(FCELL *) ptr; elevation = fvalue; } else if (globalElevMapType == DCELL_TYPE) { dvalue = *(DCELL *) ptr; elevation = dvalue; } /* Compute the coordinates */ north = Rast_row_to_northing((double)row + 0.5, &window); east = Rast_col_to_easting((double)col + 0.5, &window); /* Get the voxel value */ if (typeIntern == FCELL_TYPE) Rast3d_get_region_value(map, north, east, elevation, &fcell[col], FCELL_TYPE); if (typeIntern == DCELL_TYPE) Rast3d_get_region_value(map, north, east, elevation, &dcell[col], DCELL_TYPE); } /*Write the data to the output map */ if (typeIntern == FCELL_TYPE) Rast_put_f_row(outfd, fcell); if (typeIntern == DCELL_TYPE) Rast_put_d_row(outfd, dcell); } G_debug(3, "\nDone\n"); /*Free the mem */ if (elevrast) G_free(elevrast); if (dcell) G_free(dcell); if (fcell) G_free(fcell); }
/* ************************************************************************* */ void write_vtk_vector_data(void *map_x, void *map_y, void *map_z, FILE * fp, const char *varname, RASTER3D_Region region, int dp) { double value = 0; int x, y, z, percentage, k; int rows, cols, depths; int typeIntern[3]; void *mapvect = NULL; G_debug(3, "write_vtk_vector_data: Writing vector data"); rows = region.rows; cols = region.cols; depths = region.depths; typeIntern[0] = Rast3d_tile_type_map(map_x); typeIntern[1] = Rast3d_tile_type_map(map_y); typeIntern[2] = Rast3d_tile_type_map(map_z); percentage = 0; /********************** WRITE VECTOR DATA; CELL OR POINT ****************/ fprintf(fp, "VECTORS %s float\n", varname); for (z = 0; z < depths; z++) { /*From the bottom to the top */ for (y = 0; y < rows; y++) { G_percent(percentage, (rows * depths - 1), 10); percentage++; for (x = 0; x < cols; x++) { for (k = 0; k < 3; k++) { if (k == 0) mapvect = map_x; if (k == 1) mapvect = map_y; if (k == 2) mapvect = map_z; /* In case of structured grid data, the point/cell coordinates are computed based on the default north->south raster3d coordinate system. We need to compute south -> north ordering for image data. */ if (!param.structgrid->answer) value = get_g3d_raster_value_as_double(mapvect, x, rows - y - 1, z, typeIntern[k], 0.0); else value = get_g3d_raster_value_as_double(mapvect, x, y, z, typeIntern[k], 0.0); fprintf(fp, "%.*f ", dp, value); } fprintf(fp, "\n"); } } } return; }
/* ************************************************************************* */ void write_vtk_rgb_data(void *map_r, void *map_g, void *map_b, FILE * fp, const char *varname, RASTER3D_Region region, int dp) { double value = 0; int x, y, z, percentage, k; int rows, cols, depths; int typeIntern[3]; void *maprgb = NULL; G_debug(3, "write_vtk_rgb_data: Writing RGB data"); rows = region.rows; cols = region.cols; depths = region.depths; typeIntern[0] = Rast3d_tile_type_map(map_r); typeIntern[1] = Rast3d_tile_type_map(map_g); typeIntern[2] = Rast3d_tile_type_map(map_b); percentage = 0; /********************** WRITE RGB VOXEL DATA; CELL OR POINT ****************/ fprintf(fp, "COLOR_SCALARS %s 3\n", varname); for (z = 0; z < depths; z++) { for (y = 0; y < rows; y++) { G_percent(percentage, (rows * depths - 1), 10); percentage++; for (x = 0; x < cols; x++) { for (k = 0; k < 3; k++) { if (k == 0) maprgb = map_r; if (k == 1) maprgb = map_g; if (k == 2) maprgb = map_b; /* In case of structured grid data, the point/cell coordinates are computed based on the default north->south raster3d coordinate system. We need to compute south -> north ordering for image data. */ if (!param.structgrid->answer) value = get_g3d_raster_value_as_double(maprgb, x, rows - y - 1, z, typeIntern[k], 0.0); else value = get_g3d_raster_value_as_double(maprgb, x, y, z, typeIntern[k], 0.0); /*Test of value range, the data should be 1 byte gray values */ if (value > 255 || value < 0) { G_warning(_("Wrong 3D raster map values! Values should in between 0 and 255!")); fprintf(fp, "0 "); } else { fprintf(fp, "%.*f ", dp, (value / 255)); } } fprintf(fp, "\n"); } } } return; }
/* ************************************************************************* */ void write_vtk_data(FILE * fp, void *map, RASTER3D_Region region, char *varname, int dp) { double value; double nullvalue; int x, y, z, percentage; int rows, cols, depths, typeIntern; rows = region.rows; cols = region.cols; depths = region.depths; /*the nullvalue */ if (!sscanf(param.null_val->answer, "%lf", &nullvalue)) { G_warning("Null value is not valid, using 0 instead."); nullvalue = 0; } G_debug(3, _("write_vtk_data: Writing Celldata %s with rows %i cols %i depths %i to vtk-ascii file"), varname, rows, cols, depths); fprintf(fp, "SCALARS %s float 1\n", varname); fprintf(fp, "LOOKUP_TABLE default\n"); typeIntern = Rast3d_tile_type_map(map); percentage = 0; for (z = 0; z < depths; z++) { /* In case of structured grid data, the point/cell coordinates are computed based on the default north->south raster3d coordinate system. We need to compute south -> north ordering for image data. */ if (!param.structgrid->answer) { for (y = rows - 1; y >= 0; y--) { G_percent(percentage, (rows * depths - 1), 10); percentage++; for (x = 0; x < cols; x++) { value = get_g3d_raster_value_as_double(map, x, y, z, typeIntern, nullvalue); fprintf(fp, "%.*f ", dp, value); } fprintf(fp, "\n"); } } else { for (y = 0; y < rows; y++) { G_percent(percentage, (rows * depths - 1), 10); percentage++; for (x = 0; x < cols; x++) { value = get_g3d_raster_value_as_double(map, x, y, z, typeIntern, nullvalue); fprintf(fp, "%.*f ", dp, value); } fprintf(fp, "\n"); } } } }
/* *************************************************************** */ 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); }
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); }