GRASS Programmer's Manual  6.4.2(2012)
test_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:      Unit tests for arrays
00009 *
00010 * COPYRIGHT:    (C) 2000 by the GRASS Development Team
00011 *
00012 *               This program is free software under the GNU General Public
00013 *               License (>=v2). Read the file COPYING that comes with GRASS
00014 *               for details.
00015 *
00016 *****************************************************************************/
00017 
00018 
00019 #include <stdio.h>
00020 #include <stdlib.h>
00021 #include <string.h>
00022 #include <grass/glocale.h>
00023 #include <grass/N_pde.h>
00024 #include "test_gpde_lib.h"
00025 
00026 /* prototypes */
00027 static int fill_array_2d(N_array_2d * a);
00028 static int fill_array_2d_null(N_array_2d * a);
00029 static int compare_array_2d(N_array_2d * a, N_array_2d * b);
00030 static int fill_array_3d(N_array_3d * a);
00031 static int fill_array_3d_null(N_array_3d * a);
00032 static int compare_array_3d(N_array_3d * a, N_array_3d * b);
00033 static int test_array_2d(void);
00034 static int test_array_3d(void);
00035 static int io_bench_2d(void);
00036 static int io_bench_3d(void);
00037 
00038 /* ************************************************************************* */
00039 /* Performe the array unit tests ******************************************* */
00040 /* ************************************************************************* */
00041 int unit_test_arrays(void)
00042 {
00043     int sum = 0;
00044 
00045     io_bench_2d();
00046     return sum;
00047 
00048     G_message(_("\n++ Running array unit tests ++"));
00049 
00050     G_message(_("\t 1. testing 2d arrays"));
00051     sum += test_array_2d();
00052 
00053     G_message(_("\t 2. testing 3d arrays"));
00054     sum += test_array_3d();
00055 
00056     if (sum > 0)
00057         G_warning(_("\n-- Array unit tests failure --"));
00058     else
00059         G_message(_("\n-- Array unit tests finished successfully --"));
00060 
00061     return sum;
00062 }
00063 
00064 /* ************************************************************************* */
00065 /* Fill an 2d array with valid data **************************************** */
00066 /* ************************************************************************* */
00067 int fill_array_2d(N_array_2d * a)
00068 {
00069     int rows, cols, type;
00070     int i, j, res = 0;
00071 
00072     rows = a->rows;
00073     cols = a->cols;
00074     type = N_get_array_2d_type(a);
00075 
00076 #pragma omp parallel for private (i, j) shared (cols, rows, type, a) reduction(+:res)
00077     for (j = 0; j < rows; j++) {
00078         for (i = 0; i < cols; i++) {
00079             if (type == CELL_TYPE) {
00080                 N_put_array_2d_c_value(a, i, j, (CELL) i * (CELL) j);
00081                 if (N_get_array_2d_c_value(a, i, j) != (CELL) i * (CELL) j)
00082                     res++;
00083             }
00084             if (type == FCELL_TYPE) {
00085                 N_put_array_2d_f_value(a, i, j, (FCELL) i * (FCELL) j);
00086                 if (N_get_array_2d_f_value(a, i, j) != (FCELL) i * (FCELL) j)
00087                     res++;
00088             }
00089             if (type == DCELL_TYPE) {
00090                 N_put_array_2d_d_value(a, i, j, (DCELL) i * (DCELL) j);
00091                 if (N_get_array_2d_d_value(a, i, j) != (DCELL) i * (DCELL) j)
00092                     res++;
00093             }
00094         }
00095     }
00096 
00097     return res;
00098 }
00099 
00100 /* ************************************************************************* */
00101 /* Fill an 2d array with null values *************************************** */
00102 /* ************************************************************************* */
00103 int fill_array_2d_null(N_array_2d * a)
00104 {
00105     int rows, cols;
00106     int i, j, res = 0;
00107 
00108     cols = a->cols;
00109     rows = a->rows;
00110 
00111 #pragma omp parallel for private (i, j) shared (rows, cols, a) reduction(+:res)
00112     for (j = 0; j < rows; j++) {
00113         for (i = 0; i < cols; i++) {
00114             N_put_array_2d_value_null(a, i, j);
00115             if (!N_is_array_2d_value_null(a, i, j))
00116                 res++;
00117         }
00118     }
00119 
00120     return res;
00121 }
00122 
00123 /* ************************************************************************* */
00124 /* Compare two 2d arrays *************************************************** */
00125 /* ************************************************************************* */
00126 int compare_array_2d(N_array_2d * a, N_array_2d * b)
00127 {
00128     int rows, cols, type;
00129     int i, j, res = 0;
00130 
00131     cols = a->cols;
00132     rows = a->rows;
00133     type = N_get_array_2d_type(a);
00134 
00135 #pragma omp parallel for private (i, j) shared (cols, rows, type, a, b) reduction(+:res)
00136     for (j = 0; j < rows; j++) {
00137         for (i = 0; i < cols; i++) {
00138             if (type == CELL_TYPE) {
00139                 if (N_get_array_2d_c_value(a, i, j) !=
00140                     N_get_array_2d_c_value(b, i, j))
00141                     res++;
00142             }
00143             if (type == FCELL_TYPE) {
00144                 if (N_get_array_2d_f_value(a, i, j) !=
00145                     N_get_array_2d_f_value(b, i, j))
00146                     res++;
00147             }
00148             if (type == DCELL_TYPE) {
00149                 if (N_get_array_2d_d_value(a, i, j) !=
00150                     N_get_array_2d_d_value(b, i, j))
00151                     res++;
00152             }
00153         }
00154     }
00155 
00156     return res;
00157 }
00158 
00159 /* ************************************************************************* */
00160 /* Fill an 3d array with valid data **************************************** */
00161 /* ************************************************************************* */
00162 int fill_array_3d(N_array_3d * a)
00163 {
00164     int rows, cols, depths, type;
00165     int i, j, k, res = 0;
00166 
00167     cols = a->cols;
00168     rows = a->rows;
00169     depths = a->depths;
00170     type = N_get_array_3d_type(a);
00171 
00172 #pragma omp parallel for private (i, j, k) shared (depths, rows, cols, type, a) reduction(+:res)
00173     for (k = 0; k < depths; k++) {
00174         for (j = 0; j < rows; j++) {
00175             for (i = 0; i < cols; i++) {
00176                 if (type == FCELL_TYPE) {
00177                     N_put_array_3d_f_value(a, i, j, k,
00178                                            (float)i * (float)j * (float)k);
00179                     if (N_get_array_3d_f_value(a, i, j, k) !=
00180                         (float)i * (float)j * (float)k)
00181                         res++;
00182                 }
00183                 if (type == DCELL_TYPE) {
00184                     N_put_array_3d_d_value(a, i, j, k,
00185                                            (double)i * (double)j * (double)k);
00186                     if (N_get_array_3d_d_value(a, i, j, k) !=
00187                         (double)i * (double)j * (double)k)
00188                         res++;
00189                 }
00190             }
00191         }
00192     }
00193 
00194     return res;
00195 }
00196 
00197 /* ************************************************************************* */
00198 /* Fill an 3d array with null data ***************************************** */
00199 /* ************************************************************************* */
00200 int fill_array_3d_null(N_array_3d * a)
00201 {
00202     int rows, cols, depths, type;
00203     int i, j, k, res = 0;
00204 
00205     cols = a->cols;
00206     rows = a->rows;
00207     depths = a->depths;
00208     type = N_get_array_3d_type(a);
00209 
00210 #pragma omp parallel for private (i, j, k) shared (cols, rows, depths, type, a) reduction(+:res)
00211     for (k = 0; k < depths; k++) {
00212         for (j = 0; j < rows; j++) {
00213             for (i = 0; i < cols; i++) {
00214                 N_put_array_3d_value_null(a, i, j, k);
00215                 if (!N_is_array_3d_value_null(a, i, j, k))
00216                     res++;
00217             }
00218         }
00219     }
00220 
00221     return res;
00222 }
00223 
00224 /* ************************************************************************* */
00225 /* Compare two 3d arrays *************************************************** */
00226 /* ************************************************************************* */
00227 int compare_array_3d(N_array_3d * a, N_array_3d * b)
00228 {
00229     int rows, cols, depths, type;
00230     int i, j, k, res = 0;
00231 
00232     rows = a->rows;
00233     cols = a->cols;
00234     depths = a->depths;
00235     type = N_get_array_3d_type(a);
00236 
00237 #pragma omp parallel for private (i, j, k) shared (depths, rows, cols, type, a, b) reduction(+:res)
00238     for (k = 0; k < depths; k++) {
00239         for (i = 0; i < rows; i++) {
00240             for (j = 0; j < cols; j++) {
00241                 if (type == FCELL_TYPE) {
00242                     if (N_get_array_3d_f_value(a, i, j, k) !=
00243                         N_get_array_3d_f_value(b, i, j, k))
00244                         res++;
00245                 }
00246                 if (type == DCELL_TYPE) {
00247                     if (N_get_array_3d_d_value(a, i, j, k) !=
00248                         N_get_array_3d_d_value(b, i, j, k))
00249                         res++;
00250                 }
00251             }
00252         }
00253     }
00254 
00255     return res;
00256 }
00257 
00258 /* *************************************************************** */
00259 /* *************************************************************** */
00260 /* *************************************************************** */
00261 int io_bench_2d(void)
00262 {
00263     int sum = 0, res = 0;
00264     char buff[1024];
00265 
00266     struct Cell_head region;
00267     N_array_2d *data1;
00268     N_array_2d *data2;
00269     N_array_2d *data3;
00270     N_array_2d *tmp;
00271 
00272     G_get_set_window(&region);
00273 
00274     data1 = N_alloc_array_2d(region.cols, region.rows, 0, CELL_TYPE);
00275     data2 = N_alloc_array_2d(region.cols, region.rows, 0, FCELL_TYPE);
00276     data3 = N_alloc_array_2d(region.cols, region.rows, 0, DCELL_TYPE);
00277 
00278     fill_array_2d(data1);
00279     fill_array_2d(data2);
00280     fill_array_2d(data3);
00281 
00282     /*raster IO methods */
00283     N_write_array_2d_to_rast(data1, "gpde_lib_test_raster_1");
00284     N_write_array_2d_to_rast(data2, "gpde_lib_test_raster_2");
00285     N_write_array_2d_to_rast(data2, "gpde_lib_test_raster_3");
00286     tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_1", NULL);
00287     N_read_rast_to_array_2d("gpde_lib_test_raster_1", tmp);
00288     N_free_array_2d(tmp);
00289     tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_2", NULL);
00290     N_read_rast_to_array_2d("gpde_lib_test_raster_2", tmp);
00291     N_free_array_2d(tmp);
00292     tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_3", NULL);
00293     N_read_rast_to_array_2d("gpde_lib_test_raster_3", tmp);
00294     N_free_array_2d(tmp);
00295 
00296 
00297     sprintf(buff,
00298             "g.remove rast=gpde_lib_test_raster_1,gpde_lib_test_raster_2,gpde_lib_test_raster_3");
00299     system(buff);
00300 
00301     N_free_array_2d(data1);
00302     N_free_array_2d(data2);
00303     N_free_array_2d(data3);
00304 
00305     return sum;
00306 }
00307 
00308 
00309 /* *************************************************************** */
00310 /* *************************************************************** */
00311 /* *************************************************************** */
00312 int test_array_2d(void)
00313 {
00314     int sum = 0, res = 0;
00315 
00316     struct Cell_head region;
00317     N_array_2d *data1;
00318     N_array_2d *data11;
00319     N_array_2d *data2;
00320     N_array_2d *data22;
00321     N_array_2d *data3;
00322     N_array_2d *data33;
00323     char buff[1024];
00324     double min, max, ssum;
00325     int nonzero;
00326 
00327     N_array_2d *tmp;
00328 
00329     /*Alloacte memory for all arrays */
00330     data1 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, CELL_TYPE);
00331     N_print_array_2d_info(data1);
00332     data11 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, CELL_TYPE);
00333     data2 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, FCELL_TYPE);
00334     N_print_array_2d_info(data2);
00335     data22 =
00336         N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, FCELL_TYPE);
00337     data3 = N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, DCELL_TYPE);
00338     N_print_array_2d_info(data3);
00339     data33 =
00340         N_alloc_array_2d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, 1, DCELL_TYPE);
00341 
00342     /*Fill the first arrays with data */
00343 
00344     res = fill_array_2d(data1);
00345     if (res != 0)
00346         G_warning("test_array_2d: error while filling array with values");
00347     sum += res;
00348     res = fill_array_2d(data2);
00349     if (res != 0)
00350         G_warning("test_array_2d: error while filling array with values");
00351     sum += res;
00352     res = fill_array_2d(data3);
00353     if (res != 0)
00354         G_warning("test_array_2d: error while filling array with values");
00355     sum += res;
00356 
00357     /*Copy the data */
00358     N_copy_array_2d(data1, data11);
00359     N_copy_array_2d(data2, data22);
00360     N_copy_array_2d(data3, data33);
00361 
00362     /*Compare the data */
00363     res = compare_array_2d(data1, data11);
00364     if (res != 0)
00365         G_warning("test_array_2d: error in  N_copy_array_2d");
00366     sum += res;
00367     res = compare_array_2d(data2, data22);
00368     if (res != 0)
00369         G_warning("test_array_2d: error in  N_copy_array_2d");
00370     sum += res;
00371     res = compare_array_2d(data3, data33);
00372     if (res != 0)
00373         G_warning("test_array_2d: error in  N_copy_array_2d");
00374     sum += res;
00375 
00376     /*compute statistics */
00377     N_calc_array_2d_stats(data1, &min, &max, &ssum, &nonzero, 0);
00378     G_message("CELL Min %g Max %g Sum %g  nonzero %i\n", min, max, ssum,
00379               nonzero);
00380     if (min != 0 || max != 81 || ssum != 2025 || nonzero != 100) {
00381         G_warning("test_array_2d: error in  N_calc_array_2d_stats");
00382         sum++;
00383     }
00384     N_calc_array_2d_stats(data1, &min, &max, &ssum, &nonzero, 1);
00385     G_message("CELL Min %g Max %g Sum %g  nonzero %i\n", min, max, ssum,
00386               nonzero);
00387     if (min != 0 || max != 81 || ssum != 2025 || nonzero != 144) {
00388         G_warning("test_array_2d: error in  N_calc_array_2d_stats");
00389         sum++;
00390     }
00391 
00392     N_calc_array_2d_stats(data2, &min, &max, &ssum, &nonzero, 0);
00393     G_message("FCELL Min %g Max %g Sum %g  nonzero %i\n", min, max, ssum,
00394               nonzero);
00395     if (min != 0 || max != 81 || ssum != 2025 || nonzero != 100) {
00396         G_warning("test_array_2d: error in  N_calc_array_2d_stats");
00397         sum++;
00398     }
00399 
00400     N_calc_array_2d_stats(data2, &min, &max, &ssum, &nonzero, 1);
00401     G_message("FCELL Min %g Max %g Sum %g  nonzero %i\n", min, max, ssum,
00402               nonzero);
00403     if (min != 0 || max != 81 || ssum != 2025 || nonzero != 144) {
00404         G_warning("test_array_2d: error in  N_calc_array_2d_stats");
00405         sum++;
00406     }
00407 
00408     N_calc_array_2d_stats(data3, &min, &max, &ssum, &nonzero, 0);
00409     G_message("DCELL Min %g Max %g Sum %g  nonzero %i\n", min, max, ssum,
00410               nonzero);
00411     if (min != 0 || max != 81 || ssum != 2025 || nonzero != 100) {
00412         G_warning("test_array_2d: error in  N_calc_array_2d_stats");
00413         sum++;
00414     }
00415 
00416     N_calc_array_2d_stats(data3, &min, &max, &ssum, &nonzero, 1);
00417     G_message("DCELL Min %g Max %g Sum %g  nonzero %i\n", min, max, ssum,
00418               nonzero);
00419     if (min != 0 || max != 81 || ssum != 2025 || nonzero != 144) {
00420         G_warning("test_array_2d: error in  N_calc_array_2d_stats");
00421         sum++;
00422     }
00423 
00424 
00425 
00426     /*test the array math functions */
00427     tmp = N_math_array_2d(data1, data2, NULL, N_ARRAY_SUM);
00428     N_math_array_2d(data2, data2, tmp, N_ARRAY_SUM);
00429     res = N_convert_array_2d_null_to_zero(tmp);
00430     if (res != 0)
00431         G_warning("test_array_2d: error in  N_convert_array_2d_null_to_zero");
00432     sum = res;
00433     N_free_array_2d(tmp);
00434 
00435     tmp = N_math_array_2d(data2, data3, NULL, N_ARRAY_DIF);
00436     N_math_array_2d(data1, data2, tmp, N_ARRAY_DIF);
00437     res = N_convert_array_2d_null_to_zero(tmp);
00438     if (res != 0)
00439         G_warning("test_array_2d: error in  N_convert_array_2d_null_to_zero");
00440     sum = res;
00441     N_free_array_2d(tmp);
00442 
00443     tmp = N_math_array_2d(data1, data1, NULL, N_ARRAY_MUL);
00444     N_math_array_2d(data1, data1, tmp, N_ARRAY_MUL);
00445     res = N_convert_array_2d_null_to_zero(tmp);
00446     if (res != 0)
00447         G_warning("test_array_2d: error in  N_convert_array_2d_null_to_zero");
00448     sum = res;
00449     N_free_array_2d(tmp);
00450 
00451     tmp = N_math_array_2d(data2, data3, NULL, N_ARRAY_DIV);
00452     N_math_array_2d(data1, data2, tmp, N_ARRAY_DIV);
00453     res = N_convert_array_2d_null_to_zero(tmp);
00454     if (res == 0) {             /* if a division with zero is detected, the value is set to null, not to nan */
00455         G_warning("test_array_2d: error in  N_convert_array_2d_null_to_zero");
00456         sum++;
00457     }
00458     N_free_array_2d(tmp);
00459 
00460 
00461 
00462     /*check for correct norm calculation */
00463     if (N_norm_array_2d(data1, data11, N_EUKLID_NORM) != 0.0) {
00464         G_warning("test_array_2d: error in  N_norm_array_2d");
00465         sum++;
00466     }
00467     if (N_norm_array_2d(data1, data11, N_MAXIMUM_NORM) != 0.0) {
00468         G_warning("test_array_2d: error in  N_norm_array_2d");
00469         sum++;
00470     }
00471 
00472     if (N_norm_array_2d(data2, data3, N_EUKLID_NORM) != 0.0) {
00473         G_warning("test_array_2d: error in  N_norm_array_2d");
00474         sum++;
00475     }
00476     if (N_norm_array_2d(data2, data3, N_MAXIMUM_NORM) != 0.0) {
00477         G_warning("test_array_2d: error in  N_norm_array_2d");
00478         sum++;
00479     }
00480 
00481     /*fill arrays with null values */
00482     res = fill_array_2d_null(data1);
00483     if (res != 0)
00484         G_warning
00485             ("test_array_2d: error while filling array with cell null values");
00486     sum += res;
00487     res = fill_array_2d_null(data2);
00488     if (res != 0)
00489         G_warning
00490             ("test_array_2d: error while filling array with fcell null values");
00491     sum += res;
00492     res = fill_array_2d_null(data3);
00493     if (res != 0)
00494         G_warning
00495             ("test_array_2d: error while filling array with dcell null values");
00496     sum += res;
00497 
00498     /*Copy the data */
00499     N_copy_array_2d(data1, data11);
00500     N_copy_array_2d(data2, data22);
00501     N_copy_array_2d(data3, data33);
00502 
00503     /*Compare the data */
00504     compare_array_2d(data1, data11);
00505     compare_array_2d(data2, data22);
00506     compare_array_2d(data3, data33);
00507 
00508     /*check for correct norm calculation in case of null values */
00509     if (N_norm_array_2d(data1, data11, N_EUKLID_NORM) != 0.0) {
00510         G_warning("test_array_2d: error in  N_norm_array_2d");
00511         sum++;
00512     }
00513     if (N_norm_array_2d(data1, data11, N_MAXIMUM_NORM) != 0.0) {
00514         G_warning("test_array_2d: error in  N_norm_array_2d");
00515         sum++;
00516     }
00517 
00518     if (N_norm_array_2d(data2, data3, N_EUKLID_NORM) != 0.0) {
00519         G_warning("test_array_2d: error in  N_norm_array_2d");
00520         sum++;
00521     }
00522     if (N_norm_array_2d(data2, data3, N_MAXIMUM_NORM) != 0.0) {
00523         G_warning("test_array_2d: error in  N_norm_array_2d");
00524         sum++;
00525     }
00526 
00527     /*test the array math functions with null values */
00528     tmp = N_math_array_2d(data1, data11, NULL, N_ARRAY_SUM);
00529     N_math_array_2d(data2, data22, tmp, N_ARRAY_SUM);
00530     res = N_convert_array_2d_null_to_zero(tmp);
00531     if (res == 0) {
00532         G_warning
00533             ("test_array_2d: error in  N_convert_array_2d_null_to_zero ");
00534         sum++;
00535     }
00536     N_free_array_2d(tmp);
00537 
00538     tmp = N_math_array_2d(data2, data22, NULL, N_ARRAY_DIF);
00539     N_math_array_2d(data3, data33, tmp, N_ARRAY_DIF);
00540     res = N_convert_array_2d_null_to_zero(tmp);
00541     if (res == 0) {
00542         G_warning("test_array_2d: error in  N_convert_array_2d_null_to_zero");
00543         sum++;
00544     }
00545     N_free_array_2d(tmp);
00546 
00547     tmp = N_math_array_2d(data1, data11, NULL, N_ARRAY_MUL);
00548     N_math_array_2d(data3, data33, tmp, N_ARRAY_MUL);
00549     res = N_convert_array_2d_null_to_zero(tmp);
00550     if (res == 0) {
00551         G_warning("test_array_2d: error in  N_convert_array_2d_null_to_zero");
00552         sum++;
00553     }
00554     N_free_array_2d(tmp);
00555 
00556     tmp = N_math_array_2d(data2, data3, NULL, N_ARRAY_DIV);
00557     N_math_array_2d(data1, data11, tmp, N_ARRAY_DIV);
00558     res = N_convert_array_2d_null_to_zero(tmp);
00559     if (res == 0) {
00560         G_warning("test_array_2d: error in  N_convert_array_2d_null_to_zero");
00561         sum++;
00562     }
00563     N_free_array_2d(tmp);
00564 
00565 
00566     N_free_array_2d(data1);
00567     N_free_array_2d(data2);
00568     N_free_array_2d(data3);
00569 
00570     G_get_set_window(&region);
00571 
00572     data1 = N_alloc_array_2d(region.cols, region.rows, 0, CELL_TYPE);
00573     data2 = N_alloc_array_2d(region.cols, region.rows, 0, FCELL_TYPE);
00574     data3 = N_alloc_array_2d(region.cols, region.rows, 0, DCELL_TYPE);
00575     fill_array_2d(data1);
00576     fill_array_2d(data2);
00577     fill_array_2d(data3);
00578 
00579     /*raster IO methods */
00580     N_write_array_2d_to_rast(data1, "gpde_lib_test_raster_1");
00581     N_write_array_2d_to_rast(data2, "gpde_lib_test_raster_2");
00582     N_write_array_2d_to_rast(data2, "gpde_lib_test_raster_3");
00583     tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_1", NULL);
00584     N_read_rast_to_array_2d("gpde_lib_test_raster_1", tmp);
00585     N_free_array_2d(tmp);
00586     tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_2", NULL);
00587     N_read_rast_to_array_2d("gpde_lib_test_raster_2", tmp);
00588     N_free_array_2d(tmp);
00589     tmp = N_read_rast_to_array_2d("gpde_lib_test_raster_3", NULL);
00590     N_read_rast_to_array_2d("gpde_lib_test_raster_3", tmp);
00591     N_free_array_2d(tmp);
00592 
00593 
00594     sprintf(buff,
00595             "g.remove rast=gpde_lib_test_raster_1,gpde_lib_test_raster_2,gpde_lib_test_raster_3");
00596     system(buff);
00597 
00598 
00599 
00600     N_free_array_2d(data1);
00601     N_free_array_2d(data11);
00602     N_free_array_2d(data2);
00603     N_free_array_2d(data22);
00604     N_free_array_2d(data3);
00605     N_free_array_2d(data33);
00606 
00607     return sum;
00608 }
00609 
00610 /* *************************************************************** */
00611 /* *************************************************************** */
00612 /* *************************************************************** */
00613 int test_array_3d(void)
00614 {
00615     int sum = 0, res = 0;
00616     char buff[1024];
00617     G3D_Region region;
00618 
00619     N_array_3d *data1;
00620     N_array_3d *data11;
00621     N_array_3d *data2;
00622     N_array_3d *data22;
00623 
00624     N_array_3d *tmp;
00625     double min, max, ssum;
00626     int nonzero;
00627 
00628     /*Alloacte memory for all arrays */
00629     data1 =
00630         N_alloc_array_3d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, TEST_N_NUM_DEPTHS,
00631                          2, FCELL_TYPE);
00632     N_print_array_3d_info(data1);
00633     data11 =
00634         N_alloc_array_3d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, TEST_N_NUM_DEPTHS,
00635                          2, FCELL_TYPE);
00636     data2 =
00637         N_alloc_array_3d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, TEST_N_NUM_DEPTHS,
00638                          2, DCELL_TYPE);
00639     N_print_array_3d_info(data2);
00640     data22 =
00641         N_alloc_array_3d(TEST_N_NUM_COLS, TEST_N_NUM_ROWS, TEST_N_NUM_DEPTHS,
00642                          2, DCELL_TYPE);
00643 
00644 
00645     /*Fill the first arrays with data */
00646 
00647     res = fill_array_3d(data1);
00648     if (res != 0)
00649         G_warning("test_array_3d: error while filling array with values");
00650     sum += res;
00651     res = fill_array_3d(data2);
00652     if (res != 0)
00653         G_warning("test_array_3d: error while filling array with values");
00654     sum += res;
00655 
00656     /*Copy the data */
00657     N_copy_array_3d(data1, data11);
00658     N_copy_array_3d(data2, data22);
00659 
00660     /*Compare the data */
00661     res = compare_array_3d(data1, data11);
00662     if (res != 0)
00663         G_warning("test_array_3d: error in  N_copy_array_2d");
00664     sum += res;
00665     res = compare_array_3d(data1, data11);
00666     if (res != 0)
00667         G_warning("test_array_3d: error in  N_copy_array_2d");
00668     sum += res;
00669 
00670 
00671 
00672     /*compute statistics */
00673     N_calc_array_3d_stats(data1, &min, &max, &ssum, &nonzero, 0);
00674     G_message("FELL Min %g Max %g Sum %g  nonzero %i\n", min, max, ssum,
00675               nonzero);
00676     if (min != 0 || max != 729 || ssum != 91125 || nonzero != 1000) {
00677         G_warning("test_array_3d: error in  N_calc_array_3d_stats");
00678         sum++;
00679     }
00680     N_calc_array_3d_stats(data1, &min, &max, &ssum, &nonzero, 1);
00681     G_message("FELL Min %g Max %g Sum %g  nonzero %i\n", min, max, ssum,
00682               nonzero);
00683     if (min != 0 || max != 729 || ssum != 91125 || nonzero != 2744) {
00684         G_warning("test_array_3d: error in  N_calc_array_3d_stats");
00685         sum++;
00686     }
00687 
00688     N_calc_array_3d_stats(data2, &min, &max, &ssum, &nonzero, 0);
00689     G_message("DCELL Min %g Max %g Sum %g  nonzero %i\n", min, max, ssum,
00690               nonzero);
00691     if (min != 0 || max != 729 || ssum != 91125 || nonzero != 1000) {
00692         G_warning("test_array_3d: error in  N_calc_array_3d_stats");
00693         sum++;
00694     }
00695 
00696     N_calc_array_3d_stats(data2, &min, &max, &ssum, &nonzero, 1);
00697     G_message("DCELL Min %g Max %g Sum %g  nonzero %i\n", min, max, ssum,
00698               nonzero);
00699     if (min != 0 || max != 729 || ssum != 91125 || nonzero != 2744) {
00700         G_warning("test_array_3d: error in  N_calc_array_3d_stats");
00701         sum++;
00702     }
00703 
00704 
00705     /*test the array math functions */
00706     tmp = N_math_array_3d(data1, data2, NULL, N_ARRAY_SUM);
00707     N_math_array_3d(data2, data2, tmp, N_ARRAY_SUM);
00708     res = N_convert_array_3d_null_to_zero(tmp);
00709     if (res != 0)
00710         G_warning("test_array_3d: error in  N_convert_array_3d_null_to_zero");
00711     sum = res;
00712     N_free_array_3d(tmp);
00713 
00714     tmp = N_math_array_3d(data2, data1, NULL, N_ARRAY_DIF);
00715     N_math_array_3d(data1, data2, tmp, N_ARRAY_DIF);
00716     res = N_convert_array_3d_null_to_zero(tmp);
00717     if (res != 0)
00718         G_warning("test_array_3d: error in  N_convert_array_3d_null_to_zero");
00719     sum = res;
00720     N_free_array_3d(tmp);
00721 
00722     tmp = N_math_array_3d(data1, data1, NULL, N_ARRAY_MUL);
00723     N_math_array_3d(data1, data1, tmp, N_ARRAY_MUL);
00724     res = N_convert_array_3d_null_to_zero(tmp);
00725     if (res != 0)
00726         G_warning("test_array_3d: error in  N_convert_array_3d_null_to_zero");
00727     sum = res;
00728     N_free_array_3d(tmp);
00729 
00730     tmp = N_math_array_3d(data2, data1, NULL, N_ARRAY_DIV);
00731     N_math_array_3d(data1, data2, tmp, N_ARRAY_DIV);
00732     res = N_convert_array_3d_null_to_zero(tmp);
00733     if (res == 0) {             /* if a division with zero is detected, the value is set to null, not to nan */
00734         G_warning("test_array_3d: error in  N_convert_array_3d_null_to_zero");
00735         sum++;
00736     }
00737     N_free_array_3d(tmp);
00738 
00739 
00740     /*check for correct norm calculation */
00741     if (N_norm_array_3d(data1, data11, N_EUKLID_NORM) != 0.0) {
00742         G_warning("test_array_3d: error in  N_norm_array_3d");
00743         sum++;
00744     }
00745     if (N_norm_array_3d(data1, data11, N_MAXIMUM_NORM) != 0.0) {
00746         G_warning("test_array_3d: error in  N_norm_array_3d");
00747         sum++;
00748     }
00749 
00750     if (N_norm_array_3d(data1, data2, N_EUKLID_NORM) != 0.0) {
00751         G_warning("test_array_3d: error in  N_norm_array_3d");
00752         sum++;
00753     }
00754     if (N_norm_array_3d(data1, data2, N_MAXIMUM_NORM) != 0.0) {
00755         G_warning("test_array_3d: error in  N_norm_array_3d");
00756         sum++;
00757     }
00758 
00759     /*fill arrays with null values */
00760     res = fill_array_3d_null(data1);
00761     if (res != 0)
00762         G_warning
00763             ("test_array_3d: error while filling array with float null values");
00764     sum += res;
00765     res = fill_array_3d_null(data2);
00766     if (res != 0)
00767         G_warning
00768             ("test_array_3d: error while filling array with double null values");
00769     sum += res;
00770 
00771     /*Copy the data */
00772     N_copy_array_3d(data1, data11);
00773     N_copy_array_3d(data2, data22);
00774 
00775     /*Compare the data */
00776     compare_array_3d(data1, data11);
00777     compare_array_3d(data2, data22);
00778 
00779     /*test the array math functions */
00780     tmp = N_math_array_3d(data1, data2, NULL, N_ARRAY_SUM);
00781     N_math_array_3d(data2, data2, tmp, N_ARRAY_SUM);
00782     res = N_convert_array_3d_null_to_zero(tmp);
00783     if (res == 0) {
00784         G_warning("test_array_3d: error in  N_convert_array_3d_null_to_zero");
00785         sum++;
00786     }
00787     N_free_array_3d(tmp);
00788 
00789     tmp = N_math_array_3d(data2, data1, NULL, N_ARRAY_DIF);
00790     N_math_array_3d(data1, data2, tmp, N_ARRAY_DIF);
00791     res = N_convert_array_3d_null_to_zero(tmp);
00792     if (res == 0) {
00793         G_warning("test_array_3d: error in  N_convert_array_3d_null_to_zero");
00794         sum++;
00795     }
00796     N_free_array_3d(tmp);
00797 
00798     tmp = N_math_array_3d(data1, data1, NULL, N_ARRAY_MUL);
00799     N_math_array_3d(data1, data1, tmp, N_ARRAY_MUL);
00800     res = N_convert_array_3d_null_to_zero(tmp);
00801     if (res == 0) {
00802         G_warning("test_array_3d: error in  N_convert_array_3d_null_to_zero");
00803         sum++;
00804     }
00805     N_free_array_3d(tmp);
00806 
00807     tmp = N_math_array_3d(data2, data1, NULL, N_ARRAY_DIV);
00808     N_math_array_3d(data1, data2, tmp, N_ARRAY_DIV);
00809     res = N_convert_array_3d_null_to_zero(tmp);
00810     if (res == 0) {
00811         G_warning("test_array_3d: error in  N_convert_array_3d_null_to_zero");
00812         sum++;
00813     }
00814     N_free_array_3d(tmp);
00815 
00816 
00817     /*check for correct norm calculation in case of null values */
00818     if (N_norm_array_3d(data1, data11, N_EUKLID_NORM) != 0.0) {
00819         G_warning("test_array_3d: error in  N_norm_array_3d");
00820         sum++;
00821     }
00822     if (N_norm_array_3d(data1, data11, N_MAXIMUM_NORM) != 0.0) {
00823         G_warning("test_array_3d: error in  N_norm_array_3d");
00824         sum++;
00825     }
00826 
00827     if (N_norm_array_3d(data1, data2, N_EUKLID_NORM) != 0.0) {
00828         G_warning("test_array_3d: error in  N_norm_array_3d");
00829         sum++;
00830     }
00831     if (N_norm_array_3d(data1, data2, N_MAXIMUM_NORM) != 0.0) {
00832         G_warning("test_array_3d: error in  N_norm_array_3d");
00833         sum++;
00834     }
00835 
00836     N_free_array_3d(data1);
00837     N_free_array_3d(data2);
00838 
00839     /*Set the defaults */
00840     G3d_initDefaults();
00841     G3d_getWindow(&region);
00842 
00843     data1 =
00844         N_alloc_array_3d(region.cols, region.rows, region.depths, 0,
00845                          FCELL_TYPE);
00846     data2 =
00847         N_alloc_array_3d(region.cols, region.rows, region.depths, 0,
00848                          DCELL_TYPE);
00849     fill_array_3d(data1);
00850     fill_array_3d(data2);
00851 
00852 
00853     /*Volume IO methods */
00854     N_write_array_3d_to_rast3d(data1, "gpde_lib_test_volume_1", 1);
00855     N_write_array_3d_to_rast3d(data2, "gpde_lib_test_volume_2", 1);
00856     tmp = N_read_rast3d_to_array_3d("gpde_lib_test_volume_1", NULL, 1);
00857     N_read_rast3d_to_array_3d("gpde_lib_test_volume_1", tmp, 1);
00858     N_free_array_3d(tmp);
00859     tmp = N_read_rast3d_to_array_3d("gpde_lib_test_volume_2", NULL, 1);
00860     N_read_rast3d_to_array_3d("gpde_lib_test_volume_2", tmp, 1);
00861     N_free_array_3d(tmp);
00862 
00863     sprintf(buff,
00864             "g.remove rast3d=gpde_lib_test_volume_1,gpde_lib_test_volume_2");
00865     system(buff);
00866 
00867     N_free_array_3d(data1);
00868     N_free_array_3d(data11);
00869     N_free_array_3d(data2);
00870     N_free_array_3d(data22);
00871 
00872     return sum;
00873 }
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines