37 #ifndef VIGRA_STDCONVOLUTION_HXX
38 #define VIGRA_STDCONVOLUTION_HXX
41 #include "stdimage.hxx"
42 #include "bordertreatment.hxx"
43 #include "separableconvolution.hxx"
44 #include "utilities.hxx"
45 #include "sized_int.hxx"
179 template <
class SrcIterator,
class SrcAccessor,
180 class DestIterator,
class DestAccessor,
181 class KernelIterator,
class KernelAccessor>
182 void convolveImage(SrcIterator src_ul, SrcIterator src_lr, SrcAccessor src_acc,
183 DestIterator dest_ul, DestAccessor dest_acc,
184 KernelIterator ki, KernelAccessor ak,
187 vigra_precondition((border == BORDER_TREATMENT_CLIP ||
188 border == BORDER_TREATMENT_AVOID ||
189 border == BORDER_TREATMENT_REFLECT ||
190 border == BORDER_TREATMENT_REPEAT ||
191 border == BORDER_TREATMENT_WRAP ||
192 border == BORDER_TREATMENT_ZEROPAD),
194 " Border treatment must be one of follow treatments:\n"
195 " - BORDER_TREATMENT_CLIP\n"
196 " - BORDER_TREATMENT_AVOID\n"
197 " - BORDER_TREATMENT_REFLECT\n"
198 " - BORDER_TREATMENT_REPEAT\n"
199 " - BORDER_TREATMENT_WRAP\n"
200 " - BORDER_TREATMENT_ZEROPAD\n");
202 vigra_precondition(kul.
x <= 0 && kul.
y <= 0,
203 "convolveImage(): coordinates of "
204 "kernel's upper left must be <= 0.");
205 vigra_precondition(klr.
x >= 0 && klr.
y >= 0,
206 "convolveImage(): coordinates of "
207 "kernel's lower right must be >= 0.");
211 PromoteTraits<
typename SrcAccessor::value_type,
212 typename KernelAccessor::value_type>::Promote SumType;
214 NumericTraits<typename KernelAccessor::value_type>::RealPromote KernelSumType;
215 typedef typename DestAccessor::value_type DestType;
218 int w = src_lr.x - src_ul.x;
219 int h = src_lr.y - src_ul.y;
222 int kernel_width = klr.
x - kul.
x + 1;
223 int kernel_height = klr.
y - kul.
y + 1;
225 vigra_precondition(w >= std::max(klr.
x, -kul.
x) + 1 && h >= std::max(klr.
y, -kul.
y) + 1,
226 "convolveImage(): kernel larger than image.");
228 KernelSumType
norm = KernelSumType();
229 if(border == BORDER_TREATMENT_CLIP)
232 KernelIterator yk = ki + klr;
235 for(
int y = 0; y < kernel_height; ++y, --yk.y)
237 KernelIterator xk = yk;
238 for(
int x = 0; x < kernel_width; ++x, --xk.x)
243 vigra_precondition(norm != NumericTraits<KernelSumType>::zero(),
244 "convolveImage(): Cannot use BORDER_TREATMENT_CLIP with a DC-free kernel");
247 DestIterator yd = dest_ul;
248 SrcIterator ys = src_ul;
251 for(
int y=0; y<h; ++y, ++ys.y, ++yd.y)
257 for(
int x=0; x < w; ++x, ++xs.x, ++xd.x)
260 SumType
sum = NumericTraits<SumType>::zero();
261 KernelIterator ykernel = ki + klr;
263 if(x >= klr.x && y >= klr.y && x < w + kul.
x && y < h + kul.
y)
266 SrcIterator yys = xs - klr;
267 SrcIterator yyend = xs - kul;
269 for(; yys.y <= yyend.y; ++yys.y, --ykernel.y)
271 typename SrcIterator::row_iterator xxs = yys.
rowIterator();
272 typename SrcIterator::row_iterator xxe = xxs + kernel_width;
273 typename KernelIterator::row_iterator xkernel= ykernel.rowIterator();
275 for(; xxs < xxe; ++xxs, --xkernel)
277 sum += ak(xkernel) * src_acc(xxs);
281 else if(border == BORDER_TREATMENT_REPEAT)
284 for(
int yk = klr.y; yk >= kul.
y; --yk, --ykernel.y)
286 diff.
y = std::min(std::max(y - yk, 0), h-1);
287 typename KernelIterator::row_iterator xkernel = ykernel.rowIterator();
289 for(
int xk = klr.x; xk >= kul.
x; --xk, --xkernel)
291 diff.
x = std::min(std::max(x - xk, 0), w-1);
292 sum += ak(xkernel) * src_acc(src_ul, diff);
296 else if(border == BORDER_TREATMENT_REFLECT)
299 for(
int yk = klr.y; yk >= kul.
y; --yk , --ykernel.y)
301 diff.
y =
abs(y - yk);
303 diff.
y = 2*h - 2 - diff.
y;
304 typename KernelIterator::row_iterator xkernel = ykernel.rowIterator();
306 for(
int xk = klr.x; xk >= kul.
x; --xk, --xkernel)
308 diff.
x =
abs(x - xk);
310 diff.
x = 2*w - 2 - diff.
x;
311 sum += ak(xkernel) * src_acc(src_ul, diff);
315 else if(border == BORDER_TREATMENT_WRAP)
318 for(
int yk = klr.y; yk >= kul.
y; --yk, --ykernel.y)
320 diff.
y = (y - yk + h) % h;
321 typename KernelIterator::row_iterator xkernel = ykernel.rowIterator();
323 for(
int xk = klr.x; xk >= kul.
x; --xk, --xkernel)
325 diff.
x = (x - xk + w) % w;
326 sum += ak(xkernel) * src_acc(src_ul, diff);
330 else if(border == BORDER_TREATMENT_CLIP)
332 KernelSumType ksum = NumericTraits<KernelSumType>::zero();
334 for(
int yk = klr.y; yk >= kul.
y; --yk, --ykernel.y)
337 if(diff.
y < 0 || diff.
y >= h)
339 typename KernelIterator::row_iterator xkernel = ykernel.rowIterator();
341 for(
int xk = klr.x; xk >= kul.
x; --xk, --xkernel)
344 if(diff.
x < 0 || diff.
x >= w)
347 sum += ak(xkernel) * src_acc(src_ul, diff);
353 else if(border == BORDER_TREATMENT_ZEROPAD)
356 for(
int yk = klr.y; yk >= kul.
y; --yk, --ykernel.y)
359 if(diff.
y < 0 || diff.
y >= h)
361 typename KernelIterator::row_iterator xkernel = ykernel.rowIterator();
363 for(
int xk = klr.x; xk >= kul.
x; --xk, --xkernel)
366 if(diff.
x < 0 || diff.
x >= w)
368 sum += ak(xkernel) * src_acc(src_ul, diff);
372 else if(border == BORDER_TREATMENT_AVOID)
378 dest_acc.set(detail::RequiresExplicitCast<DestType>::cast(sum), xd);
383 template <
class SrcIterator,
class SrcAccessor,
384 class DestIterator,
class DestAccessor,
385 class KernelIterator,
class KernelAccessor>
388 triple<SrcIterator, SrcIterator, SrcAccessor> src,
389 pair<DestIterator, DestAccessor> dest,
390 tuple5<KernelIterator, KernelAccessor, Diff2D, Diff2D,
391 BorderTreatmentMode> kernel)
394 dest.first, dest.second,
395 kernel.first, kernel.second, kernel.third,
396 kernel.fourth, kernel.fifth);
541 template <
class SrcIterator,
class SrcAccessor,
542 class DestIterator,
class DestAccessor,
543 class MaskIterator,
class MaskAccessor,
544 class KernelIterator,
class KernelAccessor>
547 MaskIterator
mul, MaskAccessor am,
548 DestIterator dest_ul, DestAccessor dest_acc,
549 KernelIterator ki, KernelAccessor ak,
550 Diff2D kul, Diff2D klr, BorderTreatmentMode border)
552 vigra_precondition((border == BORDER_TREATMENT_CLIP ||
553 border == BORDER_TREATMENT_AVOID),
554 "normalizedConvolveImage(): "
555 "Border treatment must be BORDER_TREATMENT_CLIP or BORDER_TREATMENT_AVOID.");
557 vigra_precondition(kul.x <= 0 && kul.y <= 0,
558 "normalizedConvolveImage(): left borders must be <= 0.");
559 vigra_precondition(klr.x >= 0 && klr.y >= 0,
560 "normalizedConvolveImage(): right borders must be >= 0.");
564 NumericTraits<typename SrcAccessor::value_type>::RealPromote SumType;
566 NumericTraits<typename KernelAccessor::value_type>::RealPromote KSumType;
568 NumericTraits<typename DestAccessor::value_type> DestTraits;
571 int w = src_lr.x - src_ul.x;
572 int h = src_lr.y - src_ul.y;
573 int kernel_width = klr.x - kul.x + 1;
574 int kernel_height = klr.y - kul.y + 1;
577 int ystart = (border == BORDER_TREATMENT_AVOID) ? klr.y : 0;
578 int yend = (border == BORDER_TREATMENT_AVOID) ? h+kul.y : h;
579 int xstart = (border == BORDER_TREATMENT_AVOID) ? klr.x : 0;
580 int xend = (border == BORDER_TREATMENT_AVOID) ? w+kul.x : w;
583 DestIterator yd = dest_ul + Diff2D(xstart, ystart);
584 SrcIterator ys = src_ul + Diff2D(xstart, ystart);
585 MaskIterator ym = mul + Diff2D(xstart, ystart);
587 KSumType
norm = ak(ki);
589 KernelIterator yk = ki + klr;
590 for(yy=0; yy<kernel_height; ++yy, --yk.y)
592 KernelIterator xk = yk;
594 for(xx=0; xx<kernel_width; ++xx, --xk.x)
602 for(y=ystart; y < yend; ++y, ++ys.y, ++yd.y, ++ym.y)
609 for(x=xstart; x < xend; ++x, ++xs.x, ++xd.x, ++xm.x)
614 y0 = (y<klr.y) ? -y : -klr.y;
615 y1 = (h-y-1<-kul.y) ? h-y-1 : -kul.y;
616 x0 = (x<klr.x) ? -x : -klr.x;
617 x1 = (w-x-1<-kul.x) ? w-x-1 : -kul.x;
621 SumType
sum = NumericTraits<SumType>::zero();
622 KSumType ksum = NumericTraits<KSumType>::zero();
624 SrcIterator yys = xs + Diff2D(x0, y0);
625 MaskIterator yym = xm + Diff2D(x0, y0);
626 KernelIterator yk = ki - Diff2D(x0, y0);
628 int kernel_width, kernel_height;
629 kernel_width = x1 - x0 + 1;
630 kernel_height = y1 - y0 + 1;
631 for(yy=0; yy<kernel_height; ++yy, ++yys.y, --yk.y, ++yym.y)
633 typename SrcIterator::row_iterator xxs = yys.rowIterator();
634 typename SrcIterator::row_iterator xxend = xxs + kernel_width;
635 typename MaskIterator::row_iterator xxm = yym.rowIterator();
636 typename KernelIterator::row_iterator xk = yk.rowIterator();
638 for(xx=0; xxs < xxend; ++xxs, --xk, ++xxm)
640 if(!am(xxm))
continue;
644 sum = detail::RequiresExplicitCast<SumType>::cast(ak(xk) * src_acc(xxs));
650 sum = detail::RequiresExplicitCast<SumType>::cast(sum + ak(xk) * src_acc(xxs));
656 if(ksum != NumericTraits<KSumType>::zero())
658 dest_acc.set(DestTraits::fromRealPromote(
659 detail::RequiresExplicitCast<SumType>::cast((norm / ksum) * sum)), xd);
666 template <
class SrcIterator,
class SrcAccessor,
667 class DestIterator,
class DestAccessor,
668 class MaskIterator,
class MaskAccessor,
669 class KernelIterator,
class KernelAccessor>
672 triple<SrcIterator, SrcIterator, SrcAccessor> src,
673 pair<MaskIterator, MaskAccessor> mask,
674 pair<DestIterator, DestAccessor> dest,
675 tuple5<KernelIterator, KernelAccessor, Diff2D, Diff2D,
676 BorderTreatmentMode> kernel)
679 mask.first, mask.second,
680 dest.first, dest.second,
681 kernel.first, kernel.second, kernel.third,
682 kernel.fourth, kernel.fifth);
725 template <
class SrcIterator,
class SrcAccessor,
726 class DestIterator,
class DestAccessor,
727 class MaskIterator,
class MaskAccessor,
728 class KernelIterator,
class KernelAccessor>
731 MaskIterator mul, MaskAccessor am,
732 DestIterator dest_ul, DestAccessor dest_acc,
733 KernelIterator ki, KernelAccessor ak,
734 Diff2D kul, Diff2D klr, BorderTreatmentMode border)
739 ki, ak, kul, klr, border);
742 template <
class SrcIterator,
class SrcAccessor,
743 class DestIterator,
class DestAccessor,
744 class MaskIterator,
class MaskAccessor,
745 class KernelIterator,
class KernelAccessor>
748 triple<SrcIterator, SrcIterator, SrcAccessor> src,
749 pair<MaskIterator, MaskAccessor> mask,
750 pair<DestIterator, DestAccessor> dest,
751 tuple5<KernelIterator, KernelAccessor, Diff2D, Diff2D,
752 BorderTreatmentMode> kernel)
755 mask.first, mask.second,
756 dest.first, dest.second,
757 kernel.first, kernel.second, kernel.third,
758 kernel.fourth, kernel.fifth);
817 template <
class ARITHTYPE>
847 : iter_(i), base_(i),
848 count_(count), sum_(count),
854 vigra_precondition(count_ == 1 || count_ == sum_,
855 "Kernel2D::initExplicitly(): "
856 "Too few init values.");
861 if(count_ == sum_) norm_ = *iter_;
864 vigra_precondition(count_ > 0,
865 "Kernel2D::initExplicitly(): "
866 "Too many init values.");
881 static value_type one() {
return NumericTraits<value_type>::one(); }
888 : kernel_(1, 1, one()),
892 border_treatment_(BORDER_TREATMENT_REFLECT)
898 : kernel_(k.kernel_),
902 border_treatment_(k.border_treatment_)
915 border_treatment_ = k.border_treatment_;
941 int size = (right_.
x - left_.
x + 1) *
942 (right_.
y - left_.
y + 1);
944 norm_ = (double)size*v;
946 return InitProxy(kernel_.
begin(), size, norm_);
972 int w = right_.
x - left_.
x + 1;
973 int h = right_.
y - left_.
y + 1;
981 KIter kiy = ky.
center() + left_.
y;
984 for(
int y=left_.
y; y<=right_.
y; ++y, ++kiy, ++iy.y)
986 KIter kix = kx.
center() + left_.
x;
988 for(
int x=left_.
x; x<=right_.
x; ++x, ++kix, ++ix.x)
990 *ix = ka(kix) * ka(kiy);
1018 template <
class KernelIterator>
1020 KernelIterator kycenter,
int yleft,
int yright)
1022 vigra_precondition(xleft <= 0 && yleft <= 0,
1023 "Kernel2D::initSeparable(): left borders must be <= 0.");
1024 vigra_precondition(xright >= 0 && yright >= 0,
1025 "Kernel2D::initSeparable(): right borders must be >= 0.");
1027 left_ =
Point2D(xleft, yleft);
1028 right_ =
Point2D(xright, yright);
1030 int w = right_.
x - left_.
x + 1;
1031 int h = right_.
y - left_.
y + 1;
1034 KernelIterator kiy = kycenter + left_.
y;
1037 for(
int y=left_.
y; y<=right_.
y; ++y, ++kiy, ++iy.y)
1039 KernelIterator kix = kxcenter + left_.
x;
1041 for(
int x=left_.
x; x<=right_.
x; ++x, ++kix, ++ix.x)
1052 for(; i!= iend; ++i)
1071 initGaussian(std_dev, NumericTraits<value_type>::one());
1096 vigra_precondition(radius > 0,
1097 "Kernel2D::initDisk(): radius must be > 0.");
1099 left_ =
Point2D(-radius, -radius);
1100 right_ =
Point2D(radius, radius);
1101 int w = right_.
x - left_.
x + 1;
1102 int h = right_.
y - left_.
y + 1;
1104 norm_ = NumericTraits<value_type>::one();
1106 kernel_ = NumericTraits<value_type>::zero();
1110 double r2 = (double)radius*radius;
1113 for(i=0; i<= radius; ++i)
1115 double r = (double) i - 0.5;
1117 for(
int j=-w; j<=w; ++j)
1119 k(j, i) = NumericTraits<value_type>::one();
1120 k(j, -i) = NumericTraits<value_type>::one();
1121 count += (i != 0) ? 2.0 : 1.0;
1125 count = 1.0 / count;
1127 for(
int y=-radius; y<=radius; ++y)
1129 for(
int x=-radius; x<=radius; ++x)
1131 k(x,y) = count * k(x,y);
1176 vigra_precondition(upperleft.
x <= 0 && upperleft.
y <= 0,
1177 "Kernel2D::initExplicitly(): left borders must be <= 0.");
1178 vigra_precondition(lowerright.
x >= 0 && lowerright.
y >= 0,
1179 "Kernel2D::initExplicitly(): right borders must be >= 0.");
1184 int w = right_.
x - left_.
x + 1;
1185 int h = right_.
y - left_.
y + 1;
1201 int width()
const {
return right_.
x - left_.
x + 1; }
1218 {
return kernel_[
Diff2D(x,y) - left_]; }
1223 {
return kernel_[
Diff2D(x,y) - left_]; }
1228 {
return kernel_[d - left_]; }
1233 {
return kernel_[d - left_]; }
1266 typename NumericTraits<value_type>::RealPromote sum = *i;
1269 for(; i!= iend; ++i)
1275 i = kernel_.
begin();
1276 for(; i != iend; ++i)
1294 {
return border_treatment_; }
1302 vigra_precondition((new_mode == BORDER_TREATMENT_CLIP ||
1303 new_mode == BORDER_TREATMENT_AVOID ||
1304 new_mode == BORDER_TREATMENT_REFLECT ||
1305 new_mode == BORDER_TREATMENT_REPEAT ||
1306 new_mode == BORDER_TREATMENT_WRAP),
1307 "convolveImage():\n"
1308 " Border treatment must be one of follow treatments:\n"
1309 " - BORDER_TREATMENT_CLIP\n"
1310 " - BORDER_TREATMENT_AVOID\n"
1311 " - BORDER_TREATMENT_REFLECT\n"
1312 " - BORDER_TREATMENT_REPEAT\n"
1313 " - BORDER_TREATMENT_WRAP\n");
1315 border_treatment_ = new_mode;
1323 BorderTreatmentMode border_treatment_;
1334 template <
class KernelIterator,
class KernelAccessor>
1336 tuple5<KernelIterator, KernelAccessor, Diff2D, Diff2D, BorderTreatmentMode>
1337 kernel2d(KernelIterator ik, KernelAccessor ak, Diff2D kul, Diff2D klr,
1338 BorderTreatmentMode border)
1342 tuple5<KernelIterator, KernelAccessor, Diff2D, Diff2D, BorderTreatmentMode> (
1343 ik, ak, kul, klr, border);
1348 tuple5<typename Kernel2D<T>::ConstIterator,
1349 typename Kernel2D<T>::ConstAccessor,
1350 Diff2D, Diff2D, BorderTreatmentMode>
1351 kernel2d(Kernel2D<T>
const & k)
1355 tuple5<typename Kernel2D<T>::ConstIterator,
1356 typename Kernel2D<T>::ConstAccessor,
1357 Diff2D, Diff2D, BorderTreatmentMode>(
1360 k.upperLeft(), k.lowerRight(),
1361 k.borderTreatment());
1366 tuple5<typename Kernel2D<T>::ConstIterator,
1367 typename Kernel2D<T>::ConstAccessor,
1368 Diff2D, Diff2D, BorderTreatmentMode>
1369 kernel2d(Kernel2D<T>
const & k, BorderTreatmentMode border)
1373 tuple5<typename Kernel2D<T>::ConstIterator,
1374 typename Kernel2D<T>::ConstAccessor,
1375 Diff2D, Diff2D, BorderTreatmentMode>(
1378 k.upperLeft(), k.lowerRight(),
1385 #endif // VIGRA_STDCONVOLUTION_HXX
iterator end()
Definition: basicimage.hxx:972
iterator begin()
Definition: basicimage.hxx:963
Kernel2D & operator=(Kernel2D const &k)
Definition: stdconvolution.hxx:907
value_type norm() const
Definition: separableconvolution.hxx:2077
BasicImage< value_type >::ConstAccessor ConstAccessor
Definition: stdconvolution.hxx:839
Generic 1 dimensional convolution kernel.
Definition: separableconvolution.hxx:1267
ARITHTYPE value_type
Definition: stdconvolution.hxx:823
Accessor accessor()
Definition: stdconvolution.hxx:1241
Kernel2D & initExplicitly(Diff2D upperleft, Diff2D lowerright)
Definition: stdconvolution.hxx:1174
int y
Definition: diff2d.hxx:392
void initGaussian(double std_dev, value_type norm, double windowRatio=0.0)
Definition: separableconvolution.hxx:2154
void convolveImageWithMask(...)
Deprecated name of 2-dimensional normalized convolution, i.e. convolution with a mask image...
value_type operator()(int x, int y) const
Definition: stdconvolution.hxx:1222
void initSeparable(KernelIterator kxcenter, int xleft, int xright, KernelIterator kycenter, int yleft, int yright)
Definition: stdconvolution.hxx:1019
BorderTreatmentMode borderTreatment() const
Definition: stdconvolution.hxx:1293
Kernel2D()
Definition: stdconvolution.hxx:887
int x
Definition: diff2d.hxx:385
Point2D lowerRight() const
Definition: stdconvolution.hxx:1197
value_type operator[](Diff2D const &d) const
Definition: stdconvolution.hxx:1232
int height() const
Definition: stdconvolution.hxx:1205
Two dimensional difference vector.
Definition: diff2d.hxx:185
BasicImage< value_type >::Accessor Accessor
Definition: stdconvolution.hxx:835
InitProxy operator=(value_type const &v)
Definition: stdconvolution.hxx:939
ConstIterator center() const
Definition: stdconvolution.hxx:1213
Iterator center()
Definition: stdconvolution.hxx:1209
int left() const
Definition: separableconvolution.hxx:2055
Two dimensional point or position.
Definition: diff2d.hxx:592
FFTWComplex< R >::NormType norm(const FFTWComplex< R > &a)
norm (= magnitude)
Definition: fftw3.hxx:1037
Point2D upperLeft() const
Definition: stdconvolution.hxx:1193
void mul(FixedPoint< IntBits1, FracBits1 > l, FixedPoint< IntBits2, FracBits2 > r, FixedPoint< IntBits3, FracBits3 > &result)
multiplication with enforced result type.
Definition: fixedpoint.hxx:605
void normalize()
Definition: stdconvolution.hxx:1286
value_type & operator[](Diff2D const &d)
Definition: stdconvolution.hxx:1227
NumericTraits< V >::Promote sum(TinyVectorBase< V, SIZE, D1, D2 > const &l)
sum of the vector's elements
Definition: tinyvector.hxx:1683
row_iterator rowIterator() const
Definition: diff2d.hxx:431
ConstAccessor accessor() const
Definition: stdconvolution.hxx:1245
void resize(int width, int height)
Definition: basicimage.hxx:776
void initDisk(int radius)
Definition: stdconvolution.hxx:1094
void normalize(value_type norm)
Definition: stdconvolution.hxx:1262
value_type norm() const
Definition: stdconvolution.hxx:1237
BasicImage< value_type >::const_traverser ConstIterator
Definition: stdconvolution.hxx:831
void initSeparable(Kernel1D< value_type > const &kx, Kernel1D< value_type > const &ky)
Definition: stdconvolution.hxx:967
Fundamental class template for images.
Definition: basicimage.hxx:473
Generic 2 dimensional convolution kernel.
Definition: stdconvolution.hxx:818
void initGaussian(double std_dev, value_type norm)
Definition: stdconvolution.hxx:1060
int width() const
Definition: stdconvolution.hxx:1201
FFTWComplex< R >::NormType abs(const FFTWComplex< R > &a)
absolute value (= magnitude)
Definition: fftw3.hxx:1002
void convolveImage(SrcIterator supperleft, SrcIterator slowerright, SrcAccessor sa, DestIterator dupperleft, DestAccessor da, Kernel1D< T > const &kx, Kernel1D< T > const &ky)
Apply two separable filters successively, the first in x-direction, the second in y-direction...
Definition: convolution.hxx:257
int right() const
Definition: separableconvolution.hxx:2059
void initGaussian(double std_dev)
Definition: stdconvolution.hxx:1069
InternalVector::const_iterator const_iterator
Definition: separableconvolution.hxx:1294
iterator center()
Definition: separableconvolution.hxx:2025
value_type & operator()(int x, int y)
Definition: stdconvolution.hxx:1217
Encapsulate access to the values an iterator points to.
Definition: accessor.hxx:132
void normalizedConvolveImage(...)
Performs a 2-dimensional normalized convolution, i.e. convolution with a mask image.
~Kernel2D()
Definition: stdconvolution.hxx:951
void setBorderTreatment(BorderTreatmentMode new_mode)
Definition: stdconvolution.hxx:1300
BasicImage< value_type >::traverser Iterator
Definition: stdconvolution.hxx:827
SquareRootTraits< FixedPoint< IntBits, FracBits > >::SquareRootResult sqrt(FixedPoint< IntBits, FracBits > v)
square root.
Definition: fixedpoint.hxx:616
traverser upperLeft()
Definition: basicimage.hxx:923
Kernel2D(Kernel2D const &k)
Definition: stdconvolution.hxx:897