GRASS 8 Programmer's Manual 8.6.0dev(2026)-1878fdfec5
Loading...
Searching...
No Matches
InterpSpline.c
Go to the documentation of this file.
1/***********************************************************************
2 *
3 * MODULE: lidarlib
4 *
5 * AUTHOR(S): Roberto Antolin
6 *
7 * PURPOSE: LIDAR Spline Interpolation
8 *
9 * SPDX-FileCopyrightText: 2006 Politecnico di Milano - Polo Regionale di Como
10 * SPDX-FileCopyrightText: GRASS Development Team
11 * SPDX-License-Identifier: GPL-2.0-or-later
12 *
13 **************************************************************************/
14
15#include <stdio.h>
16#include <stdlib.h>
17#include <float.h>
18#include <math.h>
19#include <string.h>
20#include <grass/lidar.h>
21
22/*----------------------------------------------------------------------------*/
23/* Abscissa node index computation */
24
25void node_x(double x, int *i_x, double *csi_x, double xMin, double deltaX)
26{
27
28 *i_x = (int)((x - xMin) / deltaX);
29 *csi_x = (double)((x - xMin) - (*i_x * deltaX));
30
31 return;
32}
33
34/*----------------------------------------------------------------------------*/
35/* Ordinate node index computation */
36
37void node_y(double y, int *i_y, double *csi_y, double yMin, double deltaY)
38{
39
40 *i_y = (int)((y - yMin) / deltaY);
41 *csi_y = (double)((y - yMin) - (*i_y * deltaY));
42
43 return;
44}
45
46/*----------------------------------------------------------------------------*/
47/* Node order computation */
48
49int order(int i_x, int i_y, int yNum)
50{
51
52 return (i_y + i_x * yNum);
53}
54
55/*----------------------------------------------------------------------------*/
56/* Design matrix coefficients computation */
57
58double phi_3(double csi)
59{
60
61 return ((pow(2 - csi, 3.) - pow(1 - csi, 3.) * 4) / 6.);
62}
63
64double phi_4(double csi)
65{
66
67 return (pow(2 - csi, 3.) / 6.);
68}
69
70double phi_33(double csi_x, double csi_y)
71{
72
73 return (phi_3(csi_x) * phi_3(csi_y));
74}
75
76double phi_34(double csi_x, double csi_y)
77{
78
79 return (phi_3(csi_x) * phi_4(csi_y));
80}
81
82double phi_43(double csi_x, double csi_y)
83{
84
85 return (phi_4(csi_x) * phi_3(csi_y));
86}
87
88double phi_44(double csi_x, double csi_y)
89{
90
91 return (phi_4(csi_x) * phi_4(csi_y));
92}
93
94double phi(double csi_x, double csi_y)
95{
96
97 return ((1 - csi_x) * (1 - csi_y));
98}
99
100/*----------------------------------------------------------------------------*/
101/* Normal system computation for bicubic spline interpolation */
102
103void normalDefBicubic(double **N, double *TN, double *Q, double **obsVect,
104 double deltaX, double deltaY, int xNum, int yNum,
105 double xMin, double yMin, int obsNum, int parNum, int BW)
106{
107
108 int i, k, h, m, n, n0; /* counters */
109 double alpha[4][4]; /* coefficients */
110
111 int i_x; /* x = (xMin + (i_x * deltaX) + csi_x) */
112 double csi_x;
113
114 int i_y; /* y = (yMin + (i_y * deltaY) + csi_y) */
115 double csi_y;
116
117 /*--------------------------------------*/
118 for (k = 0; k < parNum; k++) {
119 for (h = 0; h < BW; h++)
120 N[k][h] = 0.; /* Normal matrix inizialization */
121 TN[k] = 0.; /* Normal vector inizialization */
122 }
123
124 /*--------------------------------------*/
125
126 for (i = 0; i < obsNum; i++) {
127
128 node_x(obsVect[i][0], &i_x, &csi_x, xMin, deltaX);
129 node_y(obsVect[i][1], &i_y, &csi_y, yMin, deltaY);
130
131 if ((i_x >= -2) && (i_x <= xNum) && (i_y >= -2) && (i_y <= yNum)) {
132
133 csi_x = csi_x / deltaX;
134 csi_y = csi_y / deltaY;
135
136 alpha[0][0] = phi_44(1 + csi_x, 1 + csi_y);
137 alpha[0][1] = phi_43(1 + csi_x, csi_y);
138 alpha[0][2] = phi_43(1 + csi_x, 1 - csi_y);
139 alpha[0][3] = phi_44(1 + csi_x, 2 - csi_y);
140
141 alpha[1][0] = phi_34(csi_x, 1 + csi_y);
142 alpha[1][1] = phi_33(csi_x, csi_y);
143 alpha[1][2] = phi_33(csi_x, 1 - csi_y);
144 alpha[1][3] = phi_34(csi_x, 2 - csi_y);
145
146 alpha[2][0] = phi_34(1 - csi_x, 1 + csi_y);
147 alpha[2][1] = phi_33(1 - csi_x, csi_y);
148 alpha[2][2] = phi_33(1 - csi_x, 1 - csi_y);
149 alpha[2][3] = phi_34(1 - csi_x, 2 - csi_y);
150
151 alpha[3][0] = phi_44(2 - csi_x, 1 + csi_y);
152 alpha[3][1] = phi_43(2 - csi_x, csi_y);
153 alpha[3][2] = phi_43(2 - csi_x, 1 - csi_y);
154 alpha[3][3] = phi_44(2 - csi_x, 2 - csi_y);
155
156 for (k = -1; k <= 2; k++) {
157 for (h = -1; h <= 2; h++) {
158
159 if (((i_x + k) >= 0) && ((i_x + k) < xNum) &&
160 ((i_y + h) >= 0) && ((i_y + h) < yNum)) {
161 for (m = k; m <= 2; m++) {
162
163 if (m == k)
164 n0 = h;
165 else
166 n0 = -1;
167
168 for (n = n0; n <= 2; n++) {
169 if (((i_x + m) >= 0) && ((i_x + m) < xNum) &&
170 ((i_y + n) >= 0) && ((i_y + n) < yNum)) {
171 N[order(i_x + k, i_y + h, yNum)]
172 [order(i_x + m, i_y + n, yNum) -
173 order(i_x + k, i_y + h, yNum)] +=
174 alpha[k + 1][h + 1] * (1 / Q[i]) *
175 alpha[m + 1][n + 1];
176 /* 1/Q[i] only refers to the variances */
177 }
178 }
179 }
180 TN[order(i_x + k, i_y + h, yNum)] +=
181 obsVect[i][2] * (1 / Q[i]) * alpha[k + 1][h + 1];
182 }
183 }
184 }
185 }
186 }
187
188 return;
189}
190
191/*----------------------------------------------------------------------------*/
192/* Normal system correction - Introduzione della correzione dovuta alle
193 pseudosservazioni (Tykonov) - LAPALCIANO - */
194
195void nCorrectLapl(double **N, double lambda, int xNum, int yNum, double deltaX,
196 double deltaY)
197{
198
199 int i_x, i_y; /* counters */
200 int k, h, m, n, n0; /* counters */
201
202 double alpha[5][5]; /* coefficients */
203
204 double lambdaX, lambdaY;
205
206 /*--------------------------------------*/
207 lambdaX = lambda * (deltaY / deltaX);
208 lambdaY = lambda * (deltaX / deltaY);
209
210 alpha[0][0] = 0;
211 alpha[0][1] =
212 lambdaX *
213 (1 / 36.); /* There is lambda because Q^(-1) contains 1/(1/lambda) */
214 alpha[0][2] = lambdaX * (1 / 9.);
215 alpha[0][3] = lambdaX * (1 / 36.);
216 alpha[0][4] = 0;
217
218 alpha[1][0] = lambdaY * (1 / 36.);
219 alpha[1][1] = lambdaX * (1 / 18.) + lambdaY * (1 / 18.);
220 alpha[1][2] = lambdaX * (2 / 9.) - lambdaY * (1 / 6.);
221 alpha[1][3] = lambdaX * (1 / 18.) + lambdaY * (1 / 18.);
222 alpha[1][4] = lambdaY * (1 / 36.);
223
224 alpha[2][0] = lambdaY * (1 / 9.);
225 alpha[2][1] = -lambdaX * (1 / 6.) + lambdaY * (2 / 9.);
226 alpha[2][2] = -lambdaX * (2 / 3.) - lambdaY * (2 / 3.);
227 alpha[2][3] = -lambdaX * (1 / 6.) + lambdaY * (2 / 9.);
228 alpha[2][4] = lambdaY * (1 / 9.);
229
230 alpha[3][0] = lambdaY * (1 / 36.);
231 alpha[3][1] = lambdaX * (1 / 18.) + lambdaY * (1 / 18.);
232 alpha[3][2] = lambdaX * (2 / 9.) - lambdaY * (1 / 6.);
233 alpha[3][3] = lambdaX * (1 / 18.) + lambdaY * (1 / 18.);
234 alpha[3][4] = lambdaY * (1 / 36.);
235
236 alpha[4][0] = 0;
237 alpha[4][1] = lambdaX * (1 / 36.);
238 alpha[4][2] = lambdaX * (1 / 9.);
239 alpha[4][3] = lambdaX * (1 / 36.);
240 alpha[4][4] = 0;
241
242 for (i_x = 0; i_x < xNum; i_x++) {
243 for (i_y = 0; i_y < yNum; i_y++) {
244
245 for (k = -2; k <= 2; k++) {
246 for (h = -2; h <= 2; h++) {
247
248 if (((i_x + k) >= 0) && ((i_x + k) < xNum) &&
249 ((i_y + h) >= 0) && ((i_y + h) < yNum)) {
250
251 for (m = k; m <= 2; m++) {
252
253 if (m == k)
254 n0 = h;
255 else
256 n0 = -2;
257
258 for (n = n0; n <= 2; n++) {
259 if (((i_x + m) >= 0) &&
260 ((i_x + m) <= (xNum - 1)) &&
261 ((i_y + n) >= 0) &&
262 ((i_y + n) <= (yNum - 1))) {
263
264 if ((alpha[k + 2][h + 2] != 0) &&
265 (alpha[m + 2][n + 2] != 0)) {
266 N[order(i_x + k, i_y + h, yNum)]
267 [order(i_x + m, i_y + n, yNum) -
268 order(i_x + k, i_y + h, yNum)] +=
269 alpha[k + 2][h + 2] *
270 alpha[m + 2][n + 2];
271 }
272 }
273 }
274 }
275 }
276 }
277 }
278 }
279 }
280
281 return;
282}
283
284/*----------------------------------------------------------------------------*/
285/* Normal system computation for bilinear spline interpolation */
286
287void normalDefBilin(double **N, double *TN, double *Q, double **obsVect,
288 double deltaX, double deltaY, int xNum, int yNum,
289 double xMin, double yMin, int obsNum, int parNum, int BW)
290{
291
292 int i, k, h, m, n, n0; /* counters */
293 double alpha[2][2]; /* coefficients */
294
295 int i_x; /* x = (xMin + (i_x * deltaX) + csi_x) */
296 double csi_x;
297
298 int i_y; /* y = (yMin + (i_y * deltaY) + csi_y) */
299 double csi_y;
300
301 /*--------------------------------------*/
302 for (k = 0; k < parNum; k++) {
303 for (h = 0; h < BW; h++)
304 N[k][h] = 0.; /* Normal matrix inizialization */
305 TN[k] = 0.; /* Normal vector inizialization */
306 }
307
308 /*--------------------------------------*/
309
310 for (i = 0; i < obsNum; i++) {
311
312 node_x(obsVect[i][0], &i_x, &csi_x, xMin, deltaX);
313 node_y(obsVect[i][1], &i_y, &csi_y, yMin, deltaY);
314
315 if ((i_x >= -1) && (i_x < xNum) && (i_y >= -1) && (i_y < yNum)) {
316
317 csi_x = csi_x / deltaX;
318 csi_y = csi_y / deltaY;
319
320 alpha[0][0] = phi(csi_x, csi_y);
321 alpha[0][1] = phi(csi_x, 1 - csi_y);
322 alpha[1][0] = phi(1 - csi_x, csi_y);
323 alpha[1][1] = phi(1 - csi_x, 1 - csi_y);
324
325 for (k = 0; k <= 1; k++) {
326 for (h = 0; h <= 1; h++) {
327
328 if (((i_x + k) >= 0) && ((i_x + k) <= (xNum - 1)) &&
329 ((i_y + h) >= 0) && ((i_y + h) <= (yNum - 1))) {
330
331 for (m = k; m <= 1; m++) {
332 if (m == k)
333 n0 = h;
334 else
335 n0 = 0;
336
337 for (n = n0; n <= 1; n++) {
338 if (((i_x + m) >= 0) && ((i_x + m) < xNum) &&
339 ((i_y + n) >= 0) && ((i_y + n) < yNum)) {
340 N[order(i_x + k, i_y + h, yNum)]
341 [order(i_x + m, i_y + n, yNum) -
342 order(i_x + k, i_y + h, yNum)] +=
343 alpha[k][h] * (1 / Q[i]) * alpha[m][n];
344 /* 1/Q[i] only refers to the variances */
345 }
346 }
347 }
348 TN[order(i_x + k, i_y + h, yNum)] +=
349 obsVect[i][2] * (1 / Q[i]) * alpha[k][h];
350 }
351 }
352 }
353 }
354 }
355
356 return;
357}
358
359/*----------------------------------------------------------------------------*/
360/* Normal system correction - Introduzione della correzione dovuta alle
361 pseudosservazioni (Tykonov) - GRADIENTE - */
362#ifdef notdef
363void nCorrectGrad(double **N, double lambda, int xNum, int yNum, double deltaX,
364 double deltaY)
365{
366
367 int i;
368 int parNum;
369
370 double alpha[3];
371 double lambdaX, lambdaY;
372
373 lambdaX = lambda * (deltaY / deltaX);
374 lambdaY = lambda * (deltaX / deltaY);
375
376 parNum = xNum * yNum;
377
378 alpha[0] = lambdaX / 2. + lambdaY / 2.;
379 alpha[1] = -lambdaX / 4.;
380 alpha[2] = -lambdaY / 4.;
381
382 for (i = 0; i < parNum; i++) {
383 N[i][0] += alpha[0];
384
385 if ((i + 2) < parNum)
386 N[i][2] += alpha[2];
387
388 if ((i + 2 * yNum) < parNum)
389 N[i][2 * yNum] += alpha[1];
390 }
391}
392#endif
393
394/*1-DELTA discretization */
395void nCorrectGrad(double **N, double lambda, int xNum, int yNum, double deltaX,
396 double deltaY)
397{
398
399 int i;
400 int parNum;
401
402 double alpha[3];
403 double lambdaX, lambdaY;
404
405 lambdaX = lambda * (deltaY / deltaX);
406 lambdaY = lambda * (deltaX / deltaY);
407
408 parNum = xNum * yNum;
409
410 alpha[0] = 2 * lambdaX + 2 * lambdaY;
411 alpha[1] = -lambdaX;
412 alpha[2] = -lambdaY;
413
414 for (i = 0; i < parNum; i++) {
415 N[i][0] += alpha[0];
416
417 if ((i + 1) < parNum)
418 N[i][1] += alpha[2];
419
420 if ((i + 1 * yNum) < parNum)
421 N[i][1 * yNum] += alpha[1];
422 }
423
424 return;
425}
426
427/*----------------------------------------------------------------------------*/
428/* Observations estimation */
429
430void obsEstimateBicubic(double **obsV, double *obsE, double *parV, double deltX,
431 double deltY, int xNm, int yNm, double xMi, double yMi,
432 int obsN)
433{
434
435 int i, k, h; /* counters */
436 double alpha[4][4]; /* coefficients */
437
438 int i_x; /* x = (xMin + (i_x * deltaX) + csi_x) */
439 double csi_x;
440
441 int i_y; /* y = (yMin + (i_y * deltaY) + csi_y) */
442 double csi_y;
443
444 for (i = 0; i < obsN; i++) {
445
446 obsE[i] = 0;
447
448 node_x(obsV[i][0], &i_x, &csi_x, xMi, deltX);
449 node_y(obsV[i][1], &i_y, &csi_y, yMi, deltY);
450
451 if ((i_x >= -2) && (i_x <= xNm) && (i_y >= -2) && (i_y <= yNm)) {
452
453 csi_x = csi_x / deltX;
454 csi_y = csi_y / deltY;
455
456 alpha[0][0] = phi_44(1 + csi_x, 1 + csi_y);
457 alpha[0][1] = phi_43(1 + csi_x, csi_y);
458 alpha[0][2] = phi_43(1 + csi_x, 1 - csi_y);
459 alpha[0][3] = phi_44(1 + csi_x, 2 - csi_y);
460
461 alpha[1][0] = phi_34(csi_x, 1 + csi_y);
462 alpha[1][1] = phi_33(csi_x, csi_y);
463 alpha[1][2] = phi_33(csi_x, 1 - csi_y);
464 alpha[1][3] = phi_34(csi_x, 2 - csi_y);
465
466 alpha[2][0] = phi_34(1 - csi_x, 1 + csi_y);
467 alpha[2][1] = phi_33(1 - csi_x, csi_y);
468 alpha[2][2] = phi_33(1 - csi_x, 1 - csi_y);
469 alpha[2][3] = phi_34(1 - csi_x, 2 - csi_y);
470
471 alpha[3][0] = phi_44(2 - csi_x, 1 + csi_y);
472 alpha[3][1] = phi_43(2 - csi_x, csi_y);
473 alpha[3][2] = phi_43(2 - csi_x, 1 - csi_y);
474 alpha[3][3] = phi_44(2 - csi_x, 2 - csi_y);
475
476 for (k = -1; k <= 2; k++) {
477 for (h = -1; h <= 2; h++) {
478 if (((i_x + k) >= 0) && ((i_x + k) < xNm) &&
479 ((i_y + h) >= 0) && ((i_y + h) < yNm))
480 obsE[i] += parV[order(i_x + k, i_y + h, yNm)] *
481 alpha[k + 1][h + 1];
482 }
483 }
484 }
485 }
486
487 return;
488}
489
490/*--------------------------------------------------------------------------------------*/
491/* Data interpolation in a generic point */
492
493double dataInterpolateBicubic(double x, double y, double deltaX, double deltaY,
494 int xNum, int yNum, double xMin, double yMin,
495 double *parVect)
496{
497
498 double z; /* abscissa, ordinate and associated value */
499
500 int k, h; /* counters */
501 double alpha[4][4]; /* coefficients */
502
503 int i_x, i_y; /* x = (xMin + (i_x * deltaX) + csi_x) */
504 double csi_x, csi_y; /* y = (yMin + (i_y * deltaY) + csi_y) */
505
506 z = 0;
507
508 node_x(x, &i_x, &csi_x, xMin, deltaX);
509 node_y(y, &i_y, &csi_y, yMin, deltaY);
510
511 if ((i_x >= -2) && (i_x <= xNum) && (i_y >= -2) && (i_y <= yNum)) {
512
513 csi_x = csi_x / deltaX;
514 csi_y = csi_y / deltaY;
515
516 alpha[0][0] = phi_44(1 + csi_x, 1 + csi_y);
517 alpha[0][1] = phi_43(1 + csi_x, csi_y);
518 alpha[0][2] = phi_43(1 + csi_x, 1 - csi_y);
519 alpha[0][3] = phi_44(1 + csi_x, 2 - csi_y);
520
521 alpha[1][0] = phi_34(csi_x, 1 + csi_y);
522 alpha[1][1] = phi_33(csi_x, csi_y);
523 alpha[1][2] = phi_33(csi_x, 1 - csi_y);
524 alpha[1][3] = phi_34(csi_x, 2 - csi_y);
525
526 alpha[2][0] = phi_34(1 - csi_x, 1 + csi_y);
527 alpha[2][1] = phi_33(1 - csi_x, csi_y);
528 alpha[2][2] = phi_33(1 - csi_x, 1 - csi_y);
529 alpha[2][3] = phi_34(1 - csi_x, 2 - csi_y);
530
531 alpha[3][0] = phi_44(2 - csi_x, 1 + csi_y);
532 alpha[3][1] = phi_43(2 - csi_x, csi_y);
533 alpha[3][2] = phi_43(2 - csi_x, 1 - csi_y);
534 alpha[3][3] = phi_44(2 - csi_x, 2 - csi_y);
535
536 for (k = -1; k <= 2; k++) {
537 for (h = -1; h <= 2; h++) {
538 if (((i_x + k) >= 0) && ((i_x + k) < xNum) &&
539 ((i_y + h) >= 0) && ((i_y + h) < yNum))
540 z += parVect[order(i_x + k, i_y + h, yNum)] *
541 alpha[k + 1][h + 1];
542 }
543 }
544 }
545
546 return z;
547}
548
549/*----------------------------------------------------------------------------*/
550/* Observations estimation */
551
552void obsEstimateBilin(double **obsV, double *obsE, double *parV, double deltX,
553 double deltY, int xNm, int yNm, double xMi, double yMi,
554 int obsN)
555{
556
557 int i, k, h; /* counters */
558 double alpha[2][2]; /* coefficients */
559
560 int i_x; /* x = (xMin + (i_x * deltaX) + csi_x) */
561 double csi_x;
562
563 int i_y; /* y = (yMin + (i_y * deltaY) + csi_y) */
564 double csi_y;
565
566 for (i = 0; i < obsN; i++) {
567
568 obsE[i] = 0;
569
570 node_x(obsV[i][0], &i_x, &csi_x, xMi, deltX);
571 node_y(obsV[i][1], &i_y, &csi_y, yMi, deltY);
572
573 if ((i_x >= -1) && (i_x < xNm) && (i_y >= -1) && (i_y < yNm)) {
574
575 csi_x = csi_x / deltX;
576 csi_y = csi_y / deltY;
577
578 alpha[0][0] = phi(csi_x, csi_y);
579 alpha[0][1] = phi(csi_x, 1 - csi_y);
580 alpha[1][0] = phi(1 - csi_x, csi_y);
581 alpha[1][1] = phi(1 - csi_x, 1 - csi_y);
582
583 for (k = 0; k <= 1; k++) {
584 for (h = 0; h <= 1; h++) {
585 if (((i_x + k) >= 0) && ((i_x + k) < xNm) &&
586 ((i_y + h) >= 0) && ((i_y + h) < yNm))
587 obsE[i] +=
588 parV[order(i_x + k, i_y + h, yNm)] * alpha[k][h];
589 }
590 }
591 }
592 }
593
594 return;
595}
596
597/*--------------------------------------------------------------------------------------*/
598/* Data interpolation in a generic point */
599
600double dataInterpolateBilin(double x, double y, double deltaX, double deltaY,
601 int xNum, int yNum, double xMin, double yMin,
602 double *parVect)
603{
604
605 double z; /* abscissa, ordinate and associated value */
606
607 int k, h; /* counters */
608 double alpha[2][2]; /* coefficients */
609
610 int i_x, i_y; /* x = (xMin + (i_x * deltaX) + csi_x) */
611 double csi_x, csi_y; /* y = (yMin + (i_y * deltaY) + csi_y) */
612
613 z = 0;
614
615 node_x(x, &i_x, &csi_x, xMin, deltaX);
616 node_y(y, &i_y, &csi_y, yMin, deltaY);
617
618 if ((i_x >= -1) && (i_x < xNum) && (i_y >= -1) && (i_y < yNum)) {
619
620 csi_x = csi_x / deltaX;
621 csi_y = csi_y / deltaY;
622
623 alpha[0][0] = phi(csi_x, csi_y);
624 alpha[0][1] = phi(csi_x, 1 - csi_y);
625
626 alpha[1][0] = phi(1 - csi_x, csi_y);
627 alpha[1][1] = phi(1 - csi_x, 1 - csi_y);
628
629 for (k = 0; k <= 1; k++) {
630 for (h = 0; h <= 1; h++) {
631 if (((i_x + k) >= 0) && ((i_x + k) < xNum) &&
632 ((i_y + h) >= 0) && ((i_y + h) < yNum))
633 z += parVect[order(i_x + k, i_y + h, yNum)] * alpha[k][h];
634 }
635 }
636 }
637
638 return z;
639}
phi_44
double phi_44(double csi_x, double csi_y)
Definition InterpSpline.c:88
phi_4
double phi_4(double csi)
Definition InterpSpline.c:64
dataInterpolateBicubic
double dataInterpolateBicubic(double x, double y, double deltaX, double deltaY, int xNum, int yNum, double xMin, double yMin, double *parVect)
Definition InterpSpline.c:493
order
int order(int i_x, int i_y, int yNum)
Definition InterpSpline.c:49
phi_43
double phi_43(double csi_x, double csi_y)
Definition InterpSpline.c:82
phi_33
double phi_33(double csi_x, double csi_y)
Definition InterpSpline.c:70
normalDefBicubic
void normalDefBicubic(double **N, double *TN, double *Q, double **obsVect, double deltaX, double deltaY, int xNum, int yNum, double xMin, double yMin, int obsNum, int parNum, int BW)
Definition InterpSpline.c:103
normalDefBilin
void normalDefBilin(double **N, double *TN, double *Q, double **obsVect, double deltaX, double deltaY, int xNum, int yNum, double xMin, double yMin, int obsNum, int parNum, int BW)
Definition InterpSpline.c:287
node_y
void node_y(double y, int *i_y, double *csi_y, double yMin, double deltaY)
Definition InterpSpline.c:37
obsEstimateBilin
void obsEstimateBilin(double **obsV, double *obsE, double *parV, double deltX, double deltY, int xNm, int yNm, double xMi, double yMi, int obsN)
Definition InterpSpline.c:552
phi_34
double phi_34(double csi_x, double csi_y)
Definition InterpSpline.c:76
phi_3
double phi_3(double csi)
Definition InterpSpline.c:58
dataInterpolateBilin
double dataInterpolateBilin(double x, double y, double deltaX, double deltaY, int xNum, int yNum, double xMin, double yMin, double *parVect)
Definition InterpSpline.c:600
nCorrectGrad
void nCorrectGrad(double **N, double lambda, int xNum, int yNum, double deltaX, double deltaY)
Definition InterpSpline.c:395
node_x
void node_x(double x, int *i_x, double *csi_x, double xMin, double deltaX)
Definition InterpSpline.c:25
phi
double phi(double csi_x, double csi_y)
Definition InterpSpline.c:94
obsEstimateBicubic
void obsEstimateBicubic(double **obsV, double *obsE, double *parV, double deltX, double deltY, int xNm, int yNm, double xMi, double yMi, int obsN)
Definition InterpSpline.c:430
nCorrectLapl
void nCorrectLapl(double **N, double lambda, int xNum, int yNum, double deltaX, double deltaY)
Definition InterpSpline.c:195
AMI_STREAM
Definition ami_stream.h:153
N
#define N
Definition e_intersect.c:924
x
#define x