GRASS Programmer's Manual  6.4.2(2012)
N_arrays.c
Go to the documentation of this file.
00001 
00002 /*****************************************************************************
00003 *
00004 * MODULE:       Grass PDE Numerical Library
00005 * AUTHOR(S):    Soeren Gebbert, Berlin (GER) Dec 2006
00006 *               soerengebbert <at> gmx <dot> de
00007 *               
00008 * PURPOSE:      Array managment functions 
00009 *               part of the gpde library
00010 *
00011 * COPYRIGHT:    (C) 2000 by the GRASS Development Team
00012 *
00013 *               This program is free software under the GNU General Public
00014 *               License (>=v2). Read the file COPYING that comes with GRASS
00015 *               for details.
00016 *
00017 *****************************************************************************/
00018 
00019 #include "grass/N_pde.h"
00020 #include "grass/glocale.h"
00021 #include <math.h>
00022 
00023 /* ******************** 2D ARRAY FUNCTIONS *********************** */
00024 
00069 N_array_2d *N_alloc_array_2d(int cols, int rows, int offset, int type)
00070 {
00071     N_array_2d *data = NULL;
00072 
00073     if (rows < 1 || cols < 1)
00074         G_fatal_error("N_alloc_array_2d: cols and rows should be > 0");
00075 
00076     if (type != CELL_TYPE && type != FCELL_TYPE && type != DCELL_TYPE)
00077         G_fatal_error
00078             ("N_alloc_array_2d: Wrong data type, should be CELL_TYPE, FCELL_TYPE or DCELL_TYPE");
00079 
00080     data = (N_array_2d *) G_calloc(1, sizeof(N_array_2d));
00081 
00082     data->cols = cols;
00083     data->rows = rows;
00084     data->type = type;
00085     data->offset = offset;
00086     data->rows_intern = rows + 2 * offset;      /*offset position at booth sides */
00087     data->cols_intern = cols + 2 * offset;      /*offset position at booth sides */
00088     data->cell_array = NULL;
00089     data->fcell_array = NULL;
00090     data->dcell_array = NULL;
00091 
00092     if (data->type == CELL_TYPE) {
00093         data->cell_array =
00094             (CELL *) G_calloc(data->rows_intern * data->cols_intern,
00095                               sizeof(CELL));
00096         G_debug(3,
00097                 "N_alloc_array_2d: CELL array allocated rows_intern %i cols_intern %i offset %i",
00098                 data->rows_intern, data->cols_intern, data->offset = offset);
00099     }
00100     else if (data->type == FCELL_TYPE) {
00101         data->fcell_array =
00102             (FCELL *) G_calloc(data->rows_intern * data->cols_intern,
00103                                sizeof(FCELL));
00104         G_debug(3,
00105                 "N_alloc_array_2d: FCELL array allocated rows_intern %i cols_intern %i offset %i",
00106                 data->rows_intern, data->cols_intern, data->offset = offset);
00107 
00108     }
00109     else if (data->type == DCELL_TYPE) {
00110         data->dcell_array =
00111             (DCELL *) G_calloc(data->rows_intern * data->cols_intern,
00112                                sizeof(DCELL));
00113         G_debug(3,
00114                 "N_alloc_array_2d: DCELL array allocated rows_intern %i cols_intern %i offset %i",
00115                 data->rows_intern, data->cols_intern, data->offset = offset);
00116     }
00117 
00118     return data;
00119 }
00120 
00127 void N_free_array_2d(N_array_2d * data)
00128 {
00129 
00130     if (data != NULL) {
00131         G_debug(3, "N_free_array_2d: free N_array_2d");
00132 
00133         if (data->type == CELL_TYPE && data->cell_array != NULL) {
00134             G_free(data->cell_array);
00135         }
00136         else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
00137             G_free(data->fcell_array);
00138 
00139         }
00140         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
00141             G_free(data->dcell_array);
00142         }
00143 
00144         G_free(data);
00145         data = NULL;
00146 
00147     }
00148 
00149     return;
00150 }
00151 
00152 
00161 int N_get_array_2d_type(N_array_2d * array)
00162 {
00163     return array->type;
00164 }
00165 
00178 void N_get_array_2d_value(N_array_2d * data, int col, int row, void *value)
00179 {
00180 
00181     if (data->offset == 0) {
00182         if (data->type == CELL_TYPE && data->cell_array != NULL) {
00183             *((CELL *) value) =
00184                 data->cell_array[row * data->cols_intern + col];
00185         }
00186         else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
00187             *((FCELL *) value) =
00188                 data->fcell_array[row * data->cols_intern + col];
00189         }
00190         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
00191             *((DCELL *) value) =
00192                 data->dcell_array[row * data->cols_intern + col];
00193         }
00194     }
00195     else {
00196         if (data->type == CELL_TYPE && data->cell_array != NULL) {
00197             *((CELL *) value) =
00198                 data->cell_array[(row + data->offset) * data->cols_intern +
00199                                  col + data->offset];
00200         }
00201         else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
00202             *((FCELL *) value) =
00203                 data->fcell_array[(row + data->offset) * data->cols_intern +
00204                                   col + data->offset];
00205         }
00206         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
00207             *((DCELL *) value) =
00208                 data->dcell_array[(row + data->offset) * data->cols_intern +
00209                                   col + data->offset];
00210         }
00211     }
00212 
00213     return;
00214 }
00215 
00228 int N_is_array_2d_value_null(N_array_2d * data, int col, int row)
00229 {
00230 
00231     if (data->offset == 0) {
00232         if (data->type == CELL_TYPE && data->cell_array != NULL) {
00233             G_debug(6,
00234                     "N_is_array_2d_value_null: null value is of type CELL at pos [%i][%i]",
00235                     col, row);
00236             return G_is_null_value((void *)
00237                                    &(data->
00238                                      cell_array[row * data->cols_intern +
00239                                                 col]), CELL_TYPE);
00240         }
00241         else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
00242             G_debug(6,
00243                     "N_is_array_2d_value_null: null value is of type FCELL at pos [%i][%i]",
00244                     col, row);
00245             return G_is_null_value((void *)
00246                                    &(data->
00247                                      fcell_array[row * data->cols_intern +
00248                                                  col]), FCELL_TYPE);
00249         }
00250         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
00251             G_debug(6,
00252                     "N_is_array_2d_value_null: null value is of type DCELL at pos [%i][%i]",
00253                     col, row);
00254             return G_is_null_value((void *)
00255                                    &(data->
00256                                      dcell_array[row * data->cols_intern +
00257                                                  col]), DCELL_TYPE);
00258         }
00259     }
00260     else {
00261         if (data->type == CELL_TYPE && data->cell_array != NULL) {
00262             G_debug(6,
00263                     "N_is_array_2d_value_null: null value is of type CELL at pos [%i][%i]",
00264                     col, row);
00265             return G_is_null_value((void *)
00266                                    &(data->
00267                                      cell_array[(row +
00268                                                  data->offset) *
00269                                                 data->cols_intern + col +
00270                                                 data->offset]), CELL_TYPE);
00271         }
00272         else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
00273             G_debug(6,
00274                     "N_is_array_2d_value_null: null value is of type FCELL at pos [%i][%i]",
00275                     col, row);
00276             return G_is_null_value((void *)
00277                                    &(data->
00278                                      fcell_array[(row +
00279                                                   data->offset) *
00280                                                  data->cols_intern + col +
00281                                                  data->offset]), FCELL_TYPE);
00282         }
00283         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
00284             G_debug(6,
00285                     "N_is_array_2d_value_null: null value is of type DCELL at pos [%i][%i]",
00286                     col, row);
00287             return G_is_null_value((void *)
00288                                    &(data->
00289                                      dcell_array[(row +
00290                                                   data->offset) *
00291                                                  data->cols_intern + col +
00292                                                  data->offset]), DCELL_TYPE);
00293         }
00294     }
00295 
00296     return 0;
00297 }
00298 
00299 
00311 CELL N_get_array_2d_c_value(N_array_2d * data, int col, int row)
00312 {
00313     CELL value = 0;
00314     FCELL fvalue = 0.0;
00315     DCELL dvalue = 0.0;
00316 
00317     switch (data->type) {
00318     case CELL_TYPE:
00319         N_get_array_2d_value(data, col, row, (void *)&value);
00320         return (CELL) value;
00321     case FCELL_TYPE:
00322         N_get_array_2d_value(data, col, row, (void *)&fvalue);
00323         return (CELL) fvalue;
00324     case DCELL_TYPE:
00325         N_get_array_2d_value(data, col, row, (void *)&dvalue);
00326         return (CELL) dvalue;
00327     }
00328 
00329     return value;
00330 }
00331 
00343 FCELL N_get_array_2d_f_value(N_array_2d * data, int col, int row)
00344 {
00345     CELL value = 0;
00346     FCELL fvalue = 0.0;
00347     DCELL dvalue = 0.0;
00348 
00349     switch (data->type) {
00350     case CELL_TYPE:
00351         N_get_array_2d_value(data, col, row, (void *)&value);
00352         return (FCELL) value;
00353     case FCELL_TYPE:
00354         N_get_array_2d_value(data, col, row, (void *)&fvalue);
00355         return (FCELL) fvalue;
00356     case DCELL_TYPE:
00357         N_get_array_2d_value(data, col, row, (void *)&dvalue);
00358         return (FCELL) dvalue;
00359     }
00360 
00361     return fvalue;
00362 }
00363 
00375 DCELL N_get_array_2d_d_value(N_array_2d * data, int col, int row)
00376 {
00377     CELL value = 0;
00378     FCELL fvalue = 0.0;
00379     DCELL dvalue = 0.0;
00380 
00381     switch (data->type) {
00382     case CELL_TYPE:
00383         N_get_array_2d_value(data, col, row, (void *)&value);
00384         return (DCELL) value;
00385     case FCELL_TYPE:
00386         N_get_array_2d_value(data, col, row, (void *)&fvalue);
00387         return (DCELL) fvalue;
00388     case DCELL_TYPE:
00389         N_get_array_2d_value(data, col, row, (void *)&dvalue);
00390         return (DCELL) dvalue;
00391     }
00392 
00393     return dvalue;
00394 
00395 }
00396 
00408 void N_put_array_2d_value(N_array_2d * data, int col, int row, char *value)
00409 {
00410 
00411     G_debug(6, "N_put_array_2d_value: put value to array");
00412 
00413     if (data->offset == 0) {
00414         if (data->type == CELL_TYPE && data->cell_array != NULL) {
00415             data->cell_array[row * data->cols_intern + col] =
00416                 *((CELL *) value);
00417         }
00418         else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
00419             data->fcell_array[row * data->cols_intern + col] =
00420                 *((FCELL *) value);
00421         }
00422         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
00423             data->dcell_array[row * data->cols_intern + col] =
00424                 *((DCELL *) value);
00425         }
00426     }
00427     else {
00428         if (data->type == CELL_TYPE && data->cell_array != NULL) {
00429             data->cell_array[(row + data->offset) * data->cols_intern + col +
00430                              data->offset] = *((CELL *) value);
00431         }
00432         else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
00433             data->fcell_array[(row + data->offset) * data->cols_intern + col +
00434                               data->offset] = *((FCELL *) value);
00435         }
00436         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
00437             data->dcell_array[(row + data->offset) * data->cols_intern + col +
00438                               data->offset] = *((DCELL *) value);
00439         }
00440     }
00441 
00442     return;
00443 }
00444 
00455 void N_put_array_2d_value_null(N_array_2d * data, int col, int row)
00456 {
00457 
00458     G_debug(6,
00459             "N_put_array_2d_value_null: put null value to array pos [%i][%i]",
00460             col, row);
00461 
00462     if (data->offset == 0) {
00463         if (data->type == CELL_TYPE && data->cell_array != NULL) {
00464             G_set_c_null_value((void *)
00465                                &(data->
00466                                  cell_array[row * data->cols_intern + col]),
00467                                1);
00468         }
00469         else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
00470             G_set_f_null_value((void *)
00471                                &(data->
00472                                  fcell_array[row * data->cols_intern + col]),
00473                                1);
00474         }
00475         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
00476             G_set_d_null_value((void *)
00477                                &(data->
00478                                  dcell_array[row * data->cols_intern + col]),
00479                                1);
00480         }
00481     }
00482     else {
00483         if (data->type == CELL_TYPE && data->cell_array != NULL) {
00484             G_set_c_null_value((void *)
00485                                &(data->
00486                                  cell_array[(row +
00487                                              data->offset) *
00488                                             data->cols_intern + col +
00489                                             data->offset]), 1);
00490         }
00491         else if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
00492             G_set_f_null_value((void *)
00493                                &(data->
00494                                  fcell_array[(row +
00495                                               data->offset) *
00496                                              data->cols_intern + col +
00497                                              data->offset]), 1);
00498         }
00499         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
00500             G_set_d_null_value((void *)
00501                                &(data->
00502                                  dcell_array[(row +
00503                                               data->offset) *
00504                                              data->cols_intern + col +
00505                                              data->offset]), 1);
00506         }
00507     }
00508 
00509     return;
00510 }
00511 
00521 void N_put_array_2d_c_value(N_array_2d * data, int col, int row, CELL value)
00522 {
00523     FCELL fvalue;
00524     DCELL dvalue;
00525 
00526     switch (data->type) {
00527     case FCELL_TYPE:
00528         fvalue = (FCELL) value;
00529         N_put_array_2d_value(data, col, row, (char *)&fvalue);
00530         return;
00531     case DCELL_TYPE:
00532         dvalue = (DCELL) value;
00533         N_put_array_2d_value(data, col, row, (char *)&dvalue);
00534         return;
00535     }
00536 
00537     N_put_array_2d_value(data, col, row, (char *)&value);
00538 
00539     return;
00540 }
00541 
00551 void N_put_array_2d_f_value(N_array_2d * data, int col, int row, FCELL value)
00552 {
00553     CELL cvalue;
00554     DCELL dvalue;
00555 
00556     switch (data->type) {
00557     case CELL_TYPE:
00558         cvalue = (CELL) value;
00559         N_put_array_2d_value(data, col, row, (char *)&cvalue);
00560         return;
00561     case DCELL_TYPE:
00562         dvalue = (DCELL) value;
00563         N_put_array_2d_value(data, col, row, (char *)&dvalue);
00564         return;
00565     }
00566 
00567     N_put_array_2d_value(data, col, row, (char *)&value);
00568 
00569     return;
00570 }
00571 
00581 void N_put_array_2d_d_value(N_array_2d * data, int col, int row, DCELL value)
00582 {
00583     CELL cvalue;
00584     FCELL fvalue;
00585 
00586     switch (data->type) {
00587     case CELL_TYPE:
00588         cvalue = (CELL) value;
00589         N_put_array_2d_value(data, col, row, (char *)&cvalue);
00590         return;
00591     case FCELL_TYPE:
00592         fvalue = (FCELL) value;
00593         N_put_array_2d_value(data, col, row, (char *)&fvalue);
00594         return;
00595     }
00596 
00597     N_put_array_2d_value(data, col, row, (char *)&value);
00598 
00599     return;
00600 }
00601 
00608 void N_print_array_2d_info(N_array_2d * data)
00609 {
00610 
00611     fprintf(stdout, "N_array_2d \n");
00612     fprintf(stdout, "Cols %i\n", data->cols);
00613     fprintf(stdout, "Rows: %i\n", data->rows);
00614     fprintf(stdout, "Array type: %i\n", data->type);
00615     fprintf(stdout, "Offset: %i\n", data->offset);
00616     fprintf(stdout, "Internal cols: %i\n", data->cols_intern);
00617     fprintf(stdout, "Internal rows: %i\n", data->rows_intern);
00618     fprintf(stdout, "CELL array pointer: %p\n", data->cell_array);
00619     fprintf(stdout, "FCELL array pointer: %p\n", data->fcell_array);
00620     fprintf(stdout, "DCELL array pointer: %p\n", data->dcell_array);
00621 
00622 
00623     return;
00624 }
00625 
00634 void N_print_array_2d(N_array_2d * data)
00635 {
00636     int i, j;
00637 
00638     N_print_array_2d_info(data);
00639 
00640     for (j = 0 - data->offset; j < data->rows + data->offset; j++) {
00641         for (i = 0 - data->offset; i < data->cols + data->offset; i++) {
00642             if (data->type == CELL_TYPE)
00643                 fprintf(stdout, "%6d ", N_get_array_2d_c_value(data, i, j));
00644             else if (data->type == FCELL_TYPE)
00645                 fprintf(stdout, "%6.6f ", N_get_array_2d_f_value(data, i, j));
00646             else if (data->type == DCELL_TYPE)
00647                 printf("%6.6f ", N_get_array_2d_d_value(data, i, j));
00648         }
00649         fprintf(stdout, "\n");
00650     }
00651     fprintf(stdout, "\n");
00652 
00653     return;
00654 }
00655 
00656 
00657 /* ******************** 3D ARRAY FUNCTIONS *********************** */
00658 
00723 N_array_3d *N_alloc_array_3d(int cols, int rows, int depths, int offset,
00724                              int type)
00725 {
00726     N_array_3d *data = NULL;
00727 
00728     if (rows < 1 || cols < 1 || depths < 1)
00729         G_fatal_error
00730             ("N_alloc_array_3d: depths, cols and rows should be > 0");
00731 
00732     if (type != DCELL_TYPE && type != FCELL_TYPE)
00733         G_fatal_error
00734             ("N_alloc_array_3d: Wrong data type, should be FCELL_TYPE or DCELL_TYPE");
00735 
00736     data = (N_array_3d *) G_calloc(1, sizeof(N_array_3d));
00737 
00738     data->cols = cols;
00739     data->rows = rows;
00740     data->depths = depths;
00741     data->type = type;
00742     data->offset = offset;
00743     data->rows_intern = rows + 2 * offset;
00744     data->cols_intern = cols + 2 * offset;
00745     data->depths_intern = depths + 2 * offset;
00746     data->fcell_array = NULL;
00747     data->dcell_array = NULL;
00748 
00749     if (data->type == FCELL_TYPE) {
00750         data->fcell_array =
00751             (float *)G_calloc(data->depths_intern * data->rows_intern *
00752                               data->cols_intern, sizeof(float));
00753         G_debug(3,
00754                 "N_alloc_array_3d: float array allocated rows_intern %i cols_intern %i depths_intern %i offset %i",
00755                 data->rows_intern, data->cols_intern, data->depths_intern,
00756                 data->offset = offset);
00757     }
00758     else if (data->type == DCELL_TYPE) {
00759         data->dcell_array =
00760             (double *)G_calloc(data->depths_intern * data->rows_intern *
00761                                data->cols_intern, sizeof(double));
00762         G_debug(3,
00763                 "N_alloc_array_3d: double array allocated rows_intern %i cols_intern %i depths_intern %i offset %i",
00764                 data->rows_intern, data->cols_intern, data->depths_intern,
00765                 data->offset = offset);
00766     }
00767 
00768     return data;
00769 }
00770 
00777 void N_free_array_3d(N_array_3d * data)
00778 {
00779 
00780     if (data != NULL) {
00781         G_debug(3, "N_free_array_3d: free N_array_3d");
00782 
00783         if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
00784             G_free(data->fcell_array);
00785         }
00786         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
00787             G_free(data->dcell_array);
00788         }
00789 
00790         G_free(data);
00791         data = NULL;
00792 
00793     }
00794 
00795     return;
00796 }
00797 
00806 int N_get_array_3d_type(N_array_3d * array)
00807 {
00808     return array->type;
00809 }
00810 
00811 
00825 void
00826 N_get_array_3d_value(N_array_3d * data, int col, int row, int depth,
00827                      void *value)
00828 {
00829 
00830     if (data->offset == 0) {
00831         if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
00832             *((float *)value) =
00833                 data->fcell_array[depth *
00834                                   (data->rows_intern * data->cols_intern) +
00835                                   row * data->cols_intern + col];
00836         }
00837         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
00838             *((double *)value) =
00839                 data->dcell_array[depth *
00840                                   (data->rows_intern * data->cols_intern) +
00841                                   row * data->cols_intern + col];
00842         }
00843     }
00844     else {
00845         if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
00846             *((float *)value) =
00847                 data->fcell_array[(depth + data->offset) *
00848                                   (data->rows_intern * data->cols_intern) +
00849                                   (row + data->offset) * data->cols_intern +
00850                                   (col + data->offset)];
00851 
00852         }
00853         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
00854             *((double *)value) =
00855                 data->dcell_array[(depth + data->offset) *
00856                                   (data->rows_intern * data->cols_intern) +
00857                                   (row + data->offset) * data->cols_intern +
00858                                   (col + data->offset)];
00859         }
00860     }
00861 
00862     return;
00863 }
00864 
00878 int N_is_array_3d_value_null(N_array_3d * data, int col, int row, int depth)
00879 {
00880 
00881     if (data->offset == 0) {
00882         if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
00883             G_debug(6,
00884                     "N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
00885                     depth, row, col);
00886             return G3d_isNullValueNum((void *)
00887                                       &(data->
00888                                         fcell_array[depth *
00889                                                     (data->rows_intern *
00890                                                      data->cols_intern) +
00891                                                     row * data->cols_intern +
00892                                                     col]), FCELL_TYPE);
00893         }
00894         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
00895             G_debug(6,
00896                     "N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
00897                     depth, row, col);
00898             return G3d_isNullValueNum((void *)
00899                                       &(data->
00900                                         dcell_array[depth *
00901                                                     (data->rows_intern *
00902                                                      data->cols_intern) +
00903                                                     row * data->cols_intern +
00904                                                     col]), DCELL_TYPE);
00905         }
00906     }
00907     else {
00908         if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
00909             G_debug(6,
00910                     "N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
00911                     depth, row, col);
00912             return G3d_isNullValueNum((void *)
00913                                       &(data->
00914                                         fcell_array[(depth +
00915                                                      data->offset) *
00916                                                     (data->rows_intern *
00917                                                      data->cols_intern) +
00918                                                     (row + data->offset)
00919                                                     * data->cols_intern +
00920                                                     (col + data->offset)]),
00921                                       FCELL_TYPE);
00922 
00923         }
00924         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
00925             G_debug(6,
00926                     "N_is_array_3d_value_null: null value is of type DCELL_TYPE at pos [%i][%i][%i]",
00927                     depth, row, col);
00928             return G3d_isNullValueNum((void *)
00929                                       &(data->
00930                                         dcell_array[(depth +
00931                                                      data->offset) *
00932                                                     (data->rows_intern *
00933                                                      data->cols_intern) +
00934                                                     (row +
00935                                                      data->offset) *
00936                                                     data->cols_intern + (col +
00937                                                                          data->
00938                                                                          offset)]),
00939                                       DCELL_TYPE);
00940         }
00941     }
00942 
00943     return 0;
00944 }
00945 
00958 float N_get_array_3d_f_value(N_array_3d * data, int col, int row, int depth)
00959 {
00960     float fvalue = 0.0;
00961     double dvalue = 0.0;
00962 
00963     switch (data->type) {
00964     case FCELL_TYPE:
00965         N_get_array_3d_value(data, col, row, depth, (void *)&fvalue);
00966         return (float)fvalue;
00967     case DCELL_TYPE:
00968         N_get_array_3d_value(data, col, row, depth, (void *)&dvalue);
00969         return (float)dvalue;
00970     }
00971 
00972     return fvalue;
00973 }
00974 
00987 double N_get_array_3d_d_value(N_array_3d * data, int col, int row, int depth)
00988 {
00989     float fvalue = 0.0;
00990     double dvalue = 0.0;
00991 
00992     switch (data->type) {
00993 
00994     case FCELL_TYPE:
00995         N_get_array_3d_value(data, col, row, depth, (void *)&fvalue);
00996         return (double)fvalue;
00997     case DCELL_TYPE:
00998         N_get_array_3d_value(data, col, row, depth, (void *)&dvalue);
00999         return (double)dvalue;
01000     }
01001 
01002     return dvalue;
01003 }
01004 
01017 void
01018 N_put_array_3d_value(N_array_3d * data, int col, int row, int depth,
01019                      char *value)
01020 {
01021 
01022     G_debug(6, "N_put_array_3d_value: put value to array at pos [%i][%i][%i]",
01023             depth, row, col);
01024 
01025     if (data->offset == 0) {
01026         if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
01027             data->fcell_array[depth *
01028                               (data->rows_intern * data->cols_intern) +
01029                               row * data->cols_intern + col]
01030                 = *((float *)value);
01031         }
01032         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
01033 
01034             data->dcell_array[depth *
01035                               (data->rows_intern * data->cols_intern) +
01036                               row * data->cols_intern + col]
01037                 = *((double *)value);
01038         }
01039     }
01040     else {
01041         if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
01042             data->fcell_array[(depth + data->offset) *
01043                               (data->rows_intern * data->cols_intern) + (row +
01044                                                                          data->
01045                                                                          offset)
01046                               * data->cols_intern + (col + data->offset)] =
01047                 *((float *)value);
01048         }
01049         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
01050             data->dcell_array[(depth + data->offset) *
01051                               (data->rows_intern * data->cols_intern) + (row +
01052                                                                          data->
01053                                                                          offset)
01054                               * data->cols_intern + (col + data->offset)] =
01055                 *((double *)value);
01056         }
01057     }
01058 
01059     return;
01060 }
01061 
01073 void N_put_array_3d_value_null(N_array_3d * data, int col, int row, int depth)
01074 {
01075 
01076     G_debug(6,
01077             "N_put_array_3d_value_null: put null value to array at pos [%i][%i][%i]",
01078             depth, row, col);
01079 
01080     if (data->offset == 0) {
01081         if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
01082             G3d_setNullValue((void *)
01083                              &(data->
01084                                fcell_array[depth *
01085                                            (data->rows_intern *
01086                                             data->cols_intern) +
01087                                            row * data->cols_intern + col]), 1,
01088                              FCELL_TYPE);
01089         }
01090         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
01091             G3d_setNullValue((void *)
01092                              &(data->
01093                                dcell_array[depth *
01094                                            (data->rows_intern *
01095                                             data->cols_intern) +
01096                                            row * data->cols_intern + col]), 1,
01097                              DCELL_TYPE);
01098         }
01099     }
01100     else {
01101         if (data->type == FCELL_TYPE && data->fcell_array != NULL) {
01102             G3d_setNullValue((void *)
01103                              &(data->
01104                                fcell_array[(depth +
01105                                             data->offset) *
01106                                            (data->rows_intern *
01107                                             data->cols_intern) + (row +
01108                                                                   data->
01109                                                                   offset) *
01110                                            data->cols_intern + (col +
01111                                                                 data->
01112                                                                 offset)]), 1,
01113                              FCELL_TYPE);
01114         }
01115         else if (data->type == DCELL_TYPE && data->dcell_array != NULL) {
01116             G3d_setNullValue((void *)
01117                              &(data->
01118                                dcell_array[(depth +
01119                                             data->offset) *
01120                                            (data->rows_intern *
01121                                             data->cols_intern) + (row +
01122                                                                   data->
01123                                                                   offset) *
01124                                            data->cols_intern + (col +
01125                                                                 data->
01126                                                                 offset)]), 1,
01127                              DCELL_TYPE);
01128         }
01129     }
01130 
01131     return;
01132 }
01133 
01144 void
01145 N_put_array_3d_f_value(N_array_3d * data, int col, int row, int depth,
01146                        float value)
01147 {
01148     double dval;
01149 
01150     if (data->type == DCELL_TYPE) {
01151         dval = (double)value;
01152         N_put_array_3d_value(data, col, row, depth, (void *)&dval);
01153     }
01154     else {
01155         N_put_array_3d_value(data, col, row, depth, (void *)&value);
01156     }
01157 
01158     return;
01159 }
01160 
01171 void
01172 N_put_array_3d_d_value(N_array_3d * data, int col, int row, int depth,
01173                        double value)
01174 {
01175     float fval;
01176 
01177     if (data->type == FCELL_TYPE) {
01178         fval = (double)value;
01179         N_put_array_3d_value(data, col, row, depth, (void *)&fval);
01180     }
01181     else {
01182         N_put_array_3d_value(data, col, row, depth, (void *)&value);
01183     }
01184 
01185     return;
01186 }
01187 
01194 void N_print_array_3d_info(N_array_3d * data)
01195 {
01196 
01197     fprintf(stdout, "N_array_3d \n");
01198     fprintf(stdout, "Cols %i\n", data->cols);
01199     fprintf(stdout, "Rows: %i\n", data->rows);
01200     fprintf(stdout, "Depths: %i\n", data->depths);
01201     fprintf(stdout, "Array type: %i\n", data->type);
01202     fprintf(stdout, "Offset: %i\n", data->offset);
01203     fprintf(stdout, "Internal cols: %i\n", data->cols_intern);
01204     fprintf(stdout, "Internal rows: %i\n", data->rows_intern);
01205     fprintf(stdout, "Internal depths: %i\n", data->depths_intern);
01206     fprintf(stdout, "FCELL array pointer: %p\n", data->fcell_array);
01207     fprintf(stdout, "DCELL array pointer: %p\n", data->dcell_array);
01208 
01209     return;
01210 }
01211 
01220 void N_print_array_3d(N_array_3d * data)
01221 {
01222     int i, j, k;
01223 
01224     N_print_array_3d_info(data);
01225 
01226     for (k = 0; k < data->depths; k++) {
01227         for (j = 0; j < data->rows; j++) {
01228             for (i = 0; i < data->cols; i++) {
01229                 if (data->type == FCELL_TYPE)
01230                     printf("%6.6f ", N_get_array_3d_f_value(data, i, j, k));
01231                 else if (data->type == DCELL_TYPE)
01232                     printf("%6.6f ", N_get_array_3d_d_value(data, i, j, k));
01233             }
01234             printf("\n");
01235         }
01236         printf("\n");
01237     }
01238     printf("\n");
01239 
01240     return;
01241 }
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines