36 #ifndef VIGRA_RBF_REGISTRATION_HXX 
   37 #define VIGRA_RBF_REGISTRATION_HXX 
   39 #include <vigra/mathutil.hxx> 
   40 #include <vigra/matrix.hxx> 
   41 #include <vigra/linear_solve.hxx> 
   42 #include <vigra/tinyvector.hxx> 
   43 #include <vigra/splineimageview.hxx> 
   44 #include <vigra/affine_registration.hxx> 
   56 template <
class SrcPo
int, 
class DestPo
int>
 
   57 inline double distance2(SrcPoint 
const & p1, DestPoint 
const & p2)
 
   59     return (
double)(p1[0]-p2[0])*(p1[0]-p2[0]) + (p1[1]-p2[1])*(p1[1]-p2[1]);
 
   71     template <
class SrcPo
int, 
class DestPo
int>
 
   72     inline double operator()(SrcPoint 
const & p1, DestPoint 
const & p2)
 const 
   74         double dist2 = detail::distance2(p1, p2);
 
   82             return dist2*
log(dist2);
 
   93     template <
class SrcPo
int, 
class DestPo
int>
 
   94     inline double operator()(SrcPoint 
const & p1, DestPoint 
const & p2)
 const 
   96         double dist2 = detail::distance2(p1, p2);
 
  104             return pow(dist2, N/2.0);
 
  123 template <
class RadialBasisFunctor,
 
  124           class SrcPointIterator, 
class DestPointIterator>
 
  125 linalg::TemporaryMatrix<double>
 
  128     int point_count = s_end - s;
 
  130     Matrix<double> L(point_count+3, point_count+3, 0.0);
 
  131     Matrix<double> Y(point_count+3,               2, 0.0);
 
  132     Matrix<double> W(point_count+3,               2, 0.0);
 
  135     for(
int i=0; i<point_count; ++i)
 
  137         L(i, point_count  ) = L(point_count,   i) = 1;
 
  138         L(i, point_count+1) = L(point_count+1, i) = (d[i])[0];
 
  139         L(i, point_count+2) = L(point_count+2, i) = (d[i])[1];
 
  146     for(
int j=0; j<point_count; j++)
 
  148         for(
int i=0; i<j; i++)
 
  150             L(i,j) = L(j,i) = rbf(d[i], d[j]);
 
  232 template <
int ORDER, 
class T,
 
  233           class DestIterator, 
class DestAccessor,
 
  234           class DestPointIterator,
 
  236           class RadialBasisFunctor>
 
  239              DestIterator dul, DestIterator dlr, DestAccessor dest,
 
  240              DestPointIterator d, DestPointIterator d_end,
 
  242              RadialBasisFunctor rbf)
 
  244     int point_count = d_end - d;
 
  247                        "vigra::rbfWarpImage(): matrix doesn't represent a proper transformation of given point size in 2D coordinates.");
 
  249     double w = dlr.x - dul.x;
 
  250     double h = dlr.y - dul.y;
 
  252     for(
double y = 0.0; y < h; ++y, ++dul.y)
 
  254         typename DestIterator::row_iterator rd = dul.rowIterator();
 
  255         for(
double x=0.0; x < w; ++x, ++rd)
 
  258             double    sx = W(point_count,0)+W(point_count+1,0)*x+ W(point_count+2,0)*y,
 
  259                     sy = W(point_count,1)+W(point_count+1,1)*x+ W(point_count+2,1)*y;
 
  262             for(
int i=0; i<point_count; i++)
 
  264                 double weight = rbf(d[i], 
Diff2D(x,y));
 
  271                 dest.set(src(sx, sy), rd);
 
  276 template <
int ORDER, 
class T,
 
  277           class DestIterator, 
class DestAccessor,
 
  278           class DestPointIterator,
 
  280           class RadialBasisFunctor>
 
  282 void rbfWarpImage(SplineImageView<ORDER, T> 
const & src,
 
  283                   triple<DestIterator, DestIterator, DestAccessor> dest,
 
  284                   DestPointIterator d, DestPointIterator d_end,
 
  285                   MultiArrayView<2, double, C> 
const & W,
 
  286                   RadialBasisFunctor rbf)
 
  288     rbfWarpImage(src, dest.first, dest.second, dest.third, d, d_end, W, rbf);
 
  291 template <
int ORDER, 
class T,
 
  293           class DestPointIterator,
 
  295           class RadialBasisFunctor>
 
  297 void rbfWarpImage(SplineImageView<ORDER, T> 
const & src,
 
  298                   MultiArrayView<2, T2, S2> dest,
 
  299                   DestPointIterator d, DestPointIterator d_end,
 
  300                   MultiArrayView<2, double, C> 
const & W,
 
  301                   RadialBasisFunctor rbf)
 
  303     rbfWarpImage(src, destImageRange(dest), d, d_end, W, rbf);
 
bool isInside(double x, double y) const 
Definition: splineimageview.hxx:487
Definition: rbf_registration.hxx:91
MultiArrayIndex rowCount(const MultiArrayView< 2, T, C > &x)
Definition: matrix.hxx:671
void rbfWarpImage(SplineImageView< ORDER, T > const &src, DestIterator dul, DestIterator dlr, DestAccessor dest, DestPointIterator d, DestPointIterator d_end, MultiArrayView< 2, double, C > const &W, RadialBasisFunctor rbf)
Warp an image according to an radial basis function based transformation. 
Definition: rbf_registration.hxx:238
Definition: rbf_registration.hxx:69
Two dimensional difference vector. 
Definition: diff2d.hxx:185
linalg::TemporaryMatrix< T > log(MultiArrayView< 2, T, C > const &v)
MultiArrayIndex columnCount(const MultiArrayView< 2, T, C > &x)
Definition: matrix.hxx:684
Base class for, and view to, vigra::MultiArray. 
Definition: multi_array.hxx:704
Create a continuous view onto a discrete image using splines. 
Definition: splineimageview.hxx:99
linalg::TemporaryMatrix< double > rbfMatrix2DFromCorrespondingPoints(SrcPointIterator s, SrcPointIterator s_end, DestPointIterator d, RadialBasisFunctor const &rbf)
Create a matrix that maps corresponding points onto each other using a given RBF. ...
Definition: rbf_registration.hxx:126