37 #ifndef VIGRA_STDCONVOLUTION_HXX 
   38 #define VIGRA_STDCONVOLUTION_HXX 
   41 #include "stdimage.hxx" 
   42 #include "bordertreatment.hxx" 
   43 #include "separableconvolution.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.");
 
  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.");
 
  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>
 
  789             : iter_(i), base_(i),
 
  790               count_(count), sum_(count),
 
  796             throw(PreconditionViolation)
 
  797 #elif _MSC_VER >= 1900 
  801             vigra_precondition(count_ == 1 || count_ == sum_,
 
  802                                "Kernel2D::initExplicitly(): " 
  803                                "Too few init values.");
 
  808             if(count_ == sum_)  norm_ = *iter_;
 
  811             vigra_precondition(count_ > 0,
 
  812                                "Kernel2D::initExplicitly(): " 
  813                                "Too many init values.");
 
  828     static value_type one() { 
return NumericTraits<value_type>::one(); }
 
  835         : kernel_(1, 1, one()),
 
  839           border_treatment_(BORDER_TREATMENT_REFLECT)
 
  845         : kernel_(k.kernel_),
 
  849           border_treatment_(k.border_treatment_)
 
  862             border_treatment_ = k.border_treatment_;
 
  888         int size = (right_.
x - left_.
x + 1) *
 
  889                    (right_.
y - left_.
y + 1);
 
  891         norm_ = (double)size*v;
 
  893         return InitProxy(kernel_.
begin(), size, norm_);
 
  919         int w = right_.
x - left_.
x + 1;
 
  920         int h = right_.
y - left_.
y + 1;
 
  928         KIter kiy = ky.
center() + left_.
y;
 
  931         for(
int y=left_.
y; y<=right_.
y; ++y, ++kiy, ++iy.y)
 
  933             KIter kix = kx.
center() + left_.
x;
 
  935             for(
int x=left_.
x; x<=right_.
x; ++x, ++kix, ++ix.x)
 
  937                 *ix = ka(kix) * ka(kiy);
 
  965     template <
class KernelIterator>
 
  967                              KernelIterator kycenter, 
int yleft, 
int yright)
 
  969         vigra_precondition(xleft <= 0 && yleft <= 0,
 
  970                            "Kernel2D::initSeparable(): left borders must be <= 0.");
 
  971         vigra_precondition(xright >= 0 && yright >= 0,
 
  972                            "Kernel2D::initSeparable(): right borders must be >= 0.");
 
  975         right_ = 
Point2D(xright, yright);
 
  977         int w = right_.
x - left_.
x + 1;
 
  978         int h = right_.
y - left_.
y + 1;
 
  981         KernelIterator kiy = kycenter + left_.
y;
 
  984         for(
int y=left_.
y; y<=right_.
y; ++y, ++kiy, ++iy.y)
 
  986             KernelIterator kix = kxcenter + left_.
x;
 
  988             for(
int x=left_.
x; x<=right_.
x; ++x, ++kix, ++ix.x)
 
 1027         return initGaussian(std_dev, NumericTraits<value_type>::one());
 
 1052         vigra_precondition(radius > 0,
 
 1053                            "Kernel2D::initDisk(): radius must be > 0.");
 
 1055         left_ = 
Point2D(-radius, -radius);
 
 1056         right_ = 
Point2D(radius, radius);
 
 1057         int w = right_.
x - left_.
x + 1;
 
 1058         int h = right_.
y - left_.
y + 1;
 
 1060         norm_ = NumericTraits<value_type>::one();
 
 1062         kernel_ = NumericTraits<value_type>::zero();
 
 1066         double r2 = (double)radius*radius;
 
 1069         for(i=0; i<= radius; ++i)
 
 1071             double r = (double) i - 0.5;
 
 1073             for(
int j=-w; j<=w; ++j)
 
 1075                 k(j, i) = NumericTraits<value_type>::one();
 
 1076                 k(j, -i) = NumericTraits<value_type>::one();
 
 1077                 count += (i != 0) ? 2.0 : 1.0;
 
 1081         count = 1.0 / count;
 
 1083         for(
int y=-radius; y<=radius; ++y)
 
 1085             for(
int x=-radius; x<=radius; ++x)
 
 1087                 k(x,y) = count * k(x,y);
 
 1132         vigra_precondition(upperleft[0] <= 0 && upperleft[1] <= 0,
 
 1133                            "Kernel2D::initExplicitly(): left borders must be <= 0.");
 
 1134         vigra_precondition(lowerright[0] >= 0 && lowerright[1] >= 0,
 
 1135                            "Kernel2D::initExplicitly(): right borders must be >= 0.");
 
 1137         left_ = 
Point2D(upperleft[0], upperleft[1]);
 
 1138         right_ = 
Point2D(lowerright[0], lowerright[1]);
 
 1140         int w = right_.
x - left_.
x + 1;
 
 1141         int h = right_.
y - left_.
y + 1;
 
 1163         vigra_precondition(image.
width() % 2 != 0 && image.
height() % 2 != 0,
 
 1164                            "Kernel2D::initExplicitly(): kernel sizes must be odd.");
 
 1170         for (
auto iter = image.
begin(); iter != image.
end(); ++iter)
 
 1190     int width()
 const { 
return right_.
x - left_.
x + 1; }
 
 1207     { 
return kernel_[
Diff2D(x,y) - left_]; }
 
 1212     { 
return kernel_[
Diff2D(x,y) - left_]; }
 
 1217     { 
return kernel_[d - left_]; }
 
 1222     { 
return kernel_[d - left_]; }
 
 1255         typename NumericTraits<value_type>::RealPromote sum = *i;
 
 1258         for(; i!= iend; ++i)
 
 1264         i = kernel_.
begin();
 
 1265         for(; i != iend; ++i)
 
 1283     { 
return border_treatment_; }
 
 1291         vigra_precondition((new_mode == BORDER_TREATMENT_CLIP    ||
 
 1292                             new_mode == BORDER_TREATMENT_AVOID   ||
 
 1293                             new_mode == BORDER_TREATMENT_REFLECT ||
 
 1294                             new_mode == BORDER_TREATMENT_REPEAT  ||
 
 1295                             new_mode == BORDER_TREATMENT_WRAP),
 
 1296                            "convolveImage():\n" 
 1297                            "  Border treatment must be one of follow treatments:\n" 
 1298                            "  - BORDER_TREATMENT_CLIP\n" 
 1299                            "  - BORDER_TREATMENT_AVOID\n" 
 1300                            "  - BORDER_TREATMENT_REFLECT\n" 
 1301                            "  - BORDER_TREATMENT_REPEAT\n" 
 1302                            "  - BORDER_TREATMENT_WRAP\n");
 
 1304         border_treatment_ = new_mode;
 
 1312     BorderTreatmentMode border_treatment_;
 
 1323 template <
class KernelIterator, 
class KernelAccessor>
 
 1325 tuple5<KernelIterator, KernelAccessor, Diff2D, Diff2D, BorderTreatmentMode>
 
 1326 kernel2d(KernelIterator ik, KernelAccessor ak, Diff2D kul, Diff2D klr,
 
 1327          BorderTreatmentMode border)
 
 1331         tuple5<KernelIterator, KernelAccessor, Diff2D, Diff2D, BorderTreatmentMode> (
 
 1332                                                              ik, ak, kul, klr, border);
 
 1337 tuple5<typename Kernel2D<T>::ConstIterator,
 
 1338        typename Kernel2D<T>::ConstAccessor,
 
 1339        Diff2D, Diff2D, BorderTreatmentMode>
 
 1340 kernel2d(Kernel2D<T> 
const & k)
 
 1344         tuple5<typename Kernel2D<T>::ConstIterator,
 
 1345                typename Kernel2D<T>::ConstAccessor,
 
 1346                Diff2D, Diff2D, BorderTreatmentMode>(
 
 1349             k.upperLeft(), k.lowerRight(),
 
 1350             k.borderTreatment());
 
 1355 tuple5<typename Kernel2D<T>::ConstIterator,
 
 1356        typename Kernel2D<T>::ConstAccessor,
 
 1357        Diff2D, Diff2D, BorderTreatmentMode>
 
 1358 kernel2d(Kernel2D<T> 
const & k, BorderTreatmentMode border)
 
 1362         tuple5<typename Kernel2D<T>::ConstIterator,
 
 1363                typename Kernel2D<T>::ConstAccessor,
 
 1364                Diff2D, Diff2D, BorderTreatmentMode>(
 
 1367             k.upperLeft(), k.lowerRight(),
 
 1374 #endif // VIGRA_STDCONVOLUTION_HXX 
iterator end()
Definition: basicimage.hxx:974
iterator begin()
Definition: basicimage.hxx:965
Kernel2D & operator=(Kernel2D const &k)
Definition: stdconvolution.hxx:854
value_type norm() const 
Definition: separableconvolution.hxx:2175
void initAveraging(int radius, value_type norm)
Definition: separableconvolution.hxx:2484
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:1230
int y
Definition: diff2d.hxx:392
void convolveImage(...)
Convolve an image with the given kernel(s). 
void initGaussian(double std_dev, value_type norm, double windowRatio=0.0)
Definition: separableconvolution.hxx:2253
value_type operator()(int x, int y) const 
Definition: stdconvolution.hxx:1211
void initSeparable(KernelIterator kxcenter, int xleft, int xright, KernelIterator kycenter, int yleft, int yright)
Definition: stdconvolution.hxx:966
BorderTreatmentMode borderTreatment() const 
Definition: stdconvolution.hxx:1282
Kernel2D()
Definition: stdconvolution.hxx:834
int x
Definition: diff2d.hxx:385
Point2D lowerRight() const 
Definition: stdconvolution.hxx:1186
value_type operator[](Diff2D const &d) const 
Definition: stdconvolution.hxx:1221
int height() const 
Definition: stdconvolution.hxx:1194
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:886
ConstIterator center() const 
Definition: stdconvolution.hxx:1202
Iterator center()
Definition: stdconvolution.hxx:1198
std::ptrdiff_t height() const 
Definition: basicimage.hxx:847
int left() const 
Definition: separableconvolution.hxx:2153
void initAveraging(int radius)
Definition: stdconvolution.hxx:1007
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:1182
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:1275
value_type & operator[](Diff2D const &d)
Definition: stdconvolution.hxx:1216
NumericTraits< V >::Promote sum(TinyVectorBase< V, SIZE, D1, D2 > const &l)
sum of the vector's elements 
Definition: tinyvector.hxx:2073
row_iterator rowIterator() const 
Definition: diff2d.hxx:431
ConstAccessor accessor() const 
Definition: stdconvolution.hxx:1234
void normalizedConvolveImage(...)
Performs a 2-dimensional normalized convolution, i.e. convolution with a mask image. 
void initDisk(int radius)
Definition: stdconvolution.hxx:1050
void normalize(value_type norm)
Definition: stdconvolution.hxx:1251
value_type norm() const 
Definition: stdconvolution.hxx:1226
doxygen_overloaded_function(template<...> void separableConvolveBlockwise) template< unsigned int N
Separated convolution on ChunkedArrays. 
BasicImage< value_type >::const_traverser ConstIterator
Definition: stdconvolution.hxx:773
void convolveImageWithMask(...)
Deprecated name of 2-dimensional normalized convolution, i.e. convolution with a mask image...
Kernel2D & initExplicitly(BasicImage< value_type > const &image)
Definition: stdconvolution.hxx:1161
void initSeparable(Kernel1D< value_type > const &kx, Kernel1D< value_type > const &ky)
Definition: stdconvolution.hxx:914
Fundamental class template for images. 
Definition: basicimage.hxx:475
Generic 2 dimensional convolution kernel. 
Definition: stdconvolution.hxx:52
void initGaussian(double std_dev, value_type norm)
Definition: stdconvolution.hxx:1016
int width() const 
Definition: stdconvolution.hxx:1190
FFTWComplex< R >::NormType abs(const FFTWComplex< R > &a)
absolute value (= magnitude) 
Definition: fftw3.hxx:1002
void resize(std::ptrdiff_t width, std::ptrdiff_t height)
Definition: basicimage.hxx:778
int right() const 
Definition: separableconvolution.hxx:2157
void initGaussian(double std_dev)
Definition: stdconvolution.hxx:1025
InternalVector::const_iterator const_iterator
Definition: separableconvolution.hxx:1393
iterator center()
Definition: separableconvolution.hxx:2123
value_type & operator()(int x, int y)
Definition: stdconvolution.hxx:1206
Kernel2D & initExplicitly(Shape2 const &upperleft, Shape2 const &lowerright)
Definition: stdconvolution.hxx:1130
Encapsulate access to the values an iterator points to. 
Definition: accessor.hxx:133
~Kernel2D()
Definition: stdconvolution.hxx:898
std::ptrdiff_t width() const 
Definition: basicimage.hxx:840
void setBorderTreatment(BorderTreatmentMode new_mode)
Definition: stdconvolution.hxx:1289
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:925
Kernel2D(Kernel2D const &k)
Definition: stdconvolution.hxx:844