vigra - vigra/recursiveconvolution.hxx Source File

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

recursiveconvolution.hxx |

1 /************************************************************************/
2 /* */
3 /* Copyright 1998-2002 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
37 #ifndef VIGRA_RECURSIVECONVOLUTION_HXX
38 #define VIGRA_RECURSIVECONVOLUTION_HXX
39
40 #include <cmath>
41 #include <vector>
42 #include "utilities.hxx"
43 #include "numerictraits.hxx"
44 #include "imageiteratoradapter.hxx"
45 #include "bordertreatment.hxx"
46 #include "array_vector.hxx"
47 #include "multi_shape.hxx"
48
49 namespace vigra {
50
51 /********************************************************/
52 /* */
53 /* Recursive convolution functions */
54 /* */
55 /********************************************************/
56
57 /** \addtogroup RecursiveConvolution Recursive convolution functions
58
59 First order recursive filters and their specialization for
60 the exponential filter and its derivatives (1D and separable 2D).
61 These filters are very fast, and the speed does not depend on the
62 filter size.
63 */
64 //@{
65
66 /********************************************************/
67 /* */
68 /* recursiveFilterLine */
69 /* */
70 /********************************************************/
71
72 /** \brief Performs a 1-dimensional recursive convolution of the source signal.
73
74 The function performs a causal and an anti-causal first or second order
75 recursive filtering with the given filter parameter <TT>b1</TT> and
76 border treatment <TT>border</TT> (first order filter, <TT>b2 = 0</TT>) or parameters
77 <TT>b1, b2</TT> and <TT>BORDER_TREATMENT_REFLECT</TT> (second order filter). Thus,
78 the result is always a filtering with linear phase.
79 \f[
80 \begin{array}{rcl}
81 a_{i, causal} & = & source_i + b1 * a_{i-1, causal} + b2 * a_{i-2, causal} \\
82 a_{i, anticausal} & = & source_i + b1 * a_{i+1, anticausal} + b2 * a_{i+2, anticausal} \\
83 dest_i & = & \frac{1 - b1 - b2}{1 + b1 + b2}(a_{i, causal} + a_{i, anticausal} - source_i)
84 \end{array}
85 \f]
86
87 The signal's value_type (SrcAccessor::value_type) must be a
88 linear space over <TT>double</TT>,
89 i.e. addition of source values, multiplication with <TT>double</TT>,
90 and <TT>NumericTraits</TT> must be defined.
91
92 <b> Declaration:</b>
93
94 <b>First order recursive filter:</b>
95
96 \code
97 namespace vigra {
98 template <class SrcIterator, class SrcAccessor,
99 class DestIterator, class DestAccessor>
100 void recursiveFilterLine(SrcIterator is, SrcIterator isend, SrcAccessor as,
101 DestIterator id, DestAccessor ad,
102 double b1, BorderTreatmentMode border)
103 }
104 \endcode
105
106 <b>Second order recursive filter:</b>
107
108 \code
109 namespace vigra {
110 template <class SrcIterator, class SrcAccessor,
111 class DestIterator, class DestAccessor>
112 void recursiveFilterLine(SrcIterator is, SrcIterator isend, SrcAccessor as,
113 DestIterator id, DestAccessor ad,
114 double b1, double b2)
115 }
116 \endcode
117
118 <b> Usage:</b>
119
120 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
121 Namespace: vigra
122
123
124 \code
125 vector<float> src, dest;
126 ...
127
128 DefaultAccessor<vector<float>::iterator, float> FAccessor;
129
130
131 recursiveFilterLine(src.begin(), src.end(), FAccessor(),
132 dest.begin(), FAccessor(),
133 0.5, BORDER_TREATMENT_REFLECT);
134 \endcode
135
136 <b> Required Interface:</b>
137
138 \code
139 RandomAccessIterator is, isend;
140 RandomAccessIterator id;
141
142 SrcAccessor src_accessor;
143 DestAccessor dest_accessor;
144
145 NumericTraits<SrcAccessor::value_type>::RealPromote s = src_accessor(is);
146 double d;
147
148 s = s + s;
149 s = d * s;
150
151 dest_accessor.set(
152 NumericTraits<DestAccessor::value_type>::fromRealPromote(s), id);
153 \endcode
154
155 <b> Preconditions:</b>
156
157 \code
158 -1 < b < 1
159 \endcode
160
161 */
162 doxygen_overloaded_function(template <...> void recursiveFilterLine)
163
164 template <class SrcIterator, class SrcAccessor,
165 class DestIterator, class DestAccessor>
166 void recursiveFilterLine(SrcIterator is, SrcIterator isend, SrcAccessor as,
167 DestIterator id, DestAccessor ad, double b, BorderTreatmentMode border)
168 {
169 int w = isend - is;
170 SrcIterator istart = is;
171
172 int x;
173
174 vigra_precondition(-1.0 < b && b < 1.0,
175 "recursiveFilterLine(): -1 < factor < 1 required.\n");
176
177 // trivial case: b == 0.0 is an identity filter => simply copy the data and return
178 if(b == 0.0)
179 {
180 for(; is != isend; ++is, ++id)
181 {
182 ad.set(as(is), id);
183 }
184 return;
185 }
186
187 double eps = 0.00001;
188 int kernelw = std::min(w-1, (int)(VIGRA_CSTD::log(eps)/VIGRA_CSTD::log(VIGRA_CSTD::fabs(b))));
189
190 typedef typename
191 NumericTraits<typename SrcAccessor::value_type>::RealPromote TempType;
192 typedef NumericTraits<typename DestAccessor::value_type> DestTraits;
193 typedef typename DestTraits::RealPromote RealPromote;
194
195 // store result of causal filtering
196 std::vector<TempType> vline(w);
197 typename std::vector<TempType>::iterator line = vline.begin();
198
199 double norm = (1.0 - b) / (1.0 + b);
200
201 TempType old;
202
203 if(border == BORDER_TREATMENT_REPEAT ||
204 border == BORDER_TREATMENT_AVOID)
205 {
206 old = TempType((1.0 / (1.0 - b)) * as(is));
207 }
208 else if(border == BORDER_TREATMENT_REFLECT)
209 {
210 is += kernelw;
211 old = TempType((1.0 / (1.0 - b)) * as(is));
212 for(x = 0; x < kernelw; ++x, --is)
213 old = TempType(as(is) + b * old);
214 }
215 else if(border == BORDER_TREATMENT_WRAP)
216 {
217 is = isend - kernelw;
218 old = TempType((1.0 / (1.0 - b)) * as(is));
219 for(x = 0; x < kernelw; ++x, ++is)
220 old = TempType(as(is) + b * old);
221 }
222 else if(border == BORDER_TREATMENT_CLIP ||
223 border == BORDER_TREATMENT_ZEROPAD)
224 {
225 old = NumericTraits<TempType>::zero();
226 }
227 else
228 {
229 vigra_fail("recursiveFilterLine(): Unknown border treatment mode.\n");
230 old = NumericTraits<TempType>::zero(); // fix a stupid warning
231 }
232
233 // left side of filter
234 for(x=0, is = istart; x < w; ++x, ++is)
235 {
236 old = TempType(as(is) + b * old);
237 line[x] = old;
238 }
239
240 // right side of the filter
241 if(border == BORDER_TREATMENT_REPEAT ||
242 border == BORDER_TREATMENT_AVOID)
243 {
244 is = isend - 1;
245 old = TempType((1.0 / (1.0 - b)) * as(is));
246 }
247 else if(border == BORDER_TREATMENT_REFLECT)
248 {
249 old = line[w-2];
250 }
251 else if(border == BORDER_TREATMENT_WRAP)
252 {
253 is = istart + kernelw - 1;
254 old = TempType((1.0 / (1.0 - b)) * as(is));
255 for(x = 0; x < kernelw; ++x, --is)
256 old = TempType(as(is) + b * old);
257 }
258 else if(border == BORDER_TREATMENT_CLIP ||
259 border == BORDER_TREATMENT_ZEROPAD)
260 {
261 old = NumericTraits<TempType>::zero();
262 }
263
264 is = isend - 1;
265 id += w - 1;
266 if(border == BORDER_TREATMENT_CLIP)
267 {
268 // correction factors for b
269 double bright = b;
270 double bleft = VIGRA_CSTD::pow(b, w);
271
272 for(x=w-1; x>=0; --x, --is, --id)
273 {
274 TempType f = TempType(b * old);
275 old = as(is) + f;
276 norm = (1.0 - b) / (1.0 + b - bleft - bright);
277 bleft /= b;
278 bright *= b;
279 ad.set(norm * (line[x] + f), id);
280 }
281 }
282 else if(border == BORDER_TREATMENT_AVOID)
283 {
284 for(x=w-1; x >= kernelw; --x, --is, --id)
285 {
286 TempType f = TempType(b * old);
287 old = as(is) + f;
288 if(x < w - kernelw)
289 ad.set(DestTraits::fromRealPromote(RealPromote(norm * (line[x] + f))), id);
290 }
291 }
292 else
293 {
294 for(x=w-1; x>=0; --x, --is, --id)
295 {
296 TempType f = TempType(b * old);
297 old = as(is) + f;
298 ad.set(DestTraits::fromRealPromote(RealPromote(norm * (line[x] + f))), id);
299 }
300 }
301 }
302
303 /********************************************************/
304 /* */
305 /* recursiveFilterLine (2nd order) */
306 /* */
307 /********************************************************/
308
309 template <class SrcIterator, class SrcAccessor,
310 class DestIterator, class DestAccessor>
311 void recursiveFilterLine(SrcIterator is, SrcIterator isend, SrcAccessor as,
312 DestIterator id, DestAccessor ad, double b1, double b2)
313 {
314 int w = isend - is;
315 int x;
316
317 typedef typename
318 NumericTraits<typename SrcAccessor::value_type>::RealPromote TempType;
319
320 // speichert den Ergebnis der linkseitigen Filterung.
321 std::vector<TempType> vline(w+1);
322 typename std::vector<TempType>::iterator line = vline.begin();
323
324 double norm = 1.0 - b1 - b2;
325 double norm1 = (1.0 - b1 - b2) / (1.0 + b1 + b2);
326 double norm2 = norm * norm;
327
328
329 // init left side of filter
330 int kernelw = std::min(w-1, std::max(8, (int)(1.0 / norm + 0.5)));
331 is += (kernelw - 2);
332 line[kernelw] = as(is);
333 line[kernelw-1] = as(is);
334 for(x = kernelw - 2; x > 0; --x, --is)
335 {
336 line[x] = detail::RequiresExplicitCast<TempType>::cast(as(is) + b1 * line[x+1] + b2 * line[x+2]);
337 }
338 line[0] = detail::RequiresExplicitCast<TempType>::cast(as(is) + b1 * line[1] + b2 * line[2]);
339 ++is;
340 line[1] = detail::RequiresExplicitCast<TempType>::cast(as(is) + b1 * line[0] + b2 * line[1]);
341 ++is;
342 for(x=2; x < w; ++x, ++is)
343 {
344 line[x] = detail::RequiresExplicitCast<TempType>::cast(as(is) + b1 * line[x-1] + b2 * line[x-2]);
345 }
346 line[w] = line[w-1];
347
348 line[w-1] = detail::RequiresExplicitCast<TempType>::cast(norm1 * (line[w-1] + b1 * line[w-2] + b2 * line[w-3]));
349 line[w-2] = detail::RequiresExplicitCast<TempType>::cast(norm1 * (line[w-2] + b1 * line[w] + b2 * line[w-2]));
350 id += w-1;
351 ad.set(line[w-1], id);
352 --id;
353 ad.set(line[w-2], id);
354 --id;
355 for(x=w-3; x>=0; --x, --id, --is)
356 {
357 line[x] = detail::RequiresExplicitCast<TempType>::cast(norm2 * line[x] + b1 * line[x+1] + b2 * line[x+2]);
358 ad.set(line[x], id);
359 }
360 }
361
362 /********************************************************/
363 /* */
364 /* recursiveGaussianFilterLine */
365 /* */
366 /********************************************************/
367
368 // AUTHOR: Sebastian Boppel
369
370 /** \brief Compute a 1-dimensional recursive approximation of Gaussian smoothing.
371
372 The function applies a causal and an anti-causal third order recursive filter
373 which optimally approximates the Gaussian filter, as proposed in
374
375 I. Young, L. van Vliet: <i>Recursive implementation of the Gaussian filter</i><br>
376 Signal Processing 44:139-151, 1995
377
378 The formulas for transforming the given scale parameter <tt>sigma</tt> into the actual filter coefficients
379 are taken from Luigi Rosa's Matlab implementation.
380
381 The signal's value_type (SrcAccessor::value_type) must be a
382 linear space over <TT>double</TT>, i.e. addition of source values, multiplication with <TT>double</TT>,
383 and <TT>NumericTraits</TT> must be defined.
384
385 <b> Declaration:</b>
386
387 \code
388 namespace vigra {
389 template <class SrcIterator, class SrcAccessor,
390 class DestIterator, class DestAccessor>
391 void
392 recursiveGaussianFilterLine(SrcIterator is, SrcIterator isend, SrcAccessor as,
393 DestIterator id, DestAccessor ad,
394 double sigma);
395 }
396 \endcode
397
398 <b> Usage:</b>
399
400 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
401 Namespace: vigra
402
403
404 \code
405 vector<float> src, dest;
406 ...
407
408 vigra::DefaultAccessor<vector<float>::iterator, float> FAccessor;
409 double sigma = 2.5;
410
411 vigra::recursiveGaussianFilterLine(src.begin(), src.end(), FAccessor(),
412 dest.begin(), FAccessor(),
413 sigma);
414 \endcode
415
416 <b> Required Interface:</b>
417
418 \code
419 RandomAccessIterator is, isend;
420 RandomAccessIterator id;
421
422 SrcAccessor src_accessor;
423 DestAccessor dest_accessor;
424
425 NumericTraits<SrcAccessor::value_type>::RealPromote s = src_accessor(is);
426 double d;
427
428 s = s + s;
429 s = d * s;
430
431 dest_accessor.set(
432 NumericTraits<DestAccessor::value_type>::fromRealPromote(s), id);
433 \endcode
434
435 <b> Preconditions:</b>
436
437 \code
438 0 <= sigma (absolute values are used for negative sigma)
439 \endcode
440
441 */
442 doxygen_overloaded_function(template <...> void recursiveGaussianFilterLine)
443
444 template <class SrcIterator, class SrcAccessor,
445 class DestIterator, class DestAccessor>
446 void
447 recursiveGaussianFilterLine(SrcIterator is, SrcIterator isend, SrcAccessor as,
448 DestIterator id, DestAccessor ad,
449 double sigma)
450 {
451 //coefficients taken out Luigi Rosa's implementation for Matlab
452 double q = 1.31564 * (std::sqrt(1.0 + 0.490811 * sigma*sigma) - 1.0);
453 double qq = q*q;
454 double qqq = qq*q;
455 double b0 = 1.0/(1.57825 + 2.44413*q + 1.4281*qq + 0.422205*qqq);
456 double b1 = (2.44413*q + 2.85619*qq + 1.26661*qqq)*b0;
457 double b2 = (-1.4281*qq - 1.26661*qqq)*b0;
458 double b3 = 0.422205*qqq*b0;
459 double B = 1.0 - (b1 + b2 + b3);
460
461 int w = isend - is;
462 vigra_precondition(w >= 4,
463 "recursiveGaussianFilterLine(): line must have at least length 4.");
464
465 int kernelw = std::min(w-4, (int)(4.0*sigma));
466
467 int x;
468
469 typedef typename
470 NumericTraits<typename SrcAccessor::value_type>::RealPromote TempType;
471
472 // speichert das Ergebnis der linkseitigen Filterung.
473 std::vector<TempType> yforward(w);
474
475 std::vector<TempType> ybackward(w, 0.0);
476
477 // initialise the filter for reflective boundary conditions
478 for(x=kernelw; x>=0; --x)
479 {
480 ybackward[x] = detail::RequiresExplicitCast<TempType>::cast(B*as(is, x) + (b1*ybackward[x+1]+b2*ybackward[x+2]+b3*ybackward[x+3]));
481 }
482
483 //from left to right - causal - forward
484 yforward[0] = detail::RequiresExplicitCast<TempType>::cast(B*as(is) + (b1*ybackward[1]+b2*ybackward[2]+b3*ybackward[3]));
485
486 ++is;
487 yforward[1] = detail::RequiresExplicitCast<TempType>::cast(B*as(is) + (b1*yforward[0]+b2*ybackward[1]+b3*ybackward[2]));
488
489 ++is;
490 yforward[2] = detail::RequiresExplicitCast<TempType>::cast(B*as(is) + (b1*yforward[1]+b2*yforward[0]+b3*ybackward[1]));
491
492 ++is;
493 for(x=3; x < w; ++x, ++is)
494 {
495 yforward[x] = detail::RequiresExplicitCast<TempType>::cast(B*as(is) + (b1*yforward[x-1]+b2*yforward[x-2]+b3*yforward[x-3]));
496 }
497
498 //from right to left - anticausal - backward
499 ybackward[w-1] = detail::RequiresExplicitCast<TempType>::cast(B*yforward[w-1] + (b1*yforward[w-2]+b2*yforward[w-3]+b3*yforward[w-4]));
500
501 ybackward[w-2] = detail::RequiresExplicitCast<TempType>::cast(B*yforward[w-2] + (b1*ybackward[w-1]+b2*yforward[w-2]+b3*yforward[w-3]));
502
503 ybackward[w-3] = detail::RequiresExplicitCast<TempType>::cast(B*yforward[w-3] + (b1*ybackward[w-2]+b2*ybackward[w-1]+b3*yforward[w-2]));
504
505 for(x=w-4; x>=0; --x)
506 {
507 ybackward[x] = detail::RequiresExplicitCast<TempType>::cast(B*yforward[x]+(b1*ybackward[x+1]+b2*ybackward[x+2]+b3*ybackward[x+3]));
508 }
509
510 // output
511 for(x=0; x < w; ++x, ++id)
512 {
513 ad.set(ybackward[x], id);
514 }
515 }
516
517
518 /********************************************************/
519 /* */
520 /* recursiveSmoothLine */
521 /* */
522 /********************************************************/
523
524 /** \brief Convolves the image with a 1-dimensional exponential filter.
525
526 This function calls \ref recursiveFilterLine() with <TT>b = exp(-1.0/scale)</TT>
527 and <TT>border = BORDER_TREATMENT_REPEAT</TT>. See
528 \ref recursiveFilterLine() for more documentation.
529
530 <b> Declaration:</b>
531
532 \code
533 namespace vigra {
534 template <class SrcIterator, class SrcAccessor,
535 class DestIterator, class DestAccessor>
536 void recursiveSmoothLine(SrcIterator is, SrcIterator isend, SrcAccessor as,
537 DestIterator id, DestAccessor ad, double scale)
538 }
539 \endcode
540
541 <b> Usage:</b>
542
543 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
544 Namespace: vigra
545
546
547 \code
548 vector<float> src, dest;
549 ...
550
551 vigra::DefaultAccessor<vector<float>::iterator, float> FAccessor;
552
553
554 vigra::recursiveSmoothLine(src.begin(), src.end(), FAccessor(),
555 dest.begin(), FAccessor(), 3.0);
556 \endcode
557
558 <b> Required Interface:</b>
559
560 \code
561 RandomAccessIterator is, isend;
562 RandomAccessIterator id;
563
564 SrcAccessor src_accessor;
565 DestAccessor dest_accessor;
566
567 NumericTraits<SrcAccessor::value_type>::RealPromote s = src_accessor(is);
568 double d;
569
570 s = s + s;
571 s = d * s;
572
573 dest_accessor.set(
574 NumericTraits<DestAccessor::value_type>::fromRealPromote(s), id);
575 \endcode
576
577 <b> Preconditions:</b>
578
579 \code
580 scale > 0
581 \endcode
582
583 */
584 doxygen_overloaded_function(template <...> void recursiveSmoothLine)
585
586 template <class SrcIterator, class SrcAccessor,
587 class DestIterator, class DestAccessor>
588 inline
589 void recursiveSmoothLine(SrcIterator is, SrcIterator isend, SrcAccessor as,
590 DestIterator id, DestAccessor ad, double scale)
591 {
592 vigra_precondition(scale >= 0,
593 "recursiveSmoothLine(): scale must be >= 0.\n");
594
595 double b = (scale == 0.0) ?
596 0.0 :
597 VIGRA_CSTD::exp(-1.0/scale);
598
599 recursiveFilterLine(is, isend, as, id, ad, b, BORDER_TREATMENT_REPEAT);
600 }
601
602 /********************************************************/
603 /* */
604 /* recursiveFirstDerivativeLine */
605 /* */
606 /********************************************************/
607
608 /** \brief Performs a 1 dimensional recursive convolution of the source signal.
609
610 It uses the first derivative an exponential <TT>d/dx exp(-abs(x)/scale)</TT> as
611 a kernel. The signal's value_type (SrcAccessor::value_type) must be a
612 linear space over <TT>double</TT>,
613 i.e. addition and subtraction of source values, multiplication with
614 <TT>double</TT>, and <TT>NumericTraits</TT> must be defined. Border
615 treatment is always <TT>BORDER_TREATMENT_REPEAT</TT>.
616
617 <b> Declaration:</b>
618
619 \code
620 namespace vigra {
621 template <class SrcIterator, class SrcAccessor,
622 class DestIterator, class DestAccessor>
623 void recursiveFirstDerivativeLine(SrcIterator is, SrcIterator isend, SrcAccessor as,
624 DestIterator id, DestAccessor ad, double scale)
625 }
626 \endcode
627
628 <b> Usage:</b>
629
630 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
631 Namespace: vigra
632
633
634 \code
635 vector<float> src, dest;
636 ...
637
638 vigra::DefaultAccessor<vector<float>::iterator, float> FAccessor;
639
640
641 vigra::recursiveFirstDerivativeLine(src.begin(), src.end(), FAccessor(),
642 dest.begin(), FAccessor(), 3.0);
643 \endcode
644
645 <b> Required Interface:</b>
646
647 \code
648 RandomAccessIterator is, isend;
649 RandomAccessIterator id;
650
651 SrcAccessor src_accessor;
652 DestAccessor dest_accessor;
653
654 NumericTraits<SrcAccessor::value_type>::RealPromote s = src_accessor(is);
655 double d;
656
657 s = s + s;
658 s = -s;
659 s = d * s;
660
661 dest_accessor.set(
662 NumericTraits<DestAccessor::value_type>::fromRealPromote(s), id);
663 \endcode
664
665 <b> Preconditions:</b>
666
667 \code
668 scale > 0
669 \endcode
670
671 */
672 doxygen_overloaded_function(template <...> void recursiveFirstDerivativeLine)
673
674 template <class SrcIterator, class SrcAccessor,
675 class DestIterator, class DestAccessor>
676 void recursiveFirstDerivativeLine(SrcIterator is, SrcIterator isend, SrcAccessor as,
677 DestIterator id, DestAccessor ad, double scale)
678 {
679 vigra_precondition(scale > 0,
680 "recursiveFirstDerivativeLine(): scale must be > 0.\n");
681
682 int w = isend -is;
683
684 int x;
685
686 typedef typename
687 NumericTraits<typename SrcAccessor::value_type>::RealPromote
688 TempType;
689 typedef NumericTraits<typename DestAccessor::value_type> DestTraits;
690
691 std::vector<TempType> vline(w);
692 typename std::vector<TempType>::iterator line = vline.begin();
693
694 double b = VIGRA_CSTD::exp(-1.0/scale);
695 double norm = (1.0 - b) * (1.0 - b) / 2.0 / b;
696 TempType old = (1.0 / (1.0 - b)) * as(is);
697
698 // left side of filter
699 for(x=0; x<w; ++x, ++is)
700 {
701 old = as(is) + b * old;
702 line[x] = -old;
703 }
704
705 // right side of the filter
706 --is;
707 old = (1.0 / (1.0 - b)) * as(is);
708 id += w;
709 ++is;
710
711 for(x=w-1; x>=0; --x)
712 {
713 --is;
714 --id;
715
716 old = as(is) + b * old;
717
718 ad.set(DestTraits::fromRealPromote(norm * (line[x] + old)), id);
719 }
720 }
721
722 /********************************************************/
723 /* */
724 /* recursiveSecondDerivativeLine */
725 /* */
726 /********************************************************/
727
728 /** \brief Performs a 1 dimensional recursive convolution of the source signal.
729
730 It uses the second derivative an exponential <TT>d2/dx2 exp(-abs(x)/scale)</TT> as
731 a kernel. The signal's value_type (SrcAccessor::value_type) must be a
732 linear space over <TT>double</TT>,
733 i.e. addition and subtraction of source values, multiplication with
734 <TT>double</TT>, and <TT>NumericTraits</TT> must be defined. Border
735 treatment is always <TT>BORDER_TREATMENT_REPEAT</TT>.
736
737 <b> Declaration:</b>
738
739 \code
740 namespace vigra {
741 template <class SrcIterator, class SrcAccessor,
742 class DestIterator, class DestAccessor>
743 void recursiveSecondDerivativeLine(SrcIterator is, SrcIterator isend, SrcAccessor as,
744 DestIterator id, DestAccessor ad, double scale)
745 }
746 \endcode
747
748 <b> Usage:</b>
749
750 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
751 Namespace: vigra
752
753
754 \code
755 vector<float> src, dest;
756 ...
757
758 vigra::DefaultAccessor<vector<float>::iterator, float> FAccessor;
759
760
761 vigra::recursiveSecondDerivativeLine(src.begin(), src.end(), FAccessor(),
762 dest.begin(), FAccessor(), 3.0);
763 \endcode
764
765 <b> Required Interface:</b>
766
767 \code
768 RandomAccessIterator is, isend;
769 RandomAccessIterator id;
770
771 SrcAccessor src_accessor;
772 DestAccessor dest_accessor;
773
774 NumericTraits<SrcAccessor::value_type>::RealPromote s = src_accessor(is);
775 double d;
776
777 s = s + s;
778 s = s - s;
779 s = d * s;
780
781 dest_accessor.set(
782 NumericTraits<DestAccessor::value_type>::fromRealPromote(s), id);
783 \endcode
784
785 <b> Preconditions:</b>
786
787 \code
788 scale > 0
789 \endcode
790
791 */
792 doxygen_overloaded_function(template <...> void recursiveSecondDerivativeLine)
793
794 template <class SrcIterator, class SrcAccessor,
795 class DestIterator, class DestAccessor>
796 void recursiveSecondDerivativeLine(SrcIterator is, SrcIterator isend, SrcAccessor as,
797 DestIterator id, DestAccessor ad, double scale)
798 {
799 vigra_precondition(scale > 0,
800 "recursiveSecondDerivativeLine(): scale must be > 0.\n");
801
802 int w = isend -is;
803
804 int x;
805
806 typedef typename
807 NumericTraits<typename SrcAccessor::value_type>::RealPromote
808 TempType;
809 typedef NumericTraits<typename DestAccessor::value_type> DestTraits;
810
811 std::vector<TempType> vline(w);
812 typename std::vector<TempType>::iterator line = vline.begin();
813
814 double b = VIGRA_CSTD::exp(-1.0/scale);
815 double a = -2.0 / (1.0 - b);
816 double norm = (1.0 - b) * (1.0 - b) * (1.0 - b) / (1.0 + b);
817 TempType old = detail::RequiresExplicitCast<TempType>::cast((1.0 / (1.0 - b)) * as(is));
818
819 // left side of filter
820 for(x=0; x<w; ++x, ++is)
821 {
822 line[x] = old;
823 old = detail::RequiresExplicitCast<TempType>::cast(as(is) + b * old);
824 }
825
826 // right side of the filter
827 --is;
828 old = detail::RequiresExplicitCast<TempType>::cast((1.0 / (1.0 - b)) * as(is));
829 id += w;
830 ++is;
831
832 for(x=w-1; x>=0; --x)
833 {
834 --is;
835 --id;
836
837 TempType f = detail::RequiresExplicitCast<TempType>::cast(old + a * as(is));
838 old = detail::RequiresExplicitCast<TempType>::cast(as(is) + b * old);
839 ad.set(DestTraits::fromRealPromote(detail::RequiresExplicitCast<TempType>::cast(norm * (line[x] + f))), id);
840 }
841 }
842
843 /********************************************************/
844 /* */
845 /* recursiveFilterX */
846 /* */
847 /********************************************************/
848
849 /** \brief Performs 1 dimensional recursive filtering (1st and 2nd order) in x direction.
850
851 It calls \ref recursiveFilterLine() for every row of the
852 image. See \ref recursiveFilterLine() for more information about
853 required interfaces and vigra_preconditions.
854
855 <b> Declarations:</b>
856
857 pass 2D array views:
858 \code
859 namespace vigra {
860 // first order filter
861 template <class T1, class S1,
862 class T2, class S2>
863 void
864 recursiveFilterX(MultiArrayView<2, T1, S1> const & src,
865 MultiArrayView<2, T2, S2> dest,
866 double b, BorderTreatmentMode border);
867
868 // second order filter
869 template <class T1, class S1,
870 class T2, class S2>
871 void
872 recursiveFilterX(MultiArrayView<2, T1, S1> const & src,
873 MultiArrayView<2, T2, S2> dest,
874 double b1, double b2);
875 }
876 \endcode
877
878 \deprecatedAPI{recursiveFilterX}
879 pass \ref ImageIterators and \ref DataAccessors :
880 \code
881 namespace vigra {
882 // first order filter
883 template <class SrcImageIterator, class SrcAccessor,
884 class DestImageIterator, class DestAccessor>
885 void recursiveFilterX(SrcImageIterator supperleft,
886 SrcImageIterator slowerright, SrcAccessor as,
887 DestImageIterator dupperleft, DestAccessor ad,
888 double b, BorderTreatmentMode border);
889
890 // second order filter
891 template <class SrcImageIterator, class SrcAccessor,
892 class DestImageIterator, class DestAccessor>
893 void recursiveFilterX(SrcImageIterator supperleft,
894 SrcImageIterator slowerright, SrcAccessor as,
895 DestImageIterator dupperleft, DestAccessor ad,
896 double b1, double b2);
897 }
898 \endcode
899 use argument objects in conjunction with \ref ArgumentObjectFactories :
900 \code
901 namespace vigra {
902 // first order filter
903 template <class SrcImageIterator, class SrcAccessor,
904 class DestImageIterator, class DestAccessor>
905 void recursiveFilterX(
906 triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
907 pair<DestImageIterator, DestAccessor> dest,
908 double b, BorderTreatmentMode border);
909
910 // second order filter
911 template <class SrcImageIterator, class SrcAccessor,
912 class DestImageIterator, class DestAccessor>
913 void recursiveFilterX(
914 triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
915 pair<DestImageIterator, DestAccessor> dest,
916 double b1, double b2);
917 }
918 \endcode
919 \deprecatedEnd
920
921 <b> Usage:</b>
922
923 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
924 Namespace: vigra
925
926 \code
927 MultiArray<2, float> src(w,h), dest(w,h);
928 ...
929
930 // apply a first-order filter to the x-axis
931 recursiveFilterX(src, dest, 0.5, BORDER_TREATMENT_REFLECT);
932 \endcode
933
934 \deprecatedUsage{recursiveFilterX}
935 \code
936 vigra::FImage src(w,h), dest(w,h);
937 ...
938
939 vigra::recursiveFilterX(srcImageRange(src), destImage(dest),
940 0.5, BORDER_TREATMENT_REFLECT);
941 \endcode
942 \deprecatedEnd
943 */
944 doxygen_overloaded_function(template <...> void recursiveFilterX)
945
946 template <class SrcImageIterator, class SrcAccessor,
947 class DestImageIterator, class DestAccessor>
948 void recursiveFilterX(SrcImageIterator supperleft,
949 SrcImageIterator slowerright, SrcAccessor as,
950 DestImageIterator dupperleft, DestAccessor ad,
951 double b, BorderTreatmentMode border)
952 {
953 int w = slowerright.x - supperleft.x;
954 int h = slowerright.y - supperleft.y;
955
956 int y;
957
958 for(y=0; y<h; ++y, ++supperleft.y, ++dupperleft.y)
959 {
960 typename SrcImageIterator::row_iterator rs = supperleft.rowIterator();
961 typename DestImageIterator::row_iterator rd = dupperleft.rowIterator();
962
963 recursiveFilterLine(rs, rs+w, as,
964 rd, ad,
965 b, border);
966 }
967 }
968
969 template <class SrcImageIterator, class SrcAccessor,
970 class DestImageIterator, class DestAccessor>
971 inline void
972 recursiveFilterX(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
973 pair<DestImageIterator, DestAccessor> dest,
974 double b, BorderTreatmentMode border)
975 {
976 recursiveFilterX(src.first, src.second, src.third,
977 dest.first, dest.second, b, border);
978 }
979
980 template <class T1, class S1,
981 class T2, class S2>
982 inline void
983 recursiveFilterX(MultiArrayView<2, T1, S1> const & src,
984 MultiArrayView<2, T2, S2> dest,
985 double b, BorderTreatmentMode border)
986 {
987 vigra_precondition(src.shape() == dest.shape(),
988 "recursiveFilterX(): shape mismatch between input and output.");
989 recursiveFilterX(srcImageRange(src),
990 destImage(dest), b, border);
991 }
992
993 /********************************************************/
994 /* */
995 /* recursiveFilterX (2nd order) */
996 /* */
997 /********************************************************/
998
999 template <class SrcImageIterator, class SrcAccessor,
1000 class DestImageIterator, class DestAccessor>
1001 void recursiveFilterX(SrcImageIterator supperleft,
1002 SrcImageIterator slowerright, SrcAccessor as,
1003 DestImageIterator dupperleft, DestAccessor ad,
1004 double b1, double b2)
1005 {
1006 int w = slowerright.x - supperleft.x;
1007 int h = slowerright.y - supperleft.y;
1008
1009 int y;
1010
1011 for(y=0; y<h; ++y, ++supperleft.y, ++dupperleft.y)
1012 {
1013 typename SrcImageIterator::row_iterator rs = supperleft.rowIterator();
1014 typename DestImageIterator::row_iterator rd = dupperleft.rowIterator();
1015
1016 recursiveFilterLine(rs, rs+w, as,
1017 rd, ad,
1018 b1, b2);
1019 }
1020 }
1021
1022 template <class SrcImageIterator, class SrcAccessor,
1023 class DestImageIterator, class DestAccessor>
1024 inline void
1025 recursiveFilterX(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1026 pair<DestImageIterator, DestAccessor> dest,
1027 double b1, double b2)
1028 {
1029 recursiveFilterX(src.first, src.second, src.third,
1030 dest.first, dest.second, b1, b2);
1031 }
1032
1033 template <class T1, class S1,
1034 class T2, class S2>
1035 inline void
1036 recursiveFilterX(MultiArrayView<2, T1, S1> const & src,
1037 MultiArrayView<2, T2, S2> dest,
1038 double b1, double b2)
1039 {
1040 vigra_precondition(src.shape() == dest.shape(),
1041 "recursiveFilterX(): shape mismatch between input and output.");
1042 recursiveFilterX(srcImageRange(src),
1043 destImage(dest), b1, b2);
1044 }
1045
1046 /********************************************************/
1047 /* */
1048 /* recursiveGaussianFilterX */
1049 /* */
1050 /********************************************************/
1051
1052 // AUTHOR: Sebastian Boppel
1053
1054 /** \brief Compute 1 dimensional recursive approximation of Gaussian smoothing in y direction.
1055
1056 It calls \ref recursiveGaussianFilterLine() for every column of the
1057 image. See \ref recursiveGaussianFilterLine() for more information about
1058 required interfaces and vigra_preconditions.
1059
1060 <b> Declarations:</b>
1061
1062 pass 2D array views:
1063 \code
1064 namespace vigra {
1065 template <class T1, class S1,
1066 class T2, class S2>
1067 void
1068 recursiveGaussianFilterX(MultiArrayView<2, T1, S1> const & src,
1069 MultiArrayView<2, T2, S2> dest,
1070 double sigma);
1071 }
1072 \endcode
1073
1074 \deprecatedAPI{recursiveGaussianFilterX}
1075 pass \ref ImageIterators and \ref DataAccessors :
1076 \code
1077 namespace vigra {
1078 template <class SrcImageIterator, class SrcAccessor,
1079 class DestImageIterator, class DestAccessor>
1080 void
1081 recursiveGaussianFilterX(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as,
1082 DestImageIterator dupperleft, DestAccessor ad,
1083 double sigma);
1084 }
1085 \endcode
1086 use argument objects in conjunction with \ref ArgumentObjectFactories :
1087 \code
1088 namespace vigra {
1089 template <class SrcImageIterator, class SrcAccessor,
1090 class DestImageIterator, class DestAccessor>
1091 void
1092 recursiveGaussianFilterX(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1093 pair<DestImageIterator, DestAccessor> dest,
1094 double sigma);
1095 }
1096 \endcode
1097 \deprecatedEnd
1098
1099 <b> Usage:</b>
1100
1101 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
1102 Namespace: vigra
1103
1104 \code
1105 MultiArray<2, float> src(w,h), dest(w,h);
1106 ...
1107
1108 recursiveGaussianFilterX(src, dest, 3.0);
1109 \endcode
1110
1111 \deprecatedUsage{recursiveGaussianFilterX}
1112 \code
1113 vigra::FImage src(w,h), dest(w,h);
1114 ...
1115
1116 vigra::recursiveGaussianFilterX(srcImageRange(src), destImage(dest), 3.0);
1117 \endcode
1118 \deprecatedEnd
1119 */
1120 doxygen_overloaded_function(template <...> void recursiveGaussianFilterX)
1121
1122 template <class SrcImageIterator, class SrcAccessor,
1123 class DestImageIterator, class DestAccessor>
1124 void
1125 recursiveGaussianFilterX(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as,
1126 DestImageIterator dupperleft, DestAccessor ad,
1127 double sigma)
1128 {
1129 int w = slowerright.x - supperleft.x;
1130 int h = slowerright.y - supperleft.y;
1131
1132 int y;
1133
1134 for(y=0; y<h; ++y, ++supperleft.y, ++dupperleft.y)
1135 {
1136 typename SrcImageIterator::row_iterator rs = supperleft.rowIterator();
1137 typename DestImageIterator::row_iterator rd = dupperleft.rowIterator();
1138
1139 recursiveGaussianFilterLine(rs, rs+w, as,
1140 rd, ad,
1141 sigma);
1142 }
1143 }
1144
1145 template <class SrcImageIterator, class SrcAccessor,
1146 class DestImageIterator, class DestAccessor>
1147 inline void
1148 recursiveGaussianFilterX(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1149 pair<DestImageIterator, DestAccessor> dest,
1150 double sigma)
1151 {
1152 recursiveGaussianFilterX(src.first, src.second, src.third,
1153 dest.first, dest.second, sigma);
1154 }
1155
1156 template <class T1, class S1,
1157 class T2, class S2>
1158 inline void
1159 recursiveGaussianFilterX(MultiArrayView<2, T1, S1> const & src,
1160 MultiArrayView<2, T2, S2> dest,
1161 double sigma)
1162 {
1163 vigra_precondition(src.shape() == dest.shape(),
1164 "recursiveGaussianFilterX(): shape mismatch between input and output.");
1165 recursiveGaussianFilterX(srcImageRange(src),
1166 destImage(dest), sigma);
1167 }
1168
1169 /********************************************************/
1170 /* */
1171 /* recursiveSmoothX */
1172 /* */
1173 /********************************************************/
1174
1175 /** \brief Performs 1 dimensional recursive smoothing in x direction.
1176
1177 It calls \ref recursiveSmoothLine() for every row of the
1178 image. See \ref recursiveSmoothLine() for more information about
1179 required interfaces and vigra_preconditions.
1180
1181 <b> Declarations:</b>
1182
1183 pass 2D array views:
1184 \code
1185 namespace vigra {
1186 template <class T1, class S1,
1187 class T2, class S2>
1188 void
1189 recursiveSmoothX(MultiArrayView<2, T1, S1> const & src,
1190 MultiArrayView<2, T2, S2> dest,
1191 double scale);
1192 }
1193 \endcode
1194
1195 \deprecatedAPI{recursiveSmoothX}
1196 pass \ref ImageIterators and \ref DataAccessors :
1197 \code
1198 namespace vigra {
1199 template <class SrcImageIterator, class SrcAccessor,
1200 class DestImageIterator, class DestAccessor>
1201 void recursiveSmoothX(SrcImageIterator supperleft,
1202 SrcImageIterator slowerright, SrcAccessor as,
1203 DestImageIterator dupperleft, DestAccessor ad,
1204 double scale)
1205 }
1206 \endcode
1207 use argument objects in conjunction with \ref ArgumentObjectFactories :
1208 \code
1209 namespace vigra {
1210 template <class SrcImageIterator, class SrcAccessor,
1211 class DestImageIterator, class DestAccessor>
1212 void recursiveSmoothX(
1213 triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1214 pair<DestImageIterator, DestAccessor> dest,
1215 double scale)
1216 }
1217 \endcode
1218 \deprecatedEnd
1219
1220 <b> Usage:</b>
1221
1222 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
1223 Namespace: vigra
1224
1225 \code
1226 MultiArray<2, float> src(w,h), dest(w,h);
1227 ...
1228
1229 recursiveSmoothX(src, dest, 3.0);
1230 \endcode
1231
1232 \deprecatedUsage{recursiveGaussianFilterX}
1233 \code
1234 vigra::FImage src(w,h), dest(w,h);
1235 ...
1236
1237 vigra::recursiveSmoothX(srcImageRange(src), destImage(dest), 3.0);
1238 \endcode
1239 \deprecatedEnd
1240 */
1241 doxygen_overloaded_function(template <...> void recursiveSmoothX)
1242
1243 template <class SrcImageIterator, class SrcAccessor,
1244 class DestImageIterator, class DestAccessor>
1245 void recursiveSmoothX(SrcImageIterator supperleft,
1246 SrcImageIterator slowerright, SrcAccessor as,
1247 DestImageIterator dupperleft, DestAccessor ad,
1248 double scale)
1249 {
1250 int w = slowerright.x - supperleft.x;
1251 int h = slowerright.y - supperleft.y;
1252
1253 int y;
1254
1255 for(y=0; y<h; ++y, ++supperleft.y, ++dupperleft.y)
1256 {
1257 typename SrcImageIterator::row_iterator rs = supperleft.rowIterator();
1258 typename DestImageIterator::row_iterator rd = dupperleft.rowIterator();
1259
1260 recursiveSmoothLine(rs, rs+w, as,
1261 rd, ad,
1262 scale);
1263 }
1264 }
1265
1266 template <class SrcImageIterator, class SrcAccessor,
1267 class DestImageIterator, class DestAccessor>
1268 inline void
1269 recursiveSmoothX(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1270 pair<DestImageIterator, DestAccessor> dest,
1271 double scale)
1272 {
1273 recursiveSmoothX(src.first, src.second, src.third,
1274 dest.first, dest.second, scale);
1275 }
1276
1277 template <class T1, class S1,
1278 class T2, class S2>
1279 inline void
1280 recursiveSmoothX(MultiArrayView<2, T1, S1> const & src,
1281 MultiArrayView<2, T2, S2> dest,
1282 double scale)
1283 {
1284 vigra_precondition(src.shape() == dest.shape(),
1285 "recursiveSmoothX(): shape mismatch between input and output.");
1286 recursiveSmoothX(srcImageRange(src),
1287 destImage(dest), scale);
1288 }
1289
1290 /********************************************************/
1291 /* */
1292 /* recursiveFilterY */
1293 /* */
1294 /********************************************************/
1295
1296 /** \brief Performs 1 dimensional recursive filtering (1st and 2nd order) in y direction.
1297
1298 It calls \ref recursiveFilterLine() for every column of the
1299 image. See \ref recursiveFilterLine() for more information about
1300 required interfaces and vigra_preconditions.
1301
1302 <b> Declarations:</b>
1303
1304 pass 2D array views:
1305 \code
1306 namespace vigra {
1307 // first order filter
1308 template <class T1, class S1,
1309 class T2, class S2>
1310 void
1311 recursiveFilterY(MultiArrayView<2, T1, S1> const & src,
1312 MultiArrayView<2, T2, S2> dest,
1313 double b, BorderTreatmentMode border);
1314
1315 // second order filter
1316 template <class T1, class S1,
1317 class T2, class S2>
1318 void
1319 recursiveFilterY(MultiArrayView<2, T1, S1> const & src,
1320 MultiArrayView<2, T2, S2> dest,
1321 double b1, double b2);
1322 }
1323 \endcode
1324
1325 \deprecatedAPI{recursiveFilterY}
1326 pass \ref ImageIterators and \ref DataAccessors :
1327 \code
1328 namespace vigra {
1329 // first order filter
1330 template <class SrcImageIterator, class SrcAccessor,
1331 class DestImageIterator, class DestAccessor>
1332 void recursiveFilterY(SrcImageIterator supperleft,
1333 SrcImageIterator slowerright, SrcAccessor as,
1334 DestImageIterator dupperleft, DestAccessor ad,
1335 double b, BorderTreatmentMode border);
1336
1337 // second order filter
1338 template <class SrcImageIterator, class SrcAccessor,
1339 class DestImageIterator, class DestAccessor>
1340 void recursiveFilterY(SrcImageIterator supperleft,
1341 SrcImageIterator slowerright, SrcAccessor as,
1342 DestImageIterator dupperleft, DestAccessor ad,
1343 double b1, double b2);
1344 }
1345 \endcode
1346 use argument objects in conjunction with \ref ArgumentObjectFactories :
1347 \code
1348 namespace vigra {
1349 // first order filter
1350 template <class SrcImageIterator, class SrcAccessor,
1351 class DestImageIterator, class DestAccessor>
1352 void recursiveFilterY(
1353 triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1354 pair<DestImageIterator, DestAccessor> dest,
1355 double b, BorderTreatmentMode border);
1356
1357 // second order filter
1358 template <class SrcImageIterator, class SrcAccessor,
1359 class DestImageIterator, class DestAccessor>
1360 void recursiveFilterY(
1361 triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1362 pair<DestImageIterator, DestAccessor> dest,
1363 double b1, double b2);
1364 }
1365 \endcode
1366 \deprecatedEnd
1367
1368 <b> Usage:</b>
1369
1370 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
1371 Namespace: vigra
1372
1373 \code
1374 MultiArray<2, float> src(w,h), dest(w,h);
1375 ...
1376
1377 // apply a second-order filter to the y-axis
1378 recursiveFilterY(src, dest, -0.6, -0.06);
1379 \endcode
1380
1381 \deprecatedUsage{recursiveFilterY}
1382 \code
1383 vigra::FImage src(w,h), dest(w,h);
1384 ...
1385
1386 vigra::recursiveFilterY(srcImageRange(src), destImage(dest), -0.6, -0.06);
1387 \endcode
1388 \deprecatedEnd
1389 */
1390 doxygen_overloaded_function(template <...> void recursiveFilterY)
1391
1392 template <class SrcImageIterator, class SrcAccessor,
1393 class DestImageIterator, class DestAccessor>
1394 void recursiveFilterY(SrcImageIterator supperleft,
1395 SrcImageIterator slowerright, SrcAccessor as,
1396 DestImageIterator dupperleft, DestAccessor ad,
1397 double b, BorderTreatmentMode border)
1398 {
1399 int w = slowerright.x - supperleft.x;
1400 int h = slowerright.y - supperleft.y;
1401
1402 int x;
1403
1404 for(x=0; x<w; ++x, ++supperleft.x, ++dupperleft.x)
1405 {
1406 typename SrcImageIterator::column_iterator cs = supperleft.columnIterator();
1407 typename DestImageIterator::column_iterator cd = dupperleft.columnIterator();
1408
1409 recursiveFilterLine(cs, cs+h, as,
1410 cd, ad,
1411 b, border);
1412 }
1413 }
1414
1415 template <class SrcImageIterator, class SrcAccessor,
1416 class DestImageIterator, class DestAccessor>
1417 inline void
1418 recursiveFilterY(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1419 pair<DestImageIterator, DestAccessor> dest,
1420 double b, BorderTreatmentMode border)
1421 {
1422 recursiveFilterY(src.first, src.second, src.third,
1423 dest.first, dest.second, b, border);
1424 }
1425
1426 template <class T1, class S1,
1427 class T2, class S2>
1428 inline void
1429 recursiveFilterY(MultiArrayView<2, T1, S1> const & src,
1430 MultiArrayView<2, T2, S2> dest,
1431 double b, BorderTreatmentMode border)
1432 {
1433 vigra_precondition(src.shape() == dest.shape(),
1434 "recursiveFilterY(): shape mismatch between input and output.");
1435 recursiveFilterY(srcImageRange(src),
1436 destImage(dest), b, border);
1437 }
1438
1439 /********************************************************/
1440 /* */
1441 /* recursiveFilterY (2nd order) */
1442 /* */
1443 /********************************************************/
1444
1445 template <class SrcImageIterator, class SrcAccessor,
1446 class DestImageIterator, class DestAccessor>
1447 void recursiveFilterY(SrcImageIterator supperleft,
1448 SrcImageIterator slowerright, SrcAccessor as,
1449 DestImageIterator dupperleft, DestAccessor ad,
1450 double b1, double b2)
1451 {
1452 int w = slowerright.x - supperleft.x;
1453 int h = slowerright.y - supperleft.y;
1454
1455 int x;
1456
1457 for(x=0; x<w; ++x, ++supperleft.x, ++dupperleft.x)
1458 {
1459 typename SrcImageIterator::column_iterator cs = supperleft.columnIterator();
1460 typename DestImageIterator::column_iterator cd = dupperleft.columnIterator();
1461
1462 recursiveFilterLine(cs, cs+h, as,
1463 cd, ad,
1464 b1, b2);
1465 }
1466 }
1467
1468 template <class SrcImageIterator, class SrcAccessor,
1469 class DestImageIterator, class DestAccessor>
1470 inline void
1471 recursiveFilterY(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1472 pair<DestImageIterator, DestAccessor> dest,
1473 double b1, double b2)
1474 {
1475 recursiveFilterY(src.first, src.second, src.third,
1476 dest.first, dest.second, b1, b2);
1477 }
1478
1479 template <class T1, class S1,
1480 class T2, class S2>
1481 inline void
1482 recursiveFilterY(MultiArrayView<2, T1, S1> const & src,
1483 MultiArrayView<2, T2, S2> dest,
1484 double b1, double b2)
1485 {
1486 vigra_precondition(src.shape() == dest.shape(),
1487 "recursiveFilterY(): shape mismatch between input and output.");
1488 recursiveFilterY(srcImageRange(src),
1489 destImage(dest), b1, b2);
1490 }
1491
1492 /********************************************************/
1493 /* */
1494 /* recursiveGaussianFilterY */
1495 /* */
1496 /********************************************************/
1497
1498 // AUTHOR: Sebastian Boppel
1499
1500 /** \brief Compute 1 dimensional recursive approximation of Gaussian smoothing in y direction.
1501
1502 It calls \ref recursiveGaussianFilterLine() for every column of the
1503 image. See \ref recursiveGaussianFilterLine() for more information about
1504 required interfaces and vigra_preconditions.
1505
1506 <b> Declarations:</b>
1507
1508 pass 2D array views:
1509 \code
1510 namespace vigra {
1511 template <class T1, class S1,
1512 class T2, class S2>
1513 void
1514 recursiveGaussianFilterY(MultiArrayView<2, T1, S1> const & src,
1515 MultiArrayView<2, T2, S2> dest,
1516 double sigma);
1517 }
1518 \endcode
1519
1520 \deprecatedAPI{recursiveGaussianFilterY}
1521 pass \ref ImageIterators and \ref DataAccessors :
1522 \code
1523 namespace vigra {
1524 template <class SrcImageIterator, class SrcAccessor,
1525 class DestImageIterator, class DestAccessor>
1526 void
1527 recursiveGaussianFilterY(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as,
1528 DestImageIterator dupperleft, DestAccessor ad,
1529 double sigma);
1530 }
1531 \endcode
1532 use argument objects in conjunction with \ref ArgumentObjectFactories :
1533 \code
1534 namespace vigra {
1535 template <class SrcImageIterator, class SrcAccessor,
1536 class DestImageIterator, class DestAccessor>
1537 void
1538 recursiveGaussianFilterY(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1539 pair<DestImageIterator, DestAccessor> dest,
1540 double sigma);
1541 }
1542 \endcode
1543 \deprecatedEnd
1544
1545 <b> Usage:</b>
1546
1547 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
1548 Namespace: vigra
1549
1550 \code
1551 MultiArray<2, float> src(w,h), dest(w,h);
1552 ...
1553
1554 recursiveGaussianFilterY(src, dest, 3.0);
1555 \endcode
1556
1557 \deprecatedUsage{recursiveGaussianFilterY}
1558 \code
1559 vigra::FImage src(w,h), dest(w,h);
1560 ...
1561
1562 vigra::recursiveGaussianFilterY(srcImageRange(src), destImage(dest), 3.0);
1563 \endcode
1564 \deprecatedEnd
1565 */
1566 doxygen_overloaded_function(template <...> void recursiveGaussianFilterY)
1567
1568 template <class SrcImageIterator, class SrcAccessor,
1569 class DestImageIterator, class DestAccessor>
1570 void
1571 recursiveGaussianFilterY(SrcImageIterator supperleft, SrcImageIterator slowerright, SrcAccessor as,
1572 DestImageIterator dupperleft, DestAccessor ad,
1573 double sigma)
1574 {
1575 int w = slowerright.x - supperleft.x;
1576 int h = slowerright.y - supperleft.y;
1577
1578 int x;
1579
1580 for(x=0; x<w; ++x, ++supperleft.x, ++dupperleft.x)
1581 {
1582 typename SrcImageIterator::column_iterator cs = supperleft.columnIterator();
1583 typename DestImageIterator::column_iterator cd = dupperleft.columnIterator();
1584
1585 recursiveGaussianFilterLine(cs, cs+h, as,
1586 cd, ad,
1587 sigma);
1588 }
1589 }
1590
1591 template <class SrcImageIterator, class SrcAccessor,
1592 class DestImageIterator, class DestAccessor>
1593 inline void
1594 recursiveGaussianFilterY(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1595 pair<DestImageIterator, DestAccessor> dest,
1596 double sigma)
1597 {
1598 recursiveGaussianFilterY(src.first, src.second, src.third,
1599 dest.first, dest.second, sigma);
1600 }
1601
1602 template <class T1, class S1,
1603 class T2, class S2>
1604 inline void
1605 recursiveGaussianFilterY(MultiArrayView<2, T1, S1> const & src,
1606 MultiArrayView<2, T2, S2> dest,
1607 double sigma)
1608 {
1609 vigra_precondition(src.shape() == dest.shape(),
1610 "recursiveGaussianFilterY(): shape mismatch between input and output.");
1611 recursiveGaussianFilterY(srcImageRange(src),
1612 destImage(dest), sigma);
1613 }
1614
1615
1616 /********************************************************/
1617 /* */
1618 /* recursiveSmoothY */
1619 /* */
1620 /********************************************************/
1621
1622 /** \brief Performs 1 dimensional recursive smoothing in y direction.
1623
1624 It calls \ref recursiveSmoothLine() for every column of the
1625 image. See \ref recursiveSmoothLine() for more information about
1626 required interfaces and vigra_preconditions.
1627
1628 <b> Declarations:</b>
1629
1630 pass 2D array views:
1631 \code
1632 namespace vigra {
1633 template <class T1, class S1,
1634 class T2, class S2>
1635 void
1636 recursiveSmoothY(MultiArrayView<2, T1, S1> const & src,
1637 MultiArrayView<2, T2, S2> dest,
1638 double scale);
1639 }
1640 \endcode
1641
1642 \deprecatedAPI{recursiveSmoothY}
1643 pass \ref ImageIterators and \ref DataAccessors :
1644 \code
1645 namespace vigra {
1646 template <class SrcImageIterator, class SrcAccessor,
1647 class DestImageIterator, class DestAccessor>
1648 void recursiveSmoothY(SrcImageIterator supperleft,
1649 SrcImageIterator slowerright, SrcAccessor as,
1650 DestImageIterator dupperleft, DestAccessor ad,
1651 double scale)
1652 }
1653 \endcode
1654 use argument objects in conjunction with \ref ArgumentObjectFactories :
1655 \code
1656 namespace vigra {
1657 template <class SrcImageIterator, class SrcAccessor,
1658 class DestImageIterator, class DestAccessor>
1659 void recursiveSmoothY(
1660 triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1661 pair<DestImageIterator, DestAccessor> dest,
1662 double scale)
1663 }
1664 \endcode
1665 \deprecatedEnd
1666
1667 <b> Usage:</b>
1668
1669 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
1670 Namespace: vigra
1671
1672 \code
1673 MultiArray<2, float> src(w,h), dest(w,h);
1674 ...
1675
1676 recursiveSmoothY(src, dest, 3.0);
1677 \endcode
1678
1679 \deprecatedUsage{recursiveSmoothY}
1680 \code
1681 vigra::FImage src(w,h), dest(w,h);
1682 ...
1683
1684 vigra::recursiveSmoothY(srcImageRange(src), destImage(dest), 3.0);
1685 \endcode
1686 \deprecatedEnd
1687 */
1688 doxygen_overloaded_function(template <...> void recursiveSmoothY)
1689
1690 template <class SrcImageIterator, class SrcAccessor,
1691 class DestImageIterator, class DestAccessor>
1692 void recursiveSmoothY(SrcImageIterator supperleft,
1693 SrcImageIterator slowerright, SrcAccessor as,
1694 DestImageIterator dupperleft, DestAccessor ad,
1695 double scale)
1696 {
1697 int w = slowerright.x - supperleft.x;
1698 int h = slowerright.y - supperleft.y;
1699
1700 int x;
1701
1702 for(x=0; x<w; ++x, ++supperleft.x, ++dupperleft.x)
1703 {
1704 typename SrcImageIterator::column_iterator cs = supperleft.columnIterator();
1705 typename DestImageIterator::column_iterator cd = dupperleft.columnIterator();
1706
1707 recursiveSmoothLine(cs, cs+h, as,
1708 cd, ad,
1709 scale);
1710 }
1711 }
1712
1713 template <class SrcImageIterator, class SrcAccessor,
1714 class DestImageIterator, class DestAccessor>
1715 inline void
1716 recursiveSmoothY(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1717 pair<DestImageIterator, DestAccessor> dest,
1718 double scale)
1719 {
1720 recursiveSmoothY(src.first, src.second, src.third,
1721 dest.first, dest.second, scale);
1722 }
1723
1724 template <class T1, class S1,
1725 class T2, class S2>
1726 inline void
1727 recursiveSmoothY(MultiArrayView<2, T1, S1> const & src,
1728 MultiArrayView<2, T2, S2> dest,
1729 double scale)
1730 {
1731 vigra_precondition(src.shape() == dest.shape(),
1732 "recursiveSmoothY(): shape mismatch between input and output.");
1733 recursiveSmoothY(srcImageRange(src),
1734 destImage(dest), scale);
1735 }
1736
1737 /********************************************************/
1738 /* */
1739 /* recursiveFirstDerivativeX */
1740 /* */
1741 /********************************************************/
1742
1743 /** \brief Recursively calculates the 1 dimensional first derivative in x
1744 direction.
1745
1746 It calls \ref recursiveFirstDerivativeLine() for every
1747 row of the image. See \ref recursiveFirstDerivativeLine() for more
1748 information about required interfaces and vigra_preconditions.
1749
1750 <b> Declarations:</b>
1751
1752 pass 2D array views:
1753 \code
1754 namespace vigra {
1755 template <class T1, class S1,
1756 class T2, class S2>
1757 void
1758 recursiveFirstDerivativeX(MultiArrayView<2, T1, S1> const & src,
1759 MultiArrayView<2, T2, S2> dest,
1760 double scale);
1761 }
1762 \endcode
1763
1764 \deprecatedAPI{recursiveFirstDerivativeX}
1765 pass \ref ImageIterators and \ref DataAccessors :
1766 \code
1767 namespace vigra {
1768 template <class SrcImageIterator, class SrcAccessor,
1769 class DestImageIterator, class DestAccessor>
1770 void recursiveFirstDerivativeX(SrcImageIterator supperleft,
1771 SrcImageIterator slowerright, SrcAccessor as,
1772 DestImageIterator dupperleft, DestAccessor ad,
1773 double scale)
1774 }
1775 \endcode
1776 use argument objects in conjunction with \ref ArgumentObjectFactories :
1777 \code
1778 namespace vigra {
1779 template <class SrcImageIterator, class SrcAccessor,
1780 class DestImageIterator, class DestAccessor>
1781 void recursiveFirstDerivativeX(
1782 triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1783 pair<DestImageIterator, DestAccessor> dest,
1784 double scale)
1785 }
1786 \endcode
1787 \deprecatedEnd
1788
1789 <b> Usage:</b>
1790
1791 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
1792 Namespace: vigra
1793
1794 \code
1795 MultiArray<2, float> src(w,h), dest(w,h);
1796 ...
1797
1798 recursiveFirstDerivativeX(src, dest, 3.0);
1799 \endcode
1800
1801 \deprecatedUsage{recursiveFirstDerivativeX}
1802 \code
1803 vigra::FImage src(w,h), dest(w,h);
1804 ...
1805
1806 vigra::recursiveFirstDerivativeX(srcImageRange(src), destImage(dest), 3.0);
1807 \endcode
1808 \deprecatedEnd
1809 */
1810 doxygen_overloaded_function(template <...> void recursiveFirstDerivativeX)
1811
1812 template <class SrcImageIterator, class SrcAccessor,
1813 class DestImageIterator, class DestAccessor>
1814 void recursiveFirstDerivativeX(SrcImageIterator supperleft,
1815 SrcImageIterator slowerright, SrcAccessor as,
1816 DestImageIterator dupperleft, DestAccessor ad,
1817 double scale)
1818 {
1819 int w = slowerright.x - supperleft.x;
1820 int h = slowerright.y - supperleft.y;
1821
1822 int y;
1823
1824 for(y=0; y<h; ++y, ++supperleft.y, ++dupperleft.y)
1825 {
1826 typename SrcImageIterator::row_iterator rs = supperleft.rowIterator();
1827 typename DestImageIterator::row_iterator rd = dupperleft.rowIterator();
1828
1829 recursiveFirstDerivativeLine(rs, rs+w, as,
1830 rd, ad,
1831 scale);
1832 }
1833 }
1834
1835 template <class SrcImageIterator, class SrcAccessor,
1836 class DestImageIterator, class DestAccessor>
1837 inline void
1838 recursiveFirstDerivativeX(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1839 pair<DestImageIterator, DestAccessor> dest,
1840 double scale)
1841 {
1842 recursiveFirstDerivativeX(src.first, src.second, src.third,
1843 dest.first, dest.second, scale);
1844 }
1845
1846 template <class T1, class S1,
1847 class T2, class S2>
1848 inline void
1849 recursiveFirstDerivativeX(MultiArrayView<2, T1, S1> const & src,
1850 MultiArrayView<2, T2, S2> dest,
1851 double scale)
1852 {
1853 vigra_precondition(src.shape() == dest.shape(),
1854 "recursiveFirstDerivativeX(): shape mismatch between input and output.");
1855 recursiveFirstDerivativeX(srcImageRange(src),
1856 destImage(dest), scale);
1857 }
1858
1859 /********************************************************/
1860 /* */
1861 /* recursiveFirstDerivativeY */
1862 /* */
1863 /********************************************************/
1864
1865 /** \brief Recursively calculates the 1 dimensional first derivative in y
1866 direction.
1867
1868 It calls \ref recursiveFirstDerivativeLine() for every
1869 column of the image. See \ref recursiveFirstDerivativeLine() for more
1870 information about required interfaces and vigra_preconditions.
1871
1872 <b> Declarations:</b>
1873
1874 pass 2D array views:
1875 \code
1876 namespace vigra {
1877 template <class T1, class S1,
1878 class T2, class S2>
1879 void
1880 recursiveFirstDerivativeY(MultiArrayView<2, T1, S1> const & src,
1881 MultiArrayView<2, T2, S2> dest,
1882 double scale);
1883 }
1884 \endcode
1885
1886 \deprecatedAPI{recursiveFirstDerivativeY}
1887 pass \ref ImageIterators and \ref DataAccessors :
1888 \code
1889 namespace vigra {
1890 template <class SrcImageIterator, class SrcAccessor,
1891 class DestImageIterator, class DestAccessor>
1892 void recursiveFirstDerivativeY(SrcImageIterator supperleft,
1893 SrcImageIterator slowerright, SrcAccessor as,
1894 DestImageIterator dupperleft, DestAccessor ad,
1895 double scale)
1896 }
1897 \endcode
1898 use argument objects in conjunction with \ref ArgumentObjectFactories :
1899 \code
1900 namespace vigra {
1901 template <class SrcImageIterator, class SrcAccessor,
1902 class DestImageIterator, class DestAccessor>
1903 void recursiveFirstDerivativeY(
1904 triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1905 pair<DestImageIterator, DestAccessor> dest,
1906 double scale)
1907 }
1908 \endcode
1909 \deprecatedEnd
1910
1911 <b> Usage:</b>
1912
1913 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
1914 Namespace: vigra
1915
1916 \code
1917 MultiArray<2, float> src(w,h), dest(w,h);
1918 ...
1919
1920 recursiveFirstDerivativeY(src, dest, 3.0);
1921 \endcode
1922
1923 \deprecatedUsage{recursiveFirstDerivativeY}
1924 \code
1925 vigra::FImage src(w,h), dest(w,h);
1926 ...
1927
1928 vigra::recursiveFirstDerivativeY(srcImageRange(src), destImage(dest), 3.0);
1929 \endcode
1930 \deprecatedEnd
1931 */
1932 doxygen_overloaded_function(template <...> void recursiveFirstDerivativeY)
1933
1934 template <class SrcImageIterator, class SrcAccessor,
1935 class DestImageIterator, class DestAccessor>
1936 void recursiveFirstDerivativeY(SrcImageIterator supperleft,
1937 SrcImageIterator slowerright, SrcAccessor as,
1938 DestImageIterator dupperleft, DestAccessor ad,
1939 double scale)
1940 {
1941 int w = slowerright.x - supperleft.x;
1942 int h = slowerright.y - supperleft.y;
1943
1944 int x;
1945
1946 for(x=0; x<w; ++x, ++supperleft.x, ++dupperleft.x)
1947 {
1948 typename SrcImageIterator::column_iterator cs = supperleft.columnIterator();
1949 typename DestImageIterator::column_iterator cd = dupperleft.columnIterator();
1950
1951 recursiveFirstDerivativeLine(cs, cs+h, as,
1952 cd, ad,
1953 scale);
1954 }
1955 }
1956
1957 template <class SrcImageIterator, class SrcAccessor,
1958 class DestImageIterator, class DestAccessor>
1959 inline void
1960 recursiveFirstDerivativeY(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
1961 pair<DestImageIterator, DestAccessor> dest,
1962 double scale)
1963 {
1964 recursiveFirstDerivativeY(src.first, src.second, src.third,
1965 dest.first, dest.second, scale);
1966 }
1967
1968 template <class T1, class S1,
1969 class T2, class S2>
1970 inline void
1971 recursiveFirstDerivativeY(MultiArrayView<2, T1, S1> const & src,
1972 MultiArrayView<2, T2, S2> dest,
1973 double scale)
1974 {
1975 vigra_precondition(src.shape() == dest.shape(),
1976 "recursiveFirstDerivativeY(): shape mismatch between input and output.");
1977 recursiveFirstDerivativeY(srcImageRange(src),
1978 destImage(dest), scale);
1979 }
1980
1981 /********************************************************/
1982 /* */
1983 /* recursiveSecondDerivativeX */
1984 /* */
1985 /********************************************************/
1986
1987 /** \brief Recursively calculates the 1 dimensional second derivative in x
1988 direction.
1989
1990 It calls \ref recursiveSecondDerivativeLine() for every
1991 row of the image. See \ref recursiveSecondDerivativeLine() for more
1992 information about required interfaces and vigra_preconditions.
1993
1994 <b> Declarations:</b>
1995
1996 pass 2D array views:
1997 \code
1998 namespace vigra {
1999 template <class T1, class S1,
2000 class T2, class S2>
2001 void
2002 recursiveSecondDerivativeX(MultiArrayView<2, T1, S1> const & src,
2003 MultiArrayView<2, T2, S2> dest,
2004 double scale);
2005 }
2006 \endcode
2007
2008 \deprecatedAPI{recursiveSecondDerivativeX}
2009 pass \ref ImageIterators and \ref DataAccessors :
2010 \code
2011 namespace vigra {
2012 template <class SrcImageIterator, class SrcAccessor,
2013 class DestImageIterator, class DestAccessor>
2014 void recursiveSecondDerivativeX(SrcImageIterator supperleft,
2015 SrcImageIterator slowerright, SrcAccessor as,
2016 DestImageIterator dupperleft, DestAccessor ad,
2017 double scale)
2018 }
2019 \endcode
2020 use argument objects in conjunction with \ref ArgumentObjectFactories :
2021 \code
2022 namespace vigra {
2023 template <class SrcImageIterator, class SrcAccessor,
2024 class DestImageIterator, class DestAccessor>
2025 void recursiveSecondDerivativeX(
2026 triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
2027 pair<DestImageIterator, DestAccessor> dest,
2028 double scale)
2029 }
2030 \endcode
2031 \deprecatedEnd
2032
2033 <b> Usage:</b>
2034
2035 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
2036 Namespace: vigra
2037
2038 \code
2039 MultiArray<2, float> src(w,h), dest(w,h);
2040 ...
2041
2042 recursiveSecondDerivativeX(src, dest, 3.0);
2043 \endcode
2044
2045 \deprecatedUsage{recursiveSecondDerivativeX}
2046 \code
2047 vigra::FImage src(w,h), dest(w,h);
2048 ...
2049
2050 vigra::recursiveSecondDerivativeX(srcImageRange(src), destImage(dest), 3.0);
2051 \endcode
2052 \deprecatedEnd
2053 */
2054 doxygen_overloaded_function(template <...> void recursiveSecondDerivativeX)
2055
2056 template <class SrcImageIterator, class SrcAccessor,
2057 class DestImageIterator, class DestAccessor>
2058 void recursiveSecondDerivativeX(SrcImageIterator supperleft,
2059 SrcImageIterator slowerright, SrcAccessor as,
2060 DestImageIterator dupperleft, DestAccessor ad,
2061 double scale)
2062 {
2063 int w = slowerright.x - supperleft.x;
2064 int h = slowerright.y - supperleft.y;
2065
2066 int y;
2067
2068 for(y=0; y<h; ++y, ++supperleft.y, ++dupperleft.y)
2069 {
2070 typename SrcImageIterator::row_iterator rs = supperleft.rowIterator();
2071 typename DestImageIterator::row_iterator rd = dupperleft.rowIterator();
2072
2073 recursiveSecondDerivativeLine(rs, rs+w, as,
2074 rd, ad,
2075 scale);
2076 }
2077 }
2078
2079 template <class SrcImageIterator, class SrcAccessor,
2080 class DestImageIterator, class DestAccessor>
2081 inline void
2082 recursiveSecondDerivativeX(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
2083 pair<DestImageIterator, DestAccessor> dest,
2084 double scale)
2085 {
2086 recursiveSecondDerivativeX(src.first, src.second, src.third,
2087 dest.first, dest.second, scale);
2088 }
2089
2090 template <class T1, class S1,
2091 class T2, class S2>
2092 inline void
2093 recursiveSecondDerivativeX(MultiArrayView<2, T1, S1> const & src,
2094 MultiArrayView<2, T2, S2> dest,
2095 double scale)
2096 {
2097 vigra_precondition(src.shape() == dest.shape(),
2098 "recursiveSecondDerivativeX(): shape mismatch between input and output.");
2099 recursiveSecondDerivativeX(srcImageRange(src),
2100 destImage(dest), scale);
2101 }
2102
2103 /********************************************************/
2104 /* */
2105 /* recursiveSecondDerivativeY */
2106 /* */
2107 /********************************************************/
2108
2109 /** \brief Recursively calculates the 1 dimensional second derivative in y
2110 direction.
2111
2112 It calls \ref recursiveSecondDerivativeLine() for every
2113 column of the image. See \ref recursiveSecondDerivativeLine() for more
2114 information about required interfaces and vigra_preconditions.
2115
2116 <b> Declarations:</b>
2117
2118 pass 2D array views:
2119 \code
2120 namespace vigra {
2121 template <class T1, class S1,
2122 class T2, class S2>
2123 void
2124 recursiveSecondDerivativeY(MultiArrayView<2, T1, S1> const & src,
2125 MultiArrayView<2, T2, S2> dest,
2126 double scale);
2127 }
2128 \endcode
2129
2130 \deprecatedAPI{recursiveSecondDerivativeY}
2131 pass \ref ImageIterators and \ref DataAccessors :
2132 \code
2133 namespace vigra {
2134 template <class SrcImageIterator, class SrcAccessor,
2135 class DestImageIterator, class DestAccessor>
2136 void recursiveSecondDerivativeY(SrcImageIterator supperleft,
2137 SrcImageIterator slowerright, SrcAccessor as,
2138 DestImageIterator dupperleft, DestAccessor ad,
2139 double scale)
2140 }
2141 \endcode
2142 use argument objects in conjunction with \ref ArgumentObjectFactories :
2143 \code
2144 namespace vigra {
2145 template <class SrcImageIterator, class SrcAccessor,
2146 class DestImageIterator, class DestAccessor>
2147 void recursiveSecondDerivativeY(
2148 triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
2149 pair<DestImageIterator, DestAccessor> dest,
2150 double scale)
2151 }
2152 \endcode
2153 \deprecatedEnd
2154
2155 <b> Usage:</b>
2156
2157 <b>\#include</b> <vigra/recursiveconvolution.hxx><br>
2158 Namespace: vigra
2159
2160 \code
2161 MultiArray<2, float> src(w,h), dest(w,h);
2162 ...
2163
2164 recursiveSecondDerivativeY(src, dest, 3.0);
2165 \endcode
2166
2167 \deprecatedUsage{recursiveSecondDerivativeY}
2168 \code
2169 vigra::FImage src(w,h), dest(w,h);
2170 ...
2171
2172 vigra::recursiveSecondDerivativeY(srcImageRange(src), destImage(dest), 3.0);
2173 \endcode
2174 \deprecatedEnd
2175 */
2176 doxygen_overloaded_function(template <...> void recursiveSecondDerivativeY)
2177
2178 template <class SrcImageIterator, class SrcAccessor,
2179 class DestImageIterator, class DestAccessor>
2180 void recursiveSecondDerivativeY(SrcImageIterator supperleft,
2181 SrcImageIterator slowerright, SrcAccessor as,
2182 DestImageIterator dupperleft, DestAccessor ad,
2183 double scale)
2184 {
2185 int w = slowerright.x - supperleft.x;
2186 int h = slowerright.y - supperleft.y;
2187
2188 int x;
2189
2190 for(x=0; x<w; ++x, ++supperleft.x, ++dupperleft.x)
2191 {
2192 typename SrcImageIterator::column_iterator cs = supperleft.columnIterator();
2193 typename DestImageIterator::column_iterator cd = dupperleft.columnIterator();
2194
2195 recursiveSecondDerivativeLine(cs, cs+h, as,
2196 cd, ad,
2197 scale);
2198 }
2199 }
2200
2201 template <class SrcImageIterator, class SrcAccessor,
2202 class DestImageIterator, class DestAccessor>
2203 inline void
2204 recursiveSecondDerivativeY(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
2205 pair<DestImageIterator, DestAccessor> dest,
2206 double scale)
2207 {
2208 recursiveSecondDerivativeY(src.first, src.second, src.third,
2209 dest.first, dest.second, scale);
2210 }
2211
2212 template <class T1, class S1,
2213 class T2, class S2>
2214 inline void
2215 recursiveSecondDerivativeY(MultiArrayView<2, T1, S1> const & src,
2216 MultiArrayView<2, T2, S2> dest,
2217 double scale)
2218 {
2219 vigra_precondition(src.shape() == dest.shape(),
2220 "recursiveSecondDerivativeY(): shape mismatch between input and output.");
2221 recursiveSecondDerivativeY(srcImageRange(src),
2222 destImage(dest), scale);
2223 }
2224
2225 //@}
2226
2227 } // namespace vigra
2228
2229 #endif // VIGRA_RECURSIVECONVOLUTION_HXX
vigra::recursiveFirstDerivativeX
void recursiveFirstDerivativeX(...)
Recursively calculates the 1 dimensional first derivative in x direction.
vigra::recursiveGaussianFilterX
void recursiveGaussianFilterX(...)
Compute 1 dimensional recursive approximation of Gaussian smoothing in y direction.
vigra::recursiveFirstDerivativeLine
void recursiveFirstDerivativeLine(...)
Performs a 1 dimensional recursive convolution of the source signal.
vigra::recursiveFilterY
void recursiveFilterY(...)
Performs 1 dimensional recursive filtering (1st and 2nd order) in y direction.
vigra::linalg::exp
linalg::TemporaryMatrix< T > exp(MultiArrayView< 2, T, C > const &v)
vigra::recursiveSmoothLine
void recursiveSmoothLine(...)
Convolves the image with a 1-dimensional exponential filter.
vigra::recursiveSecondDerivativeY
void recursiveSecondDerivativeY(...)
Recursively calculates the 1 dimensional second derivative in y direction.
vigra::norm
FFTWComplex< R >::NormType norm(const FFTWComplex< R > &a)
norm (= magnitude)
Definition: fftw3.hxx:1037
vigra::recursiveSecondDerivativeLine
void recursiveSecondDerivativeLine(...)
Performs a 1 dimensional recursive convolution of the source signal.
vigra::recursiveFilterLine
void recursiveFilterLine(...)
Performs a 1-dimensional recursive convolution of the source signal.
vigra::recursiveFilterX
void recursiveFilterX(...)
Performs 1 dimensional recursive filtering (1st and 2nd order) in x direction.
vigra::recursiveGaussianFilterY
void recursiveGaussianFilterY(...)
Compute 1 dimensional recursive approximation of Gaussian smoothing in y direction.
vigra::recursiveGaussianFilterLine
void recursiveGaussianFilterLine(...)
Compute a 1-dimensional recursive approximation of Gaussian smoothing.
vigra::recursiveSmoothX
void recursiveSmoothX(...)
Performs 1 dimensional recursive smoothing in x direction.
vigra::recursiveSecondDerivativeX
void recursiveSecondDerivativeX(...)
Recursively calculates the 1 dimensional second derivative in x direction.
vigra::doxygen_overloaded_function
doxygen_overloaded_function(template<...> void separableConvolveBlockwise) template< unsigned int N
Separated convolution on ChunkedArrays.
utilities.hxx
vigra::recursiveSmoothY
void recursiveSmoothY(...)
Performs 1 dimensional recursive smoothing in y direction.
vigra::linalg::log
linalg::TemporaryMatrix< T > log(MultiArrayView< 2, T, C > const &v)
vigra::recursiveFirstDerivativeY
void recursiveFirstDerivativeY(...)
Recursively calculates the 1 dimensional first derivative in y direction.
vigra::sqrt
SquareRootTraits< FixedPoint< IntBits, FracBits > >::SquareRootResult sqrt(FixedPoint< IntBits, FracBits > v)
square root.
Definition: fixedpoint.hxx:616

© 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)