---

descriptor.h

Go to the documentation of this file.

#ifndef fl_descriptor_h
#define fl_descriptor_h


#include "fl/convolve.h"
#include "fl/matrix.h"
#include "fl/point.h"
#include "fl/canvas.h"

#include <iostream>
#include <vector>


namespace fl
{
  // Comparison ---------------------------------------------------------------

  class Comparison
  {
  public:
        virtual ~Comparison ();  

        virtual Vector<float> preprocess (const Vector<float> & value) const;
        virtual float value (const Vector<float> & value1, const Vector<float> & value2, bool preprocessed = false) const = 0;

        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);
        static void addProducts ();  
  };

  class Descriptor;

  class ComparisonCombo : public Comparison
  {
  public:
        ComparisonCombo (std::vector<Descriptor *> & descriptors);
        ComparisonCombo (std::istream & stream);
        virtual ~ComparisonCombo ();  

        virtual Vector<float> preprocess (const Vector<float> & value) const;
        virtual float value (const Vector<float> & value1, const Vector<float> & value2, bool preprocessed = false) const;
        virtual float value (int index, const Vector<float> & value1, const Vector<float> & value2, bool preprocessed = false) const;  
        Vector<float> extract (int index, const Vector<float> & value) const;  

        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        std::vector<Comparison *> comparisons;
        std::vector<int> dimensions;
        int totalDimension;
  };

  class NormalizedCorrelation : public Comparison
  {
  public:
        NormalizedCorrelation (bool subtractMean = true);
        NormalizedCorrelation (std::istream & stream);

        virtual Vector<float> preprocess (const Vector<float> & value) const;
        virtual float value (const Vector<float> & value1, const Vector<float> & value2, bool preprocessed = false) const;

        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        bool subtractMean;  
  };

  class MetricEuclidean : public Comparison
  {
  public:
        MetricEuclidean (float upperBound = INFINITY);
        MetricEuclidean (std::istream & stream);

        virtual float value (const Vector<float> & value1, const Vector<float> & value2, bool preprocessed = false) const;

        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        float upperBound;  
  };

  class HistogramIntersection : public Comparison
  {
  public:
        HistogramIntersection () {}
        HistogramIntersection (std::istream & stream);
        virtual float value (const Vector<float> & value1, const Vector<float> & value2, bool preprocessed = false) const;
  };

  class ChiSquared : public Comparison
  {
  public:
        ChiSquared () {}
        ChiSquared (std::istream & stream);

        virtual Vector<float> preprocess (const Vector<float> & value) const;
        virtual float value (const Vector<float> & value1, const Vector<float> & value2, bool preprocessed = false) const;
  };


  // Descriptor ---------------------------------------------------------------

  class Descriptor
  {
  public:
        Descriptor ();
        virtual ~Descriptor ();

        virtual Vector<float> value (const Image & image, const PointAffine & point) = 0;  
        virtual Vector<float> value (const Image & image);  
        virtual Image patch (const Vector<float> & value) = 0;  
        virtual Comparison * comparison ();  

        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        bool monochrome;  
        int dimension;  
        float supportRadial;  
  };

  class DescriptorCombo : public Descriptor
  {
  public:
        DescriptorCombo ();
        DescriptorCombo (std::istream & stream);
        virtual ~DescriptorCombo ();  

        void add (Descriptor * descriptor);  
        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Vector<float> value (const Image & image);
        virtual Image patch (const Vector<float> & value);
        Image patch (int index, const Vector<float> & value);  
        virtual Comparison * comparison ();
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        std::vector<Descriptor *> descriptors;

        void * lastBuffer;  
        double lastTime;  
        Image grayImage;
  };

  class DescriptorScale : public Descriptor
  {
  public:
        DescriptorScale (float firstScale = 1, float lastScale = 25, int interQuanta = 40, float quantum = 2);  
        DescriptorScale (std::istream & stream);
        void initialize (float firstScale, float lastScale, float stepSize);

        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Image patch (const Vector<float> & value);
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        std::vector<Laplacian> laplacians;
  };

  class DescriptorOrientation : public Descriptor
  {
  public:
        DescriptorOrientation (float supportRadial = 6.0f, int supportPixel = 32, float kernelSize = 2.5f);
        DescriptorOrientation (std::istream & stream);
        void initialize (float supportRadial, int supportPixel, float kernelSize);

        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Image patch (const Vector<float> & value);
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        int supportPixel;  
        float kernelSize;  
        GaussianDerivativeFirst Gx;
        GaussianDerivativeFirst Gy;
  };

  class DescriptorOrientationHistogram : public Descriptor
  {
  public:
        DescriptorOrientationHistogram (float supportRadial = 4.5f, int supportPixel = 16, float kernelSize = 2.5f, int bins = 36);
        DescriptorOrientationHistogram (std::istream & stream);

        void computeGradient (const Image & image);

        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Image patch (const Vector<float> & value);
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        int supportPixel;  
        float kernelSize;  
        int bins;  
        float cutoff;  

        void * lastBuffer;  
        double lastTime;  
        ImageOf<float> I_x;
        ImageOf<float> I_y;
  };

  class DescriptorContrast : public Descriptor
  {
  public:
        DescriptorContrast (float supportRadial = 6.0f, int supportPixel = 32);
        DescriptorContrast (std::istream & stream);

        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Image patch (const Vector<float> & value);
        virtual Comparison * comparison ();
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        int supportPixel;  
  };

  class DescriptorFilters : public Descriptor
  {
  public:
        DescriptorFilters ();
        DescriptorFilters (std::istream & stream);
        virtual ~DescriptorFilters ();  

        void prepareFilterMatrix ();

        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Image patch (const Vector<float> & value);
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        std::vector<ConvolutionDiscrete2D> filters;
        Matrix<float> filterMatrix;
        int patchWidth;
        int patchHeight;
  };

  class DescriptorFiltersTexton : public DescriptorFilters
  {
  public:
        DescriptorFiltersTexton (int angles = 6, int scales = 4, float firstScale = -1, float scaleStep = -1);
        DescriptorFiltersTexton (std::istream & stream) : DescriptorFilters (stream) {}
  };

  class DescriptorPatch : public Descriptor
  {
  public:
        DescriptorPatch (int width = 10, float supportRadial = 4.2);
        DescriptorPatch (std::istream & stream);
        virtual ~DescriptorPatch ();

        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Image patch (const Vector<float> & value);
        virtual Comparison * comparison ();
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        int width;
  };

  class DescriptorSchmidScale : public Descriptor
  {
  public:
        DescriptorSchmidScale (float sigma = 1.0);
        DescriptorSchmidScale (std::istream & stream);
        void initialize ();
        virtual ~DescriptorSchmidScale ();

        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Image patch (const Vector<float> & value);
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        float sigma;
        ConvolutionDiscrete2D G;
        ConvolutionDiscrete2D Gx;
        ConvolutionDiscrete2D Gy;
        ConvolutionDiscrete2D Gxx;
        ConvolutionDiscrete2D Gxy;
        ConvolutionDiscrete2D Gyy;
        ConvolutionDiscrete2D Gxxx;
        ConvolutionDiscrete2D Gxxy;
        ConvolutionDiscrete2D Gxyy;
        ConvolutionDiscrete2D Gyyy;
  };

  class DescriptorSchmid : public Descriptor
  {
  public:
        DescriptorSchmid (int scaleCount = 8, float scaleStep = -1);
        DescriptorSchmid (std::istream & stream);
        void initialize (int scaleCount);
        virtual ~DescriptorSchmid ();

        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Image patch (const Vector<float> & value);
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        DescriptorSchmidScale * findScale (float sigma);

        float scaleStep;
        std::vector<DescriptorSchmidScale *> descriptors;
  };

  class DescriptorSpin : public Descriptor
  {
  public:
        DescriptorSpin (int binsRadial = 5, int binsIntensity = 6, float supportRadial = 3, float supportIntensity = 3);
        DescriptorSpin (std::istream & stream);

        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Image patch (const Vector<float> & value);
        virtual Comparison * comparison ();
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        int   binsRadial;
        int   binsIntensity;
        float supportIntensity;  
  };

  class DescriptorSIFT : public Descriptor
  {
  public:
        DescriptorSIFT (int width = 4, int angles = 8);
        DescriptorSIFT (std::istream & stream);

        void computeGradient (const Image & image);

        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Image patch (const Vector<float> & value);
        void patch (const std::string & fileName, const Vector<float> & value);  
        void patch (Canvas * canvas, const Vector<float> & value, int size);  
        virtual Comparison * comparison ();  
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        int width;  
        int angles;  
        int supportPixel;  
        float sigmaWeight;  
        float maxValue;  

        void * lastBuffer;  
        double lastTime;  
        ImageOf<float> I_x;  
        ImageOf<float> I_y;  
  };

  class DescriptorColorHistogram2D : public Descriptor
  {
  public:
        DescriptorColorHistogram2D (int width = 5, float supportRadial = 4.2f);
        DescriptorColorHistogram2D (std::istream & stream);
        void initialize ();

        // The following are subroutines used by value(), and also available to client code if the programmer wishes to use a different criterion for selecting pixels to bin.
        void clear ();  
        void addToHistogram (const Image & image, const int x, const int y);  
        void add (const Image & image, int x, int y);  
        Vector<float> finish ();  

        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Vector<float> value (const Image & image);
        virtual Image patch (const Vector<float> & value);
        virtual Comparison * comparison ();
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        int width;  
        Matrix<bool> valid;  
        Matrix<float> histogram;  
  };

  class DescriptorColorHistogram3D : public Descriptor
  {
  public:
        DescriptorColorHistogram3D (int width = 5, int height = -1, float supportRadial = 4.2f);  
        DescriptorColorHistogram3D (std::istream & stream);
        ~DescriptorColorHistogram3D ();
        void initialize ();

        // The following are subroutines used by value(), and also available to client code if the programmer wishes to use a different criterion for selecting pixels to bin.
        void clear ();  
        void addToHistogram (const Image & image, const int x, const int y);  
        void add (const Image & image, int x, int y);  
        Vector<float> finish ();  

        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Vector<float> value (const Image & image);
        virtual Image patch (const Vector<float> & value);
        virtual Comparison * comparison ();
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        int width;  
        int height;  
        bool * valid;  
        float * histogram;  
  };

  class DescriptorTextonScale : public Descriptor
  {
  public:
        DescriptorTextonScale (int angles = 4, float firstScale = 1.0f, float lastScale = 4.0f, int extraSteps = 3);
        DescriptorTextonScale (std::istream & stream);
        void initialize ();

        void preprocess (const Image & image);

        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Vector<float> value (const Image & image);
        virtual Image patch (const Vector<float> & value);
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        void * lastBuffer;  
        double lastTime;  
        std::vector< ImageOf<float> > responses;  

        int angles;  
        float firstScale;  
        float lastScale;  
        int steps;  

        int bankSize;  
        float scaleRatio;  
        std::vector<ConvolutionDiscrete2D> filters;
  };

  class DescriptorLBP : public Descriptor
  {
  public:
        DescriptorLBP (int P = 8, float R = 1.0f, float supportRadial = 4.2f, int supportPixel = 32);
        DescriptorLBP (std::istream & stream);
        void initialize ();

        void preprocess (const Image & image);  
        void add (const int x, const int y, Vector<float> & result);  

        virtual Vector<float> value (const Image & image, const PointAffine & point);
        virtual Vector<float> value (const Image & image);
        virtual Image patch (const Vector<float> & value);
        virtual Comparison * comparison ();
        virtual void read (std::istream & stream);
        virtual void write (std::ostream & stream, bool withName = true);

        int P;  
        float R;  
        int supportPixel;  

        void * lastBuffer;  
        double lastTime;  
        ImageOf<unsigned char> categoryImage;  

        struct Interpolate
        {
          int xl;
          int yl;
          int xh;
          int yh;
          float wll;
          float wlh;
          float whl;
          float whh;
          bool exact;  
        };
        std::vector<Interpolate> interpolates;  
  };
}


#endif

---