GRASS Programmer's Manual
6.4.2(2012)
|
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 }