line_descriptor/descriptor.hpp

/*M///////////////////////////////////////////////////////////////////////////////////////
 //
 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
 //
 //  By downloading, copying, installing or using the software you agree to this license.
 //  If you do not agree to this license, do not download, install,
 //  copy or use the software.
 //
 //
 //                           License Agreement
 //                For Open Source Computer Vision Library
 //
 // Copyright (C) 2014, Biagio Montesano, all rights reserved.
 // Third party copyrights are property of their respective owners.
 //
 // Redistribution and use in source and binary forms, with or without modification,
 // are permitted provided that the following conditions are met:
 //
 //   * Redistribution's of source code must retain the above copyright notice,
 //     this list of conditions and the following disclaimer.
 //
 //   * Redistribution's in binary form must reproduce the above copyright notice,
 //     this list of conditions and the following disclaimer in the documentation
 //     and/or other materials provided with the distribution.
 //
 //   * The name of the copyright holders may not be used to endorse or promote products
 //     derived from this software without specific prior written permission.
 //
 // This software is provided by the copyright holders and contributors "as is" and
 // any express or implied warranties, including, but not limited to, the implied
 // warranties of merchantability and fitness for a particular purpose are disclaimed.
 // In no event shall the Intel Corporation or contributors be liable for any direct,
 // indirect, incidental, special, exemplary, or consequential damages
 // (including, but not limited to, procurement of substitute goods or services;
 // loss of use, data, or profits; or business interruption) however caused
 // and on any theory of liability, whether in contract, strict liability,
 // or tort (including negligence or otherwise) arising in any way out of
 // the use of this software, even if advised of the possibility of such damage.
 //
 //M*/
 
#ifndef __OPENCV_DESCRIPTOR_HPP__
#define __OPENCV_DESCRIPTOR_HPP__
 
#include <map>
#include <vector>
#include <list>
 
#if defined _MSC_VER && _MSC_VER <= 1700
#include <stdint.h>
#else
#include <inttypes.h>
#endif
 
#include <stdio.h>
#include <iostream>
 
#include "opencv2/core/utility.hpp"
#include <opencv2/imgproc.hpp>
#include "opencv2/core.hpp"
 
/* define data types */
typedef uint64_t UINT64;
typedef uint32_t UINT32;
typedef uint16_t UINT16;
typedef uint8_t UINT8;
 
/* define constants */
#define UINT64_1 ((UINT64)0x01)
#define UINT32_1 ((UINT32)0x01)
 
namespace cv
{
namespace line_descriptor
{
 
 
struct CV_EXPORTS_W_SIMPLE KeyLine
{
 public:
  CV_PROP_RW float angle;
 
  CV_PROP_RW int class_id;
 
  CV_PROP_RW int octave;
 
  CV_PROP_RW Point2f pt;
 
  CV_PROP_RW float response;
 
  CV_PROP_RW float size;
 
  CV_PROP_RW float startPointX;
  CV_PROP_RW float startPointY;
  CV_PROP_RW float endPointX;
  CV_PROP_RW float endPointY;
 
  CV_PROP_RW float sPointInOctaveX;
  CV_PROP_RW float sPointInOctaveY;
  CV_PROP_RW float ePointInOctaveX;
  CV_PROP_RW float ePointInOctaveY;
 
  CV_PROP_RW float lineLength;
 
  CV_PROP_RW int numOfPixels;
 
  CV_WRAP Point2f getStartPoint() const
  {
    return Point2f(startPointX, startPointY);
  }
 
  CV_WRAP Point2f getEndPoint() const
  {
    return Point2f(endPointX, endPointY);
  }
 
  CV_WRAP Point2f getStartPointInOctave() const
  {
    return Point2f(sPointInOctaveX, sPointInOctaveY);
  }
 
  CV_WRAP Point2f getEndPointInOctave() const
  {
    return Point2f(ePointInOctaveX, ePointInOctaveY);
  }
 
  CV_WRAP KeyLine()
  {
  }
};
 
class CV_EXPORTS_W BinaryDescriptor : public Algorithm
{
 
 public:
  struct CV_EXPORTS Params
  {
    /*CV_WRAP*/
    Params();
 
    int numOfOctave_;
 
    int widthOfBand_;
 
    int reductionRatio;
 
    int ksize_;
 
    void read( const FileNode& fn );
 
    void write( FileStorage& fs ) const;
 
  };
 
  BinaryDescriptor( const BinaryDescriptor::Params &parameters = BinaryDescriptor::Params() );
 
  CV_WRAP static Ptr<BinaryDescriptor> createBinaryDescriptor();
  static Ptr<BinaryDescriptor> createBinaryDescriptor( Params parameters );
 
  ~BinaryDescriptor();
 
  CV_WRAP int getNumOfOctaves();
  CV_WRAP void setNumOfOctaves( int octaves );
  CV_WRAP int getWidthOfBand();
  CV_WRAP void setWidthOfBand( int width );
  CV_WRAP int getReductionRatio();
  CV_WRAP void setReductionRatio( int rRatio );
 
  virtual void read( const cv::FileNode& fn ) CV_OVERRIDE;
 
  virtual void write( cv::FileStorage& fs ) const CV_OVERRIDE;
 
  CV_WRAP void detect( const Mat& image, CV_OUT std::vector<KeyLine>& keypoints, const Mat& mask = Mat() );
 
  void detect( const std::vector<Mat>& images, std::vector<std::vector<KeyLine> >& keylines, const std::vector<Mat>& masks =
                   std::vector<Mat>() ) const;
 
  CV_WRAP void compute( const Mat& image, CV_OUT CV_IN_OUT std::vector<KeyLine>& keylines, CV_OUT Mat& descriptors, bool returnFloatDescr = false ) const;
 
  void compute( const std::vector<Mat>& images, std::vector<std::vector<KeyLine> >& keylines, std::vector<Mat>& descriptors, bool returnFloatDescr =
                    false ) const;
 
  int descriptorSize() const;
 
  int descriptorType() const;
 
  /*CV_WRAP*/
  int defaultNorm() const;
 
  virtual void operator()( InputArray image, InputArray mask, CV_OUT std::vector<KeyLine>& keylines, OutputArray descriptors,
                           bool useProvidedKeyLines = false, bool returnFloatDescr = false ) const;
 
 protected:
  virtual void detectImpl( const Mat& imageSrc, std::vector<KeyLine>& keylines, const Mat& mask = Mat() ) const;
 
  virtual void computeImpl( const Mat& imageSrc, std::vector<KeyLine>& keylines, Mat& descriptors, bool returnFloatDescr,
                            bool useDetectionData ) const;
 
 private:
  struct OctaveLine
  {
    unsigned int octaveCount;  //the octave which this line is detected
    unsigned int lineIDInOctave;  //the line ID in that octave image
    unsigned int lineIDInScaleLineVec;  //the line ID in Scale line vector
    float lineLength;  //the length of line in original image scale
  };
 
  // A 2D line (normal equation parameters).
  struct SingleLine
  {
    //note: rho and theta are based on coordinate origin, i.e. the top-left corner of image
    double rho;  //unit: pixel length
    double theta;  //unit: rad
    double linePointX;  // = rho * cos(theta);
    double linePointY;  // = rho * sin(theta);
    //for EndPoints, the coordinate origin is the top-left corner of image.
    double startPointX;
    double startPointY;
    double endPointX;
    double endPointY;
    //direction of a line, the angle between positive line direction (dark side is in the left) and positive X axis.
    double direction;
    //mean gradient magnitude
    double gradientMagnitude;
    //mean gray value of pixels in dark side of line
    double darkSideGrayValue;
    //mean gray value of pixels in light side of line
    double lightSideGrayValue;
    //the length of line
    double lineLength;
    //the width of line;
    double width;
    //number of pixels
    int numOfPixels;
    //the decriptor of line
    std::vector<double> descriptor;
  };
 
  // Specifies a vector of lines.
  typedef std::vector<SingleLine> Lines_list;
 
  struct OctaveSingleLine
  {
    /*endPoints, the coordinate origin is the top-left corner of the original image.
     *startPointX = sPointInOctaveX * (factor)^octaveCount; */
    float startPointX;
    float startPointY;
    float endPointX;
    float endPointY;
    //endPoints, the coordinate origin is the top-left corner of the octave image.
    float sPointInOctaveX;
    float sPointInOctaveY;
    float ePointInOctaveX;
    float ePointInOctaveY;
    //direction of a line, the angle between positive line direction (dark side is in the left) and positive X axis.
    float direction;
    //the summation of gradient magnitudes of pixels on lines
    float salience;
    //the length of line
    float lineLength;
    //number of pixels
    unsigned int numOfPixels;
    //the octave which this line is detected
    unsigned int octaveCount;
    //the decriptor of line
    std::vector<float> descriptor;
 
    OctaveSingleLine() : startPointX(0), startPointY(0), endPointX(0), endPointY(0),
        sPointInOctaveX(0), sPointInOctaveY(0), ePointInOctaveX(0), ePointInOctaveY(0),
        direction(0), salience(0), lineLength(0), numOfPixels(0), octaveCount(0),
        descriptor(std::vector<float>())
    {}
  };
 
  struct Pixel
  {
    unsigned int x;  //X coordinate
    unsigned int y;  //Y coordinate
  };
  struct EdgeChains
  {
    std::vector<unsigned int> xCors;  //all the x coordinates of edge points
    std::vector<unsigned int> yCors;  //all the y coordinates of edge points
    std::vector<unsigned int> sId;  //the start index of each edge in the coordinate arrays
    unsigned int numOfEdges;  //the number of edges whose length are larger than minLineLen; numOfEdges < sId.size;
  };
 
  struct LineChains
  {
    std::vector<unsigned int> xCors;  //all the x coordinates of line points
    std::vector<unsigned int> yCors;  //all the y coordinates of line points
    std::vector<unsigned int> sId;  //the start index of each line in the coordinate arrays
    unsigned int numOfLines;  //the number of lines whose length are larger than minLineLen; numOfLines < sId.size;
  };
 
  typedef std::list<Pixel> PixelChain;  //each edge is a pixel chain
 
  struct CV_EXPORTS_W_SIMPLE EDLineParam
  {
    CV_PROP_RW int ksize;
    CV_PROP_RW float sigma;
    CV_PROP_RW float gradientThreshold;
    CV_PROP_RW float anchorThreshold;
    CV_PROP_RW int scanIntervals;
    CV_PROP_RW int minLineLen;
    CV_PROP_RW double lineFitErrThreshold;
  };
 
  #define RELATIVE_ERROR_FACTOR   100.0
  #define MLN10   2.30258509299404568402
  #define log_gamma(x)    ((x)>15.0?log_gamma_windschitl(x):log_gamma_lanczos(x))
 
  class CV_EXPORTS_W EDLineDetector
  {
   public:
    CV_WRAP EDLineDetector();
    CV_WRAP_AS(EDLineDetectorWithParams) EDLineDetector( EDLineParam param );
    ~EDLineDetector();
 
    CV_WRAP static Ptr<EDLineDetector> createEDLineDetector();
 
 
    CV_WRAP_AS(createEDLineDetectorWithParams) static Ptr<EDLineDetector> createEDLineDetector(EDLineParam params);
    /*extract edges from image
     *image:    In, gray image;
     *edges:    Out, store the edges, each edge is a pixel chain
     *return -1: error happen
     */
    int EdgeDrawing( cv::Mat &image, EdgeChains &edgeChains );
 
    /*extract lines from image
     *image:    In, gray image;
     *lines:    Out, store the extracted lines,
     *return -1: error happen
     */
    int EDline( cv::Mat &image, LineChains &lines );
 
    CV_WRAP int EDline( cv::Mat &image );
 
    cv::Mat dxImg_;  //store the dxImg;
 
    cv::Mat dyImg_;  //store the dyImg;
 
    cv::Mat gImgWO_;  //store the gradient image without threshold;
 
    LineChains lines_;  //store the detected line chains;
 
    //store the line Equation coefficients, vec3=[w1,w2,w3] for line w1*x + w2*y + w3=0;
    std::vector<std::vector<double> > lineEquations_;
 
    //store the line endpoints, [x1,y1,x2,y3]
    std::vector<std::vector<float> > lineEndpoints_;
 
    //store the line direction
    std::vector<float> lineDirection_;
 
    //store the line salience, which is the summation of gradients of pixels on line
    std::vector<float> lineSalience_;
 
    // image sizes
    unsigned int imageWidth;
    unsigned int imageHeight;
 
    /*The threshold of line fit error;
     *If lineFitErr is large than this threshold, then
     *the pixel chain is not accepted as a single line segment.*/
    double lineFitErrThreshold_;
 
    /*the threshold of pixel gradient magnitude.
     *Only those pixel whose gradient magnitude are larger than this threshold will be
     *taken as possible edge points. Default value is 36*/
    short gradienThreshold_;
 
    /*If the pixel's gradient value is bigger than both of its neighbors by a
     *certain threshold (ANCHOR_THRESHOLD), the pixel is marked to be an anchor.
     *Default value is 8*/
    unsigned char anchorThreshold_;
 
    /*anchor testing can be performed at different scan intervals, i.e.,
     *every row/column, every second row/column etc.
     *Default value is 2*/
    unsigned int scanIntervals_;
 
    int minLineLen_;  //minimal acceptable line length
 
   private:
    void InitEDLine_();
 
    /*For an input edge chain, find the best fit line, the default chain length is minLineLen_
     *xCors:  In, pointer to the X coordinates of pixel chain;
     *yCors:  In, pointer to the Y coordinates of pixel chain;
     *offsetS:In, start index of this chain in vector;
     *lineEquation: Out, [a,b] which are the coefficient of lines y=ax+b(horizontal) or x=ay+b(vertical);
     *return:  line fit error; -1:error happens;
     */
    double LeastSquaresLineFit_( unsigned int *xCors, unsigned int *yCors, unsigned int offsetS, std::vector<double> &lineEquation );
 
    /*For an input pixel chain, find the best fit line. Only do the update based on new points.
     *For A*x=v,  Least square estimation of x = Inv(A^T * A) * (A^T * v);
     *If some new observations are added, i.e, [A; A'] * x = [v; v'],
     *then x' = Inv(A^T * A + (A')^T * A') * (A^T * v + (A')^T * v');
     *xCors:  In, pointer to the X coordinates of pixel chain;
     *yCors:  In, pointer to the Y coordinates of pixel chain;
     *offsetS:In, start index of this chain in vector;
     *newOffsetS: In, start index of extended part;
     *offsetE:In, end index of this chain in vector;
     *lineEquation: Out, [a,b] which are the coefficient of lines y=ax+b(horizontal) or x=ay+b(vertical);
     *return:  line fit error; -1:error happens;
     */
    double LeastSquaresLineFit_( unsigned int *xCors, unsigned int *yCors, unsigned int offsetS, unsigned int newOffsetS, unsigned int offsetE,
                                 std::vector<double> &lineEquation );
 
    bool LineValidation_( unsigned int *xCors, unsigned int *yCors, unsigned int offsetS, unsigned int offsetE, std::vector<double> &lineEquation,
                          float &direction );
 
    bool bValidate_;  //flag to decide whether line will be validated
 
    int ksize_;  //the size of Gaussian kernel: ksize X ksize, default value is 5.
 
    float sigma_;  //the sigma of Gaussian kernal, default value is 1.0.
 
    /*For example, there two edges in the image:
     *edge1 = [(7,4), (8,5), (9,6),| (10,7)|, (11, 8), (12,9)] and
     *edge2 = [(14,9), (15,10), (16,11), (17,12),| (18, 13)|, (19,14)] ; then we store them as following:
     *pFirstPartEdgeX_ = [10, 11, 12, 18, 19];//store the first part of each edge[from middle to end]
     *pFirstPartEdgeY_ = [7,  8,  9,  13, 14];
     *pFirstPartEdgeS_ = [0,3,5];// the index of start point of first part of each edge
     *pSecondPartEdgeX_ = [10, 9, 8, 7, 18, 17, 16, 15, 14];//store the second part of each edge[from middle to front]
     *pSecondPartEdgeY_ = [7,  6, 5, 4, 13, 12, 11, 10, 9];//anchor points(10, 7) and (18, 13) are stored again
     *pSecondPartEdgeS_ = [0, 4, 9];// the index of start point of second part of each edge
     *This type of storage order is because of the order of edge detection process.
     *For each edge, start from one anchor point, first go right, then go left or first go down, then go up*/
 
    //store the X coordinates of the first part of the pixels for chains
    unsigned int *pFirstPartEdgeX_;
 
    //store the Y coordinates of the first part of the pixels for chains
    unsigned int *pFirstPartEdgeY_;
 
    //store the start index of every edge chain in the first part arrays
    unsigned int *pFirstPartEdgeS_;
 
    //store the X coordinates of the second part of the pixels for chains
    unsigned int *pSecondPartEdgeX_;
 
    //store the Y coordinates of the second part of the pixels for chains
    unsigned int *pSecondPartEdgeY_;
 
    //store the start index of every edge chain in the second part arrays
    unsigned int *pSecondPartEdgeS_;
 
    //store the X coordinates of anchors
    unsigned int *pAnchorX_;
 
    //store the Y coordinates of anchors
    unsigned int *pAnchorY_;
 
    //edges
    cv::Mat edgeImage_;
 
    cv::Mat gImg_;  //store the gradient image;
 
    cv::Mat dirImg_;  //store the direction image
 
    double logNT_;
 
    cv::Mat_<float> ATA;   //the previous matrix of A^T * A;
 
    cv::Mat_<float> ATV;    //the previous vector of A^T * V;
 
    cv::Mat_<float> fitMatT;   //the matrix used in line fit function;
 
    cv::Mat_<float> fitVec;    //the vector used in line fit function;
 
    cv::Mat_<float> tempMatLineFit;  //the matrix used in line fit function;
 
    cv::Mat_<float> tempVecLineFit;    //the vector used in line fit function;
 
};
 
  // Specifies a vector of lines.
typedef std::vector<OctaveSingleLine> LinesVec;
 
// each element in ScaleLines is a vector of lines
// which corresponds the same line detected in different octave images.
typedef std::vector<LinesVec> ScaleLines;
 
/* compute Gaussian pyramids */
void computeGaussianPyramid( const Mat& image, const int numOctaves );
 
/* compute Sobel's derivatives */
void computeSobel( const Mat& image, const int numOctaves );
 
/* conversion of an LBD descriptor to its binary representation */
unsigned char binaryConversion( float* f1, float* f2 );
 
/* compute LBD descriptors using EDLine extractor */
int computeLBD( ScaleLines &keyLines, bool useDetectionData = false );
 
/* gathers lines in groups using EDLine extractor.
 Each group contains the same line, detected in different octaves */
int OctaveKeyLines( cv::Mat& image, ScaleLines &keyLines );
 
/* the local gaussian coefficient applied to the orthogonal line direction within each band */
std::vector<double> gaussCoefL_;
 
/* the global gaussian coefficient applied to each row within line support region */
std::vector<double> gaussCoefG_;
 
/* descriptor parameters */
Params params;
 
/* vector of sizes of downsampled and blurred images */
std::vector<cv::Size> images_sizes;
 
/*For each octave of image, we define an EDLineDetector, because we can get gradient images (dxImg, dyImg, gImg)
 *from the EDLineDetector class without extra computation cost. Another reason is that, if we use
 *a single EDLineDetector to detect lines in different octave of images, then we need to allocate and release
 *memory for gradient images (dxImg, dyImg, gImg) repeatedly for their varying size*/
std::vector<Ptr<EDLineDetector> > edLineVec_;
 
/* Sobel's derivatives */
std::vector<cv::Mat> dxImg_vector, dyImg_vector;
 
/* Gaussian pyramid */
std::vector<cv::Mat> octaveImages;
 
};
 
struct CV_EXPORTS_W_SIMPLE LSDParam
{
  CV_PROP_RW double scale ;
  CV_PROP_RW double sigma_scale;
  CV_PROP_RW double quant;
  CV_PROP_RW double ang_th;
  CV_PROP_RW double log_eps;
  CV_PROP_RW double density_th ;
  CV_PROP_RW int n_bins ;
 
 
CV_WRAP LSDParam():scale(0.8),
                   sigma_scale(0.6),
                   quant(2.0),
                   ang_th(22.5),
                   log_eps(0),
                   density_th(0.7),
                   n_bins(1024){}
 
};
 
class CV_EXPORTS_W LSDDetector : public Algorithm
{
public:
 
/* constructor */
CV_WRAP LSDDetector() : params()
{
}
;
 
CV_WRAP_AS(LSDDetectorWithParams) LSDDetector(LSDParam _params) : params(_params)
{
}
;
 
CV_WRAP static Ptr<LSDDetector> createLSDDetector();
 
 
CV_WRAP_AS(createLSDDetectorWithParams) static Ptr<LSDDetector> createLSDDetector(LSDParam params);
 
 
CV_WRAP void detect( const Mat& image, CV_OUT std::vector<KeyLine>& keypoints, int scale, int numOctaves, const Mat& mask = Mat() );
 
CV_WRAP void detect( const std::vector<Mat>& images, std::vector<std::vector<KeyLine> >& keylines, int scale, int numOctaves,
const std::vector<Mat>& masks = std::vector<Mat>() ) const;
 
private:
/* compute Gaussian pyramid of input image */
void computeGaussianPyramid( const Mat& image, int numOctaves, int scale );
 
/* implementation of line detection */
void detectImpl( const Mat& imageSrc, std::vector<KeyLine>& keylines, int numOctaves, int scale, const Mat& mask ) const;
 
/* matrices for Gaussian pyramids */
std::vector<cv::Mat> gaussianPyrs;
 
/* parameters */
LSDParam params;
};
 
class CV_EXPORTS_W BinaryDescriptorMatcher : public Algorithm
{
 
public:
CV_WRAP void match( const Mat& queryDescriptors, const Mat& trainDescriptors, CV_OUT std::vector<DMatch>& matches, const Mat& mask = Mat() ) const;
 
CV_WRAP_AS(matchQuery) void match( const Mat& queryDescriptors, CV_OUT std::vector<DMatch>& matches, const std::vector<Mat>& masks = std::vector<Mat>() );
 
CV_WRAP void knnMatch( const Mat& queryDescriptors, const Mat& trainDescriptors, CV_OUT std::vector<std::vector<DMatch> >& matches, int k, const Mat& mask = Mat(),
bool compactResult = false ) const;
 
CV_WRAP_AS(knnMatchQuery) void knnMatch( const Mat& queryDescriptors, std::vector<std::vector<DMatch> >& matches, int k, const std::vector<Mat>& masks = std::vector<Mat>(),
bool compactResult = false );
 
void radiusMatch( const Mat& queryDescriptors, const Mat& trainDescriptors, std::vector<std::vector<DMatch> >& matches, float maxDistance,
const Mat& mask = Mat(), bool compactResult = false ) const;
 
void radiusMatch( const Mat& queryDescriptors, std::vector<std::vector<DMatch> >& matches, float maxDistance, const std::vector<Mat>& masks =
std::vector<Mat>(),
bool compactResult = false );
 
void add( const std::vector<Mat>& descriptors );
 
void train();
 
static Ptr<BinaryDescriptorMatcher> createBinaryDescriptorMatcher();
 
void clear() CV_OVERRIDE;
 
CV_WRAP BinaryDescriptorMatcher();
 
~BinaryDescriptorMatcher()
{
}
 
private:
class BucketGroup
{
 
public:
BucketGroup(bool needAllocateGroup = true);
 
~BucketGroup();
 
void insert( int subindex, UINT32 data );
 
UINT32* query( int subindex, int *size );
 
void insert_value( std::vector<uint32_t>& vec, int index, UINT32 data );
void push_value( std::vector<uint32_t>& vec, UINT32 Data );
 
UINT32 empty;
std::vector<uint32_t> group;
 
 
};
 
class SparseHashtable
{
 
private:
 
static const int MAX_B;
 
std::vector<BucketGroup> table;
 
public:
 
SparseHashtable();
 
~SparseHashtable();
 
int init( int _b );
 
void insert( UINT64 index, UINT32 data );
 
UINT32* query( UINT64 index, int* size );
 
int b;
 
UINT64 size;
 
};
 
class bitarray
{
 
public:
UINT32 *arr;
UINT32 length;
 
bitarray()
{
arr = NULL;
length = 0;
}
 
bitarray( UINT64 _bits )
{
arr = NULL;
init( _bits );
}
 
void init( UINT64 _bits )
{
if( arr )
delete[] arr;
length = (UINT32) ceil( _bits / 32.00 );
arr = new UINT32[length];
erase();
}
 
~bitarray()
{
if( arr )
delete[] arr;
}
 
inline void flip( UINT64 index )
{
arr[index >> 5] ^= ( (UINT32) 0x01 ) << ( index % 32 );
}
 
inline void set( UINT64 index )
{
arr[index >> 5] |= ( (UINT32) 0x01 ) << ( index % 32 );
}
 
inline UINT8 get( UINT64 index )
{
return ( arr[index >> 5] & ( ( (UINT32) 0x01 ) << ( index % 32 ) ) ) != 0;
}
 
inline void erase()
{
memset( arr, 0, sizeof(UINT32) * length );
}
 
};
 
class Mihasher
{
 
public:
int B;
 
int B_over_8;
 
int b;
 
int m;
 
int mplus;
 
int D;
 
int d;
 
int K;
 
UINT64 N;
 
cv::Mat codes;
 
Ptr<bitarray> counter;
 
std::vector<SparseHashtable> H;
 
std::vector<UINT32> xornum;
 
int power[100];
 
Mihasher();
 
~Mihasher();
 
Mihasher( int B, int m );
 
void setK( int K );
 
void populate( cv::Mat & codes, UINT32 N, int dim1codes );
 
void batchquery( UINT32 * results, UINT32 *numres/*, qstat *stats*/, const cv::Mat & q, UINT32 numq, int dim1queries );
 
private:
 
void query( UINT32 * results, UINT32* numres/*, qstat *stats*/, UINT8 *q, UINT64 * chunks, UINT32 * res );
};
 
void checkKDistances( UINT32 * numres, int k, std::vector<int>& k_distances, int row, int string_length ) const;
 
Mat descriptorsMat;
 
std::map<int, int> indexesMap;
 
Ptr<Mihasher> dataset;
 
int nextAddedIndex;
 
int numImages;
 
int descrInDS;
 
};
 
/* --------------------------------------------------------------------------------------------
 UTILITY FUNCTIONS
 -------------------------------------------------------------------------------------------- */
 
struct CV_EXPORTS_W_SIMPLE DrawLinesMatchesFlags
{
CV_PROP_RW enum
{
DEFAULT = 0,  
DRAW_OVER_OUTIMG = 1,
NOT_DRAW_SINGLE_LINES = 2
};
};
 
CV_EXPORTS_W void drawLineMatches( const Mat& img1, const std::vector<KeyLine>& keylines1, const Mat& img2, const std::vector<KeyLine>& keylines2,
                                   const std::vector<DMatch>& matches1to2, CV_OUT Mat& outImg, const Scalar& matchColor = Scalar::all( -1 ),
                                   const Scalar& singleLineColor = Scalar::all( -1 ), const std::vector<char>& matchesMask = std::vector<char>(),
                                   int flags = DrawLinesMatchesFlags::DEFAULT );
 
CV_EXPORTS_W void drawKeylines( const Mat& image, const std::vector<KeyLine>& keylines, CV_OUT Mat& outImage, const Scalar& color = Scalar::all( -1 ),
                                int flags = DrawLinesMatchesFlags::DEFAULT );
 
 
}
}
 
#endif