37 #ifndef VIGRA_MULTI_RESIZE_HXX 
   38 #define VIGRA_MULTI_RESIZE_HXX 
   41 #include "resizeimage.hxx" 
   42 #include "navigator.hxx" 
   43 #include "multi_shape.hxx" 
   49 template <
class SrcIterator, 
class Shape, 
class SrcAccessor,
 
   50           class DestIterator, 
class DestAccessor, 
class Kernel>
 
   52 internalResizeMultiArrayOneDimension(
 
   53                       SrcIterator si, Shape 
const & sshape, SrcAccessor src,
 
   54                       DestIterator di, Shape 
const & dshape, DestAccessor dest,
 
   55                       Kernel 
const & spline, 
unsigned int d)
 
   57     enum { N = 1 + SrcIterator::level };
 
   59     typedef typename NumericTraits<typename DestAccessor::value_type>::RealPromote TmpType;
 
   61     typedef MultiArrayNavigator<SrcIterator, N> SNavigator;
 
   62     typedef MultiArrayNavigator<DestIterator, N> DNavigator;
 
   64     SNavigator snav( si, sshape, d );
 
   65     DNavigator dnav( di, dshape, d );
 
   67     int ssize = sshape[d];
 
   68     int dsize = dshape[d];
 
   70     vigra_precondition(ssize > 1,
 
   71                  "resizeMultiArraySplineInterpolation(): " 
   72                  "Source array too small.\n");
 
   74     Rational<int> ratio(dsize - 1, ssize - 1);
 
   75     Rational<int> offset(0);
 
   76     resampling_detail::MapTargetToSourceCoordinate mapCoordinate(ratio, offset);
 
   77     int period = 
lcm(ratio.numerator(), ratio.denominator());
 
   79     ArrayVector<double> 
const & prefilterCoeffs = spline.prefilterCoefficients();
 
   80     ArrayVector<Kernel1D<double> > kernels(period);
 
   81     createResamplingKernels(spline, mapCoordinate, kernels);
 
   84     ArrayVector<TmpType> tmp( ssize );
 
   85     typename ArrayVector<TmpType>::iterator t = tmp.begin(), tend = tmp.end();
 
   86     typename AccessorTraits<TmpType>::default_accessor ta;
 
   88     for( ; snav.hasMore(); snav++, dnav++ )
 
   91         copyLine( snav.begin(), snav.end(), src, t, ta);
 
   93         for(
unsigned int b = 0; b < prefilterCoeffs.size(); ++b)
 
   96                                 prefilterCoeffs[b], BORDER_TREATMENT_REFLECT);
 
   99                                dnav.begin(), dnav.begin() + dsize, dest,
 
  100                                kernels, mapCoordinate);
 
  227 template <
class SrcIterator, 
class Shape, 
class SrcAccessor,
 
  228           class DestIterator, 
class DestAccessor,
 
  232                       SrcIterator si, Shape 
const & sshape, SrcAccessor src,
 
  233                       DestIterator di, Shape 
const & dshape, DestAccessor dest,
 
  234                       Kernel 
const & spline)
 
  236     enum { N = 1 + SrcIterator::level };
 
  237     typedef typename NumericTraits<typename DestAccessor::value_type>::RealPromote TmpType;
 
  238     typedef typename AccessorTraits<TmpType>::default_accessor TmpAccessor;
 
  242         detail::internalResizeMultiArrayOneDimension(si, sshape, src,
 
  243                       di, dshape, dest, spline, 0);
 
  248         Shape tmpShape(sshape);
 
  249         tmpShape[d] = dshape[d];
 
  250         MultiArray<N, TmpType> tmp(tmpShape);
 
  253         detail::internalResizeMultiArrayOneDimension(si, sshape, src,
 
  254                              tmp.traverser_begin(), tmpShape, ta, spline, d);
 
  258             tmpShape[d] = dshape[d];
 
  259             MultiArray<N, TmpType> dtmp(tmpShape);
 
  261             detail::internalResizeMultiArrayOneDimension(tmp.traverser_begin(), tmp.shape(), ta,
 
  262                                   dtmp.traverser_begin(), tmpShape, ta, spline, d);
 
  265         detail::internalResizeMultiArrayOneDimension(tmp.traverser_begin(), tmp.shape(), ta,
 
  266                                         di, dshape, dest, spline, d);
 
  270 template <
class SrcIterator, 
class Shape, 
class SrcAccessor,
 
  271           class DestIterator, 
class DestAccessor>
 
  274                       SrcIterator si, Shape 
const & sshape, SrcAccessor src,
 
  275                       DestIterator di, Shape 
const & dshape, DestAccessor dest)
 
  280 template <
class SrcIterator, 
class Shape, 
class SrcAccessor,
 
  281           class DestIterator, 
class DestAccessor,
 
  285                                     triple<DestIterator, Shape, DestAccessor> dest,
 
  286                                     Kernel 
const & spline)
 
  289                                         dest.first, dest.second, dest.third, spline);
 
  292 template <
class SrcIterator, 
class Shape, 
class SrcAccessor,
 
  293           class DestIterator, 
class DestAccessor>
 
  296                                     triple<DestIterator, Shape, DestAccessor> dest)
 
  299                                         dest.first, dest.second, dest.third);
 
  302 template <
unsigned int N, 
class T1, 
class S1,
 
  307                                     MultiArrayView<N, T2, S2> dest,
 
  308                                     Kernel 
const & spline)
 
  311                                         destMultiArrayRange(dest), spline);
 
  314 template <
unsigned int N, 
class T1, 
class S1,
 
  318                                     MultiArrayView<N, T2, S2> dest)
 
  321                                         destMultiArrayRange(dest));
 
  328 #endif // VIGRA_MULTI_RESIZE_HXX 
void recursiveFilterLine(...)
Performs a 1-dimensional recursive convolution of the source signal. 
IntType lcm(IntType n, IntType m)
Definition: rational.hxx:122
vigra::GridGraph< N, DirectedTag >::vertex_descriptor source(typename vigra::GridGraph< N, DirectedTag >::edge_descriptor const &e, vigra::GridGraph< N, DirectedTag > const &g)
Get a vertex descriptor for the start vertex of edge e in graph g (API: boost). 
Definition: multi_gridgraph.hxx:2943
doxygen_overloaded_function(template<...> void separableConvolveBlockwise) template< unsigned int N
Separated convolution on ChunkedArrays. 
void resamplingConvolveLine(...)
Performs a 1-dimensional resampling convolution of the source signal using the given set of kernels...