GRASS GIS 8 Programmer's Manual 8.4.1(2025)-45ca3179ab
Loading...
Searching...
No Matches
gvl_file.c
Go to the documentation of this file.
1/*!
2 \file lib/ogsf/gvl_file.c
3
4 \brief OGSF library - loading and manipulating volumes (lower level
5 functions)
6
7 GRASS OpenGL gsurf OGSF Library
8
9 (C) 1999-2008 by the GRASS Development Team
10
11 This program is free software under the
12 GNU General Public License (>=v2).
13 Read the file COPYING that comes with GRASS
14 for details.
15
16 \author Tomas Paudits (February 2004)
17 \author Doxygenized by Martin Landa <landa.martin gmail.com> (May 2008)
18 */
19
20#include <string.h>
21#include <stdlib.h>
22
23#include <grass/gis.h>
24#include <grass/ogsf.h>
25#include <grass/raster3d.h>
26#include <grass/glocale.h>
27
28#define LUCKY 33
29
30#define MODE_DIRECT 0
31#define MODE_SLICE 1
32#define MODE_FULL 2
33#define MODE_PRELOAD 3
34
35#define MODE_DEFAULT 0
36
37#define STATUS_READY 0
38#define STATUS_BUSY 1
39
40/*!
41 \brief structure for slice mode reading from volume file
42 */
43typedef struct {
44 int num, skip;
45 int crnt, base;
46
47 void *slice[MAX_VOL_SLICES];
48} slice_data;
49
50static geovol_file *Data[MAX_VOL_FILES];
51static geovol_file Df[MAX_VOL_FILES]; /* trying to avoid allocation */
52
53static int Numfiles = 0;
54
55static int Cur_id = LUCKY;
56static int Cur_max;
57
58static int Rows, Cols, Depths;
59
60/* local functions prototypes */
61void *open_g3d_file(const char *, IFLAG *, double *, double *);
62int close_g3d_file(void *);
63
64/*!
65 \brief Initialize volume files
66
67 \return 1
68 */
69static int init_volfiles(void)
70{
71 int i;
72 RASTER3D_Region *w3;
73
74 for (i = 0; i < MAX_VOL_FILES; i++) {
75 /* avoiding dynamic allocation */
76 Data[i] = &(Df[i]);
77 }
78
79 Cur_max = MAX_VOL_FILES;
80
81 /* get window */
82 w3 = GVL_get_window();
83
84 /* set cols, rows, depths from window */
85 Cols = w3->cols;
86 Rows = w3->rows;
87 Depths = w3->depths;
88
89 return (1);
90}
91
92/*!
93 \brief Check number of files
94
95 \return 0
96 */
97static int check_num_volfiles(void)
98{
99 if (Numfiles < Cur_max) {
100 return (0);
101 }
102
103 G_fatal_error(_("Maximum number of datafiles exceeded"));
104
105 /* This return statement keeps compilers happy, it is never executed */
106 return (0);
107}
108
109/*!
110 \brief Get geovol_file structure for given handle
111
112 \param id
113
114 \return pointer to geovol_file struct
115 \return NULL on failure
116 */
117geovol_file *gvl_file_get_volfile(int id)
118{
119 int i;
120
121 for (i = 0; i < Numfiles; i++) {
122 if (Data[i]->data_id == id) {
123 return (Data[i]);
124 }
125 }
126
127 return (NULL);
128}
129
130/*!
131 \brief Find file with name and type in geovol_file array an return handle
132
133 \param name file name
134 \param begin
135
136 \param data id
137 \param -1 not found
138 */
139int find_datah(const char *name, IFLAG type, int begin)
140{
141 static int i;
142 int start;
143
144 start = begin ? 0 : i + 1;
145
146 for (i = start; i < Numfiles; i++) {
147 if (!strcmp(Data[i]->file_name, name)) {
148 if (Data[i]->file_type == type) {
149 return (Data[i]->data_id);
150 }
151 }
152 }
153
154 return (-1);
155}
156
157/*!
158 \brief Get file name for given handle
159
160 \param id handle id
161
162 \return file name
163 \return NULL on failure
164 */
165char *gvl_file_get_name(int id)
166{
167 int i;
168 geovol_file *fvf;
169 static char retstr[GPATH_MAX];
170
171 for (i = 0; i < Numfiles; i++) {
172 if (Data[i]->data_id == id) {
173 fvf = Data[i];
174 strcpy(retstr, fvf->file_name);
175
176 return (retstr);
177 }
178 }
179
180 return (NULL);
181}
182
183/*!
184 \brief Get file type for given handle
185
186 \param vf pointer to geovol_file struct
187
188 \return file type
189 */
190int gvl_file_get_file_type(geovol_file *vf)
191{
192 return (vf->file_type);
193}
194
195/*!
196 \brief Get data type for given handle
197
198 \param vf pointer to geovol_file struct
199
200 \return data type
201 */
202int gvl_file_get_data_type(geovol_file *vf)
203{
204 return (vf->data_type);
205}
206
207/*!
208 \brief Get minimum and maximum value in volume file
209
210 \param vf pointer to geovol_file struct
211 \param[out] min min value
212 \param[out] max max value
213 */
214void gvl_file_get_min_max(geovol_file *vf, double *min, double *max)
215{
216 *min = vf->min;
217 *max = vf->max;
218}
219
220/*!
221 \brief Open 3d raster file
222
223 \param name file name
224 \param file_type file type
225 \param data_type data type
226 \param[out] min min value
227 \param[out] max max value
228
229 \return pointer to file
230 \return NULL on failure
231 */
232void *open_volfile(const char *name, IFLAG file_type, IFLAG *data_type,
233 double *min, double *max)
234{
235 if (file_type == VOL_FTYPE_RASTER3D) {
236 return open_g3d_file(name, data_type, min, max);
237 }
238
239 return (NULL);
240}
241
242/*!
243 \brief Close volume file
244
245 \param map volume filename
246 \param type file type
247
248 \return
249 \return -1 on failure
250 */
251int close_volfile(void *map, IFLAG type)
252{
253 if (type == VOL_FTYPE_RASTER3D) {
254 return close_g3d_file(map);
255 }
256
257 return (-1);
258}
259
260/*!
261 \brief Get handle for given file name and type
262
263 \param name volume filename
264 \param file_type file type
265
266 \return data id
267 \return -1 on failure
268 */
269int gvl_file_newh(const char *name, IFLAG file_type)
270{
271 geovol_file *new;
272 static int first = 1;
273 int i, id;
274 void *m;
275 IFLAG data_type;
276 double min, max;
277
278 if (first) {
279 if (0 > init_volfiles()) {
280 return (-1);
281 }
282
283 first = 0;
284 }
285
286 if (0 <= (id = find_datah(name, file_type, 1))) {
287 for (i = 0; i < Numfiles; i++) {
288 if (Data[i]->data_id == id) {
289 new = Data[i];
290 new->count++;
291
292 return (id);
293 }
294 }
295 }
296
297 if (0 > check_num_volfiles()) {
298 return (-1);
299 }
300
301 if (!name) {
302 return (-1);
303 }
304
305 if ((m = open_volfile(name, file_type, &data_type, &min, &max)) == NULL) {
306 return (-1);
307 }
308
309 new = Data[Numfiles];
310
311 if (new) {
312 Numfiles++;
313 new->data_id = Cur_id++;
314
315 new->file_name = G_store(name);
316 new->file_type = file_type;
317 new->count = 1;
318 new->map = m;
319 new->min = min;
320 new->max = max;
321 new->data_type = data_type;
322
323 new->status = STATUS_READY;
324 new->buff = NULL;
325
326 new->mode = 255;
328
329 return (new->data_id);
330 }
331
332 return (-1);
333}
334
335/*!
336 \brief Free allocated buffers
337
338 \param vf pointer to geovol_file struct
339
340 \return 1
341 */
342int free_volfile_buffs(geovol_file *vf)
343{
344 if (vf->mode == MODE_SLICE) {
345 G_free(vf->buff);
346 vf->buff = NULL;
347 }
348
349 if (vf->mode == MODE_PRELOAD) {
350 G_free(vf->buff);
351 vf->buff = NULL;
352 }
353
354 return (1);
355}
356
357/*!
358 \brief Free geovol_file structure for given handle
359
360 \param id
361
362 \return
363 */
365{
366 int i, j, found = -1;
367 geovol_file *fvf;
368
369 G_debug(5, "gvl_file_free_datah(): id=%d", id);
370
371 for (i = 0; i < Numfiles; i++) {
372 if (Data[i]->data_id == id) {
373 found = 1;
374 fvf = Data[i];
375
376 if (fvf->count > 1) {
377 fvf->count--;
378 }
379 else {
380 close_volfile(fvf->map, fvf->file_type);
382
383 G_free(fvf->file_name);
384 fvf->file_name = NULL;
385
386 fvf->data_id = 0;
387
388 for (j = i; j < (Numfiles - 1); j++) {
389 Data[j] = Data[j + 1];
390 }
391
392 Data[j] = fvf;
393
394 --Numfiles;
395 }
396 }
397 }
398
399 return (found);
400}
401
402/******************************************************************/
403/* reading from RASTER3D raster volume files */
404
405/******************************************************************/
406
407/*!
408 \brief Open 3d raster file
409
410 \param filename file name
411 \param type data type
412 \param[out] min min value
413 \param[out] max max value
414
415 \returns pointer to data
416 */
417void *open_g3d_file(const char *filename, IFLAG *type, double *min, double *max)
418{
419 const char *mapset;
420 int itype;
421 void *map;
422
423 /* search for g3d file a return his mapset */
424 mapset = G_find_raster3d(filename, "");
425 if (!mapset) {
426 G_warning(_("3D raster map <%s> not found"), filename);
427 return (NULL);
428 }
429
430 /* open g3d file */
431 map = Rast3d_open_cell_old(filename, mapset, RASTER3D_DEFAULT_WINDOW,
432 RASTER3D_TILE_SAME_AS_FILE,
433 RASTER3D_USE_CACHE_DEFAULT);
434 if (!map) {
435 G_warning(_("Unable to open 3D raster map <%s>"), filename);
436 return (NULL);
437 }
438
439 /* load range into range structure of map */
440 if (!Rast3d_range_load(map)) {
441 G_warning(_("Unable to read range of 3D raster map <%s>"), filename);
442 return (NULL);
443 }
444
445 Rast3d_range_min_max(map, min, max);
446
447 /* get file data type */
448 itype = Rast3d_file_type_map(map);
449 if (itype == FCELL_TYPE)
450 *type = VOL_DTYPE_FLOAT;
451 if (itype == DCELL_TYPE)
452 *type = VOL_DTYPE_DOUBLE;
453
454 return (map);
455}
456
457/*!
458 \brief Close g3d file
459
460 \param map 3d raster map
461
462 \return -1 on failure
463 \return 1 on success
464 */
465int close_g3d_file(void *map)
466{
467 /* close opened g3d file */
468 if (Rast3d_close((RASTER3D_Map *)map) != 1) {
469 G_warning(_("Unable to close 3D raster map <%s>"),
470 ((RASTER3D_Map *)map)->fileName);
471 return (-1);
472 }
473
474 return (1);
475}
476
477/*!
478 \brief Eead value from g3d file
479
480 \param type data type
481 \param map 3D raster map
482 \param x,y,z real coordinates
483 \param[out] value data value
484
485 \return -1 on failure
486 \return 1 on success
487 */
488int read_g3d_value(IFLAG type, void *map, int x, int y, int z, void *value)
489{
490 switch (type) {
491 /* float data type */
492 case (VOL_DTYPE_FLOAT):
493 *((float *)value) = Rast3d_get_float(map, x, y, z);
494 break;
495
496 /* double data type */
497 case (VOL_DTYPE_DOUBLE):
498 *((double *)value) = Rast3d_get_double(map, x, y, z);
499 break;
500
501 /* unsupported data type */
502 default:
503 return (-1);
504 }
505
506 return (1);
507}
508
509/*!
510 \brief Read slice of values at level from g3d file
511
512 \param type data type
513 \param map 3D raster map
514 \param level
515 \param[out] data
516
517 \return -1 on failure
518 \return 0 on success
519 */
520int read_g3d_slice(IFLAG type, void *map, int level, void *data)
521{
522 int x, y;
523
524 switch (type) {
525 /* float data type */
526 case (VOL_DTYPE_FLOAT):
527 for (x = 0; x < Cols; x++) {
528 for (y = 0; y < Rows; y++) {
529 ((float *)data)[x + y * Cols] =
530 Rast3d_get_float(map, x, y, level);
531 }
532 }
533
534 break;
535
536 /* double data type */
537 case (VOL_DTYPE_DOUBLE):
538 for (x = 0; x < Cols; x++) {
539 for (y = 0; y < Rows; y++) {
540 ((double *)data)[x + y * Cols] =
541 Rast3d_get_double(map, x, y, level);
542 }
543 }
544
545 break;
546
547 /* unsupported data type */
548 default:
549 return (-1);
550 }
551
552 return (1);
553}
554
555/*!
556 \brief Read all values from g3d file
557
558 \param type data type
559 \param map 3D raster map
560 \param[out] data data buffer
561
562 \return -1 on failure
563 \return 1 on success
564 */
565int read_g3d_vol(IFLAG type, void *map, void *data)
566{
567 int x, y, z;
568
569 switch (type) {
570 /* float data type */
571 case (VOL_DTYPE_FLOAT):
572 for (x = 0; x < Cols; x++) {
573 for (y = 0; y < Rows; y++) {
574 for (z = 0; z < Depths; z++) {
575 ((float *)data)[x + y * Cols + z * Rows * Cols] =
576 Rast3d_get_float(map, x, y, z);
577 }
578 }
579 }
580
581 break;
582
583 /* double data type */
584 case (VOL_DTYPE_DOUBLE):
585 for (x = 0; x < Cols; x++) {
586 for (y = 0; y < Rows; y++) {
587 for (z = 0; z < Depths; z++) {
588 ((double *)data)[x + y * Cols + z * Rows * Cols] =
589 Rast3d_get_double(map, x, y, z);
590 }
591 }
592 }
593
594 break;
595
596 /* unsupported data type */
597 default:
598 return (-1);
599 }
600
601 return (1);
602}
603
604/*!
605 \brief Check for null value
606
607 \param type data type
608 \param value
609
610 \return 1 if value is null
611 \return 0 if value is not null
612 \return -1 on failure (unsupported data type
613 */
614int is_null_g3d_value(IFLAG type, void *value)
615{
616 switch (type) {
617 /* float data type */
618 case (VOL_DTYPE_FLOAT):
619 return Rast3d_is_null_value_num(value, FCELL_TYPE);
620 break;
621
622 /* double data type */
623 case (VOL_DTYPE_DOUBLE):
624 return Rast3d_is_null_value_num(value, DCELL_TYPE);
625 break;
626
627 /* unsupported data type */
628 default:
629 return (-1);
630 }
631
632 return (-1);
633}
634
635/******************************************************************/
636/* reading from buffer */
637
638/******************************************************************/
639
640/*!
641 \brief Get value from buffer
642
643 \param type data type
644 \param data data buffer
645 \param offset
646 \param value
647
648 \return -1 on failure (unsupported data type)
649 \return 1 on success
650 */
651int get_buff_value(IFLAG type, void *data, int offset, void *value)
652{
653 switch (type) {
654 /* float data type */
655 case (VOL_DTYPE_FLOAT):
656 *((float *)value) = ((float *)data)[offset];
657 break;
658
659 /* double data type */
660 case (VOL_DTYPE_DOUBLE):
661 *((double *)value) = ((double *)data)[offset];
662 break;
663
664 /* unsupported data type */
665 default:
666 return (-1);
667 }
668
669 return (1);
670}
671
672/******************************************************************/
673/* direct mode reading from volume file */
674
675/******************************************************************/
676
677/*!
678 \brief Read value direct from volume file
679
680 \param vf pointer to geovol_file struct
681 \param x,y,z real point
682 \param[out] value data value
683
684 \return -1 on failure
685 \return 1 on success
686 */
687int get_direct_value(geovol_file *vf, int x, int y, int z, void *value)
688{
689 switch (vf->file_type) {
690 /* RASTER3D file type */
691 case (VOL_FTYPE_RASTER3D):
692 if (0 > read_g3d_value(vf->data_type, vf->map, x, y, z, value))
693 return (-1);
694 break;
695
696 default:
697 return (-1);
698 }
699
700 return (1);
701}
702
703/******************************************************************/
704/* full mode reading from volume file */
705
706/******************************************************************/
707
708/*!
709 \brief Allocate buffer memory for full mode reading
710
711 \param vf pointer to geovol_file
712
713 \return -1 on failure
714 \return 1 on success
715 */
716int alloc_vol_buff(geovol_file *vf)
717{
718 switch (vf->data_type) {
719 /* float data type */
720 case (VOL_DTYPE_FLOAT):
721 if ((vf->buff = (float *)G_malloc(sizeof(float) * Cols * Rows *
722 Depths)) == NULL)
723 return (-1);
724 break;
725
726 /* double data type */
727 case (VOL_DTYPE_DOUBLE):
728 if ((vf->buff = (double *)G_malloc(sizeof(double) * Cols * Rows *
729 Depths)) == NULL)
730 return (-1);
731 break;
732
733 /* unsupported data type */
734 default:
735 return (-1);
736 }
737
738 return (1);
739}
740
741/*!
742 \brief Free memory buffer memory
743
744 \param vf pointer to geovol_file struct
745
746 \return 1
747 */
748int free_vol_buff(geovol_file *vf)
749{
750 G_free(vf->buff);
751
752 return (1);
753}
754
755/*!
756 \brief Read all values from volume file
757
758 \param vf pointer to geovol_file struct
759
760 \return -1 on failure
761 \return 1 on success
762 */
763int read_vol(geovol_file *vf)
764{
765 switch (vf->file_type) {
766 /* RASTER3D file format */
767 case (VOL_FTYPE_RASTER3D):
768 if (0 > read_g3d_vol(vf->data_type, vf->map, vf->buff))
769 return (-1);
770 break;
771 /* unsupported file format */
772 default:
773 return (-1);
774 }
775
776 return (1);
777}
778
779/*!
780 \brief Get value from volume buffer
781
782 \param vf pointer to geovol_file struct
783 \param x,y,z real point
784 \param[out] value data value
785
786 \return 1
787 */
788int get_vol_value(geovol_file *vf, int x, int y, int z, void *value)
789{
790 get_buff_value(vf->data_type, vf->buff, z * Rows * Cols + y * Cols + x,
791 value);
792
793 return (1);
794}
795
796/******************************************************************/
797/* slice mode reading from volume file */
798
799/******************************************************************/
800
801/*!
802 \brief Allocate buffer for slice mode reading
803
804 \param vf pointer to geovol_file struct
805
806 \return -1 on failure
807 \return 1 on success
808 */
809int alloc_slice_buff(geovol_file *vf)
810{
811 int i;
812 slice_data *sd = (slice_data *)vf->buff;
813
814 switch (vf->data_type) {
815 /* float data type */
816 case (VOL_DTYPE_FLOAT):
817 for (i = 0; i < sd->num; i++) {
818 if ((sd->slice[i] =
819 (float *)G_malloc(sizeof(float) * Cols * Rows)) == NULL)
820 return (-1);
821 }
822 break;
823
824 /* double data type */
825 case (VOL_DTYPE_DOUBLE):
826 for (i = 0; i < sd->num; i++) {
827 if ((sd->slice[i] =
828 (double *)G_malloc(sizeof(double) * Cols * Rows)) == NULL)
829 return (-1);
830 }
831 break;
832
833 /* unsupported data type */
834 default:
835 return (-1);
836 }
837
838 return (1);
839}
840
841/*!
842 \brief Free buffer for slice mode reading
843
844 \param vf pointer to geovol_file struct
845
846 \return 1
847 */
848int free_slice_buff(geovol_file *vf)
849{
850 int i;
851 slice_data *sd = (slice_data *)vf->buff;
852
853 for (i = 0; i < sd->num; i++) {
854 G_free(sd->slice[i]);
855 }
856
857 return (1);
858}
859
860/*!
861 \brief Read slice of values at level from volume file
862
863 \param vf pointer to geovol_file struct
864 \param s
865 \param l
866
867 \return -1 on failure
868 \return 1 on success
869 */
870int read_slice(geovol_file *vf, int s, int l)
871{
872 /* get slice structure */
873 slice_data *sd = (slice_data *)vf->buff;
874
875 switch (vf->file_type) {
876 /* RASTER3D file format */
877 case (VOL_FTYPE_RASTER3D):
878 if (0 > read_g3d_slice(vf->data_type, vf->map, l, sd->slice[s]))
879 return (-1);
880 break;
881 /* unsupported file format */
882 default:
883 return (-1);
884 }
885
886 return (1);
887}
888
889/*!
890 \brief Read new slice into buffer
891
892 \param vf pointer to geovol_file struct
893 */
894void shift_slices(geovol_file *vf)
895{
896 void *tmp;
897 int i;
898
899 slice_data *sd = (slice_data *)vf->buff;
900
901 /* change pointers to slices */
902 tmp = sd->slice[0];
903 for (i = 0; i < sd->num - 1; i++) {
904 sd->slice[i] = sd->slice[i + 1];
905 }
906 sd->slice[sd->num - 1] = tmp;
907
908 /* read new slice data */
909 read_slice(vf, sd->num, sd->crnt + 1 + (sd->num - sd->base));
910
911 /* increase current slice value */
912 sd->crnt++;
913}
914
915/*!
916 \brief Get value from slice buffer
917
918 \param vf pointer to geovol_file struct
919 \param x,y,z real point
920 \param[out] value data value
921
922 \return -1 on failure
923 \return 1 on success
924 */
925int get_slice_value(geovol_file *vf, int x, int y, int z, void *value)
926{
927 slice_data *sd = (slice_data *)vf->buff;
928
929 /* value is in loaded slices */
930 if ((z >= sd->crnt - (sd->base - 1)) &&
931 (z <= sd->crnt + sd->num - sd->base)) {
932
933 get_buff_value(vf->data_type, sd->slice[(z - sd->crnt)], y * Cols + x,
934 value);
935 }
936
937 /* if value isn't in loaded slices, need read new data slice */
938 else if (z == sd->crnt - (sd->base - 1) + 1) {
939 shift_slices(vf);
940 get_buff_value(vf->data_type, sd->slice[(z - sd->crnt)], y * Cols + x,
941 value);
942 }
943
944 /* value out of range */
945 else {
946 return (-1);
947 }
948
949 return (1);
950}
951
952/******************************************************************/
953/* reading from volume file */
954
955/******************************************************************/
956
957/*!
958 \brief Start read - allocate memory buffer a read first data into buffer
959
960 \param vf pointer to geovol_file struct
961
962 \return -1 on failure
963 \return 1 on success
964 */
965int gvl_file_start_read(geovol_file *vf)
966{
967 int i;
968 slice_data *sd;
969
970 /* check status */
971 if (vf->status == STATUS_BUSY)
972 return (-1);
973
974 switch (vf->mode) {
975 /* read whole volume into memory */
976 case (MODE_FULL):
977 /* allocate memory */
978 if (0 > alloc_vol_buff(vf))
979 return (-1);
980
981 /* read volume */
982 read_vol(vf);
983 break;
984
985 /* read first data slices into memory */
986 case (MODE_SLICE):
987 /* allocate slices buffer memory */
988 if (0 > alloc_slice_buff(vf))
989 return (-1);
990
991 /* read volume */
992 sd = (slice_data *)vf->buff;
993 /* set current slice to 0 */
994 sd->crnt = 0;
995
996 /* read first slices into buffer */
997 for (i = 0; i < (sd->num - sd->base + 1); i++)
998 read_slice(vf, (sd->base - 1) + i, i);
999 break;
1000 }
1001
1002 /* set status */
1003 vf->status = STATUS_BUSY;
1004
1005 return (1);
1006}
1007
1008/*!
1009 \brief End read - free buffer memory
1010
1011 \param vf pointer to geovol_file struct
1012
1013 \return -1 on failure
1014 \return 1 on success
1015 */
1016int gvl_file_end_read(geovol_file *vf)
1017{
1018 /* check status */
1019 if (vf->status == STATUS_READY)
1020 return (-1);
1021
1022 switch (vf->mode) {
1023 case (MODE_FULL):
1024 if (0 > free_vol_buff(vf))
1025 return (-1);
1026 break;
1027
1028 case (MODE_SLICE):
1029 /* allocate slices buffer memory */
1030 if (0 > free_slice_buff(vf))
1031 return (-1);
1032 }
1033
1034 /* set status */
1035 vf->status = STATUS_READY;
1036
1037 return (1);
1038}
1039
1040/*!
1041 \brief Get value for volume file at x, y, z
1042
1043 \param vf pointer to geovol_file struct
1044
1045 \return -1 on failure
1046 \return 1 on success
1047 */
1048int gvl_file_get_value(geovol_file *vf, int x, int y, int z, void *value)
1049{
1050 /* check status */
1051 if (vf->status != STATUS_BUSY) {
1052 return (-1);
1053 }
1054
1055 switch (vf->mode) {
1056 /* read value direct from g3d file */
1057 case (MODE_DIRECT):
1058 if (0 > get_direct_value(vf, x, y, z, value))
1059 return (-1);
1060 break;
1061
1062 case (MODE_SLICE):
1063 if (0 > get_slice_value(vf, x, y, z, value))
1064 return (-1);
1065 break;
1066
1067 case (MODE_FULL):
1068 case (MODE_PRELOAD):
1069 if (0 > get_vol_value(vf, x, y, z, value))
1070 return (-1);
1071 break;
1072 }
1073 return (1);
1074}
1075
1076/*!
1077 \brief Check for null value
1078
1079 \param vf pointer to geovol_file struct
1080 \param value data value
1081
1082 \return -1 on failure
1083 \return 1 on success
1084 */
1085int gvl_file_is_null_value(geovol_file *vf, void *value)
1086{
1087 switch (vf->file_type) {
1088 /* RASTER3D file format */
1089 case (VOL_FTYPE_RASTER3D):
1090 return is_null_g3d_value(vf->file_type, value);
1091 break;
1092 /* unsupported file format */
1093 default:
1094 return (-1);
1095 }
1096
1097 return (-1);
1098}
1099
1100/******************************************************************/
1101/* set parameters for reading volumes */
1102
1103/******************************************************************/
1104
1105/*!
1106 \brief Set read mode
1107
1108 \param vf pointer to geovol_file struct
1109 \param mode read mode
1110
1111 \return -1 on failure
1112 \return 1 on success
1113 */
1114int gvl_file_set_mode(geovol_file *vf, IFLAG mode)
1115{
1116 slice_data *sd;
1117
1118 if (vf->status == STATUS_BUSY)
1119 return (-1);
1120
1121 if (vf->mode == mode)
1122 return (1);
1123
1124 if (vf->mode == MODE_SLICE)
1125 G_free(vf->buff);
1126
1127 if (vf->mode == MODE_PRELOAD)
1128 G_free(vf->buff);
1129
1130 if (mode == MODE_SLICE) {
1131 if ((vf->buff = (slice_data *)G_malloc(sizeof(slice_data))) == NULL)
1132 return (-1);
1133
1134 sd = (slice_data *)vf->buff;
1135 sd->num = 1;
1136 sd->crnt = 0;
1137 sd->base = 1;
1138 }
1139
1140 if (mode == MODE_PRELOAD) {
1141 /* allocate memory */
1142 if (0 > alloc_vol_buff(vf))
1143 return (-1);
1144
1145 /* read volume */
1146 read_vol(vf);
1147 }
1148
1149 vf->mode = mode;
1150
1151 return (1);
1152}
1153
1154/*!
1155 \brief Set parameters for slice reading
1156
1157 \param vf pointer to geovol_file struct
1158 \param n
1159 \param b
1160
1161 \return -1 on failure
1162 \return 1 on success
1163 */
1164int gvl_file_set_slices_param(geovol_file *vf, int n, int b)
1165{
1166 slice_data *sd;
1167
1168 if (vf->status == STATUS_BUSY)
1169 return (-1);
1170
1171 if (!(vf->mode == MODE_SLICE))
1172 return (-1);
1173
1174 sd = (slice_data *)vf->buff;
1175 sd->num = n;
1176 sd->base = b;
1177
1178 return (1);
1179}
void G_free(void *buf)
Free allocated memory.
Definition alloc.c:150
#define NULL
Definition ccmath.h:32
int G_debug(int level, const char *msg,...)
Print debugging message.
Definition debug.c:66
double b
double l
const char * G_find_raster3d(const char *name, const char *mapset)
Search for a 3D raster map in current search path or in a specified mapset.
Definition find_rast3d.c:28
void G_fatal_error(const char *msg,...)
Print a fatal error message to stderr.
Definition gis/error.c:159
void G_warning(const char *msg,...)
Print a warning message to stderr.
Definition gis/error.c:203
#define LUCKY
Definition gsds.c:63
void * GVL_get_window(void)
Get window.
Definition gvl2.c:98
int Rows
Definition gvl_calc.c:79
int Cols
Definition gvl_calc.c:79
int Depths
Definition gvl_calc.c:79
int close_g3d_file(void *)
Close g3d file.
Definition gvl_file.c:465
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
int gvl_file_free_datah(int id)
Free geovol_file structure for given handle.
Definition gvl_file.c:364
int gvl_file_get_data_type(geovol_file *vf)
Get data type for given handle.
Definition gvl_file.c:202
#define MODE_PRELOAD
Definition gvl_file.c:33
int close_volfile(void *map, IFLAG type)
Close volume file.
Definition gvl_file.c:251
int gvl_file_end_read(geovol_file *vf)
End read - free buffer memory.
Definition gvl_file.c:1016
void shift_slices(geovol_file *vf)
Read new slice into buffer.
Definition gvl_file.c:894
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
int get_buff_value(IFLAG type, void *data, int offset, void *value)
Get value from buffer.
Definition gvl_file.c:651
int gvl_file_newh(const char *name, IFLAG file_type)
Get handle for given file name and type.
Definition gvl_file.c:269
int read_vol(geovol_file *vf)
Read all values from volume file.
Definition gvl_file.c:763
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
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
int gvl_file_set_mode(geovol_file *vf, IFLAG mode)
Set read mode.
Definition gvl_file.c:1114
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
int free_slice_buff(geovol_file *vf)
Free buffer for slice mode reading.
Definition gvl_file.c:848
#define STATUS_READY
Definition gvl_file.c:37
int alloc_slice_buff(geovol_file *vf)
Allocate buffer for slice mode reading.
Definition gvl_file.c:809
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
#define MODE_FULL
Definition gvl_file.c:32
int gvl_file_set_slices_param(geovol_file *vf, int n, int b)
Set parameters for slice reading.
Definition gvl_file.c:1164
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
int free_vol_buff(geovol_file *vf)
Free memory buffer memory.
Definition gvl_file.c:748
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:1048
int gvl_file_start_read(geovol_file *vf)
Start read - allocate memory buffer a read first data into buffer.
Definition gvl_file.c:965
char * gvl_file_get_name(int id)
Get file name for given handle.
Definition gvl_file.c:165
void * open_g3d_file(const char *, IFLAG *, double *, double *)
Open 3d raster file.
Definition gvl_file.c:417
#define MODE_DIRECT
Definition gvl_file.c:30
#define MODE_DEFAULT
Definition gvl_file.c:35
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
#define STATUS_BUSY
Definition gvl_file.c:38
int is_null_g3d_value(IFLAG type, void *value)
Check for null value.
Definition gvl_file.c:614
int gvl_file_get_file_type(geovol_file *vf)
Get file type for given handle.
Definition gvl_file.c:190
int free_volfile_buffs(geovol_file *vf)
Free allocated buffers.
Definition gvl_file.c:342
int gvl_file_is_null_value(geovol_file *vf, void *value)
Check for null value.
Definition gvl_file.c:1085
geovol_file * gvl_file_get_volfile(int id)
Get geovol_file structure for given handle.
Definition gvl_file.c:117
#define MODE_SLICE
Definition gvl_file.c:31
int read_slice(geovol_file *vf, int s, int l)
Read slice of values at level from volume file.
Definition gvl_file.c:870
int read_g3d_vol(IFLAG type, void *map, void *data)
Read all values from g3d file.
Definition gvl_file.c:565
int alloc_vol_buff(geovol_file *vf)
Allocate buffer memory for full mode reading.
Definition gvl_file.c:716
const char * name
Definition named_colr.c:6
#define strcpy
Definition parson.c:62
#define min(a, b)
#define max(a, b)
char * G_store(const char *s)
Copy string to allocated memory.
Definition strings.c:87
#define x