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