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