OpendTect  6.6
interpol3d.h
Go to the documentation of this file.
1 #pragma once
2 
3 /*
4 ________________________________________________________________________
5 
6  (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
7  Author: Bert
8  Date: Mar 2006
9  RCS: $Id$
10 ________________________________________________________________________
11 
12 */
13 
14 #include "undefval.h"
15 
16 
17 namespace Interpolate
18 {
19 
24 template <class T>
25 mClass(Algo) LinearReg3D
26 {
27 public:
28 
29 LinearReg3D() {}
30 
31 LinearReg3D( const T* const* const* v )
32 {
33  set( v[0][0][0], v[1][0][0], v[0][1][0], v[1][1][0],
34  v[0][0][1], v[1][0][1], v[0][1][1], v[1][1][1] );
35 }
36 
37 LinearReg3D( T v000, T v100, T v010, T v110, T v001, T v101, T v011, T v111 )
38 {
39  set( v000, v100, v010, v110, v001, v101, v011, v111 );
40 }
41 
42 inline void set( T v000, T v100, T v010, T v110, T v001, T v101, T v011, T v111)
43 {
44  a_[0] = v000;
45  a_[1] = v100 - v000;
46  a_[2] = v010 - v000;
47  a_[3] = v001 - v000;
48  a_[4] = v110 + v000 - v100 - v010;
49  a_[5] = v101 + v000 - v100 - v001;
50  a_[6] = v011 + v000 - v010 - v001;
51  a_[7] = v111 + v100 + v010 + v001 - (v000 + v110 + v101 + v011);
52 }
53 
54 inline T apply( float x, float y, float z ) const
55 {
56  return a_[0] + a_[1] * x + a_[2] * y + a_[3] * z
57  + a_[4] * x * y + a_[5] * x * z + a_[6] * y * z
58  + a_[7] * x * y * z;
59 }
60 
61  T a_[8];
62 
63 };
64 
65 
66 template <class T>
67 inline T linearReg3D( T v000, T v100, T v010, T v110,
68  T v001, T v101, T v011, T v111,
69  float x, float y, float z )
70 {
71  return LinearReg3D<T>( v000, v100, v010, v110, v001, v101, v011, v111 )
72  .apply( x, y, z );
73 }
74 
75 
80 template <class T>
81 mClass(Algo) LinearReg3DWithUdf
82 {
83 public:
84 
85 LinearReg3DWithUdf() {}
86 
87 LinearReg3DWithUdf( const T* const* const* v )
88 {
89  set( v[0][0][0], v[1][0][0], v[0][1][0], v[1][1][0],
90  v[0][0][1], v[1][0][1], v[0][1][1], v[1][1][1] );
91 }
92 
93 LinearReg3DWithUdf( T v000, T v100, T v010, T v110,
94  T v001, T v101, T v011, T v111 )
95 {
96  set( v000, v100, v010, v110, v001, v101, v011, v111 );
97 }
98 
99 inline static T getReplVal( T v1, T v2, T v3, bool u1, bool u2, bool u3 )
100 {
101 
102  if ( u1 )
103  return u2 ? v3 : (u3 ? v2 : (v2 + v3) / 2);
104  else if ( u2 )
105  return u3 ? v1 : (v1 + v3) / 2;
106  else if ( u3 )
107  return (v1 + v2) / 2;
108 
109  return (v1 + v2 + v3) / 3;
110 }
111 
112 inline void set( T v000, T v100, T v010, T v110, T v001, T v101, T v011, T v111)
113 {
114  u000_ = mIsUdf(v000);
115  u100_ = mIsUdf(v100);
116  u010_ = mIsUdf(v010);
117  u110_ = mIsUdf(v110);
118  u001_ = mIsUdf(v001);
119  u101_ = mIsUdf(v101);
120  u011_ = mIsUdf(v011);
121  u111_ = mIsUdf(v111);
122  haveudf_ = u000_ || u100_ || u010_ || u110_
123  || u001_ || u101_ || u011_ || u111_;
124 
125  if ( haveudf_ )
126  {
127 # define mFillIfUdf(nd,nearx,neary,nearz,diagxy,diagxz,diagyz,opp) \
128  if ( u##nd##_ ) \
129  { \
130  if ( !u##nearx##_ || !u##neary##_ || !u##nearz##_ ) \
131  v##nd = getReplVal( v##nearx, v##neary, v##nearz, \
132  u##nearx##_, u##neary##_, u##nearz##_ ); \
133  else \
134  { \
135  if ( u##diagxy##_ && u##diagxz##_ && u##diagyz##_ ) \
136  v##nd = v##opp; \
137  else \
138  v##nd = getReplVal( v##diagxy, v##diagxz, v##diagyz, \
139  u##diagxy##_, u##diagxz##_, u##diagyz##_ ); \
140  } \
141  }
142 
143  mFillIfUdf(000,100,010,001,110,101,011,111)
144  mFillIfUdf(100,000,110,101,010,001,111,011)
145  mFillIfUdf(010,110,000,011,100,111,001,101)
146  mFillIfUdf(110,010,100,111,000,011,101,001)
147  mFillIfUdf(001,101,011,000,111,100,010,110)
148  mFillIfUdf(101,001,111,100,011,000,110,010)
149  mFillIfUdf(011,111,001,010,101,110,000,100)
150  mFillIfUdf(111,011,101,110,001,010,100,000)
151 
152 # undef mFillIfUdf
153  }
154 
155  intp_.set( v000, v100, v010, v110, v001, v101, v011, v111 );
156 }
157 
158 inline T apply( float x, float y, float z ) const
159 {
160  // return undef if the nearest node is undef
161  if ( haveudf_ && (
162  ( u000_ && x < 0.5 && y < 0.5 && z < 0.5 )
163  || ( u100_ && x >= 0.5 && y < 0.5 && z < 0.5 )
164  || ( u010_ && x < 0.5 && y >= 0.5 && z < 0.5 )
165  || ( u110_ && x >= 0.5 && y >= 0.5 && z < 0.5 )
166  || ( u001_ && x < 0.5 && y < 0.5 && z >= 0.5 )
167  || ( u101_ && x >= 0.5 && y < 0.5 && z >= 0.5 )
168  || ( u011_ && x < 0.5 && y >= 0.5 && z >= 0.5 )
169  || ( u111_ && x >= 0.5 && y >= 0.5 && z >= 0.5 ) ) )
170  return mUdf(T);
171 
172  return intp_.apply( x, y, z );
173 }
174 
175  LinearReg3D<T> intp_;
176  bool haveudf_;
177  bool u000_;
178  bool u100_;
179  bool u010_;
180  bool u110_;
181  bool u001_;
182  bool u101_;
183  bool u011_;
184  bool u111_;
185 
186 };
187 
188 template <class T>
189 inline T linearReg3DWithUdf( T v000, T v100, T v010, T v110,
190  T v001, T v101, T v011, T v111,
191  float x, float y, float z )
192 {
193  return LinearReg3DWithUdf<T>(v000,v100,v010,v110,v001,v101,v011,v111)
194  .apply( x, y, z );
195 }
196 
197 
198 
217 template <class T>
218 mClass(Algo) PolyReg3D
219 {
220 public:
221 
222 PolyReg3D() {}
223 
224 PolyReg3D( const T* const* const * v )
225 {
226  set( v[0][1][1], v[0][1][2], v[0][2][1], v[0][2][2],
227  v[1][0][1], v[1][0][2], v[1][1][0], v[1][1][1],
228  v[1][1][2], v[1][1][3], v[1][2][0], v[1][2][1],
229  v[1][2][2], v[1][2][3], v[1][3][1], v[1][3][2],
230  v[2][0][1], v[2][0][2], v[2][1][0], v[2][1][1],
231  v[2][1][2], v[2][1][3], v[2][2][0], v[2][2][1],
232  v[2][2][2], v[2][2][3], v[2][3][1], v[2][3][2],
233  v[3][1][1], v[3][1][2], v[3][2][1], v[3][2][2] );
234 }
235 
236 PolyReg3D(
237  T vm100, T vm101, T vm110, T vm111,
238  T v0m10, T v0m11, T v00m1, T v000,
239  T v001, T v002, T v01m1, T v010,
240  T v011, T v012, T v020, T v021,
241  T v1m10, T v1m11, T v10m1, T v100,
242  T v101, T v102, T v11m1, T v110,
243  T v111, T v112, T v120, T v121,
244  T v200, T v201, T v210, T v211 )
245 {
246  set( vm100, vm101, vm110, vm111,
247  v0m10, v0m11, v00m1, v000,
248  v001, v002, v01m1, v010,
249  v011, v012, v020, v021,
250  v1m10, v1m11, v10m1, v100,
251  v101, v102, v11m1, v110,
252  v111, v112, v120, v121,
253  v200, v201, v210, v211 );
254 }
255 
256 inline void set(
257  T vm100, T vm101, T vm110, T vm111,
258  T v0m10, T v0m11, T v00m1, T v000,
259  T v001, T v002, T v01m1, T v010,
260  T v011, T v012, T v020, T v021,
261  T v1m10, T v1m11, T v10m1, T v100,
262  T v101, T v102, T v11m1, T v110,
263  T v111, T v112, T v120, T v121,
264  T v200, T v201, T v210, T v211 )
265 {
266  set( v000, v100, v010, v110, v001, v101, v011, v111,
267  (v00m1 + v01m1 + v10m1 + v11m1) / 4,
268  (v0m10 + v0m11 + v1m10 + v1m11) / 4,
269  (vm100 + vm101 + vm110 + vm111) / 4,
270  (v002 + v012 + v102 + v112) / 4,
271  (v020 + v021 + v120 + v121) / 4,
272  (v200 + v201 + v210 + v211) / 4 );
273 }
274 
275 inline void set( T v000, T v100, T v010, T v110, T v001, T v101, T v011, T v111,
276  T vxym1, T vxzm1, T vyzm1, T vxy1, T vxz1, T vyz1 )
277 {
278  // TODO
279 }
280 
281 inline T apply( float x, float y, float z ) const
282 {
283  return a_[0] + a_[1] * x + a_[2] * y + a_[3] * z
284  + a_[4] * x * y + a_[5] * x * z + a_[6] * y * z
285  + a_[7] * x * y * z
286  + a_[8] * x * x * y + a_[9] * x * x * z
287  + a_[10] * y * y * x + a_[11] * y * y * z
288  + a_[12] * z * z * x + a_[13] * z * z * y;
289 }
290 
291  T a_[14];
292 
293 };
294 
295 
296 template <class T>
297 inline T polyReg3D( const T* const* const * v, float x, float y, float z )
298 {
299  return PolyReg3D<T>( v ).apply( x, y, z );
300 }
301 
302 
312 } // namespace Interpolate
313 
Interpolate::LinearReg3DWithUdf::u101_
bool u101_
Definition: interpol3d.h:182
Interpolate::LinearReg3DWithUdf::LinearReg3DWithUdf
LinearReg3DWithUdf()
Definition: interpol3d.h:85
mFillIfUdf
#define mFillIfUdf(nd, nearx, neary, nearz, diagxy, diagxz, diagyz, opp)
Interpolate::LinearReg3DWithUdf::LinearReg3DWithUdf
LinearReg3DWithUdf(T v000, T v100, T v010, T v110, T v001, T v101, T v011, T v111)
Definition: interpol3d.h:93
mIsUdf
#define mIsUdf(val)
Use mIsUdf to check for undefinedness of simple types.
Definition: undefval.h:289
Interpolate::LinearReg3DWithUdf::u000_
bool u000_
Definition: interpol3d.h:177
Interpolate::LinearReg3DWithUdf::haveudf_
bool haveudf_
Definition: interpol3d.h:176
Interpolate::LinearReg3DWithUdf::u110_
bool u110_
Definition: interpol3d.h:180
Interpolate::LinearReg3DWithUdf::LinearReg3DWithUdf
LinearReg3DWithUdf(const T *const *const *v)
Definition: interpol3d.h:87
Interpolate::LinearReg3D::LinearReg3D
LinearReg3D()
Definition: interpol3d.h:29
Interpolate::LinearReg3D::apply
T apply(float x, float y, float z) const
Definition: interpol3d.h:54
Interpolate::PolyReg3D::PolyReg3D
PolyReg3D(const T *const *const *v)
Definition: interpol3d.h:224
undefval.h
Interpolate::PolyReg3D::set
void set(T v000, T v100, T v010, T v110, T v001, T v101, T v011, T v111, T vxym1, T vxzm1, T vyzm1, T vxy1, T vxz1, T vyz1)
Definition: interpol3d.h:275
Interpolate::LinearReg3DWithUdf::u100_
bool u100_
Definition: interpol3d.h:178
Interpolate::LinearReg3DWithUdf::u111_
bool u111_
Definition: interpol3d.h:184
mClass
#define mClass(module)
Definition: commondefs.h:181
Interpolate::LinearReg3DWithUdf
Linear 3D interpolation with standard undef handling.
Definition: interpol3d.h:82
Conv::set
void set(T &_to, const F &fr)
template based type conversion
Definition: convert.h:27
Interpolate::polyReg3D
T polyReg3D(const T *const *const *v, float x, float y, float z)
PolyReg3D which smoothly handles undefined values.
Definition: interpol3d.h:297
Interpolate::PolyReg3D::PolyReg3D
PolyReg3D(T vm100, T vm101, T vm110, T vm111, T v0m10, T v0m11, T v00m1, T v000, T v001, T v002, T v01m1, T v010, T v011, T v012, T v020, T v021, T v1m10, T v1m11, T v10m1, T v100, T v101, T v102, T v11m1, T v110, T v111, T v112, T v120, T v121, T v200, T v201, T v210, T v211)
Definition: interpol3d.h:236
Interpolate::LinearReg3DWithUdf::getReplVal
static T getReplVal(T v1, T v2, T v3, bool u1, bool u2, bool u3)
Definition: interpol3d.h:99
Interpolate::LinearReg3D
Linear 3D interpolation.
Definition: interpol3d.h:26
Interpolate::LinearReg3DWithUdf::apply
T apply(float x, float y, float z) const
Definition: interpol3d.h:158
Interpolate::linearReg3DWithUdf
T linearReg3DWithUdf(T v000, T v100, T v010, T v110, T v001, T v101, T v011, T v111, float x, float y, float z)
Definition: interpol3d.h:189
Interpolate::LinearReg3DWithUdf::intp_
LinearReg3D< T > intp_
Definition: interpol3d.h:175
Interpolate::LinearReg3DWithUdf::u010_
bool u010_
Definition: interpol3d.h:179
Interpolate::PolyReg3D::set
void set(T vm100, T vm101, T vm110, T vm111, T v0m10, T v0m11, T v00m1, T v000, T v001, T v002, T v01m1, T v010, T v011, T v012, T v020, T v021, T v1m10, T v1m11, T v10m1, T v100, T v101, T v102, T v11m1, T v110, T v111, T v112, T v120, T v121, T v200, T v201, T v210, T v211)
Definition: interpol3d.h:256
Interpolate::LinearReg3D::LinearReg3D
LinearReg3D(const T *const *const *v)
Definition: interpol3d.h:31
Interpolate::LinearReg3D::LinearReg3D
LinearReg3D(T v000, T v100, T v010, T v110, T v001, T v101, T v011, T v111)
Definition: interpol3d.h:37
mUdf
#define mUdf(type)
Use this macro to get the undefined for simple types.
Definition: undefval.h:274
Interpolate
Definition: interpol1d.h:38
Interpolate::LinearReg3D::set
void set(T v000, T v100, T v010, T v110, T v001, T v101, T v011, T v111)
Definition: interpol3d.h:42
Interpolate::linearReg3D
T linearReg3D(T v000, T v100, T v010, T v110, T v001, T v101, T v011, T v111, float x, float y, float z)
Definition: interpol3d.h:67
Interpolate::LinearReg3DWithUdf::set
void set(T v000, T v100, T v010, T v110, T v001, T v101, T v011, T v111)
Definition: interpol3d.h:112
Interpolate::PolyReg3D::apply
T apply(float x, float y, float z) const
Definition: interpol3d.h:281
Interpolate::PolyReg3D
Interpolate 3D regularly sampled, using a 3rd order surface.
Definition: interpol3d.h:219
Interpolate::PolyReg3D::PolyReg3D
PolyReg3D()
Definition: interpol3d.h:222
Interpolate::LinearReg3DWithUdf::u001_
bool u001_
Definition: interpol3d.h:181
Interpolate::LinearReg3DWithUdf::u011_
bool u011_
Definition: interpol3d.h:183

Generated at for the OpendTect seismic interpretation project. Copyright (C): dGB Beheer B.V. 1995-2021