37 #ifndef VIGRA_RECURSIVECONVOLUTION_HXX 
   38 #define VIGRA_RECURSIVECONVOLUTION_HXX 
   43 #include "numerictraits.hxx" 
   44 #include "imageiteratoradapter.hxx" 
   45 #include "bordertreatment.hxx" 
   46 #include "array_vector.hxx" 
   47 #include "multi_shape.hxx" 
  164 template <
class SrcIterator, 
class SrcAccessor,
 
  165           class DestIterator, 
class DestAccessor>
 
  167                          DestIterator 
id, DestAccessor ad, 
double b, BorderTreatmentMode border)
 
  170     SrcIterator istart = is;
 
  174     vigra_precondition(-1.0 < b && b < 1.0,
 
  175                  "recursiveFilterLine(): -1 < factor < 1 required.\n");
 
  180         for(; is != isend; ++is, ++id)
 
  187     double eps = 0.00001;
 
  191         NumericTraits<typename SrcAccessor::value_type>::RealPromote TempType;
 
  192     typedef NumericTraits<typename DestAccessor::value_type> DestTraits;
 
  193     typedef typename DestTraits::RealPromote RealPromote;
 
  196     std::vector<TempType> vline(w);
 
  197     typename std::vector<TempType>::iterator line = vline.begin();
 
  199     double norm = (1.0 - b) / (1.0 + b);
 
  203     if(border == BORDER_TREATMENT_REPEAT ||
 
  204        border == BORDER_TREATMENT_AVOID)
 
  206          old = TempType((1.0 / (1.0 - b)) * as(is));
 
  208     else if(border == BORDER_TREATMENT_REFLECT)
 
  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);
 
  215     else if(border == BORDER_TREATMENT_WRAP)
 
  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);
 
  222     else if(border == BORDER_TREATMENT_CLIP ||
 
  223             border == BORDER_TREATMENT_ZEROPAD)
 
  225         old = NumericTraits<TempType>::zero();
 
  229         vigra_fail(
"recursiveFilterLine(): Unknown border treatment mode.\n");
 
  230         old = NumericTraits<TempType>::zero(); 
 
  234     for(x=0, is = istart; x < w; ++x, ++is)
 
  236         old = TempType(as(is) + b * old);
 
  241     if(border == BORDER_TREATMENT_REPEAT ||
 
  242        border == BORDER_TREATMENT_AVOID)
 
  245         old = TempType((1.0 / (1.0 - b)) * as(is));
 
  247     else if(border == BORDER_TREATMENT_REFLECT)
 
  251     else if(border == BORDER_TREATMENT_WRAP)
 
  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);
 
  258     else if(border == BORDER_TREATMENT_CLIP ||
 
  259             border == BORDER_TREATMENT_ZEROPAD)
 
  261         old = NumericTraits<TempType>::zero();
 
  266     if(border == BORDER_TREATMENT_CLIP)
 
  270         double bleft = VIGRA_CSTD::pow(b, w);
 
  272         for(x=w-1; x>=0; --x, --is, --id)
 
  274             TempType f = TempType(b * old);
 
  276             norm = (1.0 - b) / (1.0 + b - bleft - bright);
 
  279             ad.set(norm * (line[x] + f), 
id);
 
  282     else if(border == BORDER_TREATMENT_AVOID)
 
  284         for(x=w-1; x >= kernelw; --x, --is, --id)
 
  286             TempType f = TempType(b * old);
 
  289                 ad.set(DestTraits::fromRealPromote(RealPromote(norm * (line[x] + f))), 
id);
 
  294         for(x=w-1; x>=0; --x, --is, --id)
 
  296             TempType f = TempType(b * old);
 
  298             ad.set(DestTraits::fromRealPromote(RealPromote(norm * (line[x] + f))), 
id);
 
  309 template <
class SrcIterator, 
class SrcAccessor,
 
  310           class DestIterator, 
class DestAccessor>
 
  312                          DestIterator 
id, DestAccessor ad, 
double b1, 
double b2)
 
  318         NumericTraits<typename SrcAccessor::value_type>::RealPromote TempType;
 
  321     std::vector<TempType> vline(w+1);
 
  322     typename std::vector<TempType>::iterator line = vline.begin();
 
  324     double norm  = 1.0 - b1 - b2;
 
  325     double norm1 = (1.0 - b1 - b2) / (1.0 + b1 + b2);
 
  326     double norm2 = norm * 
norm;
 
  330     int kernelw = std::min(w-1, std::max(8, (
int)(1.0 / norm + 0.5)));  
 
  332     line[kernelw] = as(is);
 
  333     line[kernelw-1] = as(is);
 
  334     for(x = kernelw - 2; x > 0; --x, --is)
 
  336         line[x] = detail::RequiresExplicitCast<TempType>::cast(as(is) + b1 * line[x+1] + b2 * line[x+2]);
 
  338     line[0] = detail::RequiresExplicitCast<TempType>::cast(as(is) + b1 * line[1] + b2 * line[2]);
 
  340     line[1] = detail::RequiresExplicitCast<TempType>::cast(as(is) + b1 * line[0] + b2 * line[1]);
 
  342     for(x=2; x < w; ++x, ++is)
 
  344         line[x] = detail::RequiresExplicitCast<TempType>::cast(as(is) + b1 * line[x-1] + b2 * line[x-2]);
 
  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]));
 
  351     ad.set(line[w-1], 
id);
 
  353     ad.set(line[w-2], 
id);
 
  355     for(x=w-3; x>=0; --x, --id, --is)
 
  357         line[x] = detail::RequiresExplicitCast<TempType>::cast(norm2 * line[x] + b1 * line[x+1] + b2 * line[x+2]);
 
  444 template <
class SrcIterator, 
class SrcAccessor,
 
  445           class DestIterator, 
class DestAccessor>
 
  448                             DestIterator 
id, DestAccessor ad, 
 
  452     double q = 1.31564 * (
std::sqrt(1.0 + 0.490811 * sigma*sigma) - 1.0);
 
  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);
 
  462     vigra_precondition(w >= 4,
 
  463         "recursiveGaussianFilterLine(): line must have at least length 4.");
 
  465     int kernelw = std::min(w-4, (
int)(4.0*sigma));
 
  470         NumericTraits<typename SrcAccessor::value_type>::RealPromote TempType;
 
  473     std::vector<TempType> yforward(w);
 
  475     std::vector<TempType> ybackward(w, 0.0);
 
  478     for(x=kernelw; x>=0; --x)
 
  480         ybackward[x] = detail::RequiresExplicitCast<TempType>::cast(B*as(is, x) + (b1*ybackward[x+1]+b2*ybackward[x+2]+b3*ybackward[x+3]));
 
  484     yforward[0] = detail::RequiresExplicitCast<TempType>::cast(B*as(is) + (b1*ybackward[1]+b2*ybackward[2]+b3*ybackward[3]));
 
  487     yforward[1] = detail::RequiresExplicitCast<TempType>::cast(B*as(is) + (b1*yforward[0]+b2*ybackward[1]+b3*ybackward[2]));
 
  490     yforward[2] = detail::RequiresExplicitCast<TempType>::cast(B*as(is) + (b1*yforward[1]+b2*yforward[0]+b3*ybackward[1]));
 
  493     for(x=3; x < w; ++x, ++is)
 
  495         yforward[x] = detail::RequiresExplicitCast<TempType>::cast(B*as(is) + (b1*yforward[x-1]+b2*yforward[x-2]+b3*yforward[x-3]));
 
  499     ybackward[w-1] = detail::RequiresExplicitCast<TempType>::cast(B*yforward[w-1] + (b1*yforward[w-2]+b2*yforward[w-3]+b3*yforward[w-4]));
 
  501     ybackward[w-2] = detail::RequiresExplicitCast<TempType>::cast(B*yforward[w-2] + (b1*ybackward[w-1]+b2*yforward[w-2]+b3*yforward[w-3]));
 
  503     ybackward[w-3] = detail::RequiresExplicitCast<TempType>::cast(B*yforward[w-3] + (b1*ybackward[w-2]+b2*ybackward[w-1]+b3*yforward[w-2]));
 
  505     for(x=w-4; x>=0; --x)
 
  507         ybackward[x] = detail::RequiresExplicitCast<TempType>::cast(B*yforward[x]+(b1*ybackward[x+1]+b2*ybackward[x+2]+b3*ybackward[x+3]));
 
  511     for(x=0; x < w; ++x, ++id)
 
  513         ad.set(ybackward[x], 
id);
 
  586 template <
class SrcIterator, 
class SrcAccessor,
 
  587           class DestIterator, 
class DestAccessor>
 
  590                          DestIterator 
id, DestAccessor ad, 
double scale)
 
  592     vigra_precondition(scale >= 0,
 
  593                  "recursiveSmoothLine(): scale must be >= 0.\n");
 
  595     double b = (scale == 0.0) ? 
 
  674 template <
class SrcIterator, 
class SrcAccessor,
 
  675           class DestIterator, 
class DestAccessor>
 
  677                          DestIterator 
id, DestAccessor ad, 
double scale)
 
  679     vigra_precondition(scale > 0,
 
  680                  "recursiveFirstDerivativeLine(): scale must be > 0.\n");
 
  687         NumericTraits<typename SrcAccessor::value_type>::RealPromote 
 
  689     typedef NumericTraits<typename DestAccessor::value_type> DestTraits;
 
  691     std::vector<TempType> vline(w);
 
  692     typename std::vector<TempType>::iterator line = vline.begin();
 
  695     double norm = (1.0 - b) * (1.0 - b) / 2.0 / b;
 
  696     TempType old = (1.0 / (1.0 - b)) * as(is);
 
  699     for(x=0; x<w; ++x, ++is)
 
  701         old = as(is) + b * old;
 
  707     old = (1.0 / (1.0 - b)) * as(is);
 
  711     for(x=w-1; x>=0; --x)
 
  716         old = as(is) + b * old;
 
  718         ad.set(DestTraits::fromRealPromote(norm * (line[x] + old)), 
id);
 
  794 template <
class SrcIterator, 
class SrcAccessor,
 
  795           class DestIterator, 
class DestAccessor>
 
  797                          DestIterator 
id, DestAccessor ad, 
double scale)
 
  799     vigra_precondition(scale > 0,
 
  800                  "recursiveSecondDerivativeLine(): scale must be > 0.\n");
 
  807         NumericTraits<typename SrcAccessor::value_type>::RealPromote 
 
  809     typedef NumericTraits<typename DestAccessor::value_type> DestTraits;
 
  811     std::vector<TempType> vline(w);
 
  812     typename std::vector<TempType>::iterator line = vline.begin();
 
  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));
 
  820     for(x=0; x<w; ++x, ++is)
 
  823         old = detail::RequiresExplicitCast<TempType>::cast(as(is) + b * old);
 
  828     old = detail::RequiresExplicitCast<TempType>::cast((1.0 / (1.0 - b)) * as(is));
 
  832     for(x=w-1; x>=0; --x)
 
  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);
 
  946 template <
class SrcImageIterator, 
class SrcAccessor,
 
  947           class DestImageIterator, 
class DestAccessor>
 
  949                        SrcImageIterator slowerright, SrcAccessor as,
 
  950                        DestImageIterator dupperleft, DestAccessor ad, 
 
  951                        double b, BorderTreatmentMode border)
 
  953     int w = slowerright.x - supperleft.x;
 
  954     int h = slowerright.y - supperleft.y;
 
  958     for(y=0; y<h; ++y, ++supperleft.y, ++dupperleft.y)
 
  960         typename SrcImageIterator::row_iterator rs = supperleft.rowIterator();
 
  961         typename DestImageIterator::row_iterator rd = dupperleft.rowIterator();
 
  969 template <
class SrcImageIterator, 
class SrcAccessor,
 
  970           class DestImageIterator, 
class DestAccessor>
 
  972 recursiveFilterX(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
 
  973                  pair<DestImageIterator, DestAccessor> dest, 
 
  974                  double b, BorderTreatmentMode border)
 
  977                      dest.first, dest.second, b, border);
 
  980 template <
class T1, 
class S1,
 
  984                  MultiArrayView<2, T2, S2> dest, 
 
  985                  double b, BorderTreatmentMode border)
 
  987     vigra_precondition(src.shape() == dest.shape(),
 
  988         "recursiveFilterX(): shape mismatch between input and output.");
 
  990                      destImage(dest), b, border);
 
  999 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1000           class DestImageIterator, 
class DestAccessor>
 
 1002                        SrcImageIterator slowerright, SrcAccessor as,
 
 1003                        DestImageIterator dupperleft, DestAccessor ad, 
 
 1004                        double b1, 
double b2)
 
 1006     int w = slowerright.x - supperleft.x;
 
 1007     int h = slowerright.y - supperleft.y;
 
 1011     for(y=0; y<h; ++y, ++supperleft.y, ++dupperleft.y)
 
 1013         typename SrcImageIterator::row_iterator rs = supperleft.rowIterator();
 
 1014         typename DestImageIterator::row_iterator rd = dupperleft.rowIterator();
 
 1022 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1023           class DestImageIterator, 
class DestAccessor>
 
 1025 recursiveFilterX(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
 
 1026                  pair<DestImageIterator, DestAccessor> dest, 
 
 1027                  double b1, 
double b2)
 
 1030                      dest.first, dest.second, b1, b2);
 
 1033 template <
class T1, 
class S1,
 
 1037                  MultiArrayView<2, T2, S2> dest, 
 
 1038                  double b1, 
double b2)
 
 1040     vigra_precondition(src.shape() == dest.shape(),
 
 1041         "recursiveFilterX(): shape mismatch between input and output.");
 
 1043                      destImage(dest), b1, b2);
 
 1122 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1123           class DestImageIterator, 
class DestAccessor>
 
 1126                          DestImageIterator dupperleft, DestAccessor ad, 
 
 1129     int w = slowerright.x - supperleft.x;
 
 1130     int h = slowerright.y - supperleft.y;
 
 1134     for(y=0; y<h; ++y, ++supperleft.y, ++dupperleft.y)
 
 1136         typename SrcImageIterator::row_iterator rs = supperleft.rowIterator();
 
 1137         typename DestImageIterator::row_iterator rd = dupperleft.rowIterator();
 
 1145 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1146           class DestImageIterator, 
class DestAccessor>
 
 1149                          pair<DestImageIterator, DestAccessor> dest, 
 
 1153                              dest.first, dest.second, sigma);
 
 1156 template <
class T1, 
class S1,
 
 1160                          MultiArrayView<2, T2, S2> dest, 
 
 1163     vigra_precondition(src.shape() == dest.shape(),
 
 1164         "recursiveGaussianFilterX(): shape mismatch between input and output.");
 
 1166                              destImage(dest), sigma);
 
 1243 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1244           class DestImageIterator, 
class DestAccessor>
 
 1246                       SrcImageIterator slowerright, SrcAccessor as,
 
 1247                       DestImageIterator dupperleft, DestAccessor ad, 
 
 1250     int w = slowerright.x - supperleft.x;
 
 1251     int h = slowerright.y - supperleft.y;
 
 1255     for(y=0; y<h; ++y, ++supperleft.y, ++dupperleft.y)
 
 1257         typename SrcImageIterator::row_iterator rs = supperleft.rowIterator();
 
 1258         typename DestImageIterator::row_iterator rd = dupperleft.rowIterator();
 
 1266 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1267           class DestImageIterator, 
class DestAccessor>
 
 1269 recursiveSmoothX(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
 
 1270                  pair<DestImageIterator, DestAccessor> dest, 
 
 1274                      dest.first, dest.second, scale);
 
 1277 template <
class T1, 
class S1,
 
 1281                  MultiArrayView<2, T2, S2> dest, 
 
 1284     vigra_precondition(src.shape() == dest.shape(),
 
 1285         "recursiveSmoothX(): shape mismatch between input and output.");
 
 1287                      destImage(dest), scale);
 
 1392 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1393           class DestImageIterator, 
class DestAccessor>
 
 1395                        SrcImageIterator slowerright, SrcAccessor as,
 
 1396                        DestImageIterator dupperleft, DestAccessor ad, 
 
 1397                        double b, BorderTreatmentMode border)
 
 1399     int w = slowerright.x - supperleft.x;
 
 1400     int h = slowerright.y - supperleft.y;
 
 1404     for(x=0; x<w; ++x, ++supperleft.x, ++dupperleft.x)
 
 1406         typename SrcImageIterator::column_iterator cs = supperleft.columnIterator();
 
 1407         typename DestImageIterator::column_iterator cd = dupperleft.columnIterator();
 
 1415 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1416           class DestImageIterator, 
class DestAccessor>
 
 1418 recursiveFilterY(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
 
 1419                  pair<DestImageIterator, DestAccessor> dest, 
 
 1420                  double b, BorderTreatmentMode border)
 
 1423                      dest.first, dest.second, b, border);
 
 1426 template <
class T1, 
class S1,
 
 1430                  MultiArrayView<2, T2, S2> dest, 
 
 1431                  double b, BorderTreatmentMode border)
 
 1433     vigra_precondition(src.shape() == dest.shape(),
 
 1434         "recursiveFilterY(): shape mismatch between input and output.");
 
 1436                      destImage(dest), b, border);
 
 1445 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1446           class DestImageIterator, 
class DestAccessor>
 
 1448                        SrcImageIterator slowerright, SrcAccessor as,
 
 1449                        DestImageIterator dupperleft, DestAccessor ad, 
 
 1450                        double b1, 
double b2)
 
 1452     int w = slowerright.x - supperleft.x;
 
 1453     int h = slowerright.y - supperleft.y;
 
 1457     for(x=0; x<w; ++x, ++supperleft.x, ++dupperleft.x)
 
 1459         typename SrcImageIterator::column_iterator cs = supperleft.columnIterator();
 
 1460         typename DestImageIterator::column_iterator cd = dupperleft.columnIterator();
 
 1468 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1469           class DestImageIterator, 
class DestAccessor>
 
 1471 recursiveFilterY(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
 
 1472                  pair<DestImageIterator, DestAccessor> dest, 
 
 1473                  double b1, 
double b2)
 
 1476                      dest.first, dest.second, b1, b2);
 
 1479 template <
class T1, 
class S1,
 
 1483                  MultiArrayView<2, T2, S2> dest, 
 
 1484                  double b1, 
double b2)
 
 1486     vigra_precondition(src.shape() == dest.shape(),
 
 1487         "recursiveFilterY(): shape mismatch between input and output.");
 
 1489                      destImage(dest), b1, b2);
 
 1568 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1569           class DestImageIterator, 
class DestAccessor>
 
 1572                          DestImageIterator dupperleft, DestAccessor ad, 
 
 1575     int w = slowerright.x - supperleft.x;
 
 1576     int h = slowerright.y - supperleft.y;
 
 1580     for(x=0; x<w; ++x, ++supperleft.x, ++dupperleft.x)
 
 1582         typename SrcImageIterator::column_iterator cs = supperleft.columnIterator();
 
 1583         typename DestImageIterator::column_iterator cd = dupperleft.columnIterator();
 
 1591 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1592           class DestImageIterator, 
class DestAccessor>
 
 1595                          pair<DestImageIterator, DestAccessor> dest, 
 
 1599                              dest.first, dest.second, sigma);
 
 1602 template <
class T1, 
class S1,
 
 1606                          MultiArrayView<2, T2, S2> dest, 
 
 1609     vigra_precondition(src.shape() == dest.shape(),
 
 1610         "recursiveGaussianFilterY(): shape mismatch between input and output.");
 
 1612                              destImage(dest), sigma);
 
 1690 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1691           class DestImageIterator, 
class DestAccessor>
 
 1693                       SrcImageIterator slowerright, SrcAccessor as,
 
 1694                       DestImageIterator dupperleft, DestAccessor ad, 
 
 1697     int w = slowerright.x - supperleft.x;
 
 1698     int h = slowerright.y - supperleft.y;
 
 1702     for(x=0; x<w; ++x, ++supperleft.x, ++dupperleft.x)
 
 1704         typename SrcImageIterator::column_iterator cs = supperleft.columnIterator();
 
 1705         typename DestImageIterator::column_iterator cd = dupperleft.columnIterator();
 
 1713 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1714           class DestImageIterator, 
class DestAccessor>
 
 1716 recursiveSmoothY(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
 
 1717                  pair<DestImageIterator, DestAccessor> dest, 
 
 1721                      dest.first, dest.second, scale);
 
 1724 template <
class T1, 
class S1,
 
 1728                  MultiArrayView<2, T2, S2> dest, 
 
 1731     vigra_precondition(src.shape() == dest.shape(),
 
 1732         "recursiveSmoothY(): shape mismatch between input and output.");
 
 1734                      destImage(dest), scale);
 
 1812 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1813           class DestImageIterator, 
class DestAccessor>
 
 1815                       SrcImageIterator slowerright, SrcAccessor as,
 
 1816                       DestImageIterator dupperleft, DestAccessor ad, 
 
 1819     int w = slowerright.x - supperleft.x;
 
 1820     int h = slowerright.y - supperleft.y;
 
 1824     for(y=0; y<h; ++y, ++supperleft.y, ++dupperleft.y)
 
 1826         typename SrcImageIterator::row_iterator rs = supperleft.rowIterator();
 
 1827         typename DestImageIterator::row_iterator rd = dupperleft.rowIterator();
 
 1835 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1836           class DestImageIterator, 
class DestAccessor>
 
 1839                           pair<DestImageIterator, DestAccessor> dest, 
 
 1843                               dest.first, dest.second, scale);
 
 1846 template <
class T1, 
class S1,
 
 1850                           MultiArrayView<2, T2, S2> dest, 
 
 1853     vigra_precondition(src.shape() == dest.shape(),
 
 1854         "recursiveFirstDerivativeX(): shape mismatch between input and output.");
 
 1856                               destImage(dest), scale);
 
 1934 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1935           class DestImageIterator, 
class DestAccessor>
 
 1937                       SrcImageIterator slowerright, SrcAccessor as,
 
 1938                       DestImageIterator dupperleft, DestAccessor ad, 
 
 1941     int w = slowerright.x - supperleft.x;
 
 1942     int h = slowerright.y - supperleft.y;
 
 1946     for(x=0; x<w; ++x, ++supperleft.x, ++dupperleft.x)
 
 1948         typename SrcImageIterator::column_iterator cs = supperleft.columnIterator();
 
 1949         typename DestImageIterator::column_iterator cd = dupperleft.columnIterator();
 
 1957 template <
class SrcImageIterator, 
class SrcAccessor,
 
 1958           class DestImageIterator, 
class DestAccessor>
 
 1961                           pair<DestImageIterator, DestAccessor> dest, 
 
 1965                               dest.first, dest.second, scale);
 
 1968 template <
class T1, 
class S1,
 
 1972                           MultiArrayView<2, T2, S2> dest, 
 
 1975     vigra_precondition(src.shape() == dest.shape(),
 
 1976         "recursiveFirstDerivativeY(): shape mismatch between input and output.");
 
 1978                               destImage(dest), scale);
 
 2056 template <
class SrcImageIterator, 
class SrcAccessor,
 
 2057           class DestImageIterator, 
class DestAccessor>
 
 2059                       SrcImageIterator slowerright, SrcAccessor as,
 
 2060                       DestImageIterator dupperleft, DestAccessor ad, 
 
 2063     int w = slowerright.x - supperleft.x;
 
 2064     int h = slowerright.y - supperleft.y;
 
 2068     for(y=0; y<h; ++y, ++supperleft.y, ++dupperleft.y)
 
 2070         typename SrcImageIterator::row_iterator rs = supperleft.rowIterator();
 
 2071         typename DestImageIterator::row_iterator rd = dupperleft.rowIterator();
 
 2079 template <
class SrcImageIterator, 
class SrcAccessor,
 
 2080           class DestImageIterator, 
class DestAccessor>
 
 2083                            pair<DestImageIterator, DestAccessor> dest, 
 
 2087                                dest.first, dest.second, scale);
 
 2090 template <
class T1, 
class S1,
 
 2094                            MultiArrayView<2, T2, S2> dest, 
 
 2097     vigra_precondition(src.shape() == dest.shape(),
 
 2098         "recursiveSecondDerivativeX(): shape mismatch between input and output.");
 
 2100                                destImage(dest), scale);
 
 2178 template <
class SrcImageIterator, 
class SrcAccessor,
 
 2179           class DestImageIterator, 
class DestAccessor>
 
 2181                       SrcImageIterator slowerright, SrcAccessor as,
 
 2182                       DestImageIterator dupperleft, DestAccessor ad, 
 
 2185     int w = slowerright.x - supperleft.x;
 
 2186     int h = slowerright.y - supperleft.y;
 
 2190     for(x=0; x<w; ++x, ++supperleft.x, ++dupperleft.x)
 
 2192         typename SrcImageIterator::column_iterator cs = supperleft.columnIterator();
 
 2193         typename DestImageIterator::column_iterator cd = dupperleft.columnIterator();
 
 2201 template <
class SrcImageIterator, 
class SrcAccessor,
 
 2202           class DestImageIterator, 
class DestAccessor>
 
 2205                            pair<DestImageIterator, DestAccessor> dest, 
 
 2209                                dest.first, dest.second, scale);
 
 2212 template <
class T1, 
class S1,
 
 2216                            MultiArrayView<2, T2, S2> dest, 
 
 2219     vigra_precondition(src.shape() == dest.shape(),
 
 2220         "recursiveSecondDerivativeY(): shape mismatch between input and output.");
 
 2222                                destImage(dest), scale);
 
 2229 #endif // VIGRA_RECURSIVECONVOLUTION_HXX 
void recursiveFirstDerivativeX(...)
Recursively calculates the 1 dimensional first derivative in x direction. 
void recursiveGaussianFilterX(...)
Compute 1 dimensional recursive approximation of Gaussian smoothing in y direction. 
void recursiveFirstDerivativeLine(...)
Performs a 1 dimensional recursive convolution of the source signal. 
void recursiveFilterY(...)
Performs 1 dimensional recursive filtering (1st and 2nd order) in y direction. 
linalg::TemporaryMatrix< T > exp(MultiArrayView< 2, T, C > const &v)
void recursiveSmoothLine(...)
Convolves the image with a 1-dimensional exponential filter. 
void recursiveSecondDerivativeY(...)
Recursively calculates the 1 dimensional second derivative in y direction. 
FFTWComplex< R >::NormType norm(const FFTWComplex< R > &a)
norm (= magnitude) 
Definition: fftw3.hxx:1037
void recursiveSecondDerivativeLine(...)
Performs a 1 dimensional recursive convolution of the source signal. 
void recursiveFilterLine(...)
Performs a 1-dimensional recursive convolution of the source signal. 
void recursiveFilterX(...)
Performs 1 dimensional recursive filtering (1st and 2nd order) in x direction. 
void recursiveGaussianFilterY(...)
Compute 1 dimensional recursive approximation of Gaussian smoothing in y direction. 
void recursiveGaussianFilterLine(...)
Compute a 1-dimensional recursive approximation of Gaussian smoothing. 
void recursiveSmoothX(...)
Performs 1 dimensional recursive smoothing in x direction. 
void recursiveSecondDerivativeX(...)
Recursively calculates the 1 dimensional second derivative in x direction. 
doxygen_overloaded_function(template<...> void separableConvolveBlockwise) template< unsigned int N
Separated convolution on ChunkedArrays. 
void recursiveSmoothY(...)
Performs 1 dimensional recursive smoothing in y direction. 
linalg::TemporaryMatrix< T > log(MultiArrayView< 2, T, C > const &v)
void recursiveFirstDerivativeY(...)
Recursively calculates the 1 dimensional first derivative in y direction. 
SquareRootTraits< FixedPoint< IntBits, FracBits > >::SquareRootResult sqrt(FixedPoint< IntBits, FracBits > v)
square root. 
Definition: fixedpoint.hxx:616