ldpk
tde4_ldp_radial_decentered_deg_4_cylindric.h
Go to the documentation of this file.
1 #ifndef tde4_ldp_radial_decentered_deg_4_cylindric_sdv
2 #define tde4_ldp_radial_decentered_deg_4_cylindric_sdv
3 
4 #include <ldpk/ldpk_ldp_builtin.h>
6 #include <ldpk/ldpk_cylindric_extender.h>
7 
11 
15 template <class VEC2,class MAT2>
17  {
18 private:
19  typedef VEC2 vec2_type;
20  typedef MAT2 mat2_type;
22 
25 
26  static const char* _para[8];
27 
28  bool decypher(const char* name,int& i)
29  {
30  typedef base_type bt;
31  int n;
32  getNumParameters(n);
33  for(i = 0;i < n;++i)
34  {
35  if(0 == strcmp(name,_para[i]))
36  {
37  return true;
38  }
39  }
40  return false;
41  }
42  bool initializeParameters()
43  {
44  typedef base_type bt;
45  bt::check_builtin_parameters();
46  return true;
47  }
48  bool getNumParameters(int& n)
49  {
50  n = 8;
51  return true;
52  }
53  bool getParameterName(int i,char* identifier)
54  {
55  strcpy(identifier,_para[i]);
56  return true;
57  }
58  bool setParameterValue(const char *identifier,double v)
59  {
60  typedef base_type bt;
61  int i;
62 // Does the base class know the parameter?
63  if(bt::set_builtin_parameter_value(identifier,v))
64  {
65  return true;
66  }
67  if(!decypher(identifier,i))
68  {
69  return false;
70  }
71  if(i < 6)
72  {
73  if(_radial.get_coeff(i) != v)
74  { bt::no_longer_uptodate_lut(); }
75  _radial.set_coeff(i,v);
76  }
77  else if(i == 6)
78  {
79  if(_cylindric.get_phi() != v)
80  { bt::no_longer_uptodate_lut(); }
81  _cylindric.set_phi(v);
82  }
83  else if(i == 7)
84  {
85  if(_cylindric.get_b() != v)
86  { bt::no_longer_uptodate_lut(); }
87  _cylindric.set_b(v);
88  }
89  return true;
90  }
91  virtual bool undistort(double x0,double y0,double &x1,double &y1)
92  {
93  typedef base_type bt;
94  vec2_type q = bt::map_dn_to_unit(
95  _cylindric.eval(
96  _radial.eval(
97  bt::map_unit_to_dn(vec2_type(x0,y0)))));
98  x1 = q[0];
99  y1 = q[1];
100  return true;
101  }
102  virtual bool distort(double x0,double y0,double &x1,double &y1)
103  {
104  typedef base_type bt;
105 // The distort-method without initial values is not constant by semantics,
106 // since it may cause an update of the lookup-tables. Implementing a Nuke node
107 // it turned out that we need to prevent threads from trying so simultaneously.
108 // By the following double check of is_uptodate_lut() we keep the mutex lock
109 // out of our frequently called distort stuff (for performance reasons) and
110 // prevent threads from updating without need.
111  if(!bt::is_uptodate_lut())
112  {
113  bt::lock();
114  if(!bt::is_uptodate_lut())
115  {
116  bt::update_lut();
117  }
118  bt::unlock();
119  }
120 
121 // Get initial value from lookup-table
122  vec2_type qs = bt::get_lut().get_initial_value(vec2_type(x0,y0));
123 // Call version of distort with initial value.
124  vec2_type q = bt::map_dn_to_unit(
125  _radial.map_inverse(
126  _cylindric.eval_inv(
127  bt::map_unit_to_dn(vec2_type(x0,y0))),
128  _cylindric.eval_inv(
129  bt::map_unit_to_dn(qs))));
130  x1 = q[0];
131  y1 = q[1];
132  return true;
133  }
134  virtual bool distort(double x0,double y0,double x1_start,double y1_start,double &x1,double &y1)
135  {
136  typedef base_type bt;
137  vec2_type q = bt::map_dn_to_unit(
138  _radial.map_inverse(
139  _cylindric.eval_inv(
140  bt::map_unit_to_dn(vec2_type(x0,y0))),
141  _cylindric.eval_inv(
142  bt::map_unit_to_dn(vec2_type(x1_start,y1_start)))));
143  x1 = q[0];
144  y1 = q[1];
145  return true;
146  }
147 public:
148 // Mutex initialized and destroyed in baseclass.
150  { }
152  { }
153  bool getModelName(char *name)
154  {
155 #ifdef LDPK_COMPILE_AS_PLUGIN_SDV
156  strcpy(name,"3DE4 Radial - Standard, Degree 4 [Plugin]");
157 #else
158  strcpy(name,"3DE4 Radial - Standard, Degree 4");
159 #endif
160  return true;
161  }
162  bool getParameterType(const char* identifier,tde4_ldp_ptype& ptype)
163  {
164  typedef base_type bt;
165  int i;
166  if(bt::get_builtin_parameter_type(identifier,ptype)) return true;
167  if(!decypher(identifier,i)) return false;
168  ptype = TDE4_LDP_ADJUSTABLE_DOUBLE;
169  return true;
170  }
171  bool getParameterDefaultValue(const char* identifier,double& v)
172  {
173  typedef base_type bt;
174  int i;
175  if(!decypher(identifier,i)) return false;
176  v = 0.0;
177  return true;
178  }
179  bool getParameterRange(const char* identifier,double& a,double& b)
180  {
181  typedef base_type bt;
182  int i;
183  if(!decypher(identifier,i)) return false;
184  if((i == 0) || (i == 3))
185  {
186 // Distortion - Degree 2, Quartic Distortion - Degree 4
187  a = -0.5;b = 0.5;
188  }
189  else if((i == 1) || (i == 2) || (i == 4) || (i == 5))
190  {
191 // U2,V2,U4,V4.
192  a = -0.5;b = 0.5;
193  }
194  else if(i == 6)
195  {
196 // Phi - Cylindric Direction. In the symmetric extender version -45 to 45 would be sufficient.
197  a = -90.0;b = +90.0;
198  }
199  else if(i == 7)
200  {
201 // B - Cylindric Bending
202  a = -0.1;b = 0.1;
203  }
204  return true;
205  }
206  bool getJacobianMatrix(double x0,double y0,double& m00,double& m01,double& m10,double& m11)
207  {
208  typedef base_type bt;
209  mat2_type m = _cylindric.get_mat()
210  * _radial.jacobi(
211  bt::map_unit_to_dn(vec2_type(x0,y0)));
212 // to myself: Eigentlich w/2,h/2 bei beiden. Kuerzt sich weg.
213  mat2_type u2d(bt::w_fb_cm() / bt::r_fb_cm(),0.0,0.0,bt::h_fb_cm() / bt::r_fb_cm());
214  mat2_type d2u(bt::r_fb_cm() / bt::w_fb_cm(),0.0,0.0,bt::r_fb_cm() / bt::h_fb_cm());
215  m = d2u * m * u2d;
216  m00 = m[0][0];m01 = m[0][1];m10 = m[1][0];m11 = m[1][1];
217  return true;
218  }
219  };
220 
221 template <class VEC2,class MAT2>
223  "Distortion - Degree 2",
224  "U - Degree 2",
225  "V - Degree 2",
226  "Quartic Distortion - Degree 4",
227  "U - Degree 4",
228  "V - Degree 4",
229  "Phi - Cylindric Direction",
230  "B - Cylindric Bending"
231  };
232 
233 #endif
bool getJacobianMatrix(double x0, double y0, double &m00, double &m01, double &m10, double &m11)
calculate the Jacobian matrix of the undistort()-Method. Overwrite this, if you know the Jacobian for...
Definition: tde4_ldp_radial_decentered_deg_4_cylindric.h:206
virtual vec2_type eval_inv(const vec2_type &q) const
eval_inv() is applying lens distortion (distort)
Definition: ldpk_cylindric_extender.h:102
vec2_type eval(const vec2_type &p) const
Same as method instead of operator.
Definition: ldpk_generic_distortion_base.h:104
void set_b(double b)
This parameter expresses the strength of the cylindric deformation ("bending").
Definition: ldpk_cylindric_extender.h:94
mat2_type jacobi(const vec2_type &p_dn) const
Analytic version of the Jacobi-matrix, about two times faster than the base class version which uses ...
Definition: ldpk_radial_decentered_distortion.h:72
const mat2_type & get_mat() const
The matrix for this extender.
Definition: ldpk_cylindric_extender.h:108
A polynomial radially symmetric model of degree 4 with decentering.
Plugin class for radial distortion with decentering and optional compensation for beam-splitter artef...
Definition: tde4_ldp_radial_decentered_deg_4_cylindric.h:16
bool getModelName(char *name)
returns a name for the model as to show up in the GUI (maximum length of "name": 100 bytes)...
Definition: tde4_ldp_radial_decentered_deg_4_cylindric.h:153
bool getParameterRange(const char *identifier, double &a, double &b)
returns range for adjustable double parameters...
Definition: tde4_ldp_radial_decentered_deg_4_cylindric.h:179
This class handles the built-in parameter and the lookup table. You may find it useful for your own d...
Definition: ldpk_ldp_builtin.h:31
virtual vec2_type map_inverse(const vec2_type &q) const
Inverse mapping by solving the fixed point equation without providing initial values. Virtual, because the derived class might use some smart data structure for calculating an initial value.
Definition: ldpk_generic_distortion_base.h:122
void set_coeff(int i, double q)
Set coefficient c[i], 0 <= i < 6.
Definition: ldpk_radial_decentered_distortion.h:45
double get_coeff(int i) const
Get coefficient c[i], 0 <= i < 6.
Definition: ldpk_radial_decentered_distortion.h:39
vec2_type eval(const vec2_type &p) const
eval() is per definition removal of lens distortion (undistort).
Definition: ldpk_cylindric_extender.h:99
void set_phi(double phi)
The cylindric extender has a parameter called phi.
Definition: ldpk_cylindric_extender.h:89
bool getParameterType(const char *identifier, tde4_ldp_ptype &ptype)
returns type of given parameter... The method should return false, if the parameter addressed by iden...
Definition: tde4_ldp_radial_decentered_deg_4_cylindric.h:162
bool getParameterDefaultValue(const char *identifier, double &v)
returns default value for given parameter (maximum length of "char *v": 1000 bytes)......
Definition: tde4_ldp_radial_decentered_deg_4_cylindric.h:171