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"
46 #include "multi_iterator.hxx"
47 #include "multi_shape.hxx"
51 template <
class ARITHTYPE>
59 template <
class SrcIterator,
class SrcAccessor,
60 class DestIterator,
class DestAccessor,
61 class KernelIterator,
class KernelAccessor>
62 void convolveImage(SrcIterator src_ul, SrcIterator src_lr, SrcAccessor src_acc,
63 DestIterator dest_ul, DestAccessor dest_acc,
64 KernelIterator ki, KernelAccessor ak,
67 vigra_precondition((border == BORDER_TREATMENT_CLIP ||
68 border == BORDER_TREATMENT_AVOID ||
69 border == BORDER_TREATMENT_REFLECT ||
70 border == BORDER_TREATMENT_REPEAT ||
71 border == BORDER_TREATMENT_WRAP ||
72 border == BORDER_TREATMENT_ZEROPAD),
74 " Border treatment must be one of follow treatments:\n"
75 " - BORDER_TREATMENT_CLIP\n"
76 " - BORDER_TREATMENT_AVOID\n"
77 " - BORDER_TREATMENT_REFLECT\n"
78 " - BORDER_TREATMENT_REPEAT\n"
79 " - BORDER_TREATMENT_WRAP\n"
80 " - BORDER_TREATMENT_ZEROPAD\n");
82 vigra_precondition(kul.
x <= 0 && kul.
y <= 0,
83 "convolveImage(): coordinates of "
84 "kernel's upper left must be <= 0.");
85 vigra_precondition(klr.
x >= 0 && klr.
y >= 0,
86 "convolveImage(): coordinates of "
87 "kernel's lower right must be >= 0.");
91 PromoteTraits<
typename SrcAccessor::value_type,
92 typename KernelAccessor::value_type>::Promote SumType;
94 NumericTraits<typename KernelAccessor::value_type>::RealPromote KernelSumType;
95 typedef typename DestAccessor::value_type DestType;
98 int w = src_lr.x - src_ul.x;
99 int h = src_lr.y - src_ul.y;
102 int kernel_width = klr.
x - kul.
x + 1;
103 int kernel_height = klr.
y - kul.
y + 1;
105 vigra_precondition(w >= std::max(klr.
x, -kul.
x) + 1 && h >= std::max(klr.
y, -kul.
y) + 1,
106 "convolveImage(): kernel larger than image.");
108 KernelSumType
norm = KernelSumType();
109 if(border == BORDER_TREATMENT_CLIP)
112 KernelIterator yk = ki + klr;
115 for(
int y = 0; y < kernel_height; ++y, --yk.y)
117 KernelIterator xk = yk;
118 for(
int x = 0; x < kernel_width; ++x, --xk.x)
123 vigra_precondition(norm != NumericTraits<KernelSumType>::zero(),
124 "convolveImage(): Cannot use BORDER_TREATMENT_CLIP with a DC-free kernel");
127 DestIterator yd = dest_ul;
128 SrcIterator ys = src_ul;
131 for(
int y=0; y<h; ++y, ++ys.y, ++yd.y)
137 for(
int x=0; x < w; ++x, ++xs.x, ++xd.x)
140 SumType
sum = NumericTraits<SumType>::zero();
141 KernelIterator ykernel = ki + klr;
143 if(x >= klr.x && y >= klr.y && x < w + kul.
x && y < h + kul.
y)
146 SrcIterator yys = xs - klr;
147 SrcIterator yyend = xs - kul;
149 for(; yys.y <= yyend.y; ++yys.y, --ykernel.y)
151 typename SrcIterator::row_iterator xxs = yys.
rowIterator();
152 typename SrcIterator::row_iterator xxe = xxs + kernel_width;
153 typename KernelIterator::row_iterator xkernel= ykernel.rowIterator();
155 for(; xxs < xxe; ++xxs, --xkernel)
157 sum += ak(xkernel) * src_acc(xxs);
161 else if(border == BORDER_TREATMENT_REPEAT)
164 for(
int yk = klr.y; yk >= kul.y; --yk, --ykernel.y)
166 diff.y = std::min(std::max(y - yk, 0), h-1);
167 typename KernelIterator::row_iterator xkernel = ykernel.rowIterator();
169 for(
int xk = klr.x; xk >= kul.x; --xk, --xkernel)
171 diff.x = std::min(std::max(x - xk, 0), w-1);
172 sum += ak(xkernel) * src_acc(src_ul, diff);
176 else if(border == BORDER_TREATMENT_REFLECT)
179 for(
int yk = klr.y; yk >= kul.y; --yk , --ykernel.y)
181 diff.y =
abs(y - yk);
183 diff.y = 2*h - 2 - diff.y;
184 typename KernelIterator::row_iterator xkernel = ykernel.rowIterator();
186 for(
int xk = klr.x; xk >= kul.x; --xk, --xkernel)
188 diff.x =
abs(x - xk);
190 diff.x = 2*w - 2 - diff.x;
191 sum += ak(xkernel) * src_acc(src_ul, diff);
195 else if(border == BORDER_TREATMENT_WRAP)
198 for(
int yk = klr.y; yk >= kul.y; --yk, --ykernel.y)
200 diff.y = (y - yk + h) % h;
201 typename KernelIterator::row_iterator xkernel = ykernel.rowIterator();
203 for(
int xk = klr.x; xk >= kul.x; --xk, --xkernel)
205 diff.x = (x - xk + w) % w;
206 sum += ak(xkernel) * src_acc(src_ul, diff);
210 else if(border == BORDER_TREATMENT_CLIP)
212 KernelSumType ksum = NumericTraits<KernelSumType>::zero();
214 for(
int yk = klr.y; yk >= kul.y; --yk, --ykernel.y)
217 if(diff.y < 0 || diff.y >= h)
219 typename KernelIterator::row_iterator xkernel = ykernel.rowIterator();
221 for(
int xk = klr.x; xk >= kul.x; --xk, --xkernel)
224 if(diff.x < 0 || diff.x >= w)
227 sum += ak(xkernel) * src_acc(src_ul, diff);
233 else if(border == BORDER_TREATMENT_ZEROPAD)
236 for(
int yk = klr.y; yk >= kul.y; --yk, --ykernel.y)
239 if(diff.y < 0 || diff.y >= h)
241 typename KernelIterator::row_iterator xkernel = ykernel.rowIterator();
243 for(
int xk = klr.x; xk >= kul.x; --xk, --xkernel)
246 if(diff.x < 0 || diff.x >= w)
248 sum += ak(xkernel) * src_acc(src_ul, diff);
252 else if(border == BORDER_TREATMENT_AVOID)
258 dest_acc.set(detail::RequiresExplicitCast<DestType>::cast(sum), xd);
263 template <
class SrcIterator,
class SrcAccessor,
264 class DestIterator,
class DestAccessor,
265 class KernelIterator,
class KernelAccessor>
267 convolveImage(triple<SrcIterator, SrcIterator, SrcAccessor> src,
268 pair<DestIterator, DestAccessor> dest,
269 tuple5<KernelIterator, KernelAccessor, Diff2D, Diff2D,
270 BorderTreatmentMode> kernel)
273 dest.first, dest.second,
274 kernel.first, kernel.second, kernel.third,
275 kernel.fourth, kernel.fifth);
278 template <
class T1,
class S1,
283 MultiArrayView<2, T2, S2> dest,
284 Kernel2D<T3>
const & kernel)
286 vigra_precondition(src.shape() == dest.shape(),
287 "convolveImage(): shape mismatch between input and output.");
454 doxygen_overloaded_function(template <...>
void normalizedConvolveImage)
456 template <
class SrcIterator,
class SrcAccessor,
457 class DestIterator,
class DestAccessor,
458 class MaskIterator,
class MaskAccessor,
459 class KernelIterator,
class KernelAccessor>
462 MaskIterator
mul, MaskAccessor am,
463 DestIterator dest_ul, DestAccessor dest_acc,
464 KernelIterator ki, KernelAccessor ak,
465 Diff2D kul, Diff2D klr, BorderTreatmentMode border)
467 vigra_precondition((border == BORDER_TREATMENT_CLIP ||
468 border == BORDER_TREATMENT_AVOID),
469 "normalizedConvolveImage(): "
470 "Border treatment must be BORDER_TREATMENT_CLIP or BORDER_TREATMENT_AVOID.");
472 vigra_precondition(kul.x <= 0 && kul.y <= 0,
473 "normalizedConvolveImage(): left borders must be <= 0.");
474 vigra_precondition(klr.x >= 0 && klr.y >= 0,
475 "normalizedConvolveImage(): right borders must be >= 0.");
479 NumericTraits<typename SrcAccessor::value_type>::RealPromote SumType;
481 NumericTraits<typename KernelAccessor::value_type>::RealPromote KSumType;
483 NumericTraits<typename DestAccessor::value_type> DestTraits;
486 int w = src_lr.x - src_ul.x;
487 int h = src_lr.y - src_ul.y;
488 int kernel_width = klr.x - kul.x + 1;
489 int kernel_height = klr.y - kul.y + 1;
492 int ystart = (border == BORDER_TREATMENT_AVOID) ? klr.y : 0;
493 int yend = (border == BORDER_TREATMENT_AVOID) ? h+kul.y : h;
494 int xstart = (border == BORDER_TREATMENT_AVOID) ? klr.x : 0;
495 int xend = (border == BORDER_TREATMENT_AVOID) ? w+kul.x : w;
498 DestIterator yd = dest_ul + Diff2D(xstart, ystart);
499 SrcIterator ys = src_ul + Diff2D(xstart, ystart);
500 MaskIterator ym = mul + Diff2D(xstart, ystart);
502 KSumType norm = ak(ki);
504 KernelIterator yk = ki + klr;
505 for(yy=0; yy<kernel_height; ++yy, --yk.y)
507 KernelIterator xk = yk;
509 for(xx=0; xx<kernel_width; ++xx, --xk.x)
517 for(y=ystart; y < yend; ++y, ++ys.y, ++yd.y, ++ym.y)
524 for(x=xstart; x < xend; ++x, ++xs.x, ++xd.x, ++xm.x)
529 y0 = (y<klr.y) ? -y : -klr.y;
530 y1 = (h-y-1<-kul.y) ? h-y-1 : -kul.y;
531 x0 = (x<klr.x) ? -x : -klr.x;
532 x1 = (w-x-1<-kul.x) ? w-x-1 : -kul.x;
536 SumType sum = NumericTraits<SumType>::zero();
537 KSumType ksum = NumericTraits<KSumType>::zero();
539 SrcIterator yys = xs + Diff2D(x0, y0);
540 MaskIterator yym = xm + Diff2D(x0, y0);
541 KernelIterator yk = ki - Diff2D(x0, y0);
543 int kernel_width, kernel_height;
544 kernel_width = x1 - x0 + 1;
545 kernel_height = y1 - y0 + 1;
546 for(yy=0; yy<kernel_height; ++yy, ++yys.y, --yk.y, ++yym.y)
548 typename SrcIterator::row_iterator xxs = yys.rowIterator();
549 typename SrcIterator::row_iterator xxend = xxs + kernel_width;
550 typename MaskIterator::row_iterator xxm = yym.rowIterator();
551 typename KernelIterator::row_iterator xk = yk.rowIterator();
553 for(xx=0; xxs < xxend; ++xxs, --xk, ++xxm)
555 if(!am(xxm))
continue;
559 sum = detail::RequiresExplicitCast<SumType>::cast(ak(xk) * src_acc(xxs));
565 sum = detail::RequiresExplicitCast<SumType>::cast(sum + ak(xk) * src_acc(xxs));
571 if(ksum != NumericTraits<KSumType>::zero())
573 dest_acc.set(DestTraits::fromRealPromote(
574 detail::RequiresExplicitCast<SumType>::cast((norm / ksum) * sum)), xd);
581 template <
class SrcIterator,
class SrcAccessor,
582 class DestIterator,
class DestAccessor,
583 class MaskIterator,
class MaskAccessor,
584 class KernelIterator,
class KernelAccessor>
587 pair<MaskIterator, MaskAccessor> mask,
588 pair<DestIterator, DestAccessor> dest,
589 tuple5<KernelIterator, KernelAccessor, Diff2D, Diff2D,
590 BorderTreatmentMode> kernel)
593 mask.first, mask.second,
594 dest.first, dest.second,
595 kernel.first, kernel.second, kernel.third,
596 kernel.fourth, kernel.fifth);
599 template <
class T1,
class S1,
605 MultiArrayView<2, TM, SM>
const & mask,
606 MultiArrayView<2, T2, S2> dest,
607 Kernel2D<T3>
const & kernel)
609 vigra_precondition(src.shape() == mask.shape() && src.shape() == dest.shape(),
610 "normalizedConvolveImage(): shape mismatch between input and output.");
671 doxygen_overloaded_function(template <...>
void convolveImageWithMask)
673 template <
class SrcIterator,
class SrcAccessor,
674 class DestIterator,
class DestAccessor,
675 class MaskIterator,
class MaskAccessor,
676 class KernelIterator,
class KernelAccessor>
679 MaskIterator mul, MaskAccessor am,
680 DestIterator dest_ul, DestAccessor dest_acc,
681 KernelIterator ki, KernelAccessor ak,
682 Diff2D kul, Diff2D klr, BorderTreatmentMode border)
687 ki, ak, kul, klr, border);
690 template <
class SrcIterator,
class SrcAccessor,
691 class DestIterator,
class DestAccessor,
692 class MaskIterator,
class MaskAccessor,
693 class KernelIterator,
class KernelAccessor>
696 triple<SrcIterator, SrcIterator, SrcAccessor> src,
697 pair<MaskIterator, MaskAccessor> mask,
698 pair<DestIterator, DestAccessor> dest,
699 tuple5<KernelIterator, KernelAccessor, Diff2D, Diff2D,
700 BorderTreatmentMode> kernel)
703 mask.first, mask.second,
704 dest.first, dest.second,
705 kernel.first, kernel.second, kernel.third,
706 kernel.fourth, kernel.fifth);
759 template <
class ARITHTYPE =
double>
788 InitProxy(Iterator i,
int count, value_type & norm)
789 : iter_(i), base_(i),
790 count_(count), sum_(count),
796 vigra_precondition(count_ == 1 || count_ == sum_,
797 "Kernel2D::initExplicitly(): "
798 "Too few init values.");
801 InitProxy & operator,(value_type
const & v)
803 if(count_ == sum_) norm_ = *iter_;
806 vigra_precondition(count_ > 0,
807 "Kernel2D::initExplicitly(): "
808 "Too many init values.");
818 Iterator iter_, base_;
823 static value_type one() {
return NumericTraits<value_type>::one(); }
830 : kernel_(1, 1, one()),
834 border_treatment_(BORDER_TREATMENT_REFLECT)
840 : kernel_(k.kernel_),
844 border_treatment_(k.border_treatment_)
857 border_treatment_ = k.border_treatment_;
883 int size = (right_.
x - left_.
x + 1) *
884 (right_.
y - left_.
y + 1);
886 norm_ = (double)size*v;
888 return InitProxy(kernel_.
begin(), size, norm_);
914 int w = right_.
x - left_.
x + 1;
915 int h = right_.
y - left_.
y + 1;
923 KIter kiy = ky.
center() + left_.
y;
924 Iterator iy =
center() + left_;
926 for(
int y=left_.
y; y<=right_.
y; ++y, ++kiy, ++iy.y)
928 KIter kix = kx.
center() + left_.
x;
930 for(
int x=left_.
x; x<=right_.
x; ++x, ++kix, ++ix.x)
932 *ix = ka(kix) * ka(kiy);
960 template <
class KernelIterator>
962 KernelIterator kycenter,
int yleft,
int yright)
964 vigra_precondition(xleft <= 0 && yleft <= 0,
965 "Kernel2D::initSeparable(): left borders must be <= 0.");
966 vigra_precondition(xright >= 0 && yright >= 0,
967 "Kernel2D::initSeparable(): right borders must be >= 0.");
970 right_ =
Point2D(xright, yright);
972 int w = right_.
x - left_.
x + 1;
973 int h = right_.
y - left_.
y + 1;
976 KernelIterator kiy = kycenter + left_.
y;
977 Iterator iy =
center() + left_;
979 for(
int y=left_.
y; y<=right_.
y; ++y, ++kiy, ++iy.y)
981 KernelIterator kix = kxcenter + left_.
x;
983 for(
int x=left_.
x; x<=right_.
x; ++x, ++kix, ++ix.x)
1028 return initGaussian(std_dev, NumericTraits<value_type>::one());
1053 vigra_precondition(radius > 0,
1054 "Kernel2D::initDisk(): radius must be > 0.");
1056 left_ =
Point2D(-radius, -radius);
1057 right_ =
Point2D(radius, radius);
1058 int w = right_.
x - left_.
x + 1;
1059 int h = right_.
y - left_.
y + 1;
1061 norm_ = NumericTraits<value_type>::one();
1063 kernel_ = NumericTraits<value_type>::zero();
1067 double r2 = (double)radius*radius;
1070 for(i=0; i<= radius; ++i)
1072 double r = (double) i - 0.5;
1074 for(
int j=-w; j<=w; ++j)
1076 k(j, i) = NumericTraits<value_type>::one();
1077 k(j, -i) = NumericTraits<value_type>::one();
1078 count += (i != 0) ? 2.0 : 1.0;
1082 count = 1.0 / count;
1084 for(
int y=-radius; y<=radius; ++y)
1086 for(
int x=-radius; x<=radius; ++x)
1088 k(x,y) = count * k(x,y);
1133 vigra_precondition(upperleft[0] <= 0 && upperleft[1] <= 0,
1134 "Kernel2D::initExplicitly(): left borders must be <= 0.");
1135 vigra_precondition(lowerright[0] >= 0 && lowerright[1] >= 0,
1136 "Kernel2D::initExplicitly(): right borders must be >= 0.");
1138 left_ =
Point2D(upperleft[0], upperleft[1]);
1139 right_ =
Point2D(lowerright[0], lowerright[1]);
1141 int w = right_.
x - left_.
x + 1;
1142 int h = right_.
y - left_.
y + 1;
1163 int width()
const {
return right_.
x - left_.
x + 1; }
1180 {
return kernel_[
Diff2D(x,y) - left_]; }
1185 {
return kernel_[
Diff2D(x,y) - left_]; }
1190 {
return kernel_[d - left_]; }
1195 {
return kernel_[d - left_]; }
1199 value_type
norm()
const {
return norm_; }
1228 typename NumericTraits<value_type>::RealPromote sum = *i;
1231 for(; i!= iend; ++i)
1237 i = kernel_.
begin();
1238 for(; i != iend; ++i)
1256 {
return border_treatment_; }
1264 vigra_precondition((new_mode == BORDER_TREATMENT_CLIP ||
1265 new_mode == BORDER_TREATMENT_AVOID ||
1266 new_mode == BORDER_TREATMENT_REFLECT ||
1267 new_mode == BORDER_TREATMENT_REPEAT ||
1268 new_mode == BORDER_TREATMENT_WRAP),
1269 "convolveImage():\n"
1270 " Border treatment must be one of follow treatments:\n"
1271 " - BORDER_TREATMENT_CLIP\n"
1272 " - BORDER_TREATMENT_AVOID\n"
1273 " - BORDER_TREATMENT_REFLECT\n"
1274 " - BORDER_TREATMENT_REPEAT\n"
1275 " - BORDER_TREATMENT_WRAP\n");
1277 border_treatment_ = new_mode;
1285 BorderTreatmentMode border_treatment_;
1296 template <
class KernelIterator,
class KernelAccessor>
1298 tuple5<KernelIterator, KernelAccessor, Diff2D, Diff2D, BorderTreatmentMode>
1299 kernel2d(KernelIterator ik, KernelAccessor ak, Diff2D kul, Diff2D klr,
1300 BorderTreatmentMode border)
1304 tuple5<KernelIterator, KernelAccessor, Diff2D, Diff2D, BorderTreatmentMode> (
1305 ik, ak, kul, klr, border);
1310 tuple5<typename Kernel2D<T>::ConstIterator,
1311 typename Kernel2D<T>::ConstAccessor,
1312 Diff2D, Diff2D, BorderTreatmentMode>
1313 kernel2d(Kernel2D<T>
const & k)
1317 tuple5<typename Kernel2D<T>::ConstIterator,
1318 typename Kernel2D<T>::ConstAccessor,
1319 Diff2D, Diff2D, BorderTreatmentMode>(
1322 k.upperLeft(), k.lowerRight(),
1323 k.borderTreatment());
1328 tuple5<typename Kernel2D<T>::ConstIterator,
1329 typename Kernel2D<T>::ConstAccessor,
1330 Diff2D, Diff2D, BorderTreatmentMode>
1331 kernel2d(Kernel2D<T>
const & k, BorderTreatmentMode border)
1335 tuple5<typename Kernel2D<T>::ConstIterator,
1336 typename Kernel2D<T>::ConstAccessor,
1337 Diff2D, Diff2D, BorderTreatmentMode>(
1340 k.upperLeft(), k.lowerRight(),
1347 #endif // VIGRA_STDCONVOLUTION_HXX
iterator end()
Definition: basicimage.hxx:972
iterator begin()
Definition: basicimage.hxx:963
Kernel2D & operator=(Kernel2D const &k)
Definition: stdconvolution.hxx:849
value_type norm() const
Definition: separableconvolution.hxx:2173
void initAveraging(int radius, value_type norm)
Definition: separableconvolution.hxx:2482
BasicImage< value_type >::ConstAccessor ConstAccessor
Definition: stdconvolution.hxx:781
Generic 1 dimensional convolution kernel.
Definition: separableconvolution.hxx:52
ARITHTYPE value_type
Definition: stdconvolution.hxx:765
Accessor accessor()
Definition: stdconvolution.hxx:1203
int y
Definition: diff2d.hxx:392
void initGaussian(double std_dev, value_type norm, double windowRatio=0.0)
Definition: separableconvolution.hxx:2251
value_type operator()(int x, int y) const
Definition: stdconvolution.hxx:1184
void initSeparable(KernelIterator kxcenter, int xleft, int xright, KernelIterator kycenter, int yleft, int yright)
Definition: stdconvolution.hxx:961
BorderTreatmentMode borderTreatment() const
Definition: stdconvolution.hxx:1255
Kernel2D()
Definition: stdconvolution.hxx:829
int x
Definition: diff2d.hxx:385
Point2D lowerRight() const
Definition: stdconvolution.hxx:1159
value_type operator[](Diff2D const &d) const
Definition: stdconvolution.hxx:1194
int height() const
Definition: stdconvolution.hxx:1167
Two dimensional difference vector.
Definition: diff2d.hxx:185
BasicImage< value_type >::Accessor Accessor
Definition: stdconvolution.hxx:777
InitProxy operator=(value_type const &v)
Definition: stdconvolution.hxx:881
ConstIterator center() const
Definition: stdconvolution.hxx:1175
Iterator center()
Definition: stdconvolution.hxx:1171
Definition: accessor.hxx:43
int left() const
Definition: separableconvolution.hxx:2151
void initAveraging(int radius)
Init as a 2D box filter with given radius.
Definition: stdconvolution.hxx:1004
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:1155
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:1248
value_type & operator[](Diff2D const &d)
Definition: stdconvolution.hxx:1189
NumericTraits< V >::Promote sum(TinyVectorBase< V, SIZE, D1, D2 > const &l)
sum of the vector's elements
Definition: tinyvector.hxx:1871
row_iterator rowIterator() const
Definition: diff2d.hxx:431
ConstAccessor accessor() const
Definition: stdconvolution.hxx:1207
void resize(int width, int height)
Definition: basicimage.hxx:776
void initDisk(int radius)
Definition: stdconvolution.hxx:1051
void convolveImage(...)
Convolve an image with the given kernel(s).
void normalize(value_type norm)
Definition: stdconvolution.hxx:1224
value_type norm() const
Definition: stdconvolution.hxx:1199
BasicImage< value_type >::const_traverser ConstIterator
Definition: stdconvolution.hxx:773
void initSeparable(Kernel1D< value_type > const &kx, Kernel1D< value_type > const &ky)
Definition: stdconvolution.hxx:909
Class for fixed size vectors.This class contains an array of size SIZE of the specified VALUETYPE...
Definition: accessor.hxx:940
void normalizedConvolveImage(...)
Performs a 2-dimensional normalized convolution, i.e. convolution with a mask image.
MultiArrayShape< 2 >::type Shape2
shape type for MultiArray<2, T>
Definition: multi_shape.hxx:241
Fundamental class template for images.
Definition: basicimage.hxx:473
Generic 2 dimensional convolution kernel.
Definition: stdconvolution.hxx:52
void convolveImageWithMask(...)
Deprecated name of 2-dimensional normalized convolution, i.e. convolution with a mask image...
void initGaussian(double std_dev, value_type norm)
Init as a 2D Gaussian function with given standard deviation and norm.
Definition: stdconvolution.hxx:1015
int width() const
Definition: stdconvolution.hxx:1163
FFTWComplex< R >::NormType abs(const FFTWComplex< R > &a)
absolute value (= magnitude)
Definition: fftw3.hxx:1002
int right() const
Definition: separableconvolution.hxx:2155
void initGaussian(double std_dev)
Init as a 2D Gaussian function with given standard deviation and unit norm.
Definition: stdconvolution.hxx:1026
InternalVector::const_iterator const_iterator
Definition: separableconvolution.hxx:1393
iterator center()
Definition: separableconvolution.hxx:2121
value_type & operator()(int x, int y)
Definition: stdconvolution.hxx:1179
Kernel2D & initExplicitly(Shape2 const &upperleft, Shape2 const &lowerright)
Definition: stdconvolution.hxx:1131
Encapsulate access to the values an iterator points to.
Definition: accessor.hxx:133
~Kernel2D()
Definition: stdconvolution.hxx:893
void setBorderTreatment(BorderTreatmentMode new_mode)
Definition: stdconvolution.hxx:1262
BasicImage< value_type >::traverser Iterator
Definition: stdconvolution.hxx:769
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:839