GRASS Programmer's Manual  6.4.2(2012)
N_gradient.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:      gradient management 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 
00027 N_gradient_2d *N_alloc_gradient_2d(void)
00028 {
00029     N_gradient_2d *grad;
00030 
00031     grad = (N_gradient_2d *) G_calloc(1, sizeof(N_gradient_2d));
00032 
00033     return grad;
00034 }
00035 
00042 void N_free_gradient_2d(N_gradient_2d * grad)
00043 {
00044     G_free(grad);
00045     grad = NULL;
00046 
00047     return;
00048 }
00049 
00060 N_gradient_2d *N_create_gradient_2d(double NC, double SC, double WC,
00061                                     double EC)
00062 {
00063     N_gradient_2d *grad;
00064 
00065     G_debug(5, "N_create_gradient_2d: create N_gradient_2d");
00066 
00067     grad = N_alloc_gradient_2d();
00068 
00069     grad->NC = NC;
00070     grad->SC = SC;
00071     grad->WC = WC;
00072     grad->EC = EC;
00073 
00074     return grad;
00075 }
00076 
00085 int N_copy_gradient_2d(N_gradient_2d * source, N_gradient_2d * target)
00086 {
00087     G_debug(5, "N_copy_gradient_2d: copy N_gradient_2d");
00088 
00089     if (!source || !target)
00090         return 0;
00091 
00092     target->NC = source->NC;
00093     target->SC = source->SC;
00094     target->WC = source->WC;
00095     target->EC = source->EC;
00096 
00097     return 1;
00098 }
00099 
00115 N_gradient_2d *N_get_gradient_2d(N_gradient_field_2d * field,
00116                                  N_gradient_2d * gradient, int col, int row)
00117 {
00118     double NC = 0, SC = 0, WC = 0, EC = 0;
00119     N_gradient_2d *grad = gradient;
00120 
00121 
00122     NC = N_get_array_2d_d_value(field->y_array, col, row);
00123     SC = N_get_array_2d_d_value(field->y_array, col, row + 1);
00124     WC = N_get_array_2d_d_value(field->x_array, col, row);
00125     EC = N_get_array_2d_d_value(field->x_array, col + 1, row);
00126 
00127     G_debug(5,
00128             "N_get_gradient_2d: calculate N_gradient_2d NC %g SC %g WC %g EC %g",
00129             NC, SC, WC, EC);
00130 
00131     /*if gradient is a NULL pointer, create a new one */
00132     if (!grad) {
00133         grad = N_create_gradient_2d(NC, SC, WC, EC);
00134     }
00135     else {
00136         grad->NC = NC;
00137         grad->SC = SC;
00138         grad->WC = WC;
00139         grad->EC = EC;
00140     }
00141 
00142     return grad;
00143 }
00144 
00151 N_gradient_3d *N_alloc_gradient_3d(void)
00152 {
00153     N_gradient_3d *grad;
00154 
00155     grad = (N_gradient_3d *) G_calloc(1, sizeof(N_gradient_3d));
00156 
00157     return grad;
00158 }
00159 
00166 void N_free_gradient_3d(N_gradient_3d * grad)
00167 {
00168     G_free(grad);
00169     grad = NULL;
00170 
00171     return;
00172 }
00173 
00174 
00187 N_gradient_3d *N_create_gradient_3d(double NC, double SC, double WC,
00188                                     double EC, double TC, double BC)
00189 {
00190     N_gradient_3d *grad;
00191 
00192     G_debug(5, "N_create_gradient_3d: create N_gradient_3d");
00193 
00194     grad = N_alloc_gradient_3d();
00195 
00196     grad->NC = NC;
00197     grad->SC = SC;
00198     grad->WC = WC;
00199     grad->EC = EC;
00200     grad->TC = TC;
00201     grad->BC = BC;
00202 
00203     return grad;
00204 }
00205 
00214 int N_copy_gradient_3d(N_gradient_3d * source, N_gradient_3d * target)
00215 {
00216     G_debug(5, "N_copy_gradient_3d: copy N_gradient_3d");
00217 
00218     if (!source || !target)
00219         return 0;
00220 
00221     target->NC = source->NC;
00222     target->SC = source->SC;
00223     target->WC = source->WC;
00224     target->EC = source->EC;
00225     target->TC = source->TC;
00226     target->BC = source->BC;
00227 
00228     return 1;
00229 }
00230 
00231 
00248 N_gradient_3d *N_get_gradient_3d(N_gradient_field_3d * field,
00249                                  N_gradient_3d * gradient, int col, int row,
00250                                  int depth)
00251 {
00252     double NC, SC, WC, EC, TC, BC;
00253     N_gradient_3d *grad = gradient;
00254 
00255     NC = N_get_array_3d_d_value(field->y_array, col, row, depth);
00256     SC = N_get_array_3d_d_value(field->y_array, col, row + 1, depth);
00257     WC = N_get_array_3d_d_value(field->x_array, col, row, depth);
00258     EC = N_get_array_3d_d_value(field->x_array, col + 1, row, depth);
00259     BC = N_get_array_3d_d_value(field->z_array, col, row, depth);
00260     TC = N_get_array_3d_d_value(field->z_array, col, row, depth + 1);
00261 
00262     G_debug(6,
00263             "N_get_gradient_3d: calculate N_gradient_3d NC %g SC %g WC %g EC %g TC %g BC %g",
00264             NC, SC, WC, EC, TC, BC);
00265 
00266     /*if gradient is a NULL pointer, create a new one */
00267     if (!grad) {
00268         grad = N_create_gradient_3d(NC, SC, WC, EC, TC, BC);
00269     }
00270     else {
00271         grad->NC = NC;
00272         grad->SC = SC;
00273         grad->WC = WC;
00274         grad->EC = EC;
00275         grad->BC = BC;
00276         grad->TC = TC;
00277     }
00278 
00279     return grad;
00280 }
00281 
00290 N_gradient_neighbours_x *N_alloc_gradient_neighbours_x(void)
00291 {
00292     N_gradient_neighbours_x *grad;
00293 
00294     grad =
00295         (N_gradient_neighbours_x *) G_calloc(1,
00296                                              sizeof(N_gradient_neighbours_x));
00297 
00298     return grad;
00299 }
00300 
00307 void N_free_gradient_neighbours_x(N_gradient_neighbours_x * grad)
00308 {
00309     G_free(grad);
00310     grad = NULL;
00311 
00312     return;
00313 }
00314 
00315 
00329 N_gradient_neighbours_x *N_create_gradient_neighbours_x(double NWN,
00330                                                         double NEN, double WC,
00331                                                         double EC, double SWS,
00332                                                         double SES)
00333 {
00334     N_gradient_neighbours_x *grad;
00335 
00336     G_debug(6,
00337             "N_create_gradient_neighbours_x: create N_gradient_neighbours_x");
00338 
00339     grad = N_alloc_gradient_neighbours_x();
00340 
00341     grad->NWN = NWN;
00342     grad->NEN = NEN;
00343     grad->WC = WC;
00344     grad->EC = EC;
00345     grad->SWS = SWS;
00346     grad->SES = SES;
00347 
00348     return grad;
00349 }
00350 
00359 int
00360 N_copy_gradient_neighbours_x(N_gradient_neighbours_x * source,
00361                              N_gradient_neighbours_x * target)
00362 {
00363     G_debug(6, "N_copy_gradient_neighbours_x: copy N_gradient_neighbours_x");
00364 
00365     if (!source || !target)
00366         return 0;
00367 
00368     target->NWN = source->NWN;
00369     target->NEN = source->NEN;
00370     target->WC = source->WC;
00371     target->EC = source->EC;
00372     target->SWS = source->SWS;
00373     target->SES = source->SES;
00374 
00375     return 1;
00376 }
00377 
00386 N_gradient_neighbours_y *N_alloc_gradient_neighbours_y(void)
00387 {
00388     N_gradient_neighbours_y *grad;
00389 
00390     grad =
00391         (N_gradient_neighbours_y *) G_calloc(1,
00392                                              sizeof(N_gradient_neighbours_y));
00393 
00394     return grad;
00395 }
00396 
00403 void N_free_gradient_neighbours_y(N_gradient_neighbours_y * grad)
00404 {
00405     G_free(grad);
00406     grad = NULL;
00407 
00408     return;
00409 }
00410 
00424 N_gradient_neighbours_y *N_create_gradient_neighbours_y(double NWW,
00425                                                         double NEE, double NC,
00426                                                         double SC, double SWW,
00427                                                         double SEE)
00428 {
00429     N_gradient_neighbours_y *grad;
00430 
00431     G_debug(6,
00432             "N_create_gradient_neighbours_y: create N_gradient_neighbours_y");
00433 
00434     grad = N_alloc_gradient_neighbours_y();
00435 
00436     grad->NWW = NWW;
00437     grad->NEE = NEE;
00438     grad->NC = NC;
00439     grad->SC = SC;
00440     grad->SWW = SWW;
00441     grad->SEE = SEE;
00442 
00443     return grad;
00444 }
00445 
00454 int
00455 N_copy_gradient_neighbours_y(N_gradient_neighbours_y * source,
00456                              N_gradient_neighbours_y * target)
00457 {
00458     G_debug(6, "N_copy_gradient_neighbours_y: copy N_gradient_neighbours_y");
00459 
00460     if (!source || !target)
00461         return 0;
00462 
00463     target->NWW = source->NWW;
00464     target->NEE = source->NEE;
00465     target->NC = source->NC;
00466     target->SC = source->SC;
00467     target->SWW = source->SWW;
00468     target->SEE = source->SEE;
00469 
00470     return 1;
00471 }
00472 
00481 N_gradient_neighbours_z *N_alloc_gradient_neighbours_z(void)
00482 {
00483     N_gradient_neighbours_z *grad;
00484 
00485     grad =
00486         (N_gradient_neighbours_z *) G_calloc(1,
00487                                              sizeof(N_gradient_neighbours_z));
00488 
00489     return grad;
00490 }
00491 
00498 void N_free_gradient_neighbours_z(N_gradient_neighbours_z * grad)
00499 {
00500     G_free(grad);
00501     grad = NULL;
00502 
00503     return;
00504 }
00505 
00522 N_gradient_neighbours_z *N_create_gradient_neighbours_z(double NWZ, double NZ,
00523                                                         double NEZ, double WZ,
00524                                                         double CZ, double EZ,
00525                                                         double SWZ, double SZ,
00526                                                         double SEZ)
00527 {
00528     N_gradient_neighbours_z *grad;
00529 
00530     G_debug(6,
00531             "N_create_gradient_neighbours_z: create N_gradient_neighbours_z");
00532 
00533     grad = N_alloc_gradient_neighbours_z();
00534 
00535     grad->NWZ = NWZ;
00536     grad->NZ = NZ;
00537     grad->NEZ = NEZ;
00538     grad->WZ = WZ;
00539     grad->CZ = CZ;
00540     grad->EZ = EZ;
00541     grad->SWZ = SWZ;
00542     grad->SZ = SZ;
00543     grad->SEZ = SEZ;
00544 
00545     return grad;
00546 }
00547 
00556 int
00557 N_copy_gradient_neighbours_z(N_gradient_neighbours_z * source,
00558                              N_gradient_neighbours_z * target)
00559 {
00560     G_debug(6, "N_copy_gradient_neighbours_z: copy N_gradient_neighbours_z");
00561 
00562     if (!source || !target)
00563         return 0;
00564 
00565     target->NWZ = source->NWZ;
00566     target->NZ = source->NZ;
00567     target->NEZ = source->NEZ;
00568     target->WZ = source->WZ;
00569     target->CZ = source->CZ;
00570     target->EZ = source->EZ;
00571     target->SWZ = source->SWZ;
00572     target->SZ = source->SZ;
00573     target->SEZ = source->SEZ;
00574 
00575     return 1;
00576 }
00577 
00587 N_gradient_neighbours_2d *N_alloc_gradient_neighbours_2d(void)
00588 {
00589     N_gradient_neighbours_2d *grad;
00590 
00591     grad =
00592         (N_gradient_neighbours_2d *) G_calloc(1,
00593                                               sizeof
00594                                               (N_gradient_neighbours_2d));
00595 
00596     grad->x = N_alloc_gradient_neighbours_x();
00597     grad->y = N_alloc_gradient_neighbours_y();
00598 
00599     return grad;
00600 }
00601 
00608 void N_free_gradient_neighbours_2d(N_gradient_neighbours_2d * grad)
00609 {
00610 
00611     N_free_gradient_neighbours_x(grad->x);
00612     N_free_gradient_neighbours_y(grad->y);
00613 
00614     G_free(grad);
00615     grad = NULL;
00616 
00617     return;
00618 }
00619 
00629 N_gradient_neighbours_2d
00630     * N_create_gradient_neighbours_2d(N_gradient_neighbours_x * x,
00631                                       N_gradient_neighbours_y * y)
00632 {
00633     N_gradient_neighbours_2d *grad;
00634     int fail = 0;
00635 
00636     G_debug(5,
00637             "N_create_gradient_neighbours_2d: create N_gradient_neighbours_2d");
00638 
00639     grad = N_alloc_gradient_neighbours_2d();
00640 
00641     if (!N_copy_gradient_neighbours_x(x, grad->x))
00642         fail++;
00643     if (!N_copy_gradient_neighbours_y(y, grad->y))
00644         fail++;
00645 
00646     if (fail > 0) {
00647         N_free_gradient_neighbours_2d(grad);
00648         grad = NULL;
00649     }
00650 
00651     return grad;
00652 }
00653 
00662 int
00663 N_copy_gradient_neighbours_2d(N_gradient_neighbours_2d * source,
00664                               N_gradient_neighbours_2d * target)
00665 {
00666     int fail = 0;
00667 
00668     G_debug(5,
00669             "N_copy_gradient_neighbours_2d: copy N_gradient_neighbours_2d");
00670 
00671     if (!source || !target)
00672         return 0;
00673 
00674     if (!(N_copy_gradient_neighbours_x(source->x, target->x)))
00675         fail++;
00676     if (!(N_copy_gradient_neighbours_y(source->y, target->y)))
00677         fail++;
00678 
00679     if (fail > 0) {
00680         return 0;
00681     }
00682 
00683     return 1;
00684 }
00685 
00702 N_gradient_neighbours_2d *N_get_gradient_neighbours_2d(N_gradient_field_2d *
00703                                                        field,
00704                                                        N_gradient_neighbours_2d
00705                                                        * gradient, int col,
00706                                                        int row)
00707 {
00708     double NWN, NEN, WC, EC, SWS, SES;
00709     double NWW, NEE, NC, SC, SWW, SEE;
00710     N_gradient_neighbours_2d *grad = NULL;
00711     N_gradient_neighbours_x *grad_x = NULL;
00712     N_gradient_neighbours_y *grad_y = NULL;
00713 
00714 
00715     NWN = N_get_array_2d_d_value(field->x_array, col, row - 1);
00716     NEN = N_get_array_2d_d_value(field->x_array, col + 1, row - 1);
00717     WC = N_get_array_2d_d_value(field->x_array, col, row);
00718     EC = N_get_array_2d_d_value(field->x_array, col + 1, row);
00719     SWS = N_get_array_2d_d_value(field->x_array, col, row + 1);
00720     SES = N_get_array_2d_d_value(field->x_array, col + 1, row + 1);
00721 
00722     NWW = N_get_array_2d_d_value(field->y_array, col - 1, row);
00723     NEE = N_get_array_2d_d_value(field->y_array, col + 1, row);
00724     NC = N_get_array_2d_d_value(field->y_array, col, row);
00725     SC = N_get_array_2d_d_value(field->y_array, col, row + 1);
00726     SWW = N_get_array_2d_d_value(field->y_array, col - 1, row + 1);
00727     SEE = N_get_array_2d_d_value(field->y_array, col + 1, row + 1);
00728 
00729 
00730     grad_x = N_create_gradient_neighbours_x(NWN, NEN, WC, EC, SWS, SES);
00731     grad_y = N_create_gradient_neighbours_y(NWW, NEE, NC, SC, SWW, SEE);
00732 
00733     G_debug(5,
00734             "N_get_gradient_neighbours_2d: calculate N_gradient_neighbours_x NWN %g NEN %g WC %g EC %g SWS %g SES %g",
00735             NWN, NEN, WC, EC, SWS, SES);
00736 
00737     G_debug(5,
00738             "N_get_gradient_neighbours_2d: calculate N_gradient_neighbours_y NWW %g NEE %g NC %g SC %g SWW %g SEE %g",
00739             NWW, NEE, NC, SC, SWW, SEE);
00740 
00741 
00742     /*if gradient is a NULL pointer, create a new one */
00743     if (!gradient) {
00744         grad = N_create_gradient_neighbours_2d(grad_x, grad_y);
00745         gradient = grad;
00746     }
00747     else {
00748         grad = N_create_gradient_neighbours_2d(grad_x, grad_y);
00749         N_copy_gradient_neighbours_2d(grad, gradient);
00750         N_free_gradient_neighbours_2d(grad);
00751     }
00752 
00753     N_free_gradient_neighbours_x(grad_x);
00754     N_free_gradient_neighbours_y(grad_y);
00755 
00756     return gradient;
00757 }
00758 
00759 
00769 N_gradient_neighbours_3d *N_alloc_gradient_neighbours_3d(void)
00770 {
00771     N_gradient_neighbours_3d *grad;
00772 
00773     grad =
00774         (N_gradient_neighbours_3d *) G_calloc(1,
00775                                               sizeof
00776                                               (N_gradient_neighbours_3d));
00777 
00778     grad->xt = N_alloc_gradient_neighbours_x();
00779     grad->xc = N_alloc_gradient_neighbours_x();
00780     grad->xb = N_alloc_gradient_neighbours_x();
00781     grad->yt = N_alloc_gradient_neighbours_y();
00782     grad->yc = N_alloc_gradient_neighbours_y();
00783     grad->yb = N_alloc_gradient_neighbours_y();
00784     grad->zt = N_alloc_gradient_neighbours_z();
00785     grad->zb = N_alloc_gradient_neighbours_z();
00786 
00787     return grad;
00788 }
00789 
00796 void N_free_gradient_neighbours_3d(N_gradient_neighbours_3d * grad)
00797 {
00798 
00799     N_free_gradient_neighbours_x(grad->xt);
00800     N_free_gradient_neighbours_x(grad->xc);
00801     N_free_gradient_neighbours_x(grad->xb);
00802     N_free_gradient_neighbours_y(grad->yt);
00803     N_free_gradient_neighbours_y(grad->yc);
00804     N_free_gradient_neighbours_y(grad->yb);
00805     N_free_gradient_neighbours_z(grad->zt);
00806     N_free_gradient_neighbours_z(grad->zb);
00807 
00808     G_free(grad);
00809     grad = NULL;
00810 
00811     return;
00812 }
00813 
00824 N_gradient_neighbours_3d
00825     * N_create_gradient_neighbours_3d(N_gradient_neighbours_x * xt,
00826                                       N_gradient_neighbours_x * xc,
00827                                       N_gradient_neighbours_x * xb,
00828                                       N_gradient_neighbours_y * yt,
00829                                       N_gradient_neighbours_y * yc,
00830                                       N_gradient_neighbours_y * yb,
00831                                       N_gradient_neighbours_z * zt,
00832                                       N_gradient_neighbours_z * zb)
00833 {
00834     N_gradient_neighbours_3d *grad;
00835     int fail = 0;
00836 
00837     G_debug(5,
00838             "N_create_gradient_neighbours_3d: create N_gradient_neighbours_3d");
00839 
00840     grad = N_alloc_gradient_neighbours_3d();
00841 
00842     if (!(N_copy_gradient_neighbours_x(xt, grad->xt)))
00843         fail++;
00844     if (!(N_copy_gradient_neighbours_x(xc, grad->xc)))
00845         fail++;
00846     if (!(N_copy_gradient_neighbours_x(xb, grad->xb)))
00847         fail++;
00848     if (!(N_copy_gradient_neighbours_y(yt, grad->yt)))
00849         fail++;
00850     if (!(N_copy_gradient_neighbours_y(yc, grad->yc)))
00851         fail++;
00852     if (!(N_copy_gradient_neighbours_y(yb, grad->yb)))
00853         fail++;
00854     if (!(N_copy_gradient_neighbours_z(zt, grad->zt)))
00855         fail++;
00856     if (!(N_copy_gradient_neighbours_z(zb, grad->zb)))
00857         fail++;
00858 
00859     if (fail > 0) {
00860         return NULL;
00861     }
00862 
00863     return grad;
00864 }
00865 
00874 int
00875 N_copy_gradient_neighbours_3d(N_gradient_neighbours_3d * source,
00876                               N_gradient_neighbours_3d * target)
00877 {
00878     int fail = 0;
00879 
00880     G_debug(5,
00881             "N_copy_gradient_neighbours_3d: copy N_gradient_neighbours_3d");
00882 
00883     if (!source || !target)
00884         return 0;
00885 
00886     if (!(N_copy_gradient_neighbours_x(source->xt, target->xt)))
00887         fail++;
00888     if (!(N_copy_gradient_neighbours_x(source->xc, target->xc)))
00889         fail++;
00890     if (!(N_copy_gradient_neighbours_x(source->xb, target->xb)))
00891         fail++;
00892     if (!(N_copy_gradient_neighbours_y(source->yt, target->yt)))
00893         fail++;
00894     if (!(N_copy_gradient_neighbours_y(source->yc, target->yc)))
00895         fail++;
00896     if (!(N_copy_gradient_neighbours_y(source->yb, target->yb)))
00897         fail++;
00898     if (!(N_copy_gradient_neighbours_z(source->zt, target->zt)))
00899         fail++;
00900     if (!(N_copy_gradient_neighbours_z(source->zb, target->zb)))
00901         fail++;
00902 
00903     if (fail > 0) {
00904         return 0;
00905     }
00906 
00907     return 1;
00908 }
00909 
00920 N_gradient_field_2d *N_alloc_gradient_field_2d(int cols, int rows)
00921 {
00922     N_gradient_field_2d *field;
00923 
00924     G_debug(5,
00925             "N_alloc_gradient_field_2d: allocate a N_gradient_field_2d struct");
00926 
00927     field = (N_gradient_field_2d *) G_calloc(1, sizeof(N_gradient_field_2d));
00928 
00929     field->x_array = N_alloc_array_2d(cols, rows, 1, DCELL_TYPE);
00930     field->y_array = N_alloc_array_2d(cols, rows, 1, DCELL_TYPE);
00931 
00932     field->cols = cols;
00933     field->rows = rows;
00934 
00935     return field;
00936 }
00937 
00944 void N_free_gradient_field_2d(N_gradient_field_2d * field)
00945 {
00946 
00947     N_free_array_2d(field->x_array);
00948     N_free_array_2d(field->y_array);
00949 
00950     G_free(field);
00951 
00952     field = NULL;
00953 
00954     return;
00955 }
00956 
00965 int
00966 N_copy_gradient_field_2d(N_gradient_field_2d * source,
00967                          N_gradient_field_2d * target)
00968 {
00969     G_debug(3, "N_copy_gradient_field_2d: copy N_gradient_field_2d");
00970 
00971     if (!source || !target)
00972         return 0;
00973 
00974     N_copy_array_2d(source->x_array, target->x_array);
00975     N_copy_array_2d(source->y_array, target->y_array);
00976 
00977     return 1;
00978 }
00979 
00986 void N_print_gradient_field_2d_info(N_gradient_field_2d * field)
00987 {
00988     fprintf(stdout, "N_gradient_field_2d \n");
00989     fprintf(stdout, "Cols %i\n", field->cols);
00990     fprintf(stdout, "Rows: %i\n", field->rows);
00991     fprintf(stdout, "X array pointer: %p\n", field->x_array);
00992     fprintf(stdout, "Y array pointer: %p\n", field->y_array);
00993     fprintf(stdout, "Min %g\n", field->min);
00994     fprintf(stdout, "Max %g\n", field->max);
00995     fprintf(stdout, "Sum %g\n", field->sum);
00996     fprintf(stdout, "Mean %g\n", field->mean);
00997     fprintf(stdout, "Nonull %i\n", field->nonull);
00998     fprintf(stdout, "X array info \n");
00999     N_print_array_2d_info(field->x_array);
01000     fprintf(stdout, "Y array info \n");
01001     N_print_array_2d_info(field->y_array);
01002 
01003     return;
01004 }
01005 
01006 
01018 N_gradient_field_3d *N_alloc_gradient_field_3d(int cols, int rows, int depths)
01019 {
01020     N_gradient_field_3d *field;
01021 
01022     G_debug(5,
01023             "N_alloc_gradient_field_3d: allocate a N_gradient_field_3d struct");
01024 
01025     field = (N_gradient_field_3d *) G_calloc(1, sizeof(N_gradient_field_3d));
01026 
01027     field->x_array = N_alloc_array_3d(cols, rows, depths, 1, DCELL_TYPE);
01028     field->y_array = N_alloc_array_3d(cols, rows, depths, 1, DCELL_TYPE);
01029     field->z_array = N_alloc_array_3d(cols, rows, depths, 1, DCELL_TYPE);
01030 
01031     field->cols = cols;
01032     field->rows = rows;
01033     field->depths = depths;
01034 
01035     return field;
01036 }
01037 
01038 
01045 void N_free_gradient_field_3d(N_gradient_field_3d * field)
01046 {
01047 
01048     N_free_array_3d(field->x_array);
01049     N_free_array_3d(field->y_array);
01050     N_free_array_3d(field->z_array);
01051 
01052     G_free(field);
01053 
01054     field = NULL;
01055 
01056     return;
01057 }
01058 
01059 
01068 int
01069 N_copy_gradient_field_3d(N_gradient_field_3d * source,
01070                          N_gradient_field_3d * target)
01071 {
01072     G_debug(3, "N_copy_gradient_field_3d: copy N_gradient_field_3d");
01073 
01074     if (!source || !target)
01075         return 0;
01076 
01077     N_copy_array_3d(source->x_array, target->x_array);
01078     N_copy_array_3d(source->y_array, target->y_array);
01079     N_copy_array_3d(source->z_array, target->z_array);
01080 
01081     return 1;
01082 }
01083 
01090 void N_print_gradient_field_3d_info(N_gradient_field_3d * field)
01091 {
01092 
01093     fprintf(stdout, "N_gradient_field_3d \n");
01094     fprintf(stdout, "Cols %i\n", field->cols);
01095     fprintf(stdout, "Rows: %i\n", field->rows);
01096     fprintf(stdout, "Depths %i\n", field->depths);
01097     fprintf(stdout, "X array pointer: %p\n", field->x_array);
01098     fprintf(stdout, "Y array pointer: %p\n", field->y_array);
01099     fprintf(stdout, "Z array pointer: %p\n", field->z_array);
01100     fprintf(stdout, "Min %g\n", field->min);
01101     fprintf(stdout, "Max %g\n", field->max);
01102     fprintf(stdout, "Sum %g\n", field->sum);
01103     fprintf(stdout, "Mean %g\n", field->mean);
01104     fprintf(stdout, "Nonull %i\n", field->nonull);
01105     fprintf(stdout, "X array info \n");
01106     N_print_array_3d_info(field->x_array);
01107     fprintf(stdout, "Y array info \n");
01108     N_print_array_3d_info(field->y_array);
01109     fprintf(stdout, "Z array info \n");
01110     N_print_array_3d_info(field->z_array);
01111 
01112     return;
01113 }
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines