---

convolve.h

Go to the documentation of this file.

#ifndef convolve_h
#define convolve_h


#include "fl/image.h"
#include "fl/matrix.h"
#include "fl/point.h"

#include <ostream>


namespace fl
{
  enum BorderMode  
  {
        Crop,  
        ZeroFill,  
        Boost,  
        UseZeros  
  };

  class Convolution : public Filter
  {
  public:
        virtual Image filter (const Image & image) = 0;  
        virtual double response (const Image & image, const Point & p) const = 0;  

        BorderMode mode;
  };


  // 2D Convolutions ----------------------------------------------------------

  class ConvolutionDiscrete2D : public Convolution, public Image
  {
  public:
        ConvolutionDiscrete2D (const BorderMode mode = Crop,
                                                   const PixelFormat & format = GrayFloat);
        ConvolutionDiscrete2D (const Image & image, const BorderMode mode = Crop);

        virtual Image filter (const Image & image);
        virtual double response (const Image & image, const Point & p) const;  

        void normalFloats ();  
  };

  class Gaussian2D : public ConvolutionDiscrete2D
  {
  public:
        Gaussian2D (double sigma = 1.0,
                                const BorderMode mode = Crop,
                                const PixelFormat & format = GrayFloat);

        static double cutoff;  
  };

  class DifferenceOfGaussians : public ConvolutionDiscrete2D
  {
  public:
        DifferenceOfGaussians (double sigmaPlus,
                                                   double sigmaMinus,
                                                   const BorderMode mode = Crop,
                                                   const PixelFormat & format = GrayFloat);
  };

  class GaussianDerivativeFirst : public ConvolutionDiscrete2D
  {
  public:
        GaussianDerivativeFirst (int xy = 0,  
                                                         double sigmaX = 1.0,
                                                         double sigmaY = -1.0,
                                                         double angle = 0,
                                                         const BorderMode mode = Crop,
                                                         const PixelFormat & format = GrayFloat);
  };

  class GaussianDerivativeSecond : public ConvolutionDiscrete2D
  {
  public:
        GaussianDerivativeSecond (int xy1 = 0,
                                                          int xy2 = 0,
                                                          double sigmaX = 1.0,
                                                          double sigmaY = -1.0,
                                                          double angle = 0,
                                                          const BorderMode mode = Crop,
                                                          const PixelFormat & format = GrayFloat);
  };

  class GaussianDerivativeThird : public ConvolutionDiscrete2D
  {
  public:
        GaussianDerivativeThird (int xy1 = 0,
                                                         int xy2 = 0,
                                                         int xy3 = 0,
                                                         double sigmaX = 1.0,
                                                         double sigmaY = -1.0,
                                                         double angle = 0,
                                                         const BorderMode mode = Crop,
                                                         const PixelFormat & format = GrayFloat);
  };

  class Laplacian : public ConvolutionDiscrete2D
  {
  public:
        Laplacian (double sigma = 1.0,
                           const BorderMode mode = Crop,
                           const PixelFormat & format = GrayFloat);

        double sigma;
  };


  // 1D Convolutions ----------------------------------------------------------

  enum Direction
  {
        Vertical,
        Horizontal
  };

  class Convolution1D : public Convolution
  {
  public:
        Direction direction;
  };

  class ConvolutionDiscrete1D : public Convolution1D, public Image
  {
  public:
        ConvolutionDiscrete1D (const BorderMode mode = Crop,
                                                   const PixelFormat & format = GrayFloat,
                                                   const Direction direction = Horizontal);
        ConvolutionDiscrete1D (const Image & image,
                                                   const BorderMode mode = Crop,
                                                   const Direction direction = Horizontal);

        virtual Image filter (const Image & image);
        virtual double response (const Image & image, const Point & p) const;  

        void normalFloats ();  
  };

  class Gaussian1D : public ConvolutionDiscrete1D
  {
  public:
        Gaussian1D (double sigma = 1.0,
                                const BorderMode mode = Crop,
                                const PixelFormat & format = GrayFloat,
                                const Direction direction = Horizontal);
  };

  class GaussianDerivative1D : public ConvolutionDiscrete1D
  {
  public:
        GaussianDerivative1D (double sigma = 1.0,
                                                  const BorderMode mode = Crop,
                                                  const PixelFormat & format = GrayFloat,
                                                  const Direction direction = Horizontal);
  };

  class GaussianDerivativeSecond1D : public ConvolutionDiscrete1D
  {
  public:
        GaussianDerivativeSecond1D (double sigma = 1.0,
                                                                const BorderMode mode = Crop,
                                                                const PixelFormat & format = GrayFloat,
                                                                const Direction direction = Horizontal);
  };

  class ConvolutionRecursive1D : public Convolution1D
  {
  public:
        virtual Image filter (const Image & image);
        virtual double response (const Image & image, const Point & p) const;

        void set_nii_and_dii (double sigma,
                                                  double a0, double a1,
                                                  double b0, double b1,
                                                  double c0, double c1,
                                                  double o0, double o1);

        // Coefficients:
        double n00p;
        double n11p;
        double n22p;
        double n33p;
        double n11m;
        double n22m;
        double n33m;
        double n44m;
        double d11p;
        double d22p;
        double d33p;
        double d44p;
        double d11m;
        double d22m;
        double d33m;
        double d44m;
        double scale;
  };

  class GaussianRecursive1D : public ConvolutionRecursive1D
  {
  public:
        GaussianRecursive1D (double sigma = 1.0,
                                                 const Direction direction = Horizontal);
  };

  class GaussianDerivativeRecursive1D : public ConvolutionRecursive1D
  {
  public:
        GaussianDerivativeRecursive1D (double sigma = 1.0,
                                                                   const Direction direction = Horizontal);
  };

  class GaussianDerivativeSecondRecursive1D : public ConvolutionRecursive1D
  {
  public:
        GaussianDerivativeSecondRecursive1D (double sigma = 1.0,
                                                                                 const Direction direction = Horizontal);
  };


  // Interest operators -------------------------------------------------------

  class FilterHarris : public Filter
  {
  public:
        FilterHarris (double sigmaD = 1.0, double sigmaI = 1.4, const PixelFormat & format = GrayFloat);

        virtual Image filter (const Image & image);  
        virtual void preprocess (const Image & image);  
        virtual Image process ();  
        virtual double response (int x, int y) const;  
        virtual void gradientSquared (int x, int y, Matrix<double> & result) const;  

        double sigmaD;  
        double sigmaI;  
        Gaussian2D           G_I;   
        Gaussian1D           G1_I;  
        Gaussian1D           G1_D;  
        GaussianDerivative1D dG_D;  
        Image xx;  
        Image xy;  
        Image yy;
        int offset;   
        int offsetI;  
        int offsetD;  

        static const double alpha;

  protected:
        int offset1;
        int offset2;
  };

  class FilterHarrisEigen : public FilterHarris
  {
  public:
        FilterHarrisEigen (double sigmaD = 1.0, double sigmaI = 1.4, const PixelFormat & format = GrayFloat) : FilterHarris (sigmaD, sigmaI, format) {}

        virtual Image process ();
        virtual double response (const int x, const int y) const;
  };

  class FilterHessian : public Filter
  {
  public:
        FilterHessian (double sigma = 1.0, const PixelFormat & format = GrayFloat);

        virtual Image filter (const Image & image);

        double sigma;  
        Gaussian1D                 G;
        GaussianDerivativeSecond1D dG;
        int offset;  

  protected:
        int offset1;
        int offset2;
  };


  // Misc -----------------------------------------------------------------------

  class FiniteDifferenceX : public Filter
  {
  public:
        virtual Image filter (const Image & image);     
  };

  class FiniteDifferenceY : public Filter
  {
  public:
        virtual Image filter (const Image & image);     
  };

  class NonMaxSuppress : public Filter
  {
  public:
        NonMaxSuppress (int half = 1, BorderMode mode = UseZeros);  

        virtual Image filter (const Image & image);

        int half;  
        BorderMode mode;
        float maximum;  
        float minimum;  
        float average;  
        int count;  
  };

  class IntensityAverage : public Filter
  {
  public:
        IntensityAverage (bool ignoreZeros = false);

        virtual Image filter (const Image & image);

        float average;  
        float minimum;  
        float maximum;  
        int count;      
        bool ignoreZeros;  
  };

  class IntensityDeviation : public Filter
  {
  public:
        IntensityDeviation (float average, bool ignoreZeros = false);

        virtual Image filter (const Image & image);

        float average;  
        float deviation;  
        bool ignoreZeros;  
  };

  class IntensityHistogram : public Filter
  {
  public:
        IntensityHistogram (const std::vector<float> & ranges);
        IntensityHistogram (float minimum, float maximum, int bins);

        virtual Image filter (const Image & image);

        int total () const;  
        void dump (std::ostream & stream, bool center = false, bool percent = false) const;  

        std::vector<float> ranges;  
        std::vector<int>   counts;  
  };

  class Normalize : public Filter
  {
  public:
        Normalize (double length = 1);

        virtual Image filter (const Image & image);

        double length;
  };

  class AbsoluteValue : public Filter
  {
  public:
        virtual Image filter (const Image & image);
  };

  class Rescale : public Filter
  {
  public:
        Rescale (double a = 1.0, double b = 0);
        Rescale (const Image & image, bool useFullRange = true);  
        virtual Image filter (const Image & image);

        double a;
        double b;
  };

  class Transform : public Filter
  {
  public:
        Transform (const Matrix<double> & A, bool inverse = false);  
        Transform (const Matrix<double> & A, const double scale);  
        Transform (double angle);
        Transform (double scaleX, double scaleY);
        void initialize (const Matrix<double> & A, bool inverse = false);  

        virtual Image filter (const Image & image);

        void setPeg (float centerX = -1, float centerY = -1, int width = -1, int height = -1);  
        void setWindow (float centerX, float centerY, int width = -1, int height = -1);  
        void prepareResult (const Image & image, Image & result, Matrix3x3<float> & H);  
        Transform operator * (const Transform & that) const;

        //Matrix3x3<float> A;  ///< Maps coordinates from input image to output image.
        //Matrix3x3<float> IA;  ///< Inverse of A.  Maps coordinates from output image back to input image.
        //bool inverse;  ///< Indicates whether the matrix given to the constructor was A or IA.

        Matrix2x2<float> IA;  
        float translateX;
        float translateY;

        bool peg;  
        bool defaultViewport;  
        float centerX;
        float centerY;
        int width;
        int height;
  };

  class TransformGauss : public Transform
  {
  public:
        TransformGauss (const Matrix<double> & A, bool inverse = false) : Transform (A, inverse), G (GrayFloat) {needG = true;}
        TransformGauss (const Matrix<double> & A, const double scale) : Transform (A, scale), G (GrayFloat) {needG = true;}
        TransformGauss (double angle) : Transform (angle), G (GrayFloat) {needG = true;}
        TransformGauss (double scaleX, double scaleY) : Transform (scaleX, scaleY), G (GrayFloat) {needG = true;}
        TransformGauss (const Transform & that) : Transform (that), G (GrayFloat) {needG = true;}
        void prepareG ();

        virtual Image filter (const Image & image);

        ImageOf<float> G;  
        int Gshw;  
        int Gshh;  
        int GstepX;  
        int GstepY;
        float sigmaX;  
        float sigmaY;
        bool needG;  
  };

  class Zoom : public Filter
  {
  public:
        Zoom (int scaleX, int scaleY);

        virtual Image filter (const Image & image);

        int scaleX;
        int scaleY;
  };

  class Rotate180 : public Filter
  {
  public:
        virtual Image filter (const Image & image);
  };

  class Rotate90 : public Filter
  {
  public:
        Rotate90 (bool clockwise = false);  

        virtual Image filter (const Image & image);

        bool clockwise;
  };

  class ClearAlpha : public Filter
  {
  public:
        ClearAlpha (unsigned int color = 0x0);

        virtual Image filter (const Image & image);

        unsigned int color;
  };
}


#endif

---