vigra - vigra/splines.hxx Source File

[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

splines.hxx |

1 /************************************************************************/
2 /* */
3 /* Copyright 1998-2004 by Ullrich Koethe */
4 /* */
5 /* This file is part of the VIGRA computer vision library. */
6 /* The VIGRA Website is */
7 /* http://hci.iwr.uni-heidelberg.de/vigra/ */
8 /* Please direct questions, bug reports, and contributions to */
9 /* ullrich.koethe@iwr.uni-heidelberg.de or */
10 /* vigra@informatik.uni-hamburg.de */
11 /* */
12 /* Permission is hereby granted, free of charge, to any person */
13 /* obtaining a copy of this software and associated documentation */
14 /* files (the "Software"), to deal in the Software without */
15 /* restriction, including without limitation the rights to use, */
16 /* copy, modify, merge, publish, distribute, sublicense, and/or */
17 /* sell copies of the Software, and to permit persons to whom the */
18 /* Software is furnished to do so, subject to the following */
19 /* conditions: */
20 /* */
21 /* The above copyright notice and this permission notice shall be */
22 /* included in all copies or substantial portions of the */
23 /* Software. */
24 /* */
25 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
26 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
27 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
28 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
29 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
30 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
31 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
32 /* OTHER DEALINGS IN THE SOFTWARE. */
33 /* */
34 /************************************************************************/
35
36 #ifndef VIGRA_SPLINES_HXX
37 #define VIGRA_SPLINES_HXX
38
39 #include <cmath>
40 #include "config.hxx"
41 #include "mathutil.hxx"
42 #include "array_vector.hxx"
43 #include "fixedpoint.hxx"
44
45 namespace vigra {
46
47 namespace autodiff {
48
49 template <class T, int N>
50 class DualVector;
51
52 } // namespace autodiff
53
54 /** \addtogroup MathFunctions Mathematical Functions
55 */
56 //@{
57 /* B-Splines of arbitrary order and interpolating Catmull/Rom splines.
58
59 <b>\#include</b> <vigra/splines.hxx><br>
60 Namespace: vigra
61 */
62 #ifndef NO_PARTIAL_TEMPLATE_SPECIALIZATION
63
64 /** Basic interface of the spline functors.
65
66 Implements the spline functions defined by the recursion
67
68 \f[ B_0(x) = \left\{ \begin{array}{ll}
69 1 & -\frac{1}{2} \leq x < \frac{1}{2} \\
70 0 & \mbox{otherwise}
71 \end{array}\right.
72 \f]
73
74 and
75
76 \f[ B_n(x) = B_0(x) * B_{n-1}(x)
77 \f]
78
79 where * denotes convolution, and <i>n</i> is the spline order given by the template
80 parameter <tt>ORDER</tt> with <tt>ORDER < 18</tt>. These spline classes can be used as
81 unary and binary functors, as kernels for \ref resamplingConvolveImage(),
82 and as arguments for \ref vigra::SplineImageView. Note that the spline order
83 is given as a template argument.
84
85 <b>\#include</b> <vigra/splines.hxx><br>
86 Namespace: vigra
87 */
88 template <int ORDER, class T = double>
89 class BSplineBase
90 {
91 public:
92
93 static_assert (ORDER < 18 , "BSpline: ORDER must be less than 18." );
94
95 /** the value type if used as a kernel in \ref resamplingConvolveImage().
96 */
97 typedef T value_type;
98 /** the functor's unary argument type
99 */
100 typedef T argument_type;
101 /** the functor's first binary argument type
102 */
103 typedef T first_argument_type;
104 /** the functor's second binary argument type
105 */
106 typedef unsigned int second_argument_type;
107 /** the functor's result type (unary and binary)
108 */
109 typedef T result_type;
110 /** the spline order
111 */
112 enum StaticOrder { order = ORDER };
113
114 /** Create functor for given derivative of the spline. The spline's order
115 is specified spline by the template argument <TT>ORDER</tt>.
116 */
117 explicit BSplineBase(unsigned int derivativeOrder = 0)
118 : s1_(derivativeOrder)
119 {}
120
121 /** Unary function call.
122 Returns the value of the spline with the derivative order given in the
123 constructor. Note that only derivatives up to <tt>ORDER-1</tt> are
124 continuous, and derivatives above <tt>ORDER+1</tt> are zero.
125 */
126 result_type operator()(argument_type x) const
127 {
128 return exec(x, derivativeOrder());
129 }
130
131 /** Binary function call.
132 The given derivative order is added to the derivative order
133 specified in the constructor. Note that only derivatives up to <tt>ORDER-1</tt> are
134 continuous, and derivatives above <tt>ORDER+1</tt> are zero.
135 */
136 result_type operator()(first_argument_type x, second_argument_type derivative_order) const
137 {
138 return exec(x, derivativeOrder() + derivative_order);
139 }
140
141 /** Index operator. Same as unary function call.
142 */
143 value_type operator[](value_type x) const
144 { return operator()(x); }
145
146 /** Get the required filter radius for a discrete approximation of the
147 spline. Always equal to <tt>(ORDER + 1) / 2.0</tt>.
148 */
149 double radius() const
150 { return (ORDER + 1) * 0.5; }
151
152 /** Get the derivative order of the Gaussian.
153 */
154 unsigned int derivativeOrder() const
155 { return s1_.derivativeOrder(); }
156
157 /** Get the prefilter coefficients required for interpolation.
158 To interpolate with a B-spline, \ref resamplingConvolveImage()
159 can be used. However, the image to be interpolated must be
160 pre-filtered using \ref recursiveFilterX() and \ref recursiveFilterY()
161 with the filter coefficients given by this function. The length of the array
162 corresponds to how many times the above recursive filtering
163 has to be applied (zero length means no prefiltering necessary).
164 */
165 ArrayVector<double> const & prefilterCoefficients() const
166 {
167 return prefilterCoefficients_;
168 }
169
170 typedef ArrayVector<ArrayVector<T> > WeightMatrix;
171
172 /** Get the coefficients to transform spline coefficients into
173 the coefficients of the corresponding polynomial.
174 Currently internally used in SplineImageView; needs more
175 documentation ???
176 */
177 static WeightMatrix const & weights()
178 {
179 return weightMatrix_;
180 }
181
182 static ArrayVector<double> getPrefilterCoefficients();
183
184 protected:
185 result_type exec(first_argument_type x, second_argument_type derivative_order) const;
186
187 // factory function for the weight matrix
188 static WeightMatrix calculateWeightMatrix();
189
190 BSplineBase<ORDER-1, T> s1_;
191 static ArrayVector<double> prefilterCoefficients_;
192 static WeightMatrix weightMatrix_;
193 };
194
195 template <int ORDER, class T>
196 ArrayVector<double> BSplineBase<ORDER, T>::prefilterCoefficients_(getPrefilterCoefficients());
197
198 template <int ORDER, class T>
199 typename BSplineBase<ORDER, T>::WeightMatrix BSplineBase<ORDER, T>::weightMatrix_(calculateWeightMatrix());
200
201 template <int ORDER, class T>
202 typename BSplineBase<ORDER, T>::result_type
203 BSplineBase<ORDER, T>::exec(first_argument_type x, second_argument_type derivative_order) const
204 {
205 if(derivative_order == 0)
206 {
207 T n12 = (ORDER + 1.0) / 2.0;
208 return ((n12 + x) * s1_(x + 0.5) + (n12 - x) * s1_(x - 0.5)) / ORDER;
209 }
210 else
211 {
212 --derivative_order;
213 return s1_(x + 0.5, derivative_order) - s1_(x - 0.5, derivative_order);
214 }
215 }
216
217 template <int ORDER, class T>
218 ArrayVector<double>
219 BSplineBase<ORDER, T>::getPrefilterCoefficients()
220 {
221 static const double coeffs[18][8] = {
222 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
223 { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
224 { -0.17157287525380971, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
225 { -0.26794919243112281, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
226 { -0.36134122590022018, -0.01372542929733912, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
227 { -0.43057534709997379, -0.04309628820326465, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },
228 { -0.48829458930304398, -0.081679271076237972, -0.0014141518083258175, 0.0, 0.0, 0.0, 0.0, 0.0 },
229 { -0.53528043079643672, -0.1225546151923274, -0.0091486948096082786, 0.0, 0.0, 0.0, 0.0, 0.0 },
230 { -0.57468690924876631, -0.16303526929728085, -0.023632294694844857, -0.00015382131064169087, 0.0, 0.0, 0.0, 0.0 },
231 { -0.60799738916862989, -0.20175052019315337, -0.043222608540481752, -0.0021213069031808186, 0.0, 0.0, 0.0, 0.0 },
232 { -0.63655066396942439, -0.2381827983775629, -0.065727033228308585, -0.0075281946755486927, -1.6982762823274658e-5, 0.0, 0.0, 0.0 },
233 { -0.66126606890072925, -0.27218034929478602, -0.089759599793713341, -0.016669627366234657, -0.00051055753444650205, 0.0, 0.0, 0.0 },
234 { -0.68286488419772362, -0.30378079328825425, -0.11435052002713579, -0.028836190198663809, -0.0025161662172613372, -1.8833056450639017e-6, 0.0, 0.0 },
235 { -0.70189425181681642, -0.33310723293062366, -0.13890111319431958, -0.043213866740363663, -0.0067380314152449142, -0.00012510011321441875, 0.0, 0.0 },
236 { -0.71878378723997516, -0.3603190719169625, -0.1630335147992984, -0.059089482194831018, -0.013246756734847919, -0.00086402404095333829, -2.0913096775275374e-7, 0.0 },
237 { -0.73387257168487741, -0.38558573427843323, -0.18652010845096478, -0.075907592047668185, -0.02175206579654047, -0.0028011514820764556, -3.093568045147443e-5, 0.0 },
238 { -0.747432387772212103, -0.409073604757528353, -0.29228719338953817, -9.32547189803214355e-2 -3.18677061204386616e-2, -6.25840678512839046e-3, -3.01565363306955866e-4, -2.32324863642097035e-8 },
239 { -0.75968322407189071, -0.43093965318039579, -0.23108984359927232, -0.1108289933162471, -0.043213911456684129, -0.011258183689471605, -0.0011859331251521767, -7.6875625812546846e-6 }
240 };
241 return ArrayVector<double>(coeffs[ORDER], coeffs[ORDER]+ORDER/2);
242 }
243
244 template <int ORDER, class T>
245 typename BSplineBase<ORDER, T>::WeightMatrix
246 BSplineBase<ORDER, T>::calculateWeightMatrix()
247 {
248 WeightMatrix res(ORDER+1, ArrayVector<T>(ORDER+1));
249 double faculty = 1.0;
250 for(int d = 0; d <= ORDER; ++d)
251 {
252 if(d > 1)
253 faculty *= d;
254 double x = ORDER / 2; // (note: integer division)
255 BSplineBase spline;
256 for(int i = 0; i <= ORDER; ++i, --x)
257 res[d][i] = spline(x, d) / faculty;
258 }
259 return res;
260 }
261
262 /********************************************************/
263 /* */
264 /* BSpline<N, T> */
265 /* */
266 /********************************************************/
267
268 /** Spline functors for arbitrary orders.
269
270 Provides the interface of \ref vigra::BSplineBase with a more convenient
271 name -- see there for more documentation.
272 */
273 template <int ORDER, class T = double>
274 class BSpline
275 : public BSplineBase<ORDER, T>
276 {
277 public:
278 /** Constructor forwarded to the base class constructor..
279 */
280 explicit BSpline(unsigned int derivativeOrder = 0)
281 : BSplineBase<ORDER, T>(derivativeOrder)
282 {}
283 };
284
285 /********************************************************/
286 /* */
287 /* BSpline<0, T> */
288 /* */
289 /********************************************************/
290
291 template <class T>
292 class BSplineBase<0, T>
293 {
294 public:
295
296 typedef T value_type;
297 typedef T argument_type;
298 typedef T first_argument_type;
299 typedef unsigned int second_argument_type;
300 typedef T result_type;
301 enum StaticOrder { order = 0 };
302
303 explicit BSplineBase(unsigned int derivativeOrder = 0)
304 : derivativeOrder_(derivativeOrder)
305 {}
306
307 result_type operator()(argument_type x) const
308 {
309 return exec(x, derivativeOrder_);
310 }
311
312 template <unsigned int IntBits, unsigned int FracBits>
313 FixedPoint<IntBits, FracBits> operator()(FixedPoint<IntBits, FracBits> x) const
314 {
315 typedef FixedPoint<IntBits, FracBits> Value;
316 return x.value < Value::ONE_HALF && -Value::ONE_HALF <= x.value
317 ? Value(Value::ONE, FPNoShift)
318 : Value(0, FPNoShift);
319 }
320
321 template <class U, int N>
322 autodiff::DualVector<U, N> operator()(autodiff::DualVector<U, N> const & x) const
323 {
324 return x < 0.5 && -0.5 <= x
325 ? autodiff::DualVector<U, N>(1.0)
326 : autodiff::DualVector<U, N>(0.0);
327 }
328
329 result_type operator()(first_argument_type x, second_argument_type derivative_order) const
330 {
331 return exec(x, derivativeOrder_ + derivative_order);
332 }
333
334 value_type operator[](value_type x) const
335 { return operator()(x); }
336
337 double radius() const
338 { return 0.5; }
339
340 unsigned int derivativeOrder() const
341 { return derivativeOrder_; }
342
343 ArrayVector<double> const & prefilterCoefficients() const
344 {
345 return prefilterCoefficients_;
346 }
347
348 typedef T WeightMatrix[1][1];
349
350 static WeightMatrix const & weights()
351 {
352 return weightMatrix_;
353 }
354
355 protected:
356 result_type exec(first_argument_type x, second_argument_type derivative_order) const
357 {
358 if(derivative_order == 0)
359 return x < 0.5 && -0.5 <= x ?
360 1.0
361 : 0.0;
362 else
363 return 0.0;
364 }
365
366 unsigned int derivativeOrder_;
367 static ArrayVector<double> prefilterCoefficients_;
368 static WeightMatrix weightMatrix_;
369 };
370
371 template <class T>
372 ArrayVector<double> BSplineBase<0, T>::prefilterCoefficients_;
373
374 template <class T>
375 typename BSplineBase<0, T>::WeightMatrix BSplineBase<0, T>::weightMatrix_ = {{ 1.0 }};
376
377 /********************************************************/
378 /* */
379 /* BSpline<1, T> */
380 /* */
381 /********************************************************/
382
383 template <class T>
384 class BSpline<1, T>
385 {
386 public:
387
388 typedef T value_type;
389 typedef T argument_type;
390 typedef T first_argument_type;
391 typedef unsigned int second_argument_type;
392 typedef T result_type;
393 enum StaticOrder { order = 1 };
394
395 explicit BSpline(unsigned int derivativeOrder = 0)
396 : derivativeOrder_(derivativeOrder)
397 {}
398
399 result_type operator()(argument_type x) const
400 {
401 return exec(x, derivativeOrder_);
402 }
403
404 template <unsigned int IntBits, unsigned int FracBits>
405 FixedPoint<IntBits, FracBits> operator()(FixedPoint<IntBits, FracBits> x) const
406 {
407 typedef FixedPoint<IntBits, FracBits> Value;
408 int v = abs(x.value);
409 return v < Value::ONE ?
410 Value(Value::ONE - v, FPNoShift)
411 : Value(0, FPNoShift);
412 }
413
414 template <class U, int N>
415 autodiff::DualVector<U, N> operator()(autodiff::DualVector<U, N> x) const
416 {
417 x = abs(x);
418 return x < 1.0
419 ? 1.0 - x
420 : autodiff::DualVector<U, N>(0.0);
421 }
422
423 result_type operator()(first_argument_type x, second_argument_type derivative_order) const
424 {
425 return exec(x, derivativeOrder_ + derivative_order);
426 }
427
428 value_type operator[](value_type x) const
429 { return operator()(x); }
430
431 double radius() const
432 { return 1.0; }
433
434 unsigned int derivativeOrder() const
435 { return derivativeOrder_; }
436
437 ArrayVector<double> const & prefilterCoefficients() const
438 {
439 return prefilterCoefficients_;
440 }
441
442 typedef T WeightMatrix[2][2];
443
444 static WeightMatrix const & weights()
445 {
446 return weightMatrix_;
447 }
448
449 protected:
450 T exec(T x, unsigned int derivative_order) const;
451
452 unsigned int derivativeOrder_;
453 static ArrayVector<double> prefilterCoefficients_;
454 static WeightMatrix weightMatrix_;
455 };
456
457 template <class T>
458 ArrayVector<double> BSpline<1, T>::prefilterCoefficients_;
459
460 template <class T>
461 typename BSpline<1, T>::WeightMatrix BSpline<1, T>::weightMatrix_ = {{ 1.0, 0.0}, {-1.0, 1.0}};
462
463 template <class T>
464 T BSpline<1, T>::exec(T x, unsigned int derivative_order) const
465 {
466 switch(derivative_order)
467 {
468 case 0:
469 {
470 x = VIGRA_CSTD::fabs(x);
471 return x < 1.0 ?
472 1.0 - x
473 : 0.0;
474 }
475 case 1:
476 {
477 return x < 0.0 ?
478 -1.0 <= x ?
479 1.0
480 : 0.0
481 : x < 1.0 ?
482 -1.0
483 : 0.0;
484 }
485 default:
486 return 0.0;
487 }
488 }
489
490 /********************************************************/
491 /* */
492 /* BSpline<2, T> */
493 /* */
494 /********************************************************/
495
496 template <class T>
497 class BSpline<2, T>
498 {
499 public:
500
501 typedef T value_type;
502 typedef T argument_type;
503 typedef T first_argument_type;
504 typedef unsigned int second_argument_type;
505 typedef T result_type;
506 enum StaticOrder { order = 2 };
507
508 explicit BSpline(unsigned int derivativeOrder = 0)
509 : derivativeOrder_(derivativeOrder)
510 {}
511
512 result_type operator()(argument_type x) const
513 {
514 return exec(x, derivativeOrder_);
515 }
516
517 template <unsigned int IntBits, unsigned int FracBits>
518 FixedPoint<IntBits, FracBits> operator()(FixedPoint<IntBits, FracBits> x) const
519 {
520 typedef FixedPoint<IntBits, FracBits> Value;
521 enum { ONE_HALF = Value::ONE_HALF, THREE_HALVES = ONE_HALF * 3, THREE_QUARTERS = THREE_HALVES / 2,
522 PREMULTIPLY_SHIFT1 = FracBits <= 16 ? 0 : FracBits - 16,
523 PREMULTIPLY_SHIFT2 = FracBits - 1 <= 16 ? 0 : FracBits - 17,
524 POSTMULTIPLY_SHIFT1 = FracBits - 2*PREMULTIPLY_SHIFT1,
525 POSTMULTIPLY_SHIFT2 = FracBits - 2*PREMULTIPLY_SHIFT2 };
526 int v = abs(x.value);
527 return v == ONE_HALF
528 ? Value(ONE_HALF, FPNoShift)
529 : v <= ONE_HALF
530 ? Value(THREE_QUARTERS -
531 (int)(sq((unsigned)v >> PREMULTIPLY_SHIFT2) >> POSTMULTIPLY_SHIFT2), FPNoShift)
532 : v < THREE_HALVES
533 ? Value((int)(sq((unsigned)(THREE_HALVES-v) >> PREMULTIPLY_SHIFT1) >> (POSTMULTIPLY_SHIFT1 + 1)), FPNoShift)
534 : Value(0, FPNoShift);
535 }
536
537 template <class U, int N>
538 autodiff::DualVector<U, N> operator()(autodiff::DualVector<U, N> x) const
539 {
540 x = abs(x);
541 return x < 0.5
542 ? 0.75 - x*x
543 : x < 1.5
544 ? 0.5 * sq(1.5 - x)
545 : autodiff::DualVector<U, N>(0.0);
546 }
547
548 result_type operator()(first_argument_type x, second_argument_type derivative_order) const
549 {
550 return exec(x, derivativeOrder_ + derivative_order);
551 }
552
553 result_type dx(argument_type x) const
554 { return operator()(x, 1); }
555
556 value_type operator[](value_type x) const
557 { return operator()(x); }
558
559 double radius() const
560 { return 1.5; }
561
562 unsigned int derivativeOrder() const
563 { return derivativeOrder_; }
564
565 ArrayVector<double> const & prefilterCoefficients() const
566 {
567 return prefilterCoefficients_;
568 }
569
570 typedef T WeightMatrix[3][3];
571
572 static WeightMatrix const & weights()
573 {
574 return weightMatrix_;
575 }
576
577 protected:
578 result_type exec(first_argument_type x, second_argument_type derivative_order) const;
579
580 unsigned int derivativeOrder_;
581 static ArrayVector<double> prefilterCoefficients_;
582 static WeightMatrix weightMatrix_;
583 };
584
585 template <class T>
586 ArrayVector<double> BSpline<2, T>::prefilterCoefficients_(1, 2.0*M_SQRT2 - 3.0);
587
588 template <class T>
589 typename BSpline<2, T>::WeightMatrix BSpline<2, T>::weightMatrix_ =
590 {{ 0.125, 0.75, 0.125},
591 {-0.5, 0.0, 0.5},
592 { 0.5, -1.0, 0.5}};
593
594 template <class T>
595 typename BSpline<2, T>::result_type
596 BSpline<2, T>::exec(first_argument_type x, second_argument_type derivative_order) const
597 {
598 switch(derivative_order)
599 {
600 case 0:
601 {
602 x = VIGRA_CSTD::fabs(x);
603 return x < 0.5 ?
604 0.75 - x*x
605 : x < 1.5 ?
606 0.5 * sq(1.5 - x)
607 : 0.0;
608 }
609 case 1:
610 {
611 return x >= -0.5 ?
612 x <= 0.5 ?
613 -2.0 * x
614 : x < 1.5 ?
615 x - 1.5
616 : 0.0
617 : x > -1.5 ?
618 x + 1.5
619 : 0.0;
620 }
621 case 2:
622 {
623 return x >= -0.5 ?
624 x < 0.5 ?
625 -2.0
626 : x < 1.5 ?
627 1.0
628 : 0.0
629 : x >= -1.5 ?
630 1.0
631 : 0.0;
632 }
633 default:
634 return 0.0;
635 }
636 }
637
638 /********************************************************/
639 /* */
640 /* BSpline<3, T> */
641 /* */
642 /********************************************************/
643
644 template <class T>
645 class BSpline<3, T>
646 {
647 public:
648
649 typedef T value_type;
650 typedef T argument_type;
651 typedef T first_argument_type;
652 typedef unsigned int second_argument_type;
653 typedef T result_type;
654 enum StaticOrder { order = 3 };
655
656 explicit BSpline(unsigned int derivativeOrder = 0)
657 : derivativeOrder_(derivativeOrder)
658 {}
659
660 result_type operator()(argument_type x) const
661 {
662 return exec(x, derivativeOrder_);
663 }
664
665 template <unsigned int IntBits, unsigned int FracBits>
666 FixedPoint<IntBits, FracBits> operator()(FixedPoint<IntBits, FracBits> x) const
667 {
668 typedef FixedPoint<IntBits, FracBits> Value;
669 enum { ONE = Value::ONE, TWO = 2 * ONE, TWO_THIRDS = TWO / 3, ONE_SIXTH = ONE / 6,
670 PREMULTIPLY_SHIFT = FracBits <= 16 ? 0 : FracBits - 16,
671 POSTMULTIPLY_SHIFT = FracBits - 2*PREMULTIPLY_SHIFT };
672 int v = abs(x.value);
673 return v == ONE
674 ? Value(ONE_SIXTH, FPNoShift)
675 : v < ONE
676 ? Value(TWO_THIRDS +
677 (((int)(sq((unsigned)v >> PREMULTIPLY_SHIFT) >> (POSTMULTIPLY_SHIFT + PREMULTIPLY_SHIFT))
678 * (((v >> 1) - ONE) >> PREMULTIPLY_SHIFT)) >> POSTMULTIPLY_SHIFT), FPNoShift)
679 : v < TWO
680 ? Value((int)((sq((unsigned)(TWO-v) >> PREMULTIPLY_SHIFT) >> (POSTMULTIPLY_SHIFT + PREMULTIPLY_SHIFT))
681 * ((unsigned)(TWO-v) >> PREMULTIPLY_SHIFT) / 6) >> POSTMULTIPLY_SHIFT, FPNoShift)
682 : Value(0, FPNoShift);
683 }
684
685 template <class U, int N>
686 autodiff::DualVector<U, N> operator()(autodiff::DualVector<U, N> x) const
687 {
688 x = abs(x);
689 if(x < 1.0)
690 {
691 return 2.0/3.0 + x*x*(-1.0 + 0.5*x);
692 }
693 else if(x < 2.0)
694 {
695 x = 2.0 - x;
696 return x*x*x/6.0;
697 }
698 else
699 return autodiff::DualVector<U, N>(0.0);
700 }
701
702 result_type operator()(first_argument_type x, second_argument_type derivative_order) const
703 {
704 return exec(x, derivativeOrder_ + derivative_order);
705 }
706
707 result_type dx(argument_type x) const
708 { return operator()(x, 1); }
709
710 result_type dxx(argument_type x) const
711 { return operator()(x, 2); }
712
713 value_type operator[](value_type x) const
714 { return operator()(x); }
715
716 double radius() const
717 { return 2.0; }
718
719 unsigned int derivativeOrder() const
720 { return derivativeOrder_; }
721
722 ArrayVector<double> const & prefilterCoefficients() const
723 {
724 return prefilterCoefficients_;
725 }
726
727 typedef T WeightMatrix[4][4];
728
729 static WeightMatrix const & weights()
730 {
731 return weightMatrix_;
732 }
733
734 protected:
735 result_type exec(first_argument_type x, second_argument_type derivative_order) const;
736
737 unsigned int derivativeOrder_;
738 static ArrayVector<double> prefilterCoefficients_;
739 static WeightMatrix weightMatrix_;
740 };
741
742 template <class T>
743 ArrayVector<double> BSpline<3, T>::prefilterCoefficients_(1, VIGRA_CSTD::sqrt(3.0) - 2.0);
744
745 template <class T>
746 typename BSpline<3, T>::WeightMatrix BSpline<3, T>::weightMatrix_ =
747 {{ 1.0 / 6.0, 2.0 / 3.0, 1.0 / 6.0, 0.0},
748 {-0.5, 0.0, 0.5, 0.0},
749 { 0.5, -1.0, 0.5, 0.0},
750 {-1.0 / 6.0, 0.5, -0.5, 1.0 / 6.0}};
751
752 template <class T>
753 typename BSpline<3, T>::result_type
754 BSpline<3, T>::exec(first_argument_type x, second_argument_type derivative_order) const
755 {
756 switch(derivative_order)
757 {
758 case 0:
759 {
760 x = VIGRA_CSTD::fabs(x);
761 if(x < 1.0)
762 {
763 return 2.0/3.0 + x*x*(-1.0 + 0.5*x);
764 }
765 else if(x < 2.0)
766 {
767 x = 2.0 - x;
768 return x*x*x/6.0;
769 }
770 else
771 return 0.0;
772 }
773 case 1:
774 {
775 double s = x < 0.0 ?
776 -1.0
777 : 1.0;
778 x = VIGRA_CSTD::fabs(x);
779 return x < 1.0 ?
780 s*x*(-2.0 + 1.5*x)
781 : x < 2.0 ?
782 -0.5*s*sq(2.0 - x)
783 : 0.0;
784 }
785 case 2:
786 {
787 x = VIGRA_CSTD::fabs(x);
788 return x < 1.0 ?
789 3.0*x - 2.0
790 : x < 2.0 ?
791 2.0 - x
792 : 0.0;
793 }
794 case 3:
795 {
796 return x < 0.0 ?
797 x < -1.0 ?
798 x < -2.0 ?
799 0.0
800 : 1.0
801 : -3.0
802 : x < 1.0 ?
803 3.0
804 : x < 2.0 ?
805 -1.0
806 : 0.0;
807 }
808 default:
809 return 0.0;
810 }
811 }
812
813 typedef BSpline<3, double> CubicBSplineKernel;
814
815 /********************************************************/
816 /* */
817 /* BSpline<4, T> */
818 /* */
819 /********************************************************/
820
821 template <class T>
822 class BSpline<4, T>
823 {
824 public:
825
826 typedef T value_type;
827 typedef T argument_type;
828 typedef T first_argument_type;
829 typedef unsigned int second_argument_type;
830 typedef T result_type;
831 enum StaticOrder { order = 4 };
832
833 explicit BSpline(unsigned int derivativeOrder = 0)
834 : derivativeOrder_(derivativeOrder)
835 {}
836
837 result_type operator()(argument_type x) const
838 {
839 return exec(x, derivativeOrder_);
840 }
841
842 result_type operator()(first_argument_type x, second_argument_type derivative_order) const
843 {
844 return exec(x, derivativeOrder_ + derivative_order);
845 }
846
847 template <class U, int N>
848 autodiff::DualVector<U, N> operator()(autodiff::DualVector<U, N> x) const
849 {
850 x = abs(x);
851 if(x <= 0.5)
852 {
853 return 115.0/192.0 + x*x*(-0.625 + x*x*0.25);
854 }
855 else if(x < 1.5)
856 {
857 return (55.0/16.0 + x*(1.25 + x*(-7.5 + x*(5.0 - x)))) / 6.0;
858 }
859 else if(x < 2.5)
860 {
861 x = 2.5 - x;
862 return sq(x*x) / 24.0;
863 }
864 else
865 return autodiff::DualVector<U, N>(0.0);
866 }
867
868 result_type dx(argument_type x) const
869 { return operator()(x, 1); }
870
871 result_type dxx(argument_type x) const
872 { return operator()(x, 2); }
873
874 result_type dx3(argument_type x) const
875 { return operator()(x, 3); }
876
877 value_type operator[](value_type x) const
878 { return operator()(x); }
879
880 double radius() const
881 { return 2.5; }
882
883 unsigned int derivativeOrder() const
884 { return derivativeOrder_; }
885
886 ArrayVector<double> const & prefilterCoefficients() const
887 {
888 return prefilterCoefficients_;
889 }
890
891 typedef T WeightMatrix[5][5];
892
893 static WeightMatrix const & weights()
894 {
895 return weightMatrix_;
896 }
897
898 protected:
899 result_type exec(first_argument_type x, second_argument_type derivative_order) const;
900
901 unsigned int derivativeOrder_;
902 static ArrayVector<double> prefilterCoefficients_;
903 static WeightMatrix weightMatrix_;
904 };
905
906 template <class T>
907 ArrayVector<double> BSpline<4, T>::prefilterCoefficients_(BSplineBase<4, T>::getPrefilterCoefficients());
908
909 template <class T>
910 typename BSpline<4, T>::WeightMatrix BSpline<4, T>::weightMatrix_ =
911 {{ 1.0/384.0, 19.0/96.0, 115.0/192.0, 19.0/96.0, 1.0/384.0},
912 {-1.0/48.0, -11.0/24.0, 0.0, 11.0/24.0, 1.0/48.0},
913 { 1.0/16.0, 1.0/4.0, -5.0/8.0, 1.0/4.0, 1.0/16.0},
914 {-1.0/12.0, 1.0/6.0, 0.0, -1.0/6.0, 1.0/12.0},
915 { 1.0/24.0, -1.0/6.0, 0.25, -1.0/6.0, 1.0/24.0}};
916
917 template <class T>
918 typename BSpline<4, T>::result_type
919 BSpline<4, T>::exec(first_argument_type x, second_argument_type derivative_order) const
920 {
921 switch(derivative_order)
922 {
923 case 0:
924 {
925 x = VIGRA_CSTD::fabs(x);
926 if(x <= 0.5)
927 {
928 return 115.0/192.0 + x*x*(-0.625 + x*x*0.25);
929 }
930 else if(x < 1.5)
931 {
932 return (55.0/16.0 + x*(1.25 + x*(-7.5 + x*(5.0 - x)))) / 6.0;
933 }
934 else if(x < 2.5)
935 {
936 x = 2.5 - x;
937 return sq(x*x) / 24.0;
938 }
939 else
940 return 0.0;
941 }
942 case 1:
943 {
944 double s = x < 0.0 ?
945 -1.0 :
946 1.0;
947 x = VIGRA_CSTD::fabs(x);
948 if(x <= 0.5)
949 {
950 return s*x*(-1.25 + x*x);
951 }
952 else if(x < 1.5)
953 {
954 return s*(5.0 + x*(-60.0 + x*(60.0 - 16.0*x))) / 24.0;
955 }
956 else if(x < 2.5)
957 {
958 x = 2.5 - x;
959 return s*x*x*x / -6.0;
960 }
961 else
962 return 0.0;
963 }
964 case 2:
965 {
966 x = VIGRA_CSTD::fabs(x);
967 if(x <= 0.5)
968 {
969 return -1.25 + 3.0*x*x;
970 }
971 else if(x < 1.5)
972 {
973 return -2.5 + x*(5.0 - 2.0*x);
974 }
975 else if(x < 2.5)
976 {
977 x = 2.5 - x;
978 return x*x / 2.0;
979 }
980 else
981 return 0.0;
982 }
983 case 3:
984 {
985 double s = x < 0.0 ?
986 -1.0 :
987 1.0;
988 x = VIGRA_CSTD::fabs(x);
989 if(x <= 0.5)
990 {
991 return s*x*6.0;
992 }
993 else if(x < 1.5)
994 {
995 return s*(5.0 - 4.0*x);
996 }
997 else if(x < 2.5)
998 {
999 return s*(x - 2.5);
1000 }
1001 else
1002 return 0.0;
1003 }
1004 case 4:
1005 {
1006 return x < 0.0
1007 ? x < -2.5
1008 ? 0.0
1009 : x < -1.5
1010 ? 1.0
1011 : x < -0.5
1012 ? -4.0
1013 : 6.0
1014 : x < 0.5
1015 ? 6.0
1016 : x < 1.5
1017 ? -4.0
1018 : x < 2.5
1019 ? 1.0
1020 : 0.0;
1021 }
1022 default:
1023 return 0.0;
1024 }
1025 }
1026
1027 typedef BSpline<4, double> QuarticBSplineKernel;
1028
1029 /********************************************************/
1030 /* */
1031 /* BSpline<5, T> */
1032 /* */
1033 /********************************************************/
1034
1035 template <class T>
1036 class BSpline<5, T>
1037 {
1038 public:
1039
1040 typedef T value_type;
1041 typedef T argument_type;
1042 typedef T first_argument_type;
1043 typedef unsigned int second_argument_type;
1044 typedef T result_type;
1045 enum StaticOrder { order = 5 };
1046
1047 explicit BSpline(unsigned int derivativeOrder = 0)
1048 : derivativeOrder_(derivativeOrder)
1049 {}
1050
1051 result_type operator()(argument_type x) const
1052 {
1053 return exec(x, derivativeOrder_);
1054 }
1055
1056 result_type operator()(first_argument_type x, second_argument_type derivative_order) const
1057 {
1058 return exec(x, derivativeOrder_ + derivative_order);
1059 }
1060
1061 template <class U, int N>
1062 autodiff::DualVector<U, N> operator()(autodiff::DualVector<U, N> x) const
1063 {
1064 x = abs(x);
1065 if(x <= 1.0)
1066 {
1067 return 0.55 + x*x*(-0.5 + x*x*(0.25 - x/12.0));
1068 }
1069 else if(x < 2.0)
1070 {
1071 return 17.0/40.0 + x*(0.625 + x*(-1.75 + x*(1.25 + x*(-0.375 + x/24.0))));
1072 }
1073 else if(x < 3.0)
1074 {
1075 x = 3.0 - x;
1076 return x*sq(x*x) / 120.0;
1077 }
1078 else
1079 return autodiff::DualVector<U, N>(0.0);
1080 }
1081
1082 result_type dx(argument_type x) const
1083 { return operator()(x, 1); }
1084
1085 result_type dxx(argument_type x) const
1086 { return operator()(x, 2); }
1087
1088 result_type dx3(argument_type x) const
1089 { return operator()(x, 3); }
1090
1091 result_type dx4(argument_type x) const
1092 { return operator()(x, 4); }
1093
1094 value_type operator[](value_type x) const
1095 { return operator()(x); }
1096
1097 double radius() const
1098 { return 3.0; }
1099
1100 unsigned int derivativeOrder() const
1101 { return derivativeOrder_; }
1102
1103 ArrayVector<double> const & prefilterCoefficients() const
1104 {
1105 return prefilterCoefficients_;
1106 }
1107
1108 typedef T WeightMatrix[6][6];
1109
1110 static WeightMatrix const & weights()
1111 {
1112 return weightMatrix_;
1113 }
1114
1115 protected:
1116 result_type exec(first_argument_type x, second_argument_type derivative_order) const;
1117
1118 unsigned int derivativeOrder_;
1119 static ArrayVector<double> prefilterCoefficients_;
1120 static WeightMatrix weightMatrix_;
1121 };
1122
1123 template <class T>
1124 ArrayVector<double> BSpline<5, T>::prefilterCoefficients_(BSplineBase<5, T>::getPrefilterCoefficients());
1125
1126 template <class T>
1127 typename BSpline<5, T>::WeightMatrix BSpline<5, T>::weightMatrix_ =
1128 {{ 1.0/120.0, 13.0/60.0, 11.0/20.0, 13.0/60.0, 1.0/120.0, 0.0},
1129 {-1.0/24.0, -5.0/12.0, 0.0, 5.0/12.0, 1.0/24.0, 0.0},
1130 { 1.0/12.0, 1.0/6.0, -0.5, 1.0/6.0, 1.0/12.0, 0.0},
1131 {-1.0/12.0, 1.0/6.0, 0.0, -1.0/6.0, 1.0/12.0, 0.0},
1132 { 1.0/24.0, -1.0/6.0, 0.25, -1.0/6.0, 1.0/24.0, 0.0},
1133 {-1.0/120.0, 1.0/24.0, -1.0/12.0, 1.0/12.0, -1.0/24.0, 1.0/120.0}};
1134
1135 template <class T>
1136 typename BSpline<5, T>::result_type
1137 BSpline<5, T>::exec(first_argument_type x, second_argument_type derivative_order) const
1138 {
1139 switch(derivative_order)
1140 {
1141 case 0:
1142 {
1143 x = VIGRA_CSTD::fabs(x);
1144 if(x <= 1.0)
1145 {
1146 return 0.55 + x*x*(-0.5 + x*x*(0.25 - x/12.0));
1147 }
1148 else if(x < 2.0)
1149 {
1150 return 17.0/40.0 + x*(0.625 + x*(-1.75 + x*(1.25 + x*(-0.375 + x/24.0))));
1151 }
1152 else if(x < 3.0)
1153 {
1154 x = 3.0 - x;
1155 return x*sq(x*x) / 120.0;
1156 }
1157 else
1158 return 0.0;
1159 }
1160 case 1:
1161 {
1162 double s = x < 0.0 ?
1163 -1.0 :
1164 1.0;
1165 x = VIGRA_CSTD::fabs(x);
1166 if(x <= 1.0)
1167 {
1168 return s*x*(-1.0 + x*x*(1.0 - 5.0/12.0*x));
1169 }
1170 else if(x < 2.0)
1171 {
1172 return s*(0.625 + x*(-3.5 + x*(3.75 + x*(-1.5 + 5.0/24.0*x))));
1173 }
1174 else if(x < 3.0)
1175 {
1176 x = 3.0 - x;
1177 return s*sq(x*x) / -24.0;
1178 }
1179 else
1180 return 0.0;
1181 }
1182 case 2:
1183 {
1184 x = VIGRA_CSTD::fabs(x);
1185 if(x <= 1.0)
1186 {
1187 return -1.0 + x*x*(3.0 -5.0/3.0*x);
1188 }
1189 else if(x < 2.0)
1190 {
1191 return -3.5 + x*(7.5 + x*(-4.5 + 5.0/6.0*x));
1192 }
1193 else if(x < 3.0)
1194 {
1195 x = 3.0 - x;
1196 return x*x*x / 6.0;
1197 }
1198 else
1199 return 0.0;
1200 }
1201 case 3:
1202 {
1203 double s = x < 0.0 ?
1204 -1.0 :
1205 1.0;
1206 x = VIGRA_CSTD::fabs(x);
1207 if(x <= 1.0)
1208 {
1209 return s*x*(6.0 - 5.0*x);
1210 }
1211 else if(x < 2.0)
1212 {
1213 return s*(7.5 + x*(-9.0 + 2.5*x));
1214 }
1215 else if(x < 3.0)
1216 {
1217 x = 3.0 - x;
1218 return -0.5*s*x*x;
1219 }
1220 else
1221 return 0.0;
1222 }
1223 case 4:
1224 {
1225 x = VIGRA_CSTD::fabs(x);
1226 if(x <= 1.0)
1227 {
1228 return 6.0 - 10.0*x;
1229 }
1230 else if(x < 2.0)
1231 {
1232 return -9.0 + 5.0*x;
1233 }
1234 else if(x < 3.0)
1235 {
1236 return 3.0 - x;
1237 }
1238 else
1239 return 0.0;
1240 }
1241 case 5:
1242 {
1243 return x < 0.0 ?
1244 x < -2.0 ?
1245 x < -3.0 ?
1246 0.0
1247 : 1.0
1248 : x < -1.0 ?
1249 -5.0
1250 : 10.0
1251 : x < 2.0 ?
1252 x < 1.0 ?
1253 -10.0
1254 : 5.0
1255 : x < 3.0 ?
1256 -1.0
1257 : 0.0;
1258 }
1259 default:
1260 return 0.0;
1261 }
1262 }
1263
1264 typedef BSpline<5, double> QuinticBSplineKernel;
1265
1266 #endif // NO_PARTIAL_TEMPLATE_SPECIALIZATION
1267
1268 /********************************************************/
1269 /* */
1270 /* CatmullRomSpline */
1271 /* */
1272 /********************************************************/
1273
1274 /** Interpolating 3-rd order splines.
1275
1276 Implements the Catmull/Rom cardinal function
1277
1278 \f[ f(x) = \left\{ \begin{array}{ll}
1279 \frac{3}{2}x^3 - \frac{5}{2}x^2 + 1 & |x| \leq 1 \\
1280 -\frac{1}{2}x^3 + \frac{5}{2}x^2 -4x + 2 & |x| \leq 2 \\
1281 0 & \mbox{otherwise}
1282 \end{array}\right.
1283 \f]
1284
1285 It can be used as a functor, and as a kernel for
1286 \ref resamplingConvolveImage() to create a differentiable interpolant
1287 of an image. However, it should be noted that a twice differentiable
1288 interpolant can be created with only slightly more effort by recursive
1289 prefiltering followed by convolution with a 3rd order B-spline.
1290
1291 <b>\#include</b> <vigra/splines.hxx><br>
1292 Namespace: vigra
1293 */
1294 template <class T = double>
1295 class CatmullRomSpline
1296 {
1297 public:
1298 /** the kernel's value type
1299 */
1300 typedef T value_type;
1301 /** the unary functor's argument type
1302 */
1303 typedef T argument_type;
1304 /** the unary functor's result type
1305 */
1306 typedef T result_type;
1307 /** the splines polynomial order
1308 */
1309 enum StaticOrder { order = 3 };
1310
1311 /** function (functor) call
1312 */
1313 result_type operator()(argument_type x) const;
1314
1315 /** index operator -- same as operator()
1316 */
1317 T operator[] (T x) const
1318 { return operator()(x); }
1319
1320 /** Radius of the function's support.
1321 Needed for \ref resamplingConvolveImage(), always 2.
1322 */
1323 int radius() const
1324 {return 2;}
1325
1326 /** Derivative order of the function: always 0.
1327 */
1328 unsigned int derivativeOrder() const
1329 { return 0; }
1330
1331 /** Prefilter coefficients for compatibility with \ref vigra::BSpline.
1332 (array has zero length, since prefiltering is not necessary).
1333 */
1334 ArrayVector<double> const & prefilterCoefficients() const
1335 {
1336 return prefilterCoefficients_;
1337 }
1338
1339 protected:
1340 static ArrayVector<double> prefilterCoefficients_;
1341 };
1342
1343 template <class T>
1344 ArrayVector<double> CatmullRomSpline<T>::prefilterCoefficients_;
1345
1346 template <class T>
1347 typename CatmullRomSpline<T>::result_type
1348 CatmullRomSpline<T>::operator()(argument_type x) const
1349 {
1350 x = VIGRA_CSTD::fabs(x);
1351 if (x <= 1.0)
1352 {
1353 return 1.0 + x * x * (-2.5 + 1.5 * x);
1354 }
1355 else if (x >= 2.0)
1356 {
1357 return 0.0;
1358 }
1359 else
1360 {
1361 return 2.0 + x * (-4.0 + x * (2.5 - 0.5 * x));
1362 }
1363 }
1364
1365
1366 //@}
1367
1368 } // namespace vigra
1369
1370
1371 #endif /* VIGRA_SPLINES_HXX */
vigra::CatmullRomSpline::operator[]
T operator[](T x) const
Definition: splines.hxx:1317
vigra::CatmullRomSpline::StaticOrder
StaticOrder
Definition: splines.hxx:1309
vigra::BSplineBase::radius
double radius() const
Definition: splines.hxx:149
vigra::BSplineBase::operator[]
value_type operator[](value_type x) const
Definition: splines.hxx:143
vigra::CatmullRomSpline::result_type
T result_type
Definition: splines.hxx:1306
vigra::CatmullRomSpline::argument_type
T argument_type
Definition: splines.hxx:1303
vigra::BSplineBase::prefilterCoefficients
ArrayVector< double > const & prefilterCoefficients() const
Definition: splines.hxx:165
vigra::BSplineBase::weights
static WeightMatrix const & weights()
Definition: splines.hxx:177
vigra::BSpline
Definition: splines.hxx:274
vigra::BSplineBase< ORDER, double >::StaticOrder
StaticOrder
Definition: splines.hxx:112
vigra::BSplineBase
Definition: splines.hxx:89
vigra::BSplineBase::argument_type
T argument_type
Definition: splines.hxx:100
vigra::BSplineBase::first_argument_type
T first_argument_type
Definition: splines.hxx:103
vigra::ArrayVector< double >
vigra::sq
NumericTraits< T >::Promote sq(T t)
The square function.
Definition: mathutil.hxx:382
vigra::BSplineBase::operator()
result_type operator()(argument_type x) const
Definition: splines.hxx:126
vigra::CatmullRomSpline::radius
int radius() const
Definition: splines.hxx:1323
vigra::CatmullRomSpline::derivativeOrder
unsigned int derivativeOrder() const
Definition: splines.hxx:1328
vigra::CatmullRomSpline::value_type
T value_type
Definition: splines.hxx:1300
vigra::BSplineBase::derivativeOrder
unsigned int derivativeOrder() const
Definition: splines.hxx:154
vigra::BSplineBase::BSplineBase
BSplineBase(unsigned int derivativeOrder=0)
Definition: splines.hxx:117
vigra::BSplineBase::second_argument_type
unsigned int second_argument_type
Definition: splines.hxx:106
vigra::CatmullRomSpline::prefilterCoefficients
ArrayVector< double > const & prefilterCoefficients() const
Definition: splines.hxx:1334
vigra::BSplineBase::result_type
T result_type
Definition: splines.hxx:109
vigra::abs
FFTWComplex< R >::NormType abs(const FFTWComplex< R > &a)
absolute value (= magnitude)
Definition: fftw3.hxx:1002
vigra::BSpline::BSpline
BSpline(unsigned int derivativeOrder=0)
Definition: splines.hxx:280
vigra::BSplineBase::operator()
result_type operator()(first_argument_type x, second_argument_type derivative_order) const
Definition: splines.hxx:136
vigra::BSplineBase::value_type
T value_type
Definition: splines.hxx:93
vigra::CatmullRomSpline::operator()
result_type operator()(argument_type x) const
Definition: splines.hxx:1348
vigra::sqrt
SquareRootTraits< FixedPoint< IntBits, FracBits > >::SquareRootResult sqrt(FixedPoint< IntBits, FracBits > v)
square root.
Definition: fixedpoint.hxx:616
vigra::CatmullRomSpline
Definition: splines.hxx:1295

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany | html generated using doxygen and Python vigra 1.11.1 (Fri May 19 2017)