GRASS GIS 7 Programmer's Manual  7.5.svn(2018)-r72636
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
mask.c
Go to the documentation of this file.
1 #include <stdio.h>
2 #include <grass/gis.h>
3 #include "raster3d_intern.h"
4 
5 /*--------------------------------------------------------------------------*/
6 
7 /* the standard g3d file format is used to store the mask values. a NULL-value
8  is stored for values which are masked out and a "0." is stored for values
9  which are not masked out. to improve compression, the precision is set to
10  0 and RLE encoding is used.
11  */
12 
13 /*--------------------------------------------------------------------------*/
14 
15 static int Rast3d_maskMapExistsVar = 0;
16 static RASTER3D_Map *Rast3d_maskMap;
17 
18 /*--------------------------------------------------------------------------*/
19 static void dummy(void)
20 {
21  return;
22 }
23 
24 
25 static float RASTER3D_MASKNUMmaskValue;
26 
27 /* Call to dummy() to match void return type of Rast3d_set_null_value() */
28 #define RASTER3D_MASKNUM(map,Xmask,Ymask,Zmask,VALUEmask,TYPEmask) \
29 \
30  (RASTER3D_MASKNUMmaskValue = Rast3d_getMaskFloat (map, Xmask, Ymask, Zmask), \
31  ((Rast3d_is_null_value_num (&RASTER3D_MASKNUMmaskValue, FCELL_TYPE)) ? \
32  Rast3d_set_null_value (VALUEmask, 1, TYPEmask) : dummy()))
33 
34 /*--------------------------------------------------------------------------*/
35 
37 {
38  /* No Idea if this is correct return value */
39  if (!Rast3d_maskMapExistsVar)
40  return 1;
41 
42  Rast3d_maskMapExistsVar = 0;
43 
44  if (!Rast3d_close(Rast3d_maskMap)) {
45  Rast3d_error("Rast3d_mask_close: error closing mask");
46 
47  return 0;
48  }
49 
50  return 1;
51 }
52 
53 /*--------------------------------------------------------------------------*/
54 
55 
56 /*!
57  * \brief
58  *
59  * Returns 1 if the 3d mask file exists.
60  *
61  * \return int
62  */
63 
65 {
67 }
68 
69 /*--------------------------------------------------------------------------*/
70 
71 static int maskOpenOldCacheDefault = RASTER3D_USE_CACHE_DEFAULT;
72 
74 {
75  RASTER3D_Region region;
76 
77  /* No Idea if this is correct return value */
78  if (Rast3d_maskMapExistsVar)
79  return 1;
80 
81  Rast3d_maskMapExistsVar = Rast3d_mask_file_exists();
82 
83  if (!Rast3d_maskMapExistsVar)
84  return 1;
85 
86  if ((Rast3d_maskMap = Rast3d_open_cell_old(RASTER3D_MASK_MAP, G_mapset(),
88  maskOpenOldCacheDefault))
89  == NULL) {
90  Rast3d_error("Rast3d_mask_open_old: cannot open mask");
91 
92  return 0;
93  }
94 
95  Rast3d_get_region_struct_map(Rast3d_maskMap, &region);
96  Rast3d_set_window_map(Rast3d_maskMap, &region);
97 
98  return 1;
99 }
100 
101 /*--------------------------------------------------------------------------*/
102 
103 static float Rast3d_getMaskFloat(RASTER3D_Map * map, int x, int y, int z)
104 {
105  double north, east, top;
106  float value;
107 
108  north = ((double)map->window.rows - y - 0.5) / (double)map->window.rows *
109  (map->window.north - map->window.south) + map->window.south;
110  east = ((double)x + 0.5) / (double)map->window.cols *
111  (map->window.east - map->window.west) + map->window.west;
112  top = ((double)z + 0.5) / (double)map->window.depths *
113  (map->window.top - map->window.bottom) + map->window.bottom;
114 
115  Rast3d_get_region_value(Rast3d_maskMap, north, east, top, &value, FCELL_TYPE);
116  return value;
117 }
118 
119 /*--------------------------------------------------------------------------*/
120 
121 
122 /*!
123  * \brief
124  *
125  * This function should be used to adjust the cache size used for the
126  * 3d-mask. First the open 3d-mask is closed and then opened again with
127  * a cache size as specified with <em>cache</em>.
128  *
129  * \param cache
130  * \return 1 ... if successful
131  * 0 ... otherwise.
132  */
133 
134 int Rast3d_mask_reopen(int cache)
135 {
136  int tmp;
137 
138  if (Rast3d_maskMapExistsVar)
139  if (!Rast3d_mask_close()) {
140  Rast3d_error("Rast3d_mask_reopen: error closing mask");
141 
142  return 0;
143  }
144 
145  tmp = maskOpenOldCacheDefault;
146  maskOpenOldCacheDefault = cache;
147 
148  if (!Rast3d_mask_open_old()) {
149  Rast3d_error("Rast3d_mask_reopen: error opening mask");
150 
151  return 0;
152  }
153 
154  maskOpenOldCacheDefault = tmp;
155  return 1;
156 }
157 
158 /*--------------------------------------------------------------------------*/
159 
160 
161 /*!
162  * \brief
163  *
164  * Returns 1 if the cell with cell-coordinates <em>(x, y, z)</em> is masked
165  * out. Returns 0 otherwise.
166  *
167  * \param x
168  * \param y
169  * \param z
170  * \return int
171  */
172 
173 int Rast3d_is_masked(RASTER3D_Map * map, int x, int y, int z)
174 {
175  if (!Rast3d_maskMapExistsVar)
176  return 0;
177 
178  RASTER3D_MASKNUMmaskValue = Rast3d_getMaskFloat(map, x, y, z);
179  return (Rast3d_is_null_value_num(&RASTER3D_MASKNUMmaskValue, FCELL_TYPE));
180 }
181 
182 /*--------------------------------------------------------------------------*/
183 
184 
185 /*!
186  * \brief
187  *
188  * Replaces the value stored in <em>value</em> with the NULL-value if
189  * <em>Rast3d_is_masked (x, y, z)</em> returns 1. Does nothing otherwise.
190  * <em>value</em> is assumed to be of<em>type</em>.
191  *
192  * \param x
193  * \param y
194  * \param z
195  * \param value
196  * \param type
197  * \return void
198  */
199 
200 void Rast3d_mask_num(RASTER3D_Map * map, int x, int y, int z, void *value, int type)
201 {
202  if (!Rast3d_maskMapExistsVar)
203  return;
204  RASTER3D_MASKNUM(map, x, y, z, value, type);
205 }
206 
207 /*--------------------------------------------------------------------------*/
208 
209 
210 /*!
211  * \brief
212  *
213  * Same as <em>Rast3d_mask_num (x, y, z, value, FCELL_TYPE)</em>.
214  *
215  * \param x
216  * \param y
217  * \param z
218  * \param value
219  * \return void
220  */
221 
222 void Rast3d_mask_float(RASTER3D_Map * map, int x, int y, int z, float *value)
223 {
224  if (!Rast3d_maskMapExistsVar)
225  return;
226  RASTER3D_MASKNUM(map, x, y, z, value, FCELL_TYPE);
227 }
228 
229 /*--------------------------------------------------------------------------*/
230 
231 
232 /*!
233  * \brief
234  *
235  * Same as <em>Rast3d_mask_num (x, y, z, value, DCELL_TYPE)</em>.
236  *
237  * \param x
238  * \param y
239  * \param z
240  * \param value
241  * \return void
242  */
243 
244 void Rast3d_mask_double(RASTER3D_Map * map, int x, int y, int z, double *value)
245 {
246  if (!Rast3d_maskMapExistsVar)
247  return;
248  RASTER3D_MASKNUM(map, x, y, z, value, DCELL_TYPE);
249 }
250 
251 /*--------------------------------------------------------------------------*/
252 
253 
254 /*!
255  * \brief
256  *
257  * Replaces the values stored in <em>tile</em> (with <em>tileIndex</em>) for
258  * which <em>Rast3d_is_masked</em> returns 1 with NULL-values. Does not change
259  * the remaining values. The values are assumed to be of <em>type</em>.
260  * Whether replacement is performed or not only depends on location of the
261  * cells of the tile and not on the status of the mask for <em>map</em>
262  * (i.e. turned on or off).
263  *
264  * \param map
265  * \param tileIndex
266  * \param tile
267  * \param type
268  * \return void
269  */
270 
271 void Rast3d_mask_tile(RASTER3D_Map * map, int tileIndex, void *tile, int type)
272 {
273  int nofNum, rows, cols, depths, xRedundant, yRedundant, zRedundant;
274  int x, y, z, xLength, yLength, dx, dy, dz, length;
275 
276  if (!Rast3d_maskMapExistsVar)
277  return;
278 
279  nofNum = Rast3d_compute_clipped_tile_dimensions(map, tileIndex,
280  &rows, &cols, &depths,
281  &xRedundant, &yRedundant,
282  &zRedundant);
283  Rast3d_tile_index_origin(map, tileIndex, &x, &y, &z);
284 
285  if (nofNum == map->tileSize) {
286  /*AV*/
287  /* BEGIN OF ORIGINAL CODE */
288  /*
289  * Rast3d_get_tile_dimensions_map (map, &rows, &cols, &depths);
290  */
291  /*AV*/
292  /* BEGIN OF MY CODE */
293  Rast3d_get_tile_dimensions_map(map, &cols, &rows, &depths);
294  /* END OF MY CODE */
295  xRedundant = yRedundant = 0;
296  }
297 
298  rows += y;
299  cols += x;
300  depths += z;
301  length = Rast3d_length(type);
302  xLength = xRedundant * length;
303  yLength = map->tileX * yRedundant * length;
304 
305  for (dz = z; dz < depths; dz++) {
306  for (dy = y; dy < rows; dy++) {
307  for (dx = x; dx < cols; dx++) {
308  RASTER3D_MASKNUM(map, dx, dy, dz, tile, type);
309  tile += length;
310  }
311 
312  tile += xLength;
313  }
314  tile += yLength;
315  }
316 }
317 
318 /*--------------------------------------------------------------------------*/
319 
320 
321 /*!
322  * \brief
323  *
324  * Turns on the mask for <em>map</em>. Do
325  * not invoke this function after the first tile has been read since the result
326  * might be inconsistent cell-values.
327  *
328  * \param map
329  * \return void
330  */
331 
333 {
334  map->useMask = 1;
335 }
336 
337 
338 /*!
339  * \brief
340  *
341  * Turns off the mask for <em>map</em>.
342  * This is the default. Do not invoke this function after the first tile has
343  * been read since the result might be inconsistent cell-values.
344  *
345  * \param map
346  * \return void
347  */
348 
350 {
351  map->useMask = 0;
352 }
353 
354 
355 /*!
356  * \brief
357  *
358  * Returns 1 if the mask for <em>map</em>
359  * is turned on. Returns 0 otherwise.
360  *
361  * \param map
362  * \return int
363  */
364 
366 {
367  return map->useMask;
368 }
369 
370 
371 /*!
372  * \brief
373  *
374  * Returns 1 if the mask for <em>map</em> is turned off. Returns 0 otherwise.
375  *
376  * \param map
377  * \return int
378  */
379 
381 {
382  return !map->useMask;
383 }
384 
385 
386 /*!
387  * \brief
388  *
389  * Returns the name of the 3d mask file.
390  *
391  * \return char *
392  */
393 
394 const char *Rast3d_mask_file(void)
395 {
396  return RASTER3D_MASK_MAP;
397 }
398 
399 
400 /*!
401  * \brief
402  *
403  * Returns 1 if the 3d mask is loaded.
404  *
405  * \return int
406  */
407 
409 {
410  return Rast3d_maskMapExistsVar;
411 }
#define RASTER3D_USE_CACHE_DEFAULT
Definition: raster3d.h:20
void Rast3d_mask_on(RASTER3D_Map *map)
Turns on the mask for map. Do not invoke this function after the first tile has been read since the r...
Definition: mask.c:332
double east
Definition: raster3d.h:51
int Rast3d_mask_reopen(int cache)
This function should be used to adjust the cache size used for the 3d-mask. First the open 3d-mask is...
Definition: mask.c:134
int Rast3d_mask_is_off(RASTER3D_Map *map)
Returns 1 if the mask for map is turned off. Returns 0 otherwise.
Definition: mask.c:380
double top
Definition: raster3d.h:52
int Rast3d_close(RASTER3D_Map *map)
Close 3D raster map files.
int Rast3d_mask_map_exists(void)
Returns 1 if the 3d mask is loaded.
Definition: mask.c:408
double bottom
Definition: raster3d.h:52
void Rast3d_mask_double(RASTER3D_Map *map, int x, int y, int z, double *value)
Same as Rast3d_mask_num (x, y, z, value, DCELL_TYPE).
Definition: mask.c:244
int Rast3d_compute_clipped_tile_dimensions(RASTER3D_Map *map, int tileIndex, int *rows, int *cols, int *depths, int *xRedundant, int *yRedundant, int *zRedundant)
Computes the dimensions of the tile when clipped to fit the region of map. The clipped dimensions are...
Definition: tilemath.c:267
#define RASTER3D_DEFAULT_WINDOW
Definition: raster3d.h:29
#define RASTER3D_MASKNUM(map, Xmask, Ymask, Zmask, VALUEmask, TYPEmask)
Definition: mask.c:28
#define NULL
Definition: ccmath.h:32
void Rast3d_mask_tile(RASTER3D_Map *map, int tileIndex, void *tile, int type)
Replaces the values stored in tile (with tileIndex) for which Rast3d_is_masked returns 1 with NULL-va...
Definition: mask.c:271
#define x
void Rast3d_get_tile_dimensions_map(RASTER3D_Map *map, int *x, int *y, int *z)
Returns the tile dimensions used for map.
Definition: headerinfo.c:142
double north
Definition: raster3d.h:50
#define RASTER3D_MASK_MAP
Definition: raster3d.h:39
#define RASTER3D_CELL_ELEMENT
Definition: raster3d.h:32
#define DCELL_TYPE
Definition: raster.h:13
int Rast3d_mask_close()
Definition: mask.c:36
int Rast3d_mask_open_old(void)
Definition: mask.c:73
void Rast3d_get_region_value(RASTER3D_Map *map, double north, double east, double top, void *value, int type)
Returns in value the value of the map which corresponds to region coordinates (north, east, top).
Definition: getvalue.c:131
double west
Definition: raster3d.h:51
void Rast3d_error(const char *msg,...)
void Rast3d_tile_index_origin(RASTER3D_Map *map, int tileIndex, int *x, int *y, int *z)
Computes the cell-coordinates (x, y, z) which correspond to the origin of the tile with tileIndex...
Definition: tilemath.c:103
void Rast3d_set_window_map(RASTER3D_Map *map, RASTER3D_Region *window)
Sets the window for map to window. Can be used multiple times for the same map.
int Rast3d_is_null_value_num(const void *n, int type)
Definition: null.c:12
int Rast3d_mask_is_on(RASTER3D_Map *map)
Returns 1 if the mask for map is turned on. Returns 0 otherwise.
Definition: mask.c:365
int Rast3d_mask_file_exists(void)
Returns 1 if the 3d mask file exists.
Definition: mask.c:64
void Rast3d_get_region_struct_map(RASTER3D_Map *map, RASTER3D_Region *region)
Returns in region the region of map.
Definition: headerinfo.c:115
void Rast3d_mask_float(RASTER3D_Map *map, int x, int y, int z, float *value)
Same as Rast3d_mask_num (x, y, z, value, FCELL_TYPE).
Definition: mask.c:222
#define RASTER3D_DIRECTORY
Definition: raster3d.h:31
const char * G_find_file_misc(const char *dir, const char *element, char *name, const char *mapset)
Searches for a file from the mapset search list or in a specified mapset.
Definition: find_file.c:222
int tileSize
Definition: raster3d.h:179
#define FCELL_TYPE
Definition: raster.h:12
const char * Rast3d_mask_file(void)
Returns the name of the 3d mask file.
Definition: mask.c:394
void Rast3d_mask_num(RASTER3D_Map *map, int x, int y, int z, void *value, int type)
Replaces the value stored in value with the NULL-value if Rast3d_is_masked (x, y, z) returns 1...
Definition: mask.c:200
const char * G_mapset(void)
Get current mapset name.
Definition: gis/mapset.c:33
int Rast3d_length(int t)
Definition: raster3d/misc.c:78
double south
Definition: raster3d.h:50
int Rast3d_is_masked(RASTER3D_Map *map, int x, int y, int z)
Returns 1 if the cell with cell-coordinates (x, y, z) is masked out. Returns 0 otherwise.
Definition: mask.c:173
RASTER3D_Region window
Definition: raster3d.h:87
void * Rast3d_open_cell_old(const char *name, const char *mapset, RASTER3D_Region *window, int typeIntern, int cache)
Opens existing g3d-file name in mapset. Tiles are stored in memory with type which must be any of FCE...
Definition: raster3d/open.c:77
void Rast3d_mask_off(RASTER3D_Map *map)
Turns off the mask for map. This is the default. Do not invoke this function after the first tile has...
Definition: mask.c:349