Loading...
Searching...
No Matches
gvl_file.c
Go to the documentation of this file.
/*!
\file lib/ogsf/gvl_file.c
\brief OGSF library - loading and manipulating volumes (lower level
functions)
GRASS OpenGL gsurf OGSF Library
(C) 1999-2008 by the GRASS Development Team
This program is free software under the
GNU General Public License (>=v2).
Read the file COPYING that comes with GRASS
for details.
\author Tomas Paudits (February 2004)
\author Doxygenized by Martin Landa <landa.martin gmail.com> (May 2008)
*/
#include <string.h>
#include <stdlib.h>
#include <grass/gis.h>
#include <grass/ogsf.h>
#include <grass/raster3d.h>
#include <grass/glocale.h>
#define LUCKY 33
#define MODE_DIRECT 0
#define MODE_SLICE 1
#define MODE_FULL 2
#define MODE_PRELOAD 3
#define MODE_DEFAULT 0
#define STATUS_READY 0
#define STATUS_BUSY 1
/*!
\brief structure for slice mode reading from volume file
*/
typedef struct {
int num, skip;
int crnt, base;
void *slice[MAX_VOL_SLICES];
} slice_data;
static geovol_file *Data[MAX_VOL_FILES];
static geovol_file Df[MAX_VOL_FILES]; /* trying to avoid allocation */
static int Numfiles = 0;
static int Cur_id = LUCKY;
static int Cur_max;
static int Rows, Cols, Depths;
/* local functions prototypes */
void *open_g3d_file(const char *, IFLAG *, double *, double *);
int close_g3d_file(void *);
/*!
\brief Initialize volume files
\return 1
*/
static int init_volfiles(void)
{
int i;
RASTER3D_Region *w3;
for (i = 0; i < MAX_VOL_FILES; i++) {
/* avoiding dynamic allocation */
Data[i] = &(Df[i]);
}
Cur_max = MAX_VOL_FILES;
/* get window */
w3 = GVL_get_window();
/* set cols, rows, depths from window */
Cols = w3->cols;
Rows = w3->rows;
Depths = w3->depths;
return (1);
}
/*!
\brief Check number of files
\return 0
*/
static int check_num_volfiles(void)
{
if (Numfiles < Cur_max) {
return (0);
}
G_fatal_error(_("Maximum number of datafiles exceeded"));
/* This return statement keeps compilers happy, it is never executed */
return (0);
}
/*!
\brief Get geovol_file structure for given handle
\param id
\return pointer to geovol_file struct
\return NULL on failure
*/
geovol_file *gvl_file_get_volfile(int id)
{
int i;
for (i = 0; i < Numfiles; i++) {
if (Data[i]->data_id == id) {
return (Data[i]);
}
}
return (NULL);
}
/*!
\brief Find file with name and type in geovol_file array an return handle
\param name file name
\param begin
\param data id
\param -1 not found
*/
int find_datah(const char *name, IFLAG type, int begin)
{
static int i;
int start;
start = begin ? 0 : i + 1;
for (i = start; i < Numfiles; i++) {
if (!strcmp(Data[i]->file_name, name)) {
if (Data[i]->file_type == type) {
return (Data[i]->data_id);
}
}
}
return (-1);
}
/*!
\brief Get file name for given handle
\param id handle id
\return file name
\return NULL on failure
*/
char *gvl_file_get_name(int id)
{
int i;
geovol_file *fvf;
static char retstr[GPATH_MAX];
for (i = 0; i < Numfiles; i++) {
if (Data[i]->data_id == id) {
fvf = Data[i];
strcpy(retstr, fvf->file_name);
return (retstr);
}
}
return (NULL);
}
/*!
\brief Get file type for given handle
\param vf pointer to geovol_file struct
\return file type
*/
int gvl_file_get_file_type(geovol_file *vf)
{
return (vf->file_type);
}
/*!
\brief Get data type for given handle
\param vf pointer to geovol_file struct
\return data type
*/
int gvl_file_get_data_type(geovol_file *vf)
{
return (vf->data_type);
}
/*!
\brief Get minimum and maximum value in volume file
\param vf pointer to geovol_file struct
\param[out] min min value
\param[out] max max value
*/
void gvl_file_get_min_max(geovol_file *vf, double *min, double *max)
{
*min = vf->min;
*max = vf->max;
}
/*!
\brief Open 3d raster file
\param name file name
\param file_type file type
\param data_type data type
\param[out] min min value
\param[out] max max value
\return pointer to file
\return NULL on failure
*/
void *open_volfile(const char *name, IFLAG file_type, IFLAG *data_type,
double *min, double *max)
{
if (file_type == VOL_FTYPE_RASTER3D) {
return open_g3d_file(name, data_type, min, max);
}
return (NULL);
}
/*!
\brief Close volume file
\param map volume filename
\param type file type
\return
\return -1 on failure
*/
int close_volfile(void *map, IFLAG type)
{
if (type == VOL_FTYPE_RASTER3D) {
return close_g3d_file(map);
}
return (-1);
}
/*!
\brief Get handle for given file name and type
\param name volume filename
\param file_type file type
\return data id
\return -1 on failure
*/
int gvl_file_newh(const char *name, IFLAG file_type)
{
geovol_file *new;
static int first = 1;
int i, id;
void *m;
IFLAG data_type;
double min, max;
if (first) {
if (0 > init_volfiles()) {
return (-1);
}
first = 0;
}
if (0 <= (id = find_datah(name, file_type, 1))) {
for (i = 0; i < Numfiles; i++) {
if (Data[i]->data_id == id) {
new = Data[i];
new->count++;
return (id);
}
}
}
if (0 > check_num_volfiles()) {
return (-1);
}
if (!name) {
return (-1);
}
if ((m = open_volfile(name, file_type, &data_type, &min, &max)) == NULL) {
return (-1);
}
new = Data[Numfiles];
if (new) {
Numfiles++;
new->data_id = Cur_id++;
new->file_name = G_store(name);
new->file_type = file_type;
new->count = 1;
new->map = m;
new->min = min;
new->max = max;
new->data_type = data_type;
new->status = STATUS_READY;
new->buff = NULL;
new->mode = 255;
gvl_file_set_mode(new, MODE_DEFAULT);
return (new->data_id);
}
return (-1);
}
/*!
\brief Free allocated buffers
\param vf pointer to geovol_file struct
\return 1
*/
int free_volfile_buffs(geovol_file *vf)
{
if (vf->mode == MODE_SLICE) {
G_free(vf->buff);
vf->buff = NULL;
}
if (vf->mode == MODE_PRELOAD) {
G_free(vf->buff);
vf->buff = NULL;
}
return (1);
}
/*!
\brief Free geovol_file structure for given handle
\param id
\return
*/
int gvl_file_free_datah(int id)
{
int i, j, found = -1;
geovol_file *fvf;
G_debug(5, "gvl_file_free_datah(): id=%d", id);
for (i = 0; i < Numfiles; i++) {
if (Data[i]->data_id == id) {
found = 1;
fvf = Data[i];
if (fvf->count > 1) {
fvf->count--;
}
else {
close_volfile(fvf->map, fvf->file_type);
free_volfile_buffs(fvf);
G_free(fvf->file_name);
fvf->file_name = NULL;
fvf->data_id = 0;
for (j = i; j < (Numfiles - 1); j++) {
Data[j] = Data[j + 1];
}
Data[j] = fvf;
--Numfiles;
}
}
}
return (found);
}
/******************************************************************/
/* reading from RASTER3D raster volume files */
/******************************************************************/
/*!
\brief Open 3d raster file
\param filename file name
\param type data type
\param[out] min min value
\param[out] max max value
\returns pointer to data
*/
void *open_g3d_file(const char *filename, IFLAG *type, double *min, double *max)
{
const char *mapset;
int itype;
void *map;
/* search for g3d file a return his mapset */
mapset = G_find_raster3d(filename, "");
if (!mapset) {
G_warning(_("3D raster map <%s> not found"), filename);
return (NULL);
}
/* open g3d file */
map = Rast3d_open_cell_old(filename, mapset, RASTER3D_DEFAULT_WINDOW,
RASTER3D_TILE_SAME_AS_FILE,
RASTER3D_USE_CACHE_DEFAULT);
if (!map) {
G_warning(_("Unable to open 3D raster map <%s>"), filename);
return (NULL);
}
/* load range into range structure of map */
if (!Rast3d_range_load(map)) {
G_warning(_("Unable to read range of 3D raster map <%s>"), filename);
return (NULL);
}
Rast3d_range_min_max(map, min, max);
/* get file data type */
itype = Rast3d_file_type_map(map);
if (itype == FCELL_TYPE)
*type = VOL_DTYPE_FLOAT;
if (itype == DCELL_TYPE)
*type = VOL_DTYPE_DOUBLE;
return (map);
}
/*!
\brief Close g3d file
\param map 3d raster map
\return -1 on failure
\return 1 on success
*/
int close_g3d_file(void *map)
{
/* close opened g3d file */
if (Rast3d_close((RASTER3D_Map *)map) != 1) {
G_warning(_("Unable to close 3D raster map <%s>"),
((RASTER3D_Map *)map)->fileName);
return (-1);
}
return (1);
}
/*!
\brief Eead value from g3d file
\param type data type
\param map 3D raster map
\param x,y,z real coordinates
\param[out] value data value
\return -1 on failure
\return 1 on success
*/
int read_g3d_value(IFLAG type, void *map, int x, int y, int z, void *value)
{
switch (type) {
/* float data type */
case (VOL_DTYPE_FLOAT):
*((float *)value) = Rast3d_get_float(map, x, y, z);
break;
/* double data type */
case (VOL_DTYPE_DOUBLE):
*((double *)value) = Rast3d_get_double(map, x, y, z);
break;
/* unsupported data type */
default:
return (-1);
}
return (1);
}
/*!
\brief Read slice of values at level from g3d file
\param type data type
\param map 3D raster map
\param level
\param[out] data
\return -1 on failure
\return 0 on success
*/
int read_g3d_slice(IFLAG type, void *map, int level, void *data)
{
int x, y;
switch (type) {
/* float data type */
case (VOL_DTYPE_FLOAT):
for (x = 0; x < Cols; x++) {
for (y = 0; y < Rows; y++) {
((float *)data)[x + y * Cols] =
Rast3d_get_float(map, x, y, level);
}
}
break;
/* double data type */
case (VOL_DTYPE_DOUBLE):
for (x = 0; x < Cols; x++) {
for (y = 0; y < Rows; y++) {
((double *)data)[x + y * Cols] =
Rast3d_get_double(map, x, y, level);
}
}
break;
/* unsupported data type */
default:
return (-1);
}
return (1);
}
/*!
\brief Read all values from g3d file
\param type data type
\param map 3D raster map
\param[out] data data buffer
\return -1 on failure
\return 1 on success
*/
int read_g3d_vol(IFLAG type, void *map, void *data)
{
int x, y, z;
switch (type) {
/* float data type */
case (VOL_DTYPE_FLOAT):
for (x = 0; x < Cols; x++) {
for (y = 0; y < Rows; y++) {
for (z = 0; z < Depths; z++) {
((float *)data)[x + y * Cols + z * Rows * Cols] =
Rast3d_get_float(map, x, y, z);
}
}
}
break;
/* double data type */
case (VOL_DTYPE_DOUBLE):
for (x = 0; x < Cols; x++) {
for (y = 0; y < Rows; y++) {
for (z = 0; z < Depths; z++) {
((double *)data)[x + y * Cols + z * Rows * Cols] =
Rast3d_get_double(map, x, y, z);
}
}
}
break;
/* unsupported data type */
default:
return (-1);
}
return (1);
}
/*!
\brief Check for null value
\param type data type
\param value
\return 1 if value is null
\return 0 if value is not null
\return -1 on failure (unsupported data type
*/
int is_null_g3d_value(IFLAG type, void *value)
{
switch (type) {
/* float data type */
case (VOL_DTYPE_FLOAT):
return Rast3d_is_null_value_num(value, FCELL_TYPE);
break;
/* double data type */
case (VOL_DTYPE_DOUBLE):
return Rast3d_is_null_value_num(value, DCELL_TYPE);
break;
/* unsupported data type */
default:
return (-1);
}
return (-1);
}
/******************************************************************/
/* reading from buffer */
/******************************************************************/
/*!
\brief Get value from buffer
\param type data type
\param data data buffer
\param offset
\param value
\return -1 on failure (unsupported data type)
\return 1 on success
*/
int get_buff_value(IFLAG type, void *data, int offset, void *value)
{
switch (type) {
/* float data type */
case (VOL_DTYPE_FLOAT):
*((float *)value) = ((float *)data)[offset];
break;
/* double data type */
case (VOL_DTYPE_DOUBLE):
*((double *)value) = ((double *)data)[offset];
break;
/* unsupported data type */
default:
return (-1);
}
return (1);
}
/******************************************************************/
/* direct mode reading from volume file */
/******************************************************************/
/*!
\brief Read value direct from volume file
\param vf pointer to geovol_file struct
\param x,y,z real point
\param[out] value data value
\return -1 on failure
\return 1 on success
*/
int get_direct_value(geovol_file *vf, int x, int y, int z, void *value)
{
switch (vf->file_type) {
/* RASTER3D file type */
case (VOL_FTYPE_RASTER3D):
if (0 > read_g3d_value(vf->data_type, vf->map, x, y, z, value))
return (-1);
break;
default:
return (-1);
}
return (1);
}
/******************************************************************/
/* full mode reading from volume file */
/******************************************************************/
/*!
\brief Allocate buffer memory for full mode reading
\param vf pointer to geovol_file
\return -1 on failure
\return 1 on success
*/
int alloc_vol_buff(geovol_file *vf)
{
switch (vf->data_type) {
/* float data type */
case (VOL_DTYPE_FLOAT):
if ((vf->buff = (float *)G_malloc(sizeof(float) * Cols * Rows *
Depths)) == NULL)
return (-1);
break;
/* double data type */
case (VOL_DTYPE_DOUBLE):
if ((vf->buff = (double *)G_malloc(sizeof(double) * Cols * Rows *
Depths)) == NULL)
return (-1);
break;
/* unsupported data type */
default:
return (-1);
}
return (1);
}
/*!
\brief Free memory buffer memory
\param vf pointer to geovol_file struct
\return 1
*/
int free_vol_buff(geovol_file *vf)
{
G_free(vf->buff);
return (1);
}
/*!
\brief Read all values from volume file
\param vf pointer to geovol_file struct
\return -1 on failure
\return 1 on success
*/
int read_vol(geovol_file *vf)
{
switch (vf->file_type) {
/* RASTER3D file format */
case (VOL_FTYPE_RASTER3D):
if (0 > read_g3d_vol(vf->data_type, vf->map, vf->buff))
return (-1);
break;
/* unsupported file format */
default:
return (-1);
}
return (1);
}
/*!
\brief Get value from volume buffer
\param vf pointer to geovol_file struct
\param x,y,z real point
\param[out] value data value
\return 1
*/
int get_vol_value(geovol_file *vf, int x, int y, int z, void *value)
{
get_buff_value(vf->data_type, vf->buff, z * Rows * Cols + y * Cols + x,
value);
return (1);
}
/******************************************************************/
/* slice mode reading from volume file */
/******************************************************************/
/*!
\brief Allocate buffer for slice mode reading
\param vf pointer to geovol_file struct
\return -1 on failure
\return 1 on success
*/
int alloc_slice_buff(geovol_file *vf)
{
int i;
slice_data *sd = (slice_data *)vf->buff;
switch (vf->data_type) {
/* float data type */
case (VOL_DTYPE_FLOAT):
for (i = 0; i < sd->num; i++) {
if ((sd->slice[i] =
(float *)G_malloc(sizeof(float) * Cols * Rows)) == NULL)
return (-1);
}
break;
/* double data type */
case (VOL_DTYPE_DOUBLE):
for (i = 0; i < sd->num; i++) {
if ((sd->slice[i] =
(double *)G_malloc(sizeof(double) * Cols * Rows)) == NULL)
return (-1);
}
break;
/* unsupported data type */
default:
return (-1);
}
return (1);
}
/*!
\brief Free buffer for slice mode reading
\param vf pointer to geovol_file struct
\return 1
*/
int free_slice_buff(geovol_file *vf)
{
int i;
slice_data *sd = (slice_data *)vf->buff;
for (i = 0; i < sd->num; i++) {
G_free(sd->slice[i]);
}
return (1);
}
/*!
\brief Read slice of values at level from volume file
\param vf pointer to geovol_file struct
\param s
\param l
\return -1 on failure
\return 1 on success
*/
int read_slice(geovol_file *vf, int s, int l)
{
/* get slice structure */
slice_data *sd = (slice_data *)vf->buff;
switch (vf->file_type) {
/* RASTER3D file format */
case (VOL_FTYPE_RASTER3D):
if (0 > read_g3d_slice(vf->data_type, vf->map, l, sd->slice[s]))
return (-1);
break;
/* unsupported file format */
default:
return (-1);
}
return (1);
}
/*!
\brief Read new slice into buffer
\param vf pointer to geovol_file struct
*/
void shift_slices(geovol_file *vf)
{
void *tmp;
int i;
slice_data *sd = (slice_data *)vf->buff;
/* change pointers to slices */
tmp = sd->slice[0];
for (i = 0; i < sd->num - 1; i++) {
sd->slice[i] = sd->slice[i + 1];
}
sd->slice[sd->num - 1] = tmp;
/* read new slice data */
read_slice(vf, sd->num, sd->crnt + 1 + (sd->num - sd->base));
/* increase current slice value */
sd->crnt++;
}
/*!
\brief Get value from slice buffer
\param vf pointer to geovol_file struct
\param x,y,z real point
\param[out] value data value
\return -1 on failure
\return 1 on success
*/
int get_slice_value(geovol_file *vf, int x, int y, int z, void *value)
{
slice_data *sd = (slice_data *)vf->buff;
/* value is in loaded slices */
if ((z >= sd->crnt - (sd->base - 1)) &&
(z <= sd->crnt + sd->num - sd->base)) {
get_buff_value(vf->data_type, sd->slice[(z - sd->crnt)], y * Cols + x,
value);
}
/* if value isn't in loaded slices, need read new data slice */
else if (z == sd->crnt - (sd->base - 1) + 1) {
shift_slices(vf);
get_buff_value(vf->data_type, sd->slice[(z - sd->crnt)], y * Cols + x,
value);
}
/* value out of range */
else {
return (-1);
}
return (1);
}
/******************************************************************/
/* reading from volume file */
/******************************************************************/
/*!
\brief Start read - allocate memory buffer a read first data into buffer
\param vf pointer to geovol_file struct
\return -1 on failure
\return 1 on success
*/
int gvl_file_start_read(geovol_file *vf)
{
int i;
slice_data *sd;
/* check status */
if (vf->status == STATUS_BUSY)
return (-1);
switch (vf->mode) {
/* read whole volume into memory */
case (MODE_FULL):
/* allocate memory */
if (0 > alloc_vol_buff(vf))
return (-1);
/* read volume */
read_vol(vf);
break;
/* read first data slices into memory */
case (MODE_SLICE):
/* allocate slices buffer memory */
if (0 > alloc_slice_buff(vf))
return (-1);
/* read volume */
sd = (slice_data *)vf->buff;
/* set current slice to 0 */
sd->crnt = 0;
/* read first slices into buffer */
for (i = 0; i < (sd->num - sd->base + 1); i++)
read_slice(vf, (sd->base - 1) + i, i);
break;
}
/* set status */
vf->status = STATUS_BUSY;
return (1);
}
/*!
\brief End read - free buffer memory
\param vf pointer to geovol_file struct
\return -1 on failure
\return 1 on success
*/
int gvl_file_end_read(geovol_file *vf)
{
/* check status */
if (vf->status == STATUS_READY)
return (-1);
switch (vf->mode) {
case (MODE_FULL):
if (0 > free_vol_buff(vf))
return (-1);
break;
case (MODE_SLICE):
/* allocate slices buffer memory */
if (0 > free_slice_buff(vf))
return (-1);
}
/* set status */
vf->status = STATUS_READY;
return (1);
}
/*!
\brief Get value for volume file at x, y, z
\param vf pointer to geovol_file struct
\param x,y,z
\param[out] value
\return -1 on failure
\return 1 on success
*/
int gvl_file_get_value(geovol_file *vf, int x, int y, int z, void *value)
{
/* check status */
if (vf->status != STATUS_BUSY) {
return (-1);
}
switch (vf->mode) {
/* read value direct from g3d file */
case (MODE_DIRECT):
if (0 > get_direct_value(vf, x, y, z, value))
return (-1);
break;
case (MODE_SLICE):
if (0 > get_slice_value(vf, x, y, z, value))
return (-1);
break;
case (MODE_FULL):
case (MODE_PRELOAD):
if (0 > get_vol_value(vf, x, y, z, value))
return (-1);
break;
}
return (1);
}
/*!
\brief Check for null value
\param vf pointer to geovol_file struct
\param value data value
\return -1 on failure
\return 1 on success
*/
int gvl_file_is_null_value(geovol_file *vf, void *value)
{
switch (vf->file_type) {
/* RASTER3D file format */
case (VOL_FTYPE_RASTER3D):
return is_null_g3d_value(vf->file_type, value);
break;
/* unsupported file format */
default:
return (-1);
}
return (-1);
}
/******************************************************************/
/* set parameters for reading volumes */
/******************************************************************/
/*!
\brief Set read mode
\param vf pointer to geovol_file struct
\param mode read mode
\return -1 on failure
\return 1 on success
*/
int gvl_file_set_mode(geovol_file *vf, IFLAG mode)
{
slice_data *sd;
if (vf->status == STATUS_BUSY)
return (-1);
if (vf->mode == mode)
return (1);
if (vf->mode == MODE_SLICE)
G_free(vf->buff);
if (vf->mode == MODE_PRELOAD)
G_free(vf->buff);
if (mode == MODE_SLICE) {
if ((vf->buff = (slice_data *)G_malloc(sizeof(slice_data))) == NULL)
return (-1);
sd = (slice_data *)vf->buff;
sd->num = 1;
sd->crnt = 0;
sd->base = 1;
}
if (mode == MODE_PRELOAD) {
/* allocate memory */
if (0 > alloc_vol_buff(vf))
return (-1);
/* read volume */
read_vol(vf);
}
vf->mode = mode;
return (1);
}
/*!
\brief Set parameters for slice reading
\param vf pointer to geovol_file struct
\param n
\param b
\return -1 on failure
\return 1 on success
*/
int gvl_file_set_slices_param(geovol_file *vf, int n, int b)
{
slice_data *sd;
if (vf->status == STATUS_BUSY)
return (-1);
if (!(vf->mode == MODE_SLICE))
return (-1);
sd = (slice_data *)vf->buff;
sd->num = n;
sd->base = b;
return (1);
}
G_free
void G_free(void *buf)
Free allocated memory.
Definition alloc.c:147
NULL
#define NULL
Definition ccmath.h:32
G_debug
int G_debug(int level, const char *msg,...)
Print debugging message.
Definition debug.c:66
b
double b
Definition driver/set_window.c:5
l
double l
Definition driver/set_window.c:5
G_find_raster3d
const char * G_find_raster3d(const char *name, const char *mapset)
Definition find_rast3d.c:28
G_fatal_error
void G_fatal_error(const char *msg,...)
Print a fatal error message to stderr.
Definition gis/error.c:159
G_warning
void G_warning(const char *msg,...)
Print a warning message to stderr.
Definition gis/error.c:203
LUCKY
#define LUCKY
Definition gsds.c:63
GVL_get_window
void * GVL_get_window(void)
Get window.
Definition gvl2.c:98
Rows
int Rows
Definition gvl_calc.c:79
Cols
int Cols
Definition gvl_calc.c:79
Depths
int Depths
Definition gvl_calc.c:79
close_g3d_file
int close_g3d_file(void *)
Close g3d file.
Definition gvl_file.c:465
read_g3d_value
int read_g3d_value(IFLAG type, void *map, int x, int y, int z, void *value)
Eead value from g3d file.
Definition gvl_file.c:488
gvl_file_free_datah
int gvl_file_free_datah(int id)
Free geovol_file structure for given handle.
Definition gvl_file.c:364
gvl_file_get_data_type
int gvl_file_get_data_type(geovol_file *vf)
Get data type for given handle.
Definition gvl_file.c:202
MODE_PRELOAD
#define MODE_PRELOAD
Definition gvl_file.c:33
close_volfile
int close_volfile(void *map, IFLAG type)
Close volume file.
Definition gvl_file.c:251
gvl_file_end_read
int gvl_file_end_read(geovol_file *vf)
End read - free buffer memory.
Definition gvl_file.c:1016
shift_slices
void shift_slices(geovol_file *vf)
Read new slice into buffer.
Definition gvl_file.c:894
get_vol_value
int get_vol_value(geovol_file *vf, int x, int y, int z, void *value)
Get value from volume buffer.
Definition gvl_file.c:788
get_buff_value
int get_buff_value(IFLAG type, void *data, int offset, void *value)
Get value from buffer.
Definition gvl_file.c:651
gvl_file_newh
int gvl_file_newh(const char *name, IFLAG file_type)
Get handle for given file name and type.
Definition gvl_file.c:269
read_vol
int read_vol(geovol_file *vf)
Read all values from volume file.
Definition gvl_file.c:763
gvl_file_get_min_max
void gvl_file_get_min_max(geovol_file *vf, double *min, double *max)
Get minimum and maximum value in volume file.
Definition gvl_file.c:214
get_direct_value
int get_direct_value(geovol_file *vf, int x, int y, int z, void *value)
Read value direct from volume file.
Definition gvl_file.c:687
gvl_file_set_mode
int gvl_file_set_mode(geovol_file *vf, IFLAG mode)
Set read mode.
Definition gvl_file.c:1116
get_slice_value
int get_slice_value(geovol_file *vf, int x, int y, int z, void *value)
Get value from slice buffer.
Definition gvl_file.c:925
free_slice_buff
int free_slice_buff(geovol_file *vf)
Free buffer for slice mode reading.
Definition gvl_file.c:848
STATUS_READY
#define STATUS_READY
Definition gvl_file.c:37
alloc_slice_buff
int alloc_slice_buff(geovol_file *vf)
Allocate buffer for slice mode reading.
Definition gvl_file.c:809
open_volfile
void * open_volfile(const char *name, IFLAG file_type, IFLAG *data_type, double *min, double *max)
Open 3d raster file.
Definition gvl_file.c:232
MODE_FULL
#define MODE_FULL
Definition gvl_file.c:32
gvl_file_set_slices_param
int gvl_file_set_slices_param(geovol_file *vf, int n, int b)
Set parameters for slice reading.
Definition gvl_file.c:1166
read_g3d_slice
int read_g3d_slice(IFLAG type, void *map, int level, void *data)
Read slice of values at level from g3d file.
Definition gvl_file.c:520
free_vol_buff
int free_vol_buff(geovol_file *vf)
Free memory buffer memory.
Definition gvl_file.c:748
gvl_file_get_value
int gvl_file_get_value(geovol_file *vf, int x, int y, int z, void *value)
Get value for volume file at x, y, z.
Definition gvl_file.c:1050
gvl_file_start_read
int gvl_file_start_read(geovol_file *vf)
Start read - allocate memory buffer a read first data into buffer.
Definition gvl_file.c:965
gvl_file_get_name
char * gvl_file_get_name(int id)
Get file name for given handle.
Definition gvl_file.c:165
open_g3d_file
void * open_g3d_file(const char *, IFLAG *, double *, double *)
Open 3d raster file.
Definition gvl_file.c:417
MODE_DIRECT
#define MODE_DIRECT
Definition gvl_file.c:30
MODE_DEFAULT
#define MODE_DEFAULT
Definition gvl_file.c:35
find_datah
int find_datah(const char *name, IFLAG type, int begin)
Find file with name and type in geovol_file array an return handle.
Definition gvl_file.c:139
STATUS_BUSY
#define STATUS_BUSY
Definition gvl_file.c:38
is_null_g3d_value
int is_null_g3d_value(IFLAG type, void *value)
Check for null value.
Definition gvl_file.c:614
gvl_file_get_file_type
int gvl_file_get_file_type(geovol_file *vf)
Get file type for given handle.
Definition gvl_file.c:190
free_volfile_buffs
int free_volfile_buffs(geovol_file *vf)
Free allocated buffers.
Definition gvl_file.c:342
gvl_file_is_null_value
int gvl_file_is_null_value(geovol_file *vf, void *value)
Check for null value.
Definition gvl_file.c:1087
gvl_file_get_volfile
geovol_file * gvl_file_get_volfile(int id)
Get geovol_file structure for given handle.
Definition gvl_file.c:117
MODE_SLICE
#define MODE_SLICE
Definition gvl_file.c:31
read_slice
int read_slice(geovol_file *vf, int s, int l)
Read slice of values at level from volume file.
Definition gvl_file.c:870
read_g3d_vol
int read_g3d_vol(IFLAG type, void *map, void *data)
Read all values from g3d file.
Definition gvl_file.c:565
alloc_vol_buff
int alloc_vol_buff(geovol_file *vf)
Allocate buffer memory for full mode reading.
Definition gvl_file.c:716
name
const char * name
Definition named_colr.c:6
strcpy
#define strcpy
Definition parson.c:66
min
#define min(a, b)
Definition pngdriver/draw_bitmap.c:19
max
#define max(a, b)
Definition pngdriver/draw_bitmap.c:22
G_store
char * G_store(const char *s)
Copy string to allocated memory.
Definition strings.c:87
x
#define x