void *Rast3d_open_cell_old(const char *name, const char *mapset,
RASTER3D_Region * window, int typeIntern, int cache)
{
RASTER3D_Map *map;
int proj, zone;
int compression, useRle, useLzw, type, tileX, tileY, tileZ;
int rows, cols, depths, precision;
double ew_res, ns_res, tb_res;
int nofHeaderBytes, dataOffset, useXdr, hasIndex;
char *ltmp, *unit;
double north, south, east, west, top, bottom;
map = Rast3d_open_cell_old_no_header(name, mapset);
if (map == NULL) {
Rast3d_error(_("Rast3d_open_cell_old: error in Rast3d_open_cell_old_no_header"));
return (void *)NULL;
}
if (lseek(map->data_fd, (long)0, SEEK_SET) == -1) {
Rast3d_error(_("Rast3d_open_cell_old: can't rewind file"));
return (void *)NULL;
}
if (!Rast3d_read_header(map,
&proj, &zone,
&north, &south, &east, &west, &top, &bottom,
&rows, &cols, &depths,
&ew_res, &ns_res, &tb_res,
&tileX, &tileY, &tileZ,
&type, &compression, &useRle, &useLzw,
&precision, &dataOffset, &useXdr, &hasIndex, &unit)) {
Rast3d_error(_("Rast3d_open_cell_old: error in Rast3d_read_header"));
return 0;
}
if (window == RASTER3D_DEFAULT_WINDOW)
window = Rast3d_window_ptr();
if (proj != window->proj) {
Rast3d_error(_("Rast3d_open_cell_old: projection does not match window projection"));
return (void *)NULL;
}
if (zone != window->zone) {
Rast3d_error(_("Rast3d_open_cell_old: zone does not match window zone"));
return (void *)NULL;
}
map->useXdr = useXdr;
if (hasIndex) {
/* see RASTER3D_openCell_new () for format of header */
if ((!Rast3d_read_ints(map->data_fd, map->useXdr,
&(map->indexLongNbytes), 1)) ||
(!Rast3d_read_ints(map->data_fd, map->useXdr,
&(map->indexNbytesUsed), 1))) {
Rast3d_error(_("Rast3d_open_cell_old: can't read header"));
return (void *)NULL;
}
/* if our long is to short to store offsets we can't read the file */
if (map->indexNbytesUsed > sizeof(long))
Rast3d_fatal_error(_("Rast3d_open_cell_old: index does not fit into long"));
ltmp = Rast3d_malloc(map->indexLongNbytes);
if (ltmp == NULL) {
Rast3d_error(_("Rast3d_open_cell_old: error in Rast3d_malloc"));
return (void *)NULL;
}
/* convert file long to long */
if (read(map->data_fd, ltmp, map->indexLongNbytes) !=
map->indexLongNbytes) {
Rast3d_error(_("Rast3d_open_cell_old: can't read header"));
return (void *)NULL;
}
Rast3d_long_decode(ltmp, &(map->indexOffset), 1, map->indexLongNbytes);
Rast3d_free(ltmp);
}
nofHeaderBytes = dataOffset;
if (typeIntern == RASTER3D_TILE_SAME_AS_FILE)
typeIntern = type;
if (!Rast3d_fill_header(map, RASTER3D_READ_DATA, compression, useRle, useLzw,
type, precision, cache,
hasIndex, map->useXdr, typeIntern,
nofHeaderBytes, tileX, tileY, tileZ,
proj, zone,
north, south, east, west, top, bottom,
rows, cols, depths, ew_res, ns_res, tb_res, unit)) {
Rast3d_error(_("Rast3d_open_cell_old: error in Rast3d_fill_header"));
return (void *)NULL;
}
Rast3d_region_copy(&(map->window), window);
Rast3d_adjust_region(&(map->window));
Rast3d_get_nearest_neighbor_fun_ptr(&(map->resampleFun));
return map;
}
/* ************************************************************************* */
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);
}
void *Rast3d_open_cell_new(const char *name, int typeIntern, int cache,
RASTER3D_Region * region)
{
RASTER3D_Map *map;
int nofHeaderBytes, dummy = 0, compression, precision;
long ldummy = 0;
char xname[GNAME_MAX], xmapset[GMAPSET_MAX];
Rast3d_init_defaults();
if (!Rast3d_mask_open_old()) {
Rast3d_error(_("Rast3d_open_cell_new: error in Rast3d_mask_open_old"));
return (void *)NULL;
}
compression = g3d_do_compression;
precision = g3d_precision;
map = Rast3d_malloc(sizeof(RASTER3D_Map));
if (map == NULL) {
Rast3d_error(_("Rast3d_open_cell_new: error in Rast3d_malloc"));
return (void *)NULL;
}
if (G_unqualified_name(name, G_mapset(), xname, xmapset) < 0) {
G_warning(_("map <%s> is not in the current mapset"), name);
return (void *)NULL;
}
map->fileName = G_store(xname);
map->mapset = G_store(xmapset);
map->tempName = G_tempfile();
map->data_fd = open(map->tempName, O_RDWR | O_CREAT | O_TRUNC, 0666);
if (map->data_fd < 0) {
Rast3d_error(_("Rast3d_open_cell_new: could not open file"));
return (void *)NULL;
}
Rast3d_make_mapset_map_directory(map->fileName);
map->useXdr = RASTER3D_USE_XDR;
if (g3d_file_type == FCELL_TYPE) {
if (precision > 23)
precision = 23; /* 32 - 8 - 1 */
else if (precision < -1)
precision = 0;
}
else if (precision > 52)
precision = 52; /* 64 - 11 - 1 */
else if (precision < -1)
precision = 0;
/* no need to write trailing zeros */
if ((typeIntern == FCELL_TYPE) && (g3d_file_type == DCELL_TYPE)) {
if (precision == -1)
precision = 23;
else
precision = RASTER3D_MIN(precision, 23);
}
if (compression == RASTER3D_NO_COMPRESSION)
precision = RASTER3D_MAX_PRECISION;
if (compression == RASTER3D_COMPRESSION)
map->useXdr = RASTER3D_USE_XDR;
if (RASTER3D_HAS_INDEX) {
map->indexLongNbytes = sizeof(long);
/* at the beginning of the file write */
/* nof bytes of "long" */
/* max nof bytes used for index */
/* position of index in file */
/* the index is appended at the end of the file at closing time. since */
/* we do not know this position yet we write dummy values */
if ((!Rast3d_write_ints(map->data_fd, map->useXdr,
&(map->indexLongNbytes), 1)) ||
(!Rast3d_write_ints(map->data_fd, map->useXdr, &dummy, 1))) {
Rast3d_error(_("Rast3d_open_cell_new: can't write header"));
return (void *)NULL;
}
if (write(map->data_fd, &ldummy, map->indexLongNbytes) !=
map->indexLongNbytes) {
Rast3d_error(_("Rast3d_open_cell_new: can't write header"));
return (void *)NULL;
}
}
/* can't use a constant since this depends on sizeof (long) */
nofHeaderBytes = lseek(map->data_fd, (long)0, SEEK_CUR);
Rast3d_range_init(map);
Rast3d_adjust_region(region);
if (!Rast3d_fill_header(map, RASTER3D_WRITE_DATA, compression,
g3d_do_rle_compression, g3d_do_lzw_compression,
g3d_file_type, precision, cache, RASTER3D_HAS_INDEX,
map->useXdr, typeIntern, nofHeaderBytes,
g3d_tile_dimension[0], g3d_tile_dimension[1],
g3d_tile_dimension[2],
region->proj, region->zone,
region->north, region->south, region->east,
region->west, region->top, region->bottom,
region->rows, region->cols, region->depths,
region->ew_res, region->ns_res, region->tb_res,
g3d_unit_default)) {
Rast3d_error(_("Rast3d_open_cell_new: error in Rast3d_fill_header"));
return (void *)NULL;
}
/*Set the map window to the map region */
Rast3d_region_copy(&(map->window), region);
/*Set the resampling function to nearest neighbor for data access */
Rast3d_get_nearest_neighbor_fun_ptr(&(map->resampleFun));
Rast3d_mask_off(map);
return (void *)map;
}
int main(int argc, char *argv[]) {
struct GModule *module;
struct {
struct Option *input;
struct Option *output;
struct Option *null;
struct Option *bytes;
struct Option *order;
struct Option *north;
struct Option *south;
struct Option *top;
struct Option *bottom;
struct Option *east;
struct Option *west;
struct Option *rows;
struct Option *cols;
struct Option *depths;
} parm;
struct {
struct Flag *integer_in;
struct Flag *sign;
struct Flag *depth;
struct Flag *row;
} flag;
const char *input;
const char *output;
int is_integer;
int is_signed;
int bytes;
int order;
int byte_swap;
RASTER_MAP_TYPE map_type;
off_t file_size;
struct History history;
off_t expected;
/* Need to be allocated later */
in_cell = NULL;
G_gisinit(argv[0]);
/* Set description */
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("import"));
G_add_keyword(_("voxel"));
module->description =
_("Imports a binary raster file into a GRASS 3D raster map.");
parm.input = G_define_standard_option(G_OPT_F_BIN_INPUT);
parm.input->description = _("Name of binary 3D raster file to be imported");
parm.output = G_define_standard_option(G_OPT_R3_OUTPUT);
parm.bytes = G_define_option();
parm.bytes->key = "bytes";
parm.bytes->type = TYPE_INTEGER;
parm.bytes->required = YES;
parm.bytes->options = "1,2,4,8";
parm.bytes->description = _("Number of bytes per cell in binary file");
parm.order = G_define_option();
parm.order->key = "order";
parm.order->type = TYPE_STRING;
parm.order->required = NO;
parm.order->options = "big,little,native,swap";
parm.order->description = _("Byte order in binary file");
parm.order->answer = "native";
parm.north = G_define_option();
parm.north->key = "north";
parm.north->type = TYPE_DOUBLE;
parm.north->required = YES;
parm.north->description =
_("Northern limit of geographic region (outer edge)");
parm.north->guisection = _("Bounds");
parm.south = G_define_option();
parm.south->key = "south";
parm.south->type = TYPE_DOUBLE;
parm.south->required = YES;
parm.south->description =
_("Southern limit of geographic region (outer edge)");
parm.south->guisection = _("Bounds");
parm.east = G_define_option();
parm.east->key = "east";
parm.east->type = TYPE_DOUBLE;
parm.east->required = YES;
parm.east->description =
_("Eastern limit of geographic region (outer edge)");
parm.east->guisection = _("Bounds");
parm.west = G_define_option();
parm.west->key = "west";
parm.west->type = TYPE_DOUBLE;
parm.west->required = YES;
parm.west->description =
_("Western limit of geographic region (outer edge)");
parm.west->guisection = _("Bounds");
parm.bottom = G_define_option();
parm.bottom->key = "bottom";
parm.bottom->type = TYPE_DOUBLE;
parm.bottom->required = YES;
parm.bottom->description =
_("Bottom limit of geographic region (outer edge)");
parm.bottom->guisection = _("Bounds");
parm.top = G_define_option();
parm.top->key = "top";
parm.top->type = TYPE_DOUBLE;
parm.top->required = YES;
parm.top->description = _("Top limit of geographic region (outer edge)");
parm.top->guisection = _("Bounds");
parm.rows = G_define_option();
parm.rows->key = "rows";
parm.rows->type = TYPE_INTEGER;
parm.rows->required = YES;
parm.rows->description = _("Number of rows");
parm.rows->guisection = _("Bounds");
parm.cols = G_define_option();
parm.cols->key = "cols";
parm.cols->type = TYPE_INTEGER;
parm.cols->required = YES;
parm.cols->description = _("Number of columns");
parm.cols->guisection = _("Bounds");
parm.depths = G_define_option();
parm.depths->key = "depths";
parm.depths->type = TYPE_INTEGER;
parm.depths->required = YES;
parm.depths->description = _("Number of depths");
parm.depths->guisection = _("Bounds");
parm.null = G_define_option();
parm.null->key = "null";
parm.null->type = TYPE_DOUBLE;
parm.null->required = NO;
parm.null->description = _("Set Value to NULL");
flag.row = G_define_flag();
flag.row->key = 'r';
flag.row->description = _("Switch the row order in output from "
"north->south to south->north");
flag.depth = G_define_flag();
flag.depth->key = 'd';
flag.depth->description = _("Switch the depth order in output "
"from bottom->top to top->bottom");
flag.integer_in = G_define_flag();
flag.integer_in->key = 'i';
flag.integer_in->description =
_("Binary data is of type integer");
flag.sign = G_define_flag();
flag.sign->key = 's';
flag.sign->description = _("Signed data (two's complement)");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
input = parm.input->answer;
output = parm.output->answer;
if (G_strcasecmp(parm.order->answer, "big") == 0)
order = 0;
else if (G_strcasecmp(parm.order->answer, "little") == 0)
order = 1;
else if (G_strcasecmp(parm.order->answer, "native") == 0)
order = G_is_little_endian() ? 1 : 0;
else if (G_strcasecmp(parm.order->answer, "swap") == 0)
order = G_is_little_endian() ? 0 : 1;
byte_swap = order == (G_is_little_endian() ? 0 : 1);
is_signed = !!flag.sign->answer;
is_integer = 0;
bytes = 8;
if (parm.bytes->answer)
bytes = atoi(parm.bytes->answer);
if (!flag.integer_in->answer) {
if (bytes && bytes < 4)
G_fatal_error(
_("bytes=%d; must be 4 or 8 in case of floating point input"),
bytes);
if (!bytes)
bytes = 4;
} else {
is_integer = 1;
}
#ifndef HAVE_LONG_LONG_INT
if (is_integer && bytes > 4)
G_fatal_error(_("Integer input doesn't support size=8 in this build"));
#endif
if (bytes != 1 && bytes != 2 && bytes != 4 && bytes != 8)
G_fatal_error(_("bytes= must be 1, 2, 4 or 8"));
region.zone = G_zone();
region.proj = G_projection();
region.rows = atoi(parm.rows->answer);
region.cols = atoi(parm.cols->answer);
region.depths = atoi(parm.depths->answer);
region.top = atof(parm.top->answer);
region.bottom = atof(parm.bottom->answer);
if (!G_scan_northing(parm.north->answer, ®ion.north, region.proj))
G_fatal_error(_("Illegal north coordinate <%s>"), parm.north->answer);
if (!G_scan_northing(parm.south->answer, ®ion.south, region.proj))
G_fatal_error(_("Illegal south coordinate <%s>"), parm.south->answer);
if (!G_scan_easting(parm.east->answer, ®ion.east, region.proj))
G_fatal_error(_("Illegal east coordinate <%s>"), parm.east->answer);
if (!G_scan_easting(parm.west->answer, ®ion.west, region.proj))
G_fatal_error(_("Illegal west coordinate <%s>"), parm.west->answer);
Rast3d_adjust_region(®ion);
expected = (off_t) region.rows * region.cols * region.depths * bytes;
fp = fopen(input, "rb");
if (!fp)
G_fatal_error(_("Unable to open <%s>"), input);
/* Find File Size in Byte and Check against byte size */
G_fseek(fp, 0, SEEK_END);
file_size = G_ftell(fp);
G_fseek(fp, 0, SEEK_SET);
if (file_size != expected) {
G_warning(_("File Size %lld ... Total Bytes %lld"),
(long long int) file_size, (long long int) expected);
G_fatal_error(_("Bytes do not match file size"));
}
map_type = (bytes > 4 ? DCELL_TYPE : FCELL_TYPE);
if(is_integer && bytes >= 4)
map_type = DCELL_TYPE;
Rast3d_init_defaults();
/*Open the new 3D raster map */
map = Rast3d_open_new_opt_tile_size(output, RASTER3D_USE_CACHE_DEFAULT,
®ion, map_type, 32);
if (map == NULL)
G_fatal_error(_("Unable to open 3D raster map"));
in_cell = G_malloc(bytes);
bin_to_raster3d(parm.null->answer, map_type, is_integer, is_signed, bytes,
byte_swap, flag.row->answer, flag.depth->answer);
if (!Rast3d_close(map))
G_fatal_error(_("Unable to close 3D raster map"));
/* write input name to map history */
Rast3d_read_history(output, G_mapset(), &history);
Rast_set_history(&history, HIST_DATSRC_1, input);
Rast3d_write_history(output, &history);
fclose(fp);
if (in_cell)
G_free(in_cell);
return EXIT_SUCCESS;
}
int test_large_file(int depths, int rows, int cols, int tile_size)
{
int sum = 0;
int x, y, z, count;
DCELL value;
G_message("Testing DCELL put function for large files");
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");
map = Rast3d_open_new_opt_tile_size("test_put_get_value_dcell_large",
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);
/*Write -1 first to see if the tile handling works correctly */
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 = -1;
Rast3d_put_value(map, x, y, z, &value, DCELL_TYPE);
}
}
}
G_percent(1, 1, 1);
G_message("Rewriting the values");
/* Now write the values to be evaluated */
count = 1;
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 = count;
Rast3d_put_value(map, x, y, z, &value, DCELL_TYPE);
count++;
}
}
}
G_percent(1, 1, 1);
G_message("Verifying 3D raster map");
count = 1;
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 - (double)(count) > EPSILON)) {
G_message("At: z %i y %i x %i -- value %.14lf != %.14lf\n",
z, y, x, value, (double)(count));
sum++;
}
count++;
}
}
}
G_percent(1, 1, 1);
Rast3d_close(map);
G_remove("grid3", "test_put_get_value_dcell_large");
return sum;
}
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;
}
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;
}
