GRASS GIS 7 Programmer's Manual  7.0.2(2015)-r00000
n_arrays.c
Go to the documentation of this file.
1 
2 /*****************************************************************************
3 *
4 * MODULE: Grass PDE Numerical Library
5 * AUTHOR(S): Soeren Gebbert, Berlin (GER) Dec 2006
6 * soerengebbert <at> gmx <dot> de
7 *
8 * PURPOSE: Array managment functions
9 * part of the gpde library
10 *
11 * COPYRIGHT: (C) 2000 by the GRASS Development Team
12 *
13 * This program is free software under the GNU General Public
14 * License (>=v2). Read the file COPYING that comes with GRASS
15 * for details.
16 *
17 *****************************************************************************/
18 
19 #include <math.h>
20 
21 #include <grass/N_pde.h>
22 #include <grass/raster.h>
23 #include <grass/glocale.h>
24 
25 
26 /* ******************** 2D ARRAY FUNCTIONS *********************** */
27 
72 N_array_2d *N_alloc_array_2d(int cols, int rows, int offset, int type)
73 {
74  N_array_2d *data = NULL;
75 
76  if (rows < 1 || cols < 1)
77  G_fatal_error("N_alloc_array_2d: cols and rows should be > 0");
78 
79  if (type != CELL_TYPE && type != FCELL_TYPE && type != DCELL_TYPE)
81  ("N_alloc_array_2d: Wrong data type, should be CELL_TYPE, FCELL_TYPE or DCELL_TYPE");
82 
83  data = (N_array_2d *) G_calloc(1, sizeof(N_array_2d));
84 
85  data->cols = cols;
86  data->rows = rows;
87  data->type = type;
88  data->offset = offset;
89  data->rows_intern = rows + 2 * offset; /*offset position at booth sides */
90  data->cols_intern = cols + 2 * offset; /*offset position at booth sides */
91  data->cell_array = NULL;
92  data->fcell_array = NULL;
93  data->dcell_array = NULL;
94 
95  if (data->type == CELL_TYPE) {
96  data->cell_array =
97  (CELL *) G_calloc((size_t) data->rows_intern * data->cols_intern,
98  sizeof(CELL));
99  G_debug(3,
100  "N_alloc_array_2d: CELL array allocated rows_intern %i cols_intern %i offset %i",
101  data->rows_intern, data->cols_intern, data->offset = offset);
102  }
103  else if (data->type == FCELL_TYPE) {
104  data->fcell_array =
105  (FCELL *) G_calloc((size_t) data->rows_intern * data->cols_intern,
106  sizeof(FCELL));
107  G_debug(3,
108  "N_alloc_array_2d: FCELL array allocated rows_intern %i cols_intern %i offset %i",
109  data->rows_intern, data->cols_intern, data->offset = offset);
110 
111  }
112  else if (data->type == DCELL_TYPE) {
113  data->dcell_array =
114  (DCELL *) G_calloc((size_t) data->rows_intern * data->cols_intern,
115  sizeof(DCELL));
116  G_debug(3,
117  "N_alloc_array_2d: DCELL array allocated rows_intern %i cols_intern %i offset %i",
118  data->rows_intern, data->cols_intern, data->offset = offset);
119  }
120 
121  return data;
122 }
123 
131 {
132 
133  if (data != NULL) {
134  G_debug(3, "N_free_array_2d: free N_array_2d");
135 
136  if (data->type == CELL_TYPE && data->cell_array != NULL) {
137  G_free(data->cell_array);
138  }
139  else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
140  G_free(data->fcell_array);
141 
142  }
143  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
144  G_free(data->dcell_array);
145  }
146 
147  G_free(data);
148  data = NULL;
149 
150  }
151 
152  return;
153 }
154 
155 
165 {
166  return array->type;
167 }
168 
181 void N_get_array_2d_value(N_array_2d * data, int col, int row, void *value)
182 {
183 
184  if (data->offset == 0) {
185  if (data->type == CELL_TYPE && data->cell_array != NULL) {
186  *((CELL *) value) =
187  data->cell_array[row * data->cols_intern + col];
188  }
189  else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
190  *((FCELL *) value) =
191  data->fcell_array[row * data->cols_intern + col];
192  }
193  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
194  *((DCELL *) value) =
195  data->dcell_array[row * data->cols_intern + col];
196  }
197  }
198  else {
199  if (data->type == CELL_TYPE && data->cell_array != NULL) {
200  *((CELL *) value) =
201  data->cell_array[(row + data->offset) * data->cols_intern +
202  col + data->offset];
203  }
204  else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
205  *((FCELL *) value) =
206  data->fcell_array[(row + data->offset) * data->cols_intern +
207  col + data->offset];
208  }
209  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
210  *((DCELL *) value) =
211  data->dcell_array[(row + data->offset) * data->cols_intern +
212  col + data->offset];
213  }
214  }
215 
216  return;
217 }
218 
231 int N_is_array_2d_value_null(N_array_2d * data, int col, int row)
232 {
233 
234  if (data->offset == 0) {
235  if (data->type == CELL_TYPE && data->cell_array != NULL) {
236  G_debug(6,
237  "N_is_array_2d_value_null: null value is of type CELL at pos [%i][%i]",
238  col, row);
239  return Rast_is_null_value((void *)
240  &(data->
241  cell_array[row * data->cols_intern +
242  col]), CELL_TYPE);
243  }
244  else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
245  G_debug(6,
246  "N_is_array_2d_value_null: null value is of type FCELL at pos [%i][%i]",
247  col, row);
248  return Rast_is_null_value((void *)
249  &(data->
250  fcell_array[row * data->cols_intern +
251  col]), FCELL_TYPE);
252  }
253  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
254  G_debug(6,
255  "N_is_array_2d_value_null: null value is of type DCELL at pos [%i][%i]",
256  col, row);
257  return Rast_is_null_value((void *)
258  &(data->
259  dcell_array[row * data->cols_intern +
260  col]), DCELL_TYPE);
261  }
262  }
263  else {
264  if (data->type == CELL_TYPE && data->cell_array != NULL) {
265  G_debug(6,
266  "N_is_array_2d_value_null: null value is of type CELL at pos [%i][%i]",
267  col, row);
268  return Rast_is_null_value((void *)
269  &(data->
270  cell_array[(row +
271  data->offset) *
272  data->cols_intern + col +
273  data->offset]), CELL_TYPE);
274  }
275  else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
276  G_debug(6,
277  "N_is_array_2d_value_null: null value is of type FCELL at pos [%i][%i]",
278  col, row);
279  return Rast_is_null_value((void *)
280  &(data->
281  fcell_array[(row +
282  data->offset) *
283  data->cols_intern + col +
284  data->offset]), FCELL_TYPE);
285  }
286  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
287  G_debug(6,
288  "N_is_array_2d_value_null: null value is of type DCELL at pos [%i][%i]",
289  col, row);
290  return Rast_is_null_value((void *)
291  &(data->
292  dcell_array[(row +
293  data->offset) *
294  data->cols_intern + col +
295  data->offset]), DCELL_TYPE);
296  }
297  }
298 
299  return 0;
300 }
301 
302 
314 CELL N_get_array_2d_c_value(N_array_2d * data, int col, int row)
315 {
316  CELL value = 0;
317  FCELL fvalue = 0.0;
318  DCELL dvalue = 0.0;
319 
320  switch (data->type) {
321  case CELL_TYPE:
322  N_get_array_2d_value(data, col, row, (void *)&value);
323  return (CELL) value;
324  case FCELL_TYPE:
325  N_get_array_2d_value(data, col, row, (void *)&fvalue);
326  return (CELL) fvalue;
327  case DCELL_TYPE:
328  N_get_array_2d_value(data, col, row, (void *)&dvalue);
329  return (CELL) dvalue;
330  }
331 
332  return value;
333 }
334 
346 FCELL N_get_array_2d_f_value(N_array_2d * data, int col, int row)
347 {
348  CELL value = 0;
349  FCELL fvalue = 0.0;
350  DCELL dvalue = 0.0;
351 
352  switch (data->type) {
353  case CELL_TYPE:
354  N_get_array_2d_value(data, col, row, (void *)&value);
355  return (FCELL) value;
356  case FCELL_TYPE:
357  N_get_array_2d_value(data, col, row, (void *)&fvalue);
358  return (FCELL) fvalue;
359  case DCELL_TYPE:
360  N_get_array_2d_value(data, col, row, (void *)&dvalue);
361  return (FCELL) dvalue;
362  }
363 
364  return fvalue;
365 }
366 
378 DCELL N_get_array_2d_d_value(N_array_2d * data, int col, int row)
379 {
380  CELL value = 0;
381  FCELL fvalue = 0.0;
382  DCELL dvalue = 0.0;
383 
384  switch (data->type) {
385  case CELL_TYPE:
386  N_get_array_2d_value(data, col, row, (void *)&value);
387  return (DCELL) value;
388  case FCELL_TYPE:
389  N_get_array_2d_value(data, col, row, (void *)&fvalue);
390  return (DCELL) fvalue;
391  case DCELL_TYPE:
392  N_get_array_2d_value(data, col, row, (void *)&dvalue);
393  return (DCELL) dvalue;
394  }
395 
396  return dvalue;
397 
398 }
399 
411 void N_put_array_2d_value(N_array_2d * data, int col, int row, char *value)
412 {
413 
414  G_debug(6, "N_put_array_2d_value: put value to array");
415 
416  if (data->offset == 0) {
417  if (data->type == CELL_TYPE && data->cell_array != NULL) {
418  data->cell_array[row * data->cols_intern + col] =
419  *((CELL *) value);
420  }
421  else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
422  data->fcell_array[row * data->cols_intern + col] =
423  *((FCELL *) value);
424  }
425  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
426  data->dcell_array[row * data->cols_intern + col] =
427  *((DCELL *) value);
428  }
429  }
430  else {
431  if (data->type == CELL_TYPE && data->cell_array != NULL) {
432  data->cell_array[(row + data->offset) * data->cols_intern + col +
433  data->offset] = *((CELL *) value);
434  }
435  else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
436  data->fcell_array[(row + data->offset) * data->cols_intern + col +
437  data->offset] = *((FCELL *) value);
438  }
439  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
440  data->dcell_array[(row + data->offset) * data->cols_intern + col +
441  data->offset] = *((DCELL *) value);
442  }
443  }
444 
445  return;
446 }
447 
458 void N_put_array_2d_value_null(N_array_2d * data, int col, int row)
459 {
460 
461  G_debug(6,
462  "N_put_array_2d_value_null: put null value to array pos [%i][%i]",
463  col, row);
464 
465  if (data->offset == 0) {
466  if (data->type == CELL_TYPE && data->cell_array != NULL) {
467  Rast_set_c_null_value((void *)
468  &(data->
469  cell_array[row * data->cols_intern + col]),
470  1);
471  }
472  else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
473  Rast_set_f_null_value((void *)
474  &(data->
475  fcell_array[row * data->cols_intern + col]),
476  1);
477  }
478  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
479  Rast_set_d_null_value((void *)
480  &(data->
481  dcell_array[row * data->cols_intern + col]),
482  1);
483  }
484  }
485  else {
486  if (data->type == CELL_TYPE && data->cell_array != NULL) {
487  Rast_set_c_null_value((void *)
488  &(data->
489  cell_array[(row +
490  data->offset) *
491  data->cols_intern + col +
492  data->offset]), 1);
493  }
494  else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
495  Rast_set_f_null_value((void *)
496  &(data->
497  fcell_array[(row +
498  data->offset) *
499  data->cols_intern + col +
500  data->offset]), 1);
501  }
502  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
503  Rast_set_d_null_value((void *)
504  &(data->
505  dcell_array[(row +
506  data->offset) *
507  data->cols_intern + col +
508  data->offset]), 1);
509  }
510  }
511 
512  return;
513 }
514 
524 void N_put_array_2d_c_value(N_array_2d * data, int col, int row, CELL value)
525 {
526  FCELL fvalue;
527  DCELL dvalue;
528 
529  switch (data->type) {
530  case FCELL_TYPE:
531  fvalue = (FCELL) value;
532  N_put_array_2d_value(data, col, row, (char *)&fvalue);
533  return;
534  case DCELL_TYPE:
535  dvalue = (DCELL) value;
536  N_put_array_2d_value(data, col, row, (char *)&dvalue);
537  return;
538  }
539 
540  N_put_array_2d_value(data, col, row, (char *)&value);
541 
542  return;
543 }
544 
554 void N_put_array_2d_f_value(N_array_2d * data, int col, int row, FCELL value)
555 {
556  CELL cvalue;
557  DCELL dvalue;
558 
559  switch (data->type) {
560  case CELL_TYPE:
561  cvalue = (CELL) value;
562  N_put_array_2d_value(data, col, row, (char *)&cvalue);
563  return;
564  case DCELL_TYPE:
565  dvalue = (DCELL) value;
566  N_put_array_2d_value(data, col, row, (char *)&dvalue);
567  return;
568  }
569 
570  N_put_array_2d_value(data, col, row, (char *)&value);
571 
572  return;
573 }
574 
584 void N_put_array_2d_d_value(N_array_2d * data, int col, int row, DCELL value)
585 {
586  CELL cvalue;
587  FCELL fvalue;
588 
589  switch (data->type) {
590  case CELL_TYPE:
591  cvalue = (CELL) value;
592  N_put_array_2d_value(data, col, row, (char *)&cvalue);
593  return;
594  case FCELL_TYPE:
595  fvalue = (FCELL) value;
596  N_put_array_2d_value(data, col, row, (char *)&fvalue);
597  return;
598  }
599 
600  N_put_array_2d_value(data, col, row, (char *)&value);
601 
602  return;
603 }
604 
612 {
613 
614  fprintf(stdout, "N_array_2d \n");
615  fprintf(stdout, "Cols %i\n", data->cols);
616  fprintf(stdout, "Rows: %i\n", data->rows);
617  fprintf(stdout, "Array type: %i\n", data->type);
618  fprintf(stdout, "Offset: %i\n", data->offset);
619  fprintf(stdout, "Internal cols: %i\n", data->cols_intern);
620  fprintf(stdout, "Internal rows: %i\n", data->rows_intern);
621  fprintf(stdout, "CELL array pointer: %p\n", data->cell_array);
622  fprintf(stdout, "FCELL array pointer: %p\n", data->fcell_array);
623  fprintf(stdout, "DCELL array pointer: %p\n", data->dcell_array);
624 
625 
626  return;
627 }
628 
638 {
639  int i, j;
640 
641  N_print_array_2d_info(data);
642 
643  for (j = 0 - data->offset; j < data->rows + data->offset; j++) {
644  for (i = 0 - data->offset; i < data->cols + data->offset; i++) {
645  if (data->type == CELL_TYPE)
646  fprintf(stdout, "%6d ", N_get_array_2d_c_value(data, i, j));
647  else if (data->type == FCELL_TYPE)
648  fprintf(stdout, "%6.6f ", N_get_array_2d_f_value(data, i, j));
649  else if (data->type == DCELL_TYPE)
650  printf("%6.6f ", N_get_array_2d_d_value(data, i, j));
651  }
652  fprintf(stdout, "\n");
653  }
654  fprintf(stdout, "\n");
655 
656  return;
657 }
658 
659 
660 /* ******************** 3D ARRAY FUNCTIONS *********************** */
661 
726 N_array_3d *N_alloc_array_3d(int cols, int rows, int depths, int offset,
727  int type)
728 {
729  N_array_3d *data = NULL;
730 
731  if (rows < 1 || cols < 1 || depths < 1)
733  ("N_alloc_array_3d: depths, cols and rows should be > 0");
734 
735  if (type != DCELL_TYPE && type != FCELL_TYPE)
737  ("N_alloc_array_3d: Wrong data type, should be FCELL_TYPE or DCELL_TYPE");
738 
739  data = (N_array_3d *) G_calloc(1, sizeof(N_array_3d));
740 
741  data->cols = cols;
742  data->rows = rows;
743  data->depths = depths;
744  data->type = type;
745  data->offset = offset;
746  data->rows_intern = rows + 2 * offset;
747  data->cols_intern = cols + 2 * offset;
748  data->depths_intern = depths + 2 * offset;
749  data->fcell_array = NULL;
750  data->dcell_array = NULL;
751 
752  if (data->type == FCELL_TYPE) {
753  data->fcell_array =
754  (float *)G_calloc((size_t) data->depths_intern * data->rows_intern *
755  data->cols_intern, sizeof(float));
756  G_debug(3,
757  "N_alloc_array_3d: float array allocated rows_intern %i cols_intern %i depths_intern %i offset %i",
758  data->rows_intern, data->cols_intern, data->depths_intern,
759  data->offset = offset);
760  }
761  else if (data->type == DCELL_TYPE) {
762  data->dcell_array =
763  (double *)G_calloc((size_t) data->depths_intern * data->rows_intern *
764  data->cols_intern, sizeof(double));
765  G_debug(3,
766  "N_alloc_array_3d: double array allocated rows_intern %i cols_intern %i depths_intern %i offset %i",
767  data->rows_intern, data->cols_intern, data->depths_intern,
768  data->offset = offset);
769  }
770 
771  return data;
772 }
773 
781 {
782 
783  if (data != NULL) {
784  G_debug(3, "N_free_array_3d: free N_array_3d");
785 
786  if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
787  G_free(data->fcell_array);
788  }
789  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
790  G_free(data->dcell_array);
791  }
792 
793  G_free(data);
794  data = NULL;
795 
796  }
797 
798  return;
799 }
800 
810 {
811  return array->type;
812 }
813 
814 
828 void
829 N_get_array_3d_value(N_array_3d * data, int col, int row, int depth,
830  void *value)
831 {
832 
833  if (data->offset == 0) {
834  if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
835  *((float *)value) =
836  data->fcell_array[depth *
837  (data->rows_intern * data->cols_intern) +
838  row * data->cols_intern + col];
839  }
840  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
841  *((double *)value) =
842  data->dcell_array[depth *
843  (data->rows_intern * data->cols_intern) +
844  row * data->cols_intern + col];
845  }
846  }
847  else {
848  if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
849  *((float *)value) =
850  data->fcell_array[(depth + data->offset) *
851  (data->rows_intern * data->cols_intern) +
852  (row + data->offset) * data->cols_intern +
853  (col + data->offset)];
854 
855  }
856  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
857  *((double *)value) =
858  data->dcell_array[(depth + data->offset) *
859  (data->rows_intern * data->cols_intern) +
860  (row + data->offset) * data->cols_intern +
861  (col + data->offset)];
862  }
863  }
864 
865  return;
866 }
867 
881 int N_is_array_3d_value_null(N_array_3d * data, int col, int row, int depth)
882 {
883 
884  if (data->offset == 0) {
885  if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
886  G_debug(6,
887  "N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
888  depth, row, col);
889  return Rast3d_is_null_value_num((void *)
890  &(data->
891  fcell_array[depth *
892  (data->rows_intern *
893  data->cols_intern) +
894  row * data->cols_intern +
895  col]), FCELL_TYPE);
896  }
897  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
898  G_debug(6,
899  "N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
900  depth, row, col);
901  return Rast3d_is_null_value_num((void *)
902  &(data->
903  dcell_array[depth *
904  (data->rows_intern *
905  data->cols_intern) +
906  row * data->cols_intern +
907  col]), DCELL_TYPE);
908  }
909  }
910  else {
911  if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
912  G_debug(6,
913  "N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
914  depth, row, col);
915  return Rast3d_is_null_value_num((void *)
916  &(data->
917  fcell_array[(depth +
918  data->offset) *
919  (data->rows_intern *
920  data->cols_intern) +
921  (row + data->offset)
922  * data->cols_intern +
923  (col + data->offset)]),
924  FCELL_TYPE);
925 
926  }
927  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
928  G_debug(6,
929  "N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
930  depth, row, col);
931  return Rast3d_is_null_value_num((void *)
932  &(data->
933  dcell_array[(depth +
934  data->offset) *
935  (data->rows_intern *
936  data->cols_intern) +
937  (row +
938  data->offset) *
939  data->cols_intern + (col +
940  data->
941  offset)]),
942  DCELL_TYPE);
943  }
944  }
945 
946  return 0;
947 }
948 
961 float N_get_array_3d_f_value(N_array_3d * data, int col, int row, int depth)
962 {
963  float fvalue = 0.0;
964  double dvalue = 0.0;
965 
966  switch (data->type) {
967  case FCELL_TYPE:
968  N_get_array_3d_value(data, col, row, depth, (void *)&fvalue);
969  return (float)fvalue;
970  case DCELL_TYPE:
971  N_get_array_3d_value(data, col, row, depth, (void *)&dvalue);
972  return (float)dvalue;
973  }
974 
975  return fvalue;
976 }
977 
990 double N_get_array_3d_d_value(N_array_3d * data, int col, int row, int depth)
991 {
992  float fvalue = 0.0;
993  double dvalue = 0.0;
994 
995  switch (data->type) {
996 
997  case FCELL_TYPE:
998  N_get_array_3d_value(data, col, row, depth, (void *)&fvalue);
999  return (double)fvalue;
1000  case DCELL_TYPE:
1001  N_get_array_3d_value(data, col, row, depth, (void *)&dvalue);
1002  return (double)dvalue;
1003  }
1004 
1005  return dvalue;
1006 }
1007 
1020 void
1021 N_put_array_3d_value(N_array_3d * data, int col, int row, int depth,
1022  char *value)
1023 {
1024 
1025  G_debug(6, "N_put_array_3d_value: put value to array at pos [%i][%i][%i]",
1026  depth, row, col);
1027 
1028  if (data->offset == 0) {
1029  if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
1030  data->fcell_array[depth *
1031  (data->rows_intern * data->cols_intern) +
1032  row * data->cols_intern + col]
1033  = *((float *)value);
1034  }
1035  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
1036 
1037  data->dcell_array[depth *
1038  (data->rows_intern * data->cols_intern) +
1039  row * data->cols_intern + col]
1040  = *((double *)value);
1041  }
1042  }
1043  else {
1044  if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
1045  data->fcell_array[(depth + data->offset) *
1046  (data->rows_intern * data->cols_intern) + (row +
1047  data->
1048  offset)
1049  * data->cols_intern + (col + data->offset)] =
1050  *((float *)value);
1051  }
1052  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
1053  data->dcell_array[(depth + data->offset) *
1054  (data->rows_intern * data->cols_intern) + (row +
1055  data->
1056  offset)
1057  * data->cols_intern + (col + data->offset)] =
1058  *((double *)value);
1059  }
1060  }
1061 
1062  return;
1063 }
1064 
1076 void N_put_array_3d_value_null(N_array_3d * data, int col, int row, int depth)
1077 {
1078 
1079  G_debug(6,
1080  "N_put_array_3d_value_null: put null value to array at pos [%i][%i][%i]",
1081  depth, row, col);
1082 
1083  if (data->offset == 0) {
1084  if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
1085  Rast3d_set_null_value((void *)
1086  &(data->
1087  fcell_array[depth *
1088  (data->rows_intern *
1089  data->cols_intern) +
1090  row * data->cols_intern + col]), 1,
1091  FCELL_TYPE);
1092  }
1093  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
1094  Rast3d_set_null_value((void *)
1095  &(data->
1096  dcell_array[depth *
1097  (data->rows_intern *
1098  data->cols_intern) +
1099  row * data->cols_intern + col]), 1,
1100  DCELL_TYPE);
1101  }
1102  }
1103  else {
1104  if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
1105  Rast3d_set_null_value((void *)
1106  &(data->
1107  fcell_array[(depth +
1108  data->offset) *
1109  (data->rows_intern *
1110  data->cols_intern) + (row +
1111  data->
1112  offset) *
1113  data->cols_intern + (col +
1114  data->
1115  offset)]), 1,
1116  FCELL_TYPE);
1117  }
1118  else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
1119  Rast3d_set_null_value((void *)
1120  &(data->
1121  dcell_array[(depth +
1122  data->offset) *
1123  (data->rows_intern *
1124  data->cols_intern) + (row +
1125  data->
1126  offset) *
1127  data->cols_intern + (col +
1128  data->
1129  offset)]), 1,
1130  DCELL_TYPE);
1131  }
1132  }
1133 
1134  return;
1135 }
1136 
1147 void
1148 N_put_array_3d_f_value(N_array_3d * data, int col, int row, int depth,
1149  float value)
1150 {
1151  double dval;
1152 
1153  if (data->type == DCELL_TYPE) {
1154  dval = (double)value;
1155  N_put_array_3d_value(data, col, row, depth, (void *)&dval);
1156  }
1157  else {
1158  N_put_array_3d_value(data, col, row, depth, (void *)&value);
1159  }
1160 
1161  return;
1162 }
1163 
1174 void
1175 N_put_array_3d_d_value(N_array_3d * data, int col, int row, int depth,
1176  double value)
1177 {
1178  float fval;
1179 
1180  if (data->type == FCELL_TYPE) {
1181  fval = (double)value;
1182  N_put_array_3d_value(data, col, row, depth, (void *)&fval);
1183  }
1184  else {
1185  N_put_array_3d_value(data, col, row, depth, (void *)&value);
1186  }
1187 
1188  return;
1189 }
1190 
1198 {
1199 
1200  fprintf(stdout, "N_array_3d \n");
1201  fprintf(stdout, "Cols %i\n", data->cols);
1202  fprintf(stdout, "Rows: %i\n", data->rows);
1203  fprintf(stdout, "Depths: %i\n", data->depths);
1204  fprintf(stdout, "Array type: %i\n", data->type);
1205  fprintf(stdout, "Offset: %i\n", data->offset);
1206  fprintf(stdout, "Internal cols: %i\n", data->cols_intern);
1207  fprintf(stdout, "Internal rows: %i\n", data->rows_intern);
1208  fprintf(stdout, "Internal depths: %i\n", data->depths_intern);
1209  fprintf(stdout, "FCELL array pointer: %p\n", data->fcell_array);
1210  fprintf(stdout, "DCELL array pointer: %p\n", data->dcell_array);
1211 
1212  return;
1213 }
1214 
1224 {
1225  int i, j, k;
1226 
1227  N_print_array_3d_info(data);
1228 
1229  for (k = 0; k < data->depths; k++) {
1230  for (j = 0; j < data->rows; j++) {
1231  for (i = 0; i < data->cols; i++) {
1232  if (data->type == FCELL_TYPE)
1233  printf("%6.6f ", N_get_array_3d_f_value(data, i, j, k));
1234  else if (data->type == DCELL_TYPE)
1235  printf("%6.6f ", N_get_array_3d_d_value(data, i, j, k));
1236  }
1237  printf("\n");
1238  }
1239  printf("\n");
1240  }
1241  printf("\n");
1242 
1243  return;
1244 }
void N_put_array_2d_value_null(N_array_2d *data, int col, int row)
Writes the null value to the N_array_2d struct at position col, row.
Definition: n_arrays.c:458
int depths_intern
Definition: N_pde.h:169
int N_get_array_2d_type(N_array_2d *array)
Return the data type of the N_array_2d struct.
Definition: n_arrays.c:164
int rows
Definition: N_pde.h:134
double N_get_array_3d_d_value(N_array_3d *data, int col, int row, int depth)
This function returns the value of type float at position col, row, depth.
Definition: n_arrays.c:990
N_array_3d * N_alloc_array_3d(int cols, int rows, int depths, int offset, int type)
Allocate memory for a N_array_3d data structure.
Definition: n_arrays.c:726
void N_put_array_3d_f_value(N_array_3d *data, int col, int row, int depth, float value)
This function writes a float value to the N_array_3d data at position col, row, depth.
Definition: n_arrays.c:1148
int depths
Definition: N_pde.h:168
N_array_2d * N_alloc_array_2d(int cols, int rows, int offset, int type)
Allocate memory for a N_array_2d data structure.
Definition: n_arrays.c:72
int cols
Definition: N_pde.h:134
void N_put_array_2d_value(N_array_2d *data, int col, int row, char *value)
Writes a value to the N_array_2d struct at position col, row.
Definition: n_arrays.c:411
#define NULL
Definition: ccmath.h:32
void N_put_array_2d_c_value(N_array_2d *data, int col, int row, CELL value)
Writes a CELL value to the N_array_2d struct at position col, row.
Definition: n_arrays.c:524
void N_print_array_3d_info(N_array_3d *data)
Write the info of the array to stdout.
Definition: n_arrays.c:1197
FCELL N_get_array_2d_f_value(N_array_2d *data, int col, int row)
Returns the value of type FCELL at position col, row.
Definition: n_arrays.c:346
float N_get_array_3d_f_value(N_array_3d *data, int col, int row, int depth)
This function returns the value of type float at position col, row, depth.
Definition: n_arrays.c:961
void N_put_array_2d_f_value(N_array_2d *data, int col, int row, FCELL value)
Writes a FCELL value to the N_array_2d struct at position col, row.
Definition: n_arrays.c:554
void N_print_array_2d(N_array_2d *data)
Write info and content of the N_array_2d struct to stdout.
Definition: n_arrays.c:637
int offset
Definition: N_pde.h:170
void G_fatal_error(const char *msg,...)
Print a fatal error message to stderr.
Definition: gis/error.c:159
int offset
Definition: N_pde.h:136
void N_put_array_3d_value_null(N_array_3d *data, int col, int row, int depth)
This function writes a null value to the N_array_3d data at position col, row, depth.
Definition: n_arrays.c:1076
CELL * cell_array
Definition: N_pde.h:137
int cols_intern
Definition: N_pde.h:169
void N_print_array_3d(N_array_3d *data)
Write info and content of the array data to stdout.
Definition: n_arrays.c:1223
void N_free_array_2d(N_array_2d *data)
Release the memory of a N_array_2d structure.
Definition: n_arrays.c:130
void N_get_array_2d_value(N_array_2d *data, int col, int row, void *value)
Write the value of the N_array_2d struct at position col, row to value.
Definition: n_arrays.c:181
int cols
Definition: N_pde.h:168
int G_debug(int level, const char *msg,...)
Print debugging message.
Definition: debug.c:65
void N_put_array_3d_d_value(N_array_3d *data, int col, int row, int depth, double value)
Writes a double value to the N_array_3d struct at position col, row, depth.
Definition: n_arrays.c:1175
FCELL * fcell_array
Definition: N_pde.h:138
int N_get_array_3d_type(N_array_3d *array)
Return the data type of the N_array_3d.
Definition: n_arrays.c:809
void N_print_array_2d_info(N_array_2d *data)
This function writes the data info of the array data to stdout.
Definition: n_arrays.c:611
DCELL * dcell_array
Definition: N_pde.h:139
int N_is_array_2d_value_null(N_array_2d *data, int col, int row)
Returns 1 if the value of N_array_2d struct at postion col, row is of type null, otherwise 0...
Definition: n_arrays.c:231
float * fcell_array
Definition: N_pde.h:171
double * dcell_array
Definition: N_pde.h:172
int type
Definition: N_pde.h:133
CELL N_get_array_2d_c_value(N_array_2d *data, int col, int row)
Returns the value of type CELL at position col, row.
Definition: n_arrays.c:314
void N_put_array_2d_d_value(N_array_2d *data, int col, int row, DCELL value)
Writes a DCELL value to the N_array_2d struct at position col, row.
Definition: n_arrays.c:584
int cols_intern
Definition: N_pde.h:135
void N_put_array_3d_value(N_array_3d *data, int col, int row, int depth, char *value)
This function writes a value to the N_array_3d data at position col, row, depth.
Definition: n_arrays.c:1021
DCELL N_get_array_2d_d_value(N_array_2d *data, int col, int row)
Returns the value of type DCELL at position col, row.
Definition: n_arrays.c:378
void N_free_array_3d(N_array_3d *data)
Release the memory of a N_array_3d.
Definition: n_arrays.c:780
void G_free(void *buf)
Free allocated memory.
Definition: alloc.c:149
int type
Definition: N_pde.h:167
int rows_intern
Definition: N_pde.h:169
int rows
Definition: N_pde.h:168
int rows_intern
Definition: N_pde.h:135
int N_is_array_3d_value_null(N_array_3d *data, int col, int row, int depth)
This function returns 1 if value of N_array_3d data at position col, row, depth is of type null...
Definition: n_arrays.c:881
void N_get_array_3d_value(N_array_3d *data, int col, int row, int depth, void *value)
This function writes the value of N_array_3d data at position col, row, depth to the variable value...
Definition: n_arrays.c:829