---

/home/slang/XVision2/src/Tools/XVAffineWarp.h

// *** BEGIN_XVISION2_COPYRIGHT_NOTICE ***
// *** END_XVISION2_COPYRIGHT_NOTICE ***

#ifndef _XVAFFINEWARP_H_
#define _XVAFFINEWARP_H_

#include <iostream>
#include <math.h>
#include <string>

#include <XVMacros.h>
#include <XVTools.h>
#include <XVImageBase.h>
#include <XVImageIterator.h>

#define INVERSE 1
#define FORWARD 0

#include <XVMatrix.h>

class XVAffineMatrix {

 public:

  float a;
  float b;
  float c;
  float d;

  XVAffineMatrix(float a0, float b0, float c0, float d0) : a(a0), b(b0), c(c0), d(d0) {}
  XVAffineMatrix() : a(0),b(0),c(0),d(0){}
  XVAffineMatrix(double angle) {
    a = cos(angle);
    b = -sin(angle);
    c = sin(angle);
    d = cos(angle);
  }

  XVAffineMatrix(double sx, double sy) {
    a = sx;  d = sy; b = c = 0;
  };

  XVAffineMatrix(double sh, double d1, double d2){
    a = d = 1;  c = 0; b = sh;
  };

  XVAffineMatrix(const XVMatrix & m){
    a = m[0][0];
    b = m[0][1];
    c = m[1][0];
    d = m[1][1];
  };

  operator XVMatrix () {
    XVMatrix m(2, 2);  
    m[0][0] = a;  
    m[0][1] = b;
    m[1][0] = c;
    m[1][1] = d;
  };

  float det(){ return (a * d - b * c); }

  XVAffineMatrix i(){ 
    float det = this->det(); 
    XVAffineMatrix mat; 
    mat.a = d / det;
    mat.b = - b / det;
    mat.c = - c / det;
    mat.d = a / det;
    return mat;
  }

  XVAffineMatrix t(){
    XVAffineMatrix m;  
    m.a = this->a;  
    m.b = this->c;
    m.c = this->b;
    m.d = this->d;
  }
};

XVAffineMatrix operator * (const XVAffineMatrix & m1, const XVAffineMatrix & m2);

#include <XVGeometry.h>
typedef XV2Vec<float> XVCoord2D;

XVCoord2D operator * (XVAffineMatrix mat, XVCoord2D vec);

//------------------------------------------------------------------------
//  XVAffineWarp Class Declaration
//------------------------------------------------------------------------

template <class T>
class XVAffineWarp {
private:

  XVAffineMatrix amatrix;
  float ratio;

  void invertMatrix();

public:
  XVAffineWarp (float);      
  XVAffineWarp (float, float);  
  XVAffineWarp (float, float, float);  
  XVAffineWarp (float, float, float, float); 
  XVSize sizeNeeded (const XVImageBase<T> &); 
  void findBounds(const XVCoord2D &, const XVSize &, 
            XVCoord2D &, XVCoord2D &, XVCoord2D &, XVCoord2D &);
  XVImageBase<T> & warp (const XVImageBase<T> &, XVImageBase<T> &, 
                const XVCoord2D &, int DIREC = INVERSE);

  XVImageBase<T> & reverseWarp (const XVImageBase<T> &, XVImageBase<T> &, 
                    const XVCoord2D &);

  XVCoord2D transform (XVCoord2D);
  void print();       
};

#include <XVAffineWarp.icc>
#endif

---