int main(int argc, char *argv[])
{
char *name;
d_Mask *maskRules;
struct GModule *module;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("raster3d"));
G_add_keyword(_("mask"));
G_add_keyword(_("voxel"));
module->description =
_("Establishes the current working 3D raster mask.");
params.map = G_define_option();
params.map->key = "map";
params.map->type = TYPE_STRING;
params.map->required = YES;
params.map->multiple = NO;
params.map->gisprompt = "old,grid3,3d-raster";
params.map->description = _("3D raster map with reference values");
params.maskVals = G_define_option();
params.maskVals->key = "maskvalues";
params.maskVals->key_desc = "val[-val]";
params.maskVals->type = TYPE_STRING;
params.maskVals->required = NO;
params.maskVals->multiple = YES;
params.maskVals->description = _("List of cell values to be masked out");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (Rast3d_mask_file_exists())
G_fatal_error(_("Cannot create mask file: RASTER3D_MASK already exists"));
getParams(&name, &maskRules);
makeMask(name, maskRules);
exit(EXIT_SUCCESS);
}
/* ************************************************************************* */
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[])
{
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);
}
/* ************************************************************************* */
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;
}
/* ************************************************************************* */
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;
}
/* ************************************************************************* */
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;
}
