size_t InfEngineBackendNet::getBatchSize() const noexcept
{
CV_Error(Error::StsNotImplemented, "");
return 0;
}
//------------------------------------------------------------------------------
// Fisherfaces
//------------------------------------------------------------------------------
void Fisherfaces::train(InputArrayOfArrays src, InputArray _lbls) {
if(src.total() == 0) {
String error_message = format("Empty training data was given. You'll need more than one sample to learn a model.");
CV_Error(Error::StsBadArg, error_message);
} else if(_lbls.getMat().type() != CV_32SC1) {
String error_message = format("Labels must be given as integer (CV_32SC1). Expected %d, but was %d.", CV_32SC1, _lbls.type());
CV_Error(Error::StsBadArg, error_message);
}
// make sure data has correct size
if(src.total() > 1) {
for(int i = 1; i < static_cast<int>(src.total()); i++) {
if(src.getMat(i-1).total() != src.getMat(i).total()) {
String error_message = format("In the Fisherfaces method all input samples (training images) must be of equal size! Expected %d pixels, but was %d pixels.", src.getMat(i-1).total(), src.getMat(i).total());
CV_Error(Error::StsUnsupportedFormat, error_message);
}
}
}
// get data
Mat labels = _lbls.getMat();
Mat data = asRowMatrix(src, CV_64FC1);
// number of samples
int N = data.rows;
// make sure labels are passed in correct shape
if(labels.total() != (size_t) N) {
String error_message = format("The number of samples (src) must equal the number of labels (labels)! len(src)=%d, len(labels)=%d.", N, labels.total());
CV_Error(Error::StsBadArg, error_message);
} else if(labels.rows != 1 && labels.cols != 1) {
String error_message = format("Expected the labels in a matrix with one row or column! Given dimensions are rows=%s, cols=%d.", labels.rows, labels.cols);
CV_Error(Error::StsBadArg, error_message);
}
// clear existing model data
_labels.release();
_projections.clear();
// safely copy from cv::Mat to std::vector
std::vector<int> ll;
for(unsigned int i = 0; i < labels.total(); i++) {
ll.push_back(labels.at<int>(i));
}
// get the number of unique classes
int C = (int) remove_dups(ll).size();
// clip number of components to be a valid number
if((_num_components <= 0) || (_num_components > (C-1)))
_num_components = (C-1);
// perform a PCA and keep (N-C) components
PCA pca(data, Mat(), PCA::DATA_AS_ROW, (N-C));
// project the data and perform a LDA on it
LDA lda(pca.project(data),labels, _num_components);
// store the total mean vector
_mean = pca.mean.reshape(1,1);
// store labels
_labels = labels.clone();
// store the eigenvalues of the discriminants
lda.eigenvalues().convertTo(_eigenvalues, CV_64FC1);
// Now calculate the projection matrix as pca.eigenvectors * lda.eigenvectors.
// Note: OpenCV stores the eigenvectors by row, so we need to transpose it!
gemm(pca.eigenvectors, lda.eigenvectors(), 1.0, Mat(), 0.0, _eigenvectors, GEMM_1_T);
// store the projections of the original data
for(int sampleIdx = 0; sampleIdx < data.rows; sampleIdx++) {
Mat p = LDA::subspaceProject(_eigenvectors, _mean, data.row(sampleIdx));
_projections.push_back(p);
}
}
void crossCorr( const Mat& img, const Mat& _templ, Mat& corr,
Size corrsize, int ctype,
Point anchor, double delta, int borderType )
{
const double blockScale = 4.5;
const int minBlockSize = 256;
std::vector<uchar> buf;
Mat templ = _templ;
int depth = img.depth(), cn = img.channels();
int tdepth = templ.depth(), tcn = templ.channels();
int cdepth = CV_MAT_DEPTH(ctype), ccn = CV_MAT_CN(ctype);
CV_Assert( img.dims <= 2 && templ.dims <= 2 && corr.dims <= 2 );
if( depth != tdepth && tdepth != std::max(CV_32F, depth) )
{
_templ.convertTo(templ, std::max(CV_32F, depth));
tdepth = templ.depth();
}
CV_Assert( depth == tdepth || tdepth == CV_32F);
CV_Assert( corrsize.height <= img.rows + templ.rows - 1 &&
corrsize.width <= img.cols + templ.cols - 1 );
CV_Assert( ccn == 1 || delta == 0 );
corr.create(corrsize, ctype);
int maxDepth = depth > CV_8S ? CV_64F : std::max(std::max(CV_32F, tdepth), cdepth);
Size blocksize, dftsize;
blocksize.width = cvRound(templ.cols*blockScale);
blocksize.width = std::max( blocksize.width, minBlockSize - templ.cols + 1 );
blocksize.width = std::min( blocksize.width, corr.cols );
blocksize.height = cvRound(templ.rows*blockScale);
blocksize.height = std::max( blocksize.height, minBlockSize - templ.rows + 1 );
blocksize.height = std::min( blocksize.height, corr.rows );
dftsize.width = std::max(getOptimalDFTSize(blocksize.width + templ.cols - 1), 2);
dftsize.height = getOptimalDFTSize(blocksize.height + templ.rows - 1);
if( dftsize.width <= 0 || dftsize.height <= 0 )
CV_Error( CV_StsOutOfRange, "the input arrays are too big" );
// recompute block size
blocksize.width = dftsize.width - templ.cols + 1;
blocksize.width = MIN( blocksize.width, corr.cols );
blocksize.height = dftsize.height - templ.rows + 1;
blocksize.height = MIN( blocksize.height, corr.rows );
Mat dftTempl( dftsize.height*tcn, dftsize.width, maxDepth );
Mat dftImg( dftsize, maxDepth );
int i, k, bufSize = 0;
if( tcn > 1 && tdepth != maxDepth )
bufSize = templ.cols*templ.rows*CV_ELEM_SIZE(tdepth);
if( cn > 1 && depth != maxDepth )
bufSize = std::max( bufSize, (blocksize.width + templ.cols - 1)*
(blocksize.height + templ.rows - 1)*CV_ELEM_SIZE(depth));
if( (ccn > 1 || cn > 1) && cdepth != maxDepth )
bufSize = std::max( bufSize, blocksize.width*blocksize.height*CV_ELEM_SIZE(cdepth));
buf.resize(bufSize);
// compute DFT of each template plane
for( k = 0; k < tcn; k++ )
{
int yofs = k*dftsize.height;
Mat src = templ;
Mat dst(dftTempl, Rect(0, yofs, dftsize.width, dftsize.height));
Mat dst1(dftTempl, Rect(0, yofs, templ.cols, templ.rows));
if( tcn > 1 )
{
src = tdepth == maxDepth ? dst1 : Mat(templ.size(), tdepth, &buf[0]);
int pairs[] = {k, 0};
mixChannels(&templ, 1, &src, 1, pairs, 1);
}
if( dst1.data != src.data )
src.convertTo(dst1, dst1.depth());
if( dst.cols > templ.cols )
{
Mat part(dst, Range(0, templ.rows), Range(templ.cols, dst.cols));
part = Scalar::all(0);
}
dft(dst, dst, 0, templ.rows);
}
int tileCountX = (corr.cols + blocksize.width - 1)/blocksize.width;
int tileCountY = (corr.rows + blocksize.height - 1)/blocksize.height;
int tileCount = tileCountX * tileCountY;
Size wholeSize = img.size();
Point roiofs(0,0);
Mat img0 = img;
if( !(borderType & BORDER_ISOLATED) )
{
img.locateROI(wholeSize, roiofs);
img0.adjustROI(roiofs.y, wholeSize.height-img.rows-roiofs.y,
roiofs.x, wholeSize.width-img.cols-roiofs.x);
}
borderType |= BORDER_ISOLATED;
// calculate correlation by blocks
for( i = 0; i < tileCount; i++ )
{
int x = (i%tileCountX)*blocksize.width;
int y = (i/tileCountX)*blocksize.height;
Size bsz(std::min(blocksize.width, corr.cols - x),
std::min(blocksize.height, corr.rows - y));
Size dsz(bsz.width + templ.cols - 1, bsz.height + templ.rows - 1);
int x0 = x - anchor.x + roiofs.x, y0 = y - anchor.y + roiofs.y;
int x1 = std::max(0, x0), y1 = std::max(0, y0);
int x2 = std::min(img0.cols, x0 + dsz.width);
int y2 = std::min(img0.rows, y0 + dsz.height);
Mat src0(img0, Range(y1, y2), Range(x1, x2));
Mat dst(dftImg, Rect(0, 0, dsz.width, dsz.height));
Mat dst1(dftImg, Rect(x1-x0, y1-y0, x2-x1, y2-y1));
Mat cdst(corr, Rect(x, y, bsz.width, bsz.height));
for( k = 0; k < cn; k++ )
{
Mat src = src0;
dftImg = Scalar::all(0);
if( cn > 1 )
{
src = depth == maxDepth ? dst1 : Mat(y2-y1, x2-x1, depth, &buf[0]);
int pairs[] = {k, 0};
mixChannels(&src0, 1, &src, 1, pairs, 1);
}
if( dst1.data != src.data )
src.convertTo(dst1, dst1.depth());
if( x2 - x1 < dsz.width || y2 - y1 < dsz.height )
copyMakeBorder(dst1, dst, y1-y0, dst.rows-dst1.rows-(y1-y0),
x1-x0, dst.cols-dst1.cols-(x1-x0), borderType);
dft( dftImg, dftImg, 0, dsz.height );
Mat dftTempl1(dftTempl, Rect(0, tcn > 1 ? k*dftsize.height : 0,
dftsize.width, dftsize.height));
mulSpectrums(dftImg, dftTempl1, dftImg, 0, true);
dft( dftImg, dftImg, DFT_INVERSE + DFT_SCALE, bsz.height );
src = dftImg(Rect(0, 0, bsz.width, bsz.height));
if( ccn > 1 )
{
if( cdepth != maxDepth )
{
Mat plane(bsz, cdepth, &buf[0]);
src.convertTo(plane, cdepth, 1, delta);
src = plane;
}
int pairs[] = {0, k};
mixChannels(&src, 1, &cdst, 1, pairs, 1);
}
else
{
if( k == 0 )
src.convertTo(cdst, cdepth, 1, delta);
else
{
if( maxDepth != cdepth )
{
Mat plane(bsz, cdepth, &buf[0]);
src.convertTo(plane, cdepth);
src = plane;
}
add(src, cdst, cdst);
}
}
}
}
}
void CvHaarEvaluator::FeatureHaar::generateRandomFeature( Size patchSize )
{
cv::Point2i position;
Size baseDim;
Size sizeFactor;
int area;
//Size minSize = Size( 3, 3 );
int minArea = 9;
bool valid = false;
while ( !valid )
{
//choose position and scale
position.y = rand() % ( patchSize.height );
position.x = rand() % ( patchSize.width );
baseDim.width = (int) ( ( 1 - sqrt( 1 - (float) rand() / RAND_MAX ) ) * patchSize.width );
baseDim.height = (int) ( ( 1 - sqrt( 1 - (float) rand() / RAND_MAX ) ) * patchSize.height );
//select types
//float probType[11] = {0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0909f, 0.0950f};
float probType[11] =
{ 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.2f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
float prob = (float) rand() / RAND_MAX;
if( prob < probType[0] )
{
//check if feature is valid
sizeFactor.height = 2;
sizeFactor.width = 1;
if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
continue;
area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
if( area < minArea )
continue;
m_type = 1;
m_numAreas = 2;
m_weights.resize( m_numAreas );
m_weights[0] = 1;
m_weights[1] = -1;
m_areas.resize( m_numAreas );
m_areas[0].x = position.x;
m_areas[0].y = position.y;
m_areas[0].height = baseDim.height;
m_areas[0].width = baseDim.width;
m_areas[1].x = position.x;
m_areas[1].y = position.y + baseDim.height;
m_areas[1].height = baseDim.height;
m_areas[1].width = baseDim.width;
m_initMean = 0;
m_initSigma = INITSIGMA( m_numAreas );
valid = true;
}
else if( prob < probType[0] + probType[1] )
{
//check if feature is valid
sizeFactor.height = 1;
sizeFactor.width = 2;
if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
continue;
area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
if( area < minArea )
continue;
m_type = 2;
m_numAreas = 2;
m_weights.resize( m_numAreas );
m_weights[0] = 1;
m_weights[1] = -1;
m_areas.resize( m_numAreas );
m_areas[0].x = position.x;
m_areas[0].y = position.y;
m_areas[0].height = baseDim.height;
m_areas[0].width = baseDim.width;
m_areas[1].x = position.x + baseDim.width;
m_areas[1].y = position.y;
m_areas[1].height = baseDim.height;
m_areas[1].width = baseDim.width;
m_initMean = 0;
m_initSigma = INITSIGMA( m_numAreas );
valid = true;
}
else if( prob < probType[0] + probType[1] + probType[2] )
{
//check if feature is valid
sizeFactor.height = 4;
sizeFactor.width = 1;
if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
continue;
area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
if( area < minArea )
continue;
m_type = 3;
m_numAreas = 3;
m_weights.resize( m_numAreas );
m_weights[0] = 1;
m_weights[1] = -2;
m_weights[2] = 1;
m_areas.resize( m_numAreas );
m_areas[0].x = position.x;
m_areas[0].y = position.y;
m_areas[0].height = baseDim.height;
m_areas[0].width = baseDim.width;
m_areas[1].x = position.x;
m_areas[1].y = position.y + baseDim.height;
m_areas[1].height = 2 * baseDim.height;
m_areas[1].width = baseDim.width;
m_areas[2].y = position.y + 3 * baseDim.height;
m_areas[2].x = position.x;
m_areas[2].height = baseDim.height;
m_areas[2].width = baseDim.width;
m_initMean = 0;
m_initSigma = INITSIGMA( m_numAreas );
valid = true;
}
else if( prob < probType[0] + probType[1] + probType[2] + probType[3] )
{
//check if feature is valid
sizeFactor.height = 1;
sizeFactor.width = 4;
if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
continue;
area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
if( area < minArea )
continue;
m_type = 3;
m_numAreas = 3;
m_weights.resize( m_numAreas );
m_weights[0] = 1;
m_weights[1] = -2;
m_weights[2] = 1;
m_areas.resize( m_numAreas );
m_areas[0].x = position.x;
m_areas[0].y = position.y;
m_areas[0].height = baseDim.height;
m_areas[0].width = baseDim.width;
m_areas[1].x = position.x + baseDim.width;
m_areas[1].y = position.y;
m_areas[1].height = baseDim.height;
m_areas[1].width = 2 * baseDim.width;
m_areas[2].y = position.y;
m_areas[2].x = position.x + 3 * baseDim.width;
m_areas[2].height = baseDim.height;
m_areas[2].width = baseDim.width;
m_initMean = 0;
m_initSigma = INITSIGMA( m_numAreas );
valid = true;
}
else if( prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] )
{
//check if feature is valid
sizeFactor.height = 2;
sizeFactor.width = 2;
if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
continue;
area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
if( area < minArea )
continue;
m_type = 5;
m_numAreas = 4;
m_weights.resize( m_numAreas );
m_weights[0] = 1;
m_weights[1] = -1;
m_weights[2] = -1;
m_weights[3] = 1;
m_areas.resize( m_numAreas );
m_areas[0].x = position.x;
m_areas[0].y = position.y;
m_areas[0].height = baseDim.height;
m_areas[0].width = baseDim.width;
m_areas[1].x = position.x + baseDim.width;
m_areas[1].y = position.y;
m_areas[1].height = baseDim.height;
m_areas[1].width = baseDim.width;
m_areas[2].y = position.y + baseDim.height;
m_areas[2].x = position.x;
m_areas[2].height = baseDim.height;
m_areas[2].width = baseDim.width;
m_areas[3].y = position.y + baseDim.height;
m_areas[3].x = position.x + baseDim.width;
m_areas[3].height = baseDim.height;
m_areas[3].width = baseDim.width;
m_initMean = 0;
m_initSigma = INITSIGMA( m_numAreas );
valid = true;
}
else if( prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] )
{
//check if feature is valid
sizeFactor.height = 3;
sizeFactor.width = 3;
if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
continue;
area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
if( area < minArea )
continue;
m_type = 6;
m_numAreas = 2;
m_weights.resize( m_numAreas );
m_weights[0] = 1;
m_weights[1] = -9;
m_areas.resize( m_numAreas );
m_areas[0].x = position.x;
m_areas[0].y = position.y;
m_areas[0].height = 3 * baseDim.height;
m_areas[0].width = 3 * baseDim.width;
m_areas[1].x = position.x + baseDim.width;
m_areas[1].y = position.y + baseDim.height;
m_areas[1].height = baseDim.height;
m_areas[1].width = baseDim.width;
m_initMean = -8 * 128;
m_initSigma = INITSIGMA( m_numAreas );
valid = true;
}
else if( prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6] )
{
//check if feature is valid
sizeFactor.height = 3;
sizeFactor.width = 1;
if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
continue;
area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
if( area < minArea )
continue;
m_type = 7;
m_numAreas = 3;
m_weights.resize( m_numAreas );
m_weights[0] = 1;
m_weights[1] = -2;
m_weights[2] = 1;
m_areas.resize( m_numAreas );
m_areas[0].x = position.x;
m_areas[0].y = position.y;
m_areas[0].height = baseDim.height;
m_areas[0].width = baseDim.width;
m_areas[1].x = position.x;
m_areas[1].y = position.y + baseDim.height;
m_areas[1].height = baseDim.height;
m_areas[1].width = baseDim.width;
m_areas[2].y = position.y + baseDim.height * 2;
m_areas[2].x = position.x;
m_areas[2].height = baseDim.height;
m_areas[2].width = baseDim.width;
m_initMean = 0;
m_initSigma = INITSIGMA( m_numAreas );
valid = true;
}
else if( prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6] + probType[7] )
{
//check if feature is valid
sizeFactor.height = 1;
sizeFactor.width = 3;
if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
continue;
area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
if( area < minArea )
continue;
m_type = 8;
m_numAreas = 3;
m_weights.resize( m_numAreas );
m_weights[0] = 1;
m_weights[1] = -2;
m_weights[2] = 1;
m_areas.resize( m_numAreas );
m_areas[0].x = position.x;
m_areas[0].y = position.y;
m_areas[0].height = baseDim.height;
m_areas[0].width = baseDim.width;
m_areas[1].x = position.x + baseDim.width;
m_areas[1].y = position.y;
m_areas[1].height = baseDim.height;
m_areas[1].width = baseDim.width;
m_areas[2].y = position.y;
m_areas[2].x = position.x + 2 * baseDim.width;
m_areas[2].height = baseDim.height;
m_areas[2].width = baseDim.width;
m_initMean = 0;
m_initSigma = INITSIGMA( m_numAreas );
valid = true;
}
else if( prob < probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6] + probType[7] + probType[8] )
{
//check if feature is valid
sizeFactor.height = 3;
sizeFactor.width = 3;
if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
continue;
area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
if( area < minArea )
continue;
m_type = 9;
m_numAreas = 2;
m_weights.resize( m_numAreas );
m_weights[0] = 1;
m_weights[1] = -2;
m_areas.resize( m_numAreas );
m_areas[0].x = position.x;
m_areas[0].y = position.y;
m_areas[0].height = 3 * baseDim.height;
m_areas[0].width = 3 * baseDim.width;
m_areas[1].x = position.x + baseDim.width;
m_areas[1].y = position.y + baseDim.height;
m_areas[1].height = baseDim.height;
m_areas[1].width = baseDim.width;
m_initMean = 0;
m_initSigma = INITSIGMA( m_numAreas );
valid = true;
}
else if( prob
< probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6] + probType[7] + probType[8] + probType[9] )
{
//check if feature is valid
sizeFactor.height = 3;
sizeFactor.width = 1;
if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
continue;
area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
if( area < minArea )
continue;
m_type = 10;
m_numAreas = 3;
m_weights.resize( m_numAreas );
m_weights[0] = 1;
m_weights[1] = -1;
m_weights[2] = 1;
m_areas.resize( m_numAreas );
m_areas[0].x = position.x;
m_areas[0].y = position.y;
m_areas[0].height = baseDim.height;
m_areas[0].width = baseDim.width;
m_areas[1].x = position.x;
m_areas[1].y = position.y + baseDim.height;
m_areas[1].height = baseDim.height;
m_areas[1].width = baseDim.width;
m_areas[2].y = position.y + baseDim.height * 2;
m_areas[2].x = position.x;
m_areas[2].height = baseDim.height;
m_areas[2].width = baseDim.width;
m_initMean = 128;
m_initSigma = INITSIGMA( m_numAreas );
valid = true;
}
else if( prob
< probType[0] + probType[1] + probType[2] + probType[3] + probType[4] + probType[5] + probType[6] + probType[7] + probType[8] + probType[9]
+ probType[10] )
{
//check if feature is valid
sizeFactor.height = 1;
sizeFactor.width = 3;
if( position.y + baseDim.height * sizeFactor.height >= patchSize.height || position.x + baseDim.width * sizeFactor.width >= patchSize.width )
continue;
area = baseDim.height * sizeFactor.height * baseDim.width * sizeFactor.width;
if( area < minArea )
continue;
m_type = 11;
m_numAreas = 3;
m_weights.resize( m_numAreas );
m_weights[0] = 1;
m_weights[1] = -1;
m_weights[2] = 1;
m_areas.resize( m_numAreas );
m_areas[0].x = position.x;
m_areas[0].y = position.y;
m_areas[0].height = baseDim.height;
m_areas[0].width = baseDim.width;
m_areas[1].x = position.x + baseDim.width;
m_areas[1].y = position.y;
m_areas[1].height = baseDim.height;
m_areas[1].width = baseDim.width;
m_areas[2].y = position.y;
m_areas[2].x = position.x + 2 * baseDim.width;
m_areas[2].height = baseDim.height;
m_areas[2].width = baseDim.width;
m_initMean = 128;
m_initSigma = INITSIGMA( m_numAreas );
valid = true;
}
else
CV_Error(CV_StsAssert, "");
}
m_initSize = patchSize;
m_curSize = m_initSize;
m_scaleFactorWidth = m_scaleFactorHeight = 1.0f;
m_scaleAreas.resize( m_numAreas );
m_scaleWeights.resize( m_numAreas );
for ( int curArea = 0; curArea < m_numAreas; curArea++ )
{
m_scaleAreas[curArea] = m_areas[curArea];
m_scaleWeights[curArea] = (float) m_weights[curArea] / (float) ( m_areas[curArea].width * m_areas[curArea].height );
}
}
static void getSobelKernels( OutputArray _kx, OutputArray _ky,
int dx, int dy, int _ksize, bool normalize, int ktype )
{
int i, j, ksizeX = _ksize, ksizeY = _ksize;
if( ksizeX == 1 && dx > 0 )
ksizeX = 3;
if( ksizeY == 1 && dy > 0 )
ksizeY = 3;
CV_Assert( ktype == CV_32F || ktype == CV_64F );
_kx.create(ksizeX, 1, ktype, -1, true);
_ky.create(ksizeY, 1, ktype, -1, true);
Mat kx = _kx.getMat();
Mat ky = _ky.getMat();
if( _ksize % 2 == 0 || _ksize > 31 )
CV_Error( CV_StsOutOfRange, "The kernel size must be odd and not larger than 31" );
std::vector<int> kerI(std::max(ksizeX, ksizeY) + 1);
CV_Assert( dx >= 0 && dy >= 0 && dx+dy > 0 );
for( int k = 0; k < 2; k++ )
{
Mat* kernel = k == 0 ? &kx : &ky;
int order = k == 0 ? dx : dy;
int ksize = k == 0 ? ksizeX : ksizeY;
CV_Assert( ksize > order );
if( ksize == 1 )
kerI[0] = 1;
else if( ksize == 3 )
{
if( order == 0 )
kerI[0] = 1, kerI[1] = 2, kerI[2] = 1;
else if( order == 1 )
kerI[0] = -1, kerI[1] = 0, kerI[2] = 1;
else
kerI[0] = 1, kerI[1] = -2, kerI[2] = 1;
}
else
{
int oldval, newval;
kerI[0] = 1;
for( i = 0; i < ksize; i++ )
kerI[i+1] = 0;
for( i = 0; i < ksize - order - 1; i++ )
{
oldval = kerI[0];
for( j = 1; j <= ksize; j++ )
{
newval = kerI[j]+kerI[j-1];
kerI[j-1] = oldval;
oldval = newval;
}
}
for( i = 0; i < order; i++ )
{
oldval = -kerI[0];
for( j = 1; j <= ksize; j++ )
{
newval = kerI[j-1] - kerI[j];
kerI[j-1] = oldval;
oldval = newval;
}
}
}
Mat temp(kernel->rows, kernel->cols, CV_32S, &kerI[0]);
double scale = !normalize ? 1. : 1./(1 << (ksize-order-1));
temp.convertTo(*kernel, ktype, scale);
}
}
int cv::startLoop(int (*)(int argc, char *argv[]), int , char**)
{
CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
return 0;
}
void cv::loadWindowParameters(const String&)
{
CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
}
float Histogram::compareHist(Histogram h2,int method=comparison_method::NORM_L1)
{
Mat H1=this->getHist();
Mat H2=h2.getHist();
const Mat* arrays[] = {&H1, &H2, 0};
//planes,number of channels of histogram
Mat planes[2];
//N Dimensional array iterator
NAryMatIterator it(arrays, planes);
int len = it.planes[0].rows*it.planes[0].cols;
float result=0;
float a=0,b=0,s1=0,s2=0;
float s11=0,s12=0,s22=0;
//cerr << it.nplanes << endl;
//cerr << it.planes[0].rows << ":" << it.planes[0].cols << endl;
for( size_t i = 0; i < it.nplanes; i++, ++it )
{
const float* h1 = (const float*)it.planes[0].data;
const float* h2 = (const float*)it.planes[1].data;
if(method==comparison_method::NORM_L1)
{
for( int j = 0; j < len; j++ )
{
double a = abs(h1[j] - h2[j]);
if( fabs(a) > DBL_EPSILON )
result += a;
}
result=result/len;
}
else if(method==comparison_method::NORM_L2)
{
for( int j = 0; j < len; j++ )
{
double a = (h1[j] - h2[j])*(h1[j] - h2[j]);
if( fabs(a) > DBL_EPSILON )
result += a;
}
result=result/len;
}
else if(method == comparison_method::CHI_SQUARED)
{
for( int j = 0; j < len; j++ )
{
double a = h1[j] - h2[j];
double b = h1[j];
if( fabs(b) > DBL_EPSILON )
result += a*a/b;
}
}
else if( method == comparison_method::INTERSECTION )
{
for( int j = 0; j < len; j++ )
result += std::min(h1[j], h2[j]);
}
else if( method == comparison_method::BHATTACHRYA || method == comparison_method::BHATTACHRYA1 )
{
for( int j = 0; j < len; j++ )
{
double a = h1[j];
double b = h2[j];
result += std::sqrt(a*b);
s1 += a;
s2 += b;
}
cerr << (float)s1 <<":" << (float)s2 << endl;
}
else if( method == comparison_method::CORRELATION )
{
for( int j = 0; j < len; j++ )
{
double a = h1[j];
double b = h2[j];
s12 += a*b;
s1 += a;
s11 += a*a;
s2 += b;
s22 += b*b;
}
}
else
{
CV_Error( CV_StsBadArg, "Unknown comparison method" );
}
}
if(method==comparison_method::CORRELATION)
{
s1=s1/len;
s2=s2/len;
size_t total = len;
double scale = 1./total;
double num = s12 -(total*s1*s2);
double denom2 = (s11 - s1*s1*total)*(s22 - s2*s2*total);
result = std::abs(denom2) > DBL_EPSILON ? num/std::sqrt(denom2) : 1.;
}
else if( method == comparison_method::BHATTACHRYA|| method == comparison_method::BHATTACHRYA1)
{
s1 *= s2;
s1 = fabs(s1) > FLT_EPSILON ? 1./std::sqrt(s1) : 1.;
if( method == comparison_method::BHATTACHRYA1)
result=result*s1;
else
result = std::sqrt(std::max(1. - result*s1, 0.));
}
return result;
}
static void fitLine2D( const Point2f * points, int count, int dist,
float _param, float reps, float aeps, float *line )
{
double EPS = count*FLT_EPSILON;
void (*calc_weights) (float *, int, float *) = 0;
void (*calc_weights_param) (float *, int, float *, float) = 0;
int i, j, k;
float _line[6], _lineprev[6];
float rdelta = reps != 0 ? reps : 1.0f;
float adelta = aeps != 0 ? aeps : 0.01f;
double min_err = DBL_MAX, err = 0;
RNG rng((uint64)-1);
memset( line, 0, 4*sizeof(line[0]) );
switch (dist)
{
case CV_DIST_L2:
return fitLine2D_wods( points, count, 0, line );
case CV_DIST_L1:
calc_weights = weightL1;
break;
case CV_DIST_L12:
calc_weights = weightL12;
break;
case CV_DIST_FAIR:
calc_weights_param = weightFair;
break;
case CV_DIST_WELSCH:
calc_weights_param = weightWelsch;
break;
case CV_DIST_HUBER:
calc_weights_param = weightHuber;
break;
/*case DIST_USER:
calc_weights = (void ( * )(float *, int, float *)) _PFP.fp;
break;*/
default:
CV_Error(CV_StsBadArg, "Unknown distance type");
}
AutoBuffer<float> wr(count*2);
float *w = wr, *r = w + count;
for( k = 0; k < 20; k++ )
{
int first = 1;
for( i = 0; i < count; i++ )
w[i] = 0.f;
for( i = 0; i < MIN(count,10); )
{
j = rng.uniform(0, count);
if( w[j] < FLT_EPSILON )
{
w[j] = 1.f;
i++;
}
}
fitLine2D_wods( points, count, w, _line );
for( i = 0; i < 30; i++ )
{
double sum_w = 0;
if( first )
{
first = 0;
}
else
{
double t = _line[0] * _lineprev[0] + _line[1] * _lineprev[1];
t = MAX(t,-1.);
t = MIN(t,1.);
if( fabs(acos(t)) < adelta )
{
float x, y, d;
x = (float) fabs( _line[2] - _lineprev[2] );
y = (float) fabs( _line[3] - _lineprev[3] );
d = x > y ? x : y;
if( d < rdelta )
break;
}
}
/* calculate distances */
err = calcDist2D( points, count, _line, r );
if( err < EPS )
break;
/* calculate weights */
if( calc_weights )
calc_weights( r, count, w );
else
calc_weights_param( r, count, w, _param );
for( j = 0; j < count; j++ )
sum_w += w[j];
if( fabs(sum_w) > FLT_EPSILON )
{
sum_w = 1./sum_w;
for( j = 0; j < count; j++ )
w[j] = (float)(w[j]*sum_w);
}
else
{
for( j = 0; j < count; j++ )
w[j] = 1.f;
}
/* save the line parameters */
memcpy( _lineprev, _line, 4 * sizeof( float ));
/* Run again... */
fitLine2D_wods( points, count, w, _line );
}
if( err < min_err )
{
min_err = err;
memcpy( line, _line, 4 * sizeof(line[0]));
if( err < EPS )
break;
}
}
}
CV_IMPL double
cvPointPolygonTest( const CvArr* _contour, CvPoint2D32f pt, int measure_dist )
{
double result = 0;
CvSeqBlock block;
CvContour header;
CvSeq* contour = (CvSeq*)_contour;
CvSeqReader reader;
int i, total, counter = 0;
int is_float;
double min_dist_num = FLT_MAX, min_dist_denom = 1;
CvPoint ip = {0,0};
if( !CV_IS_SEQ(contour) )
{
contour = cvPointSeqFromMat( CV_SEQ_KIND_CURVE + CV_SEQ_FLAG_CLOSED,
_contour, &header, &block );
}
else if( CV_IS_SEQ_POINT_SET(contour) )
{
if( contour->header_size == sizeof(CvContour) && !measure_dist )
{
CvRect r = ((CvContour*)contour)->rect;
if( pt.x < r.x || pt.y < r.y ||
pt.x >= r.x + r.width || pt.y >= r.y + r.height )
return -100;
}
}
else if( CV_IS_SEQ_CHAIN(contour) )
{
CV_Error( CV_StsBadArg,
"Chains are not supported. Convert them to polygonal representation using cvApproxChains()" );
}
else
CV_Error( CV_StsBadArg, "Input contour is neither a valid sequence nor a matrix" );
total = contour->total;
is_float = CV_SEQ_ELTYPE(contour) == CV_32FC2;
cvStartReadSeq( contour, &reader, -1 );
if( !is_float && !measure_dist && (ip.x = cvRound(pt.x)) == pt.x && (ip.y = cvRound(pt.y)) == pt.y )
{
// the fastest "pure integer" branch
CvPoint v0, v;
CV_READ_SEQ_ELEM( v, reader );
for( i = 0; i < total; i++ )
{
int dist;
v0 = v;
CV_READ_SEQ_ELEM( v, reader );
if( (v0.y <= ip.y && v.y <= ip.y) ||
(v0.y > ip.y && v.y > ip.y) ||
(v0.x < ip.x && v.x < ip.x) )
{
if( ip.y == v.y && (ip.x == v.x || (ip.y == v0.y &&
((v0.x <= ip.x && ip.x <= v.x) || (v.x <= ip.x && ip.x <= v0.x)))) )
return 0;
continue;
}
dist = (ip.y - v0.y)*(v.x - v0.x) - (ip.x - v0.x)*(v.y - v0.y);
if( dist == 0 )
return 0;
if( v.y < v0.y )
dist = -dist;
counter += dist > 0;
}
result = counter % 2 == 0 ? -100 : 100;
}
else
{
CvPoint2D32f v0, v;
CvPoint iv;
if( is_float )
{
CV_READ_SEQ_ELEM( v, reader );
}
else
{
CV_READ_SEQ_ELEM( iv, reader );
v = cvPointTo32f( iv );
}
if( !measure_dist )
{
for( i = 0; i < total; i++ )
{
double dist;
v0 = v;
if( is_float )
{
CV_READ_SEQ_ELEM( v, reader );
}
else
{
CV_READ_SEQ_ELEM( iv, reader );
v = cvPointTo32f( iv );
}
if( (v0.y <= pt.y && v.y <= pt.y) ||
(v0.y > pt.y && v.y > pt.y) ||
(v0.x < pt.x && v.x < pt.x) )
{
if( pt.y == v.y && (pt.x == v.x || (pt.y == v0.y &&
((v0.x <= pt.x && pt.x <= v.x) || (v.x <= pt.x && pt.x <= v0.x)))) )
return 0;
continue;
}
dist = (double)(pt.y - v0.y)*(v.x - v0.x) - (double)(pt.x - v0.x)*(v.y - v0.y);
if( dist == 0 )
return 0;
if( v.y < v0.y )
dist = -dist;
counter += dist > 0;
}
result = counter % 2 == 0 ? -100 : 100;
}
else
{
for( i = 0; i < total; i++ )
{
double dx, dy, dx1, dy1, dx2, dy2, dist_num, dist_denom = 1;
v0 = v;
if( is_float )
{
CV_READ_SEQ_ELEM( v, reader );
}
else
{
CV_READ_SEQ_ELEM( iv, reader );
v = cvPointTo32f( iv );
}
dx = v.x - v0.x; dy = v.y - v0.y;
dx1 = pt.x - v0.x; dy1 = pt.y - v0.y;
dx2 = pt.x - v.x; dy2 = pt.y - v.y;
if( dx1*dx + dy1*dy <= 0 )
dist_num = dx1*dx1 + dy1*dy1;
else if( dx2*dx + dy2*dy >= 0 )
dist_num = dx2*dx2 + dy2*dy2;
else
{
dist_num = (dy1*dx - dx1*dy);
dist_num *= dist_num;
dist_denom = dx*dx + dy*dy;
}
if( dist_num*min_dist_denom < min_dist_num*dist_denom )
{
min_dist_num = dist_num;
min_dist_denom = dist_denom;
if( min_dist_num == 0 )
break;
}
if( (v0.y <= pt.y && v.y <= pt.y) ||
(v0.y > pt.y && v.y > pt.y) ||
(v0.x < pt.x && v.x < pt.x) )
continue;
dist_num = dy1*dx - dx1*dy;
if( dy < 0 )
dist_num = -dist_num;
counter += dist_num > 0;
}
result = sqrt(min_dist_num/min_dist_denom);
if( counter % 2 == 0 )
result = -result;
}
}
return result;
}
Context& initializeContextFromVA(VADisplay display)
{
(void)display;
#if !defined(HAVE_VAAPI)
NO_VAAPI_SUPPORT_ERROR;
#elif !defined(HAVE_OPENCL)
NO_OPENCL_SUPPORT_ERROR;
#else
contextInitialized = false;
cl_uint numPlatforms;
cl_int status = clGetPlatformIDs(0, NULL, &numPlatforms);
if (status != CL_SUCCESS)
CV_Error(cv::Error::OpenCLInitError, "OpenCL: Can't get number of platforms");
if (numPlatforms == 0)
CV_Error(cv::Error::OpenCLInitError, "OpenCL: No available platforms");
std::vector<cl_platform_id> platforms(numPlatforms);
status = clGetPlatformIDs(numPlatforms, &platforms[0], NULL);
if (status != CL_SUCCESS)
CV_Error(cv::Error::OpenCLInitError, "OpenCL: Can't get platform Id list");
// For CL-VA interop, we must find platform/device with "cl_intel_va_api_media_sharing" extension.
// With standard initialization procedure, we should examine platform extension string for that.
// But in practice, the platform ext string doesn't contain it, while device ext string does.
// Follow Intel procedure (see tutorial), we should obtain device IDs by extension call.
// Note that we must obtain function pointers using specific platform ID, and can't provide pointers in advance.
// So, we iterate and select the first platform, for which we got non-NULL pointers, device, and CL context.
int found = -1;
cl_context context = 0;
cl_device_id device = 0;
for (int i = 0; i < (int)numPlatforms; ++i)
{
// Get extension function pointers
clGetDeviceIDsFromVA_APIMediaAdapterINTEL = (clGetDeviceIDsFromVA_APIMediaAdapterINTEL_fn)
clGetExtensionFunctionAddressForPlatform(platforms[i], "clGetDeviceIDsFromVA_APIMediaAdapterINTEL");
clCreateFromVA_APIMediaSurfaceINTEL = (clCreateFromVA_APIMediaSurfaceINTEL_fn)
clGetExtensionFunctionAddressForPlatform(platforms[i], "clCreateFromVA_APIMediaSurfaceINTEL");
clEnqueueAcquireVA_APIMediaSurfacesINTEL = (clEnqueueAcquireVA_APIMediaSurfacesINTEL_fn)
clGetExtensionFunctionAddressForPlatform(platforms[i], "clEnqueueAcquireVA_APIMediaSurfacesINTEL");
clEnqueueReleaseVA_APIMediaSurfacesINTEL = (clEnqueueReleaseVA_APIMediaSurfacesINTEL_fn)
clGetExtensionFunctionAddressForPlatform(platforms[i], "clEnqueueReleaseVA_APIMediaSurfacesINTEL");
if (((void*)clGetDeviceIDsFromVA_APIMediaAdapterINTEL == NULL) ||
((void*)clCreateFromVA_APIMediaSurfaceINTEL == NULL) ||
((void*)clEnqueueAcquireVA_APIMediaSurfacesINTEL == NULL) ||
((void*)clEnqueueReleaseVA_APIMediaSurfacesINTEL == NULL))
{
continue;
}
// Query device list
cl_uint numDevices = 0;
status = clGetDeviceIDsFromVA_APIMediaAdapterINTEL(platforms[i], CL_VA_API_DISPLAY_INTEL, display,
CL_PREFERRED_DEVICES_FOR_VA_API_INTEL, 0, NULL, &numDevices);
if ((status != CL_SUCCESS) || !(numDevices > 0))
continue;
numDevices = 1; // initializeContextFromHandle() expects only 1 device
status = clGetDeviceIDsFromVA_APIMediaAdapterINTEL(platforms[i], CL_VA_API_DISPLAY_INTEL, display,
CL_PREFERRED_DEVICES_FOR_VA_API_INTEL, numDevices, &device, NULL);
if (status != CL_SUCCESS)
continue;
// Creating CL-VA media sharing OpenCL context
cl_context_properties props[] = {
CL_CONTEXT_VA_API_DISPLAY_INTEL, (cl_context_properties) display,
CL_CONTEXT_INTEROP_USER_SYNC, CL_FALSE, // no explicit sync required
0
};
context = clCreateContext(props, numDevices, &device, NULL, NULL, &status);
if (status != CL_SUCCESS)
{
clReleaseDevice(device);
}
else
{
found = i;
break;
}
}
if (found < 0)
CV_Error(cv::Error::OpenCLInitError, "OpenCL: Can't create context for VA-API interop");
Context& ctx = Context::getDefault(false);
initializeContextFromHandle(ctx, platforms[found], context, device);
contextInitialized = true;
return ctx;
#endif
}
void compute(InputArray leftarr, InputArray rightarr, OutputArray disparr)
{
int dtype = disparr.fixedType() ? disparr.type() : params.dispType;
Size leftsize = leftarr.size();
if (leftarr.size() != rightarr.size())
CV_Error(Error::StsUnmatchedSizes, "All the images must have the same size");
if (leftarr.type() != CV_8UC1 || rightarr.type() != CV_8UC1)
CV_Error(Error::StsUnsupportedFormat, "Both input images must have CV_8UC1");
if (dtype != CV_16SC1 && dtype != CV_32FC1)
CV_Error(Error::StsUnsupportedFormat, "Disparity image must have CV_16SC1 or CV_32FC1 format");
if (params.preFilterType != PREFILTER_NORMALIZED_RESPONSE &&
params.preFilterType != PREFILTER_XSOBEL)
CV_Error(Error::StsOutOfRange, "preFilterType must be = CV_STEREO_BM_NORMALIZED_RESPONSE");
if (params.preFilterSize < 5 || params.preFilterSize > 255 || params.preFilterSize % 2 == 0)
CV_Error(Error::StsOutOfRange, "preFilterSize must be odd and be within 5..255");
if (params.preFilterCap < 1 || params.preFilterCap > 63)
CV_Error(Error::StsOutOfRange, "preFilterCap must be within 1..63");
if (params.kernelSize < 5 || params.kernelSize > 255 || params.kernelSize % 2 == 0 ||
params.kernelSize >= std::min(leftsize.width, leftsize.height))
CV_Error(Error::StsOutOfRange, "kernelSize must be odd, be within 5..255 and be not larger than image width or height");
if (params.numDisparities <= 0 || params.numDisparities % 16 != 0)
CV_Error(Error::StsOutOfRange, "numDisparities must be positive and divisble by 16");
if (params.textureThreshold < 0)
CV_Error(Error::StsOutOfRange, "texture threshold must be non-negative");
if (params.uniquenessRatio < 0)
CV_Error(Error::StsOutOfRange, "uniqueness ratio must be non-negative");
int FILTERED = (params.minDisparity - 1) << DISPARITY_SHIFT;
Mat left0 = leftarr.getMat(), right0 = rightarr.getMat();
Mat disp0 = disparr.getMat();
int width = left0.cols;
int height = left0.rows;
if(previous_size != width * height)
{
previous_size = width * height;
speckleX.create(height,width,CV_32SC4);
speckleY.create(height,width,CV_32SC4);
puss.create(height,width,CV_32SC4);
censusImage[0].create(left0.rows,left0.cols,CV_32SC4);
censusImage[1].create(left0.rows,left0.cols,CV_32SC4);
partialSumsLR.create(left0.rows + 1,(left0.cols + 1) * (params.numDisparities + 1),CV_16S);
agregatedHammingLRCost.create(left0.rows + 1,(left0.cols + 1) * (params.numDisparities + 1),CV_16S);
hammingDistance.create(left0.rows, left0.cols * (params.numDisparities + 1),CV_16S);
preFilteredImg0.create(left0.size(), CV_8U);
preFilteredImg1.create(left0.size(), CV_8U);
aux.create(height,width,CV_8UC1);
}
Mat left = preFilteredImg0, right = preFilteredImg1;
int ndisp = params.numDisparities;
int wsz = params.kernelSize;
int bufSize0 = (int)((ndisp + 2)*sizeof(int));
bufSize0 += (int)((height + wsz + 2)*ndisp*sizeof(int));
bufSize0 += (int)((height + wsz + 2)*sizeof(int));
bufSize0 += (int)((height + wsz + 2)*ndisp*(wsz + 2)*sizeof(uchar) + 256);
int bufSize1 = (int)((width + params.preFilterSize + 2) * sizeof(int) + 256);
if(params.usePrefilter == true)
{
uchar *_buf = slidingSumBuf.ptr();
parallel_for_(Range(0, 2), PrefilterInvoker(left0, right0, left, right, _buf, _buf + bufSize1, ¶ms), 1);
}
else if(params.usePrefilter == false)
{
left = left0;
right = right0;
}
if(params.kernelType == CV_SPARSE_CENSUS)
{
censusTransform(left,right,params.kernelSize,censusImage[0],censusImage[1],CV_SPARSE_CENSUS);
}
else if(params.kernelType == CV_DENSE_CENSUS)
{
censusTransform(left,right,params.kernelSize,censusImage[0],censusImage[1],CV_SPARSE_CENSUS);
}
else if(params.kernelType == CV_CS_CENSUS)
{
symetricCensusTransform(left,right,params.kernelSize,censusImage[0],censusImage[1],CV_CS_CENSUS);
}
else if(params.kernelType == CV_MODIFIED_CS_CENSUS)
{
symetricCensusTransform(left,right,params.kernelSize,censusImage[0],censusImage[1],CV_MODIFIED_CS_CENSUS);
}
else if(params.kernelType == CV_MODIFIED_CENSUS_TRANSFORM)
{
modifiedCensusTransform(left,right,params.kernelSize,censusImage[0],censusImage[1],CV_MODIFIED_CENSUS_TRANSFORM,0);
}
else if(params.kernelType == CV_MEAN_VARIATION)
{
parSumsIntensityImage[0].create(left0.rows, left0.cols,CV_32SC4);
parSumsIntensityImage[1].create(left0.rows, left0.cols,CV_32SC4);
Integral[0].create(left0.rows,left0.cols,CV_32SC4);
Integral[1].create(left0.rows,left0.cols,CV_32SC4);
integral(left, parSumsIntensityImage[0],CV_32S);
integral(right, parSumsIntensityImage[1],CV_32S);
imageMeanKernelSize(parSumsIntensityImage[0], params.kernelSize,Integral[0]);
imageMeanKernelSize(parSumsIntensityImage[1], params.kernelSize, Integral[1]);
modifiedCensusTransform(left,right,params.kernelSize,censusImage[0],censusImage[1],CV_MEAN_VARIATION,0,Integral[0], Integral[1]);
}
else if(params.kernelType == CV_STAR_KERNEL)
{
starCensusTransform(left,right,params.kernelSize,censusImage[0],censusImage[1]);
}
hammingDistanceBlockMatching(censusImage[0], censusImage[1], hammingDistance);
costGathering(hammingDistance, partialSumsLR);
blockAgregation(partialSumsLR, params.agregationWindowSize, agregatedHammingLRCost);
dispartyMapFormation(agregatedHammingLRCost, disp0, 3);
Median1x9Filter<uint8_t>(disp0, aux);
Median9x1Filter<uint8_t>(aux,disp0);
if(params.regionRemoval == CV_SPECKLE_REMOVAL_AVG_ALGORITHM)
{
smallRegionRemoval<uint8_t>(disp0,params.speckleWindowSize,disp0);
}
else if(params.regionRemoval == CV_SPECKLE_REMOVAL_ALGORITHM)
{
if (params.speckleRange >= 0 && params.speckleWindowSize > 0)
filterSpeckles(disp0, FILTERED, params.speckleWindowSize, params.speckleRange, slidingSumBuf);
}
}
void InfEngineBackendLayer::forward(InputArrayOfArrays inputs, OutputArrayOfArrays outputs,
OutputArrayOfArrays internals)
{
CV_Error(Error::StsInternal, "Choose Inference Engine as a preferable backend.");
}
void InfEngineBackendLayer::forward(std::vector<Mat*> &input, std::vector<Mat> &output,
std::vector<Mat> &internals)
{
CV_Error(Error::StsError, "Choose Inference Engine as a preferable backend.");
}
void cv::addText( const Mat&, const String&, Point, const QtFont&)
{
CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
}
/* Takes an array of 3D points, type of distance (including user-defined
distance specified by callbacks, fills the array of four floats with line
parameters A, B, C, D, E, F, where (A, B, C) is the normalized direction vector,
(D, E, F) is the point that belongs to the line. */
static void fitLine3D( Point3f * points, int count, int dist,
float _param, float reps, float aeps, float *line )
{
double EPS = count*FLT_EPSILON;
void (*calc_weights) (float *, int, float *) = 0;
void (*calc_weights_param) (float *, int, float *, float) = 0;
int i, j, k;
float _line[6]={0,0,0,0,0,0}, _lineprev[6]={0,0,0,0,0,0};
float rdelta = reps != 0 ? reps : 1.0f;
float adelta = aeps != 0 ? aeps : 0.01f;
double min_err = DBL_MAX, err = 0;
RNG rng((uint64)-1);
switch (dist)
{
case CV_DIST_L2:
return fitLine3D_wods( points, count, 0, line );
case CV_DIST_L1:
calc_weights = weightL1;
break;
case CV_DIST_L12:
calc_weights = weightL12;
break;
case CV_DIST_FAIR:
calc_weights_param = weightFair;
break;
case CV_DIST_WELSCH:
calc_weights_param = weightWelsch;
break;
case CV_DIST_HUBER:
calc_weights_param = weightHuber;
break;
default:
CV_Error(CV_StsBadArg, "Unknown distance");
}
AutoBuffer<float> buf(count*2);
float *w = buf, *r = w + count;
for( k = 0; k < 20; k++ )
{
int first = 1;
for( i = 0; i < count; i++ )
w[i] = 0.f;
for( i = 0; i < MIN(count,10); )
{
j = rng.uniform(0, count);
if( w[j] < FLT_EPSILON )
{
w[j] = 1.f;
i++;
}
}
fitLine3D_wods( points, count, w, _line );
for( i = 0; i < 30; i++ )
{
double sum_w = 0;
if( first )
{
first = 0;
}
else
{
double t = _line[0] * _lineprev[0] + _line[1] * _lineprev[1] + _line[2] * _lineprev[2];
t = MAX(t,-1.);
t = MIN(t,1.);
if( fabs(acos(t)) < adelta )
{
float x, y, z, ax, ay, az, dx, dy, dz, d;
x = _line[3] - _lineprev[3];
y = _line[4] - _lineprev[4];
z = _line[5] - _lineprev[5];
ax = _line[0] - _lineprev[0];
ay = _line[1] - _lineprev[1];
az = _line[2] - _lineprev[2];
dx = (float) fabs( y * az - z * ay );
dy = (float) fabs( z * ax - x * az );
dz = (float) fabs( x * ay - y * ax );
d = dx > dy ? (dx > dz ? dx : dz) : (dy > dz ? dy : dz);
if( d < rdelta )
break;
}
}
/* calculate distances */
err = calcDist3D( points, count, _line, r );
//if( err < FLT_EPSILON*count )
// break;
/* calculate weights */
if( calc_weights )
calc_weights( r, count, w );
else
calc_weights_param( r, count, w, _param );
for( j = 0; j < count; j++ )
sum_w += w[j];
if( fabs(sum_w) > FLT_EPSILON )
{
sum_w = 1./sum_w;
for( j = 0; j < count; j++ )
w[j] = (float)(w[j]*sum_w);
}
else
{
for( j = 0; j < count; j++ )
w[j] = 1.f;
}
/* save the line parameters */
memcpy( _lineprev, _line, 6 * sizeof( float ));
/* Run again... */
fitLine3D_wods( points, count, w, _line );
}
if( err < min_err )
{
min_err = err;
memcpy( line, _line, 6 * sizeof(line[0]));
if( err < EPS )
break;
}
}
}
void cv::displayOverlay(const String&, const String&, int )
{
CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
}
/* The main function */
CV_IMPL float cvCalcEMD2( const CvArr* signature_arr1,
const CvArr* signature_arr2,
int dist_type,
CvDistanceFunction dist_func,
const CvArr* cost_matrix,
CvArr* flow_matrix,
float *lower_bound,
void *user_param )
{
cv::AutoBuffer<char> local_buf;
CvEMDState state;
float emd = 0;
memset( &state, 0, sizeof(state));
double total_cost = 0;
int result = 0;
float eps, min_delta;
CvNode2D *xp = 0;
CvMat sign_stub1, *signature1 = (CvMat*)signature_arr1;
CvMat sign_stub2, *signature2 = (CvMat*)signature_arr2;
CvMat cost_stub, *cost = &cost_stub;
CvMat flow_stub, *flow = (CvMat*)flow_matrix;
int dims, size1, size2;
signature1 = cvGetMat( signature1, &sign_stub1 );
signature2 = cvGetMat( signature2, &sign_stub2 );
if( signature1->cols != signature2->cols )
CV_Error( CV_StsUnmatchedSizes, "The arrays must have equal number of columns (which is number of dimensions but 1)" );
dims = signature1->cols - 1;
size1 = signature1->rows;
size2 = signature2->rows;
if( !CV_ARE_TYPES_EQ( signature1, signature2 ))
CV_Error( CV_StsUnmatchedFormats, "The array must have equal types" );
if( CV_MAT_TYPE( signature1->type ) != CV_32FC1 )
CV_Error( CV_StsUnsupportedFormat, "The signatures must be 32fC1" );
if( flow )
{
flow = cvGetMat( flow, &flow_stub );
if( flow->rows != size1 || flow->cols != size2 )
CV_Error( CV_StsUnmatchedSizes,
"The flow matrix size does not match to the signatures' sizes" );
if( CV_MAT_TYPE( flow->type ) != CV_32FC1 )
CV_Error( CV_StsUnsupportedFormat, "The flow matrix must be 32fC1" );
}
cost->data.fl = 0;
cost->step = 0;
if( dist_type < 0 )
{
if( cost_matrix )
{
if( dist_func )
CV_Error( CV_StsBadArg,
"Only one of cost matrix or distance function should be non-NULL in case of user-defined distance" );
if( lower_bound )
CV_Error( CV_StsBadArg,
"The lower boundary can not be calculated if the cost matrix is used" );
cost = cvGetMat( cost_matrix, &cost_stub );
if( cost->rows != size1 || cost->cols != size2 )
CV_Error( CV_StsUnmatchedSizes,
"The cost matrix size does not match to the signatures' sizes" );
if( CV_MAT_TYPE( cost->type ) != CV_32FC1 )
CV_Error( CV_StsUnsupportedFormat, "The cost matrix must be 32fC1" );
}
else if( !dist_func )
CV_Error( CV_StsNullPtr, "In case of user-defined distance Distance function is undefined" );
}
else
{
if( dims == 0 )
CV_Error( CV_StsBadSize,
"Number of dimensions can be 0 only if a user-defined metric is used" );
user_param = (void *) (size_t)dims;
switch (dist_type)
{
case CV_DIST_L1:
dist_func = icvDistL1;
break;
case CV_DIST_L2:
dist_func = icvDistL2;
break;
case CV_DIST_C:
dist_func = icvDistC;
break;
default:
CV_Error( CV_StsBadFlag, "Bad or unsupported metric type" );
}
}
result = icvInitEMD( signature1->data.fl, size1,
signature2->data.fl, size2,
dims, dist_func, user_param,
cost->data.fl, cost->step,
&state, lower_bound, local_buf );
if( result > 0 && lower_bound )
{
emd = *lower_bound;
return emd;
}
eps = CV_EMD_EPS * state.max_cost;
/* if ssize = 1 or dsize = 1 then we are done, else ... */
if( state.ssize > 1 && state.dsize > 1 )
{
int itr;
for( itr = 1; itr < MAX_ITERATIONS; itr++ )
{
/* find basic variables */
result = icvFindBasicVariables( state.cost, state.is_x,
state.u, state.v, state.ssize, state.dsize );
if( result < 0 )
break;
/* check for optimality */
min_delta = icvIsOptimal( state.cost, state.is_x,
state.u, state.v,
state.ssize, state.dsize, state.enter_x );
if( min_delta == CV_EMD_INF )
CV_Error( CV_StsNoConv, "" );
/* if no negative deltamin, we found the optimal solution */
if( min_delta >= -eps )
break;
/* improve solution */
if(!icvNewSolution( &state ))
CV_Error( CV_StsNoConv, "" );
}
}
/* compute the total flow */
for( xp = state._x; xp < state.end_x; xp++ )
{
float val = xp->val;
int i = xp->i;
int j = xp->j;
if( xp == state.enter_x )
continue;
int ci = state.idx1[i];
int cj = state.idx2[j];
if( ci >= 0 && cj >= 0 )
{
total_cost += (double)val * state.cost[i][j];
if( flow )
((float*)(flow->data.ptr + flow->step*ci))[cj] = val;
}
}
emd = (float) (total_cost / state.weight);
return emd;
}
void cv::stopLoop()
{
CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
}
/************************************************************************************\
* initialize structure, allocate buffers and generate initial golution *
\************************************************************************************/
static int icvInitEMD( const float* signature1, int size1,
const float* signature2, int size2,
int dims, CvDistanceFunction dist_func, void* user_param,
const float* cost, int cost_step,
CvEMDState* state, float* lower_bound,
cv::AutoBuffer<char>& _buffer )
{
float s_sum = 0, d_sum = 0, diff;
int i, j;
int ssize = 0, dsize = 0;
int equal_sums = 1;
int buffer_size;
float max_cost = 0;
char *buffer, *buffer_end;
memset( state, 0, sizeof( *state ));
assert( cost_step % sizeof(float) == 0 );
cost_step /= sizeof(float);
/* calculate buffer size */
buffer_size = (size1+1) * (size2+1) * (sizeof( float ) + /* cost */
sizeof( char ) + /* is_x */
sizeof( float )) + /* delta matrix */
(size1 + size2 + 2) * (sizeof( CvNode2D ) + /* _x */
sizeof( CvNode2D * ) + /* cols_x & rows_x */
sizeof( CvNode1D ) + /* u & v */
sizeof( float ) + /* s & d */
sizeof( int ) + sizeof(CvNode2D*)) + /* idx1 & idx2 */
(size1+1) * (sizeof( float * ) + sizeof( char * ) + /* rows pointers for */
sizeof( float * )) + 256; /* cost, is_x and delta */
if( buffer_size < (int) (dims * 2 * sizeof( float )))
{
buffer_size = dims * 2 * sizeof( float );
}
/* allocate buffers */
_buffer.allocate(buffer_size);
state->buffer = buffer = _buffer;
buffer_end = buffer + buffer_size;
state->idx1 = (int*) buffer;
buffer += (size1 + 1) * sizeof( int );
state->idx2 = (int*) buffer;
buffer += (size2 + 1) * sizeof( int );
state->s = (float *) buffer;
buffer += (size1 + 1) * sizeof( float );
state->d = (float *) buffer;
buffer += (size2 + 1) * sizeof( float );
/* sum up the supply and demand */
for( i = 0; i < size1; i++ )
{
float weight = signature1[i * (dims + 1)];
if( weight > 0 )
{
s_sum += weight;
state->s[ssize] = weight;
state->idx1[ssize++] = i;
}
else if( weight < 0 )
CV_Error(CV_StsOutOfRange, "");
}
for( i = 0; i < size2; i++ )
{
float weight = signature2[i * (dims + 1)];
if( weight > 0 )
{
d_sum += weight;
state->d[dsize] = weight;
state->idx2[dsize++] = i;
}
else if( weight < 0 )
CV_Error(CV_StsOutOfRange, "");
}
if( ssize == 0 || dsize == 0 )
CV_Error(CV_StsOutOfRange, "");
/* if supply different than the demand, add a zero-cost dummy cluster */
diff = s_sum - d_sum;
if( fabs( diff ) >= CV_EMD_EPS * s_sum )
{
equal_sums = 0;
if( diff < 0 )
{
state->s[ssize] = -diff;
state->idx1[ssize++] = -1;
}
else
{
state->d[dsize] = diff;
state->idx2[dsize++] = -1;
}
}
state->ssize = ssize;
state->dsize = dsize;
state->weight = s_sum > d_sum ? s_sum : d_sum;
if( lower_bound && equal_sums ) /* check lower bound */
{
int sz1 = size1 * (dims + 1), sz2 = size2 * (dims + 1);
float lb = 0;
float* xs = (float *) buffer;
float* xd = xs + dims;
memset( xs, 0, dims*sizeof(xs[0]));
memset( xd, 0, dims*sizeof(xd[0]));
for( j = 0; j < sz1; j += dims + 1 )
{
float weight = signature1[j];
for( i = 0; i < dims; i++ )
xs[i] += signature1[j + i + 1] * weight;
}
for( j = 0; j < sz2; j += dims + 1 )
{
float weight = signature2[j];
for( i = 0; i < dims; i++ )
xd[i] += signature2[j + i + 1] * weight;
}
lb = dist_func( xs, xd, user_param ) / state->weight;
i = *lower_bound <= lb;
*lower_bound = lb;
if( i )
return 1;
}
/* assign pointers */
state->is_used = (char *) buffer;
/* init delta matrix */
state->delta = (float **) buffer;
buffer += ssize * sizeof( float * );
for( i = 0; i < ssize; i++ )
{
state->delta[i] = (float *) buffer;
buffer += dsize * sizeof( float );
}
state->loop = (CvNode2D **) buffer;
buffer += (ssize + dsize + 1) * sizeof(CvNode2D*);
state->_x = state->end_x = (CvNode2D *) buffer;
buffer += (ssize + dsize) * sizeof( CvNode2D );
/* init cost matrix */
state->cost = (float **) buffer;
buffer += ssize * sizeof( float * );
/* compute the distance matrix */
for( i = 0; i < ssize; i++ )
{
int ci = state->idx1[i];
state->cost[i] = (float *) buffer;
buffer += dsize * sizeof( float );
if( ci >= 0 )
{
for( j = 0; j < dsize; j++ )
{
int cj = state->idx2[j];
if( cj < 0 )
state->cost[i][j] = 0;
else
{
float val;
if( dist_func )
{
val = dist_func( signature1 + ci * (dims + 1) + 1,
signature2 + cj * (dims + 1) + 1,
user_param );
}
else
{
assert( cost );
val = cost[cost_step*ci + cj];
}
state->cost[i][j] = val;
if( max_cost < val )
max_cost = val;
}
}
}
else
{
for( j = 0; j < dsize; j++ )
state->cost[i][j] = 0;
}
}
state->max_cost = max_cost;
memset( buffer, 0, buffer_end - buffer );
state->rows_x = (CvNode2D **) buffer;
buffer += ssize * sizeof( CvNode2D * );
state->cols_x = (CvNode2D **) buffer;
buffer += dsize * sizeof( CvNode2D * );
state->u = (CvNode1D *) buffer;
buffer += ssize * sizeof( CvNode1D );
state->v = (CvNode1D *) buffer;
buffer += dsize * sizeof( CvNode1D );
/* init is_x matrix */
state->is_x = (char **) buffer;
buffer += ssize * sizeof( char * );
for( i = 0; i < ssize; i++ )
{
state->is_x[i] = buffer;
buffer += dsize;
}
assert( buffer <= buffer_end );
icvRussel( state );
state->enter_x = (state->end_x)++;
return 0;
}
int cv::createButton(const String&, ButtonCallback, void*, int , bool )
{
CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
return 0;
}
CV_IMPL void cvSetOpenGlDrawCallback(const char*, CvOpenGlDrawCallback, void*)
{
CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support");
}
cl_mem bindTexture(const oclMat &mat)
{
cl_mem texture;
cl_image_format format;
int err;
int depth = mat.depth();
int channels = mat.oclchannels();
switch(depth)
{
case CV_8U:
format.image_channel_data_type = CL_UNSIGNED_INT8;
break;
case CV_32S:
format.image_channel_data_type = CL_UNSIGNED_INT32;
break;
case CV_32F:
format.image_channel_data_type = CL_FLOAT;
break;
default:
CV_Error(-1, "Image forma is not supported");
break;
}
switch(channels)
{
case 1:
format.image_channel_order = CL_R;
break;
case 3:
format.image_channel_order = CL_RGB;
break;
case 4:
format.image_channel_order = CL_RGBA;
break;
default:
CV_Error(-1, "Image format is not supported");
break;
}
#ifdef CL_VERSION_1_2
//this enables backwards portability to
//run on OpenCL 1.1 platform if library binaries are compiled with OpenCL 1.2 support
if(Context::getContext()->supportsFeature(FEATURE_CL_VER_1_2))
{
cl_image_desc desc;
desc.image_type = CL_MEM_OBJECT_IMAGE2D;
desc.image_width = mat.cols;
desc.image_height = mat.rows;
desc.image_depth = 0;
desc.image_array_size = 1;
desc.image_row_pitch = 0;
desc.image_slice_pitch = 0;
desc.buffer = NULL;
desc.num_mip_levels = 0;
desc.num_samples = 0;
texture = clCreateImage(*(cl_context*)mat.clCxt->getOpenCLContextPtr(), CL_MEM_READ_WRITE, &format, &desc, NULL, &err);
}
else
#endif
{
texture = clCreateImage2D(
*(cl_context*)mat.clCxt->getOpenCLContextPtr(),
CL_MEM_READ_WRITE,
&format,
mat.cols,
mat.rows,
0,
NULL,
&err);
}
size_t origin[] = { 0, 0, 0 };
size_t region[] = { mat.cols, mat.rows, 1 };
cl_mem devData;
if (mat.cols * mat.elemSize() != mat.step)
{
devData = clCreateBuffer(*(cl_context*)mat.clCxt->getOpenCLContextPtr(), CL_MEM_READ_ONLY, mat.cols * mat.rows
* mat.elemSize(), NULL, NULL);
const size_t regin[3] = {mat.cols * mat.elemSize(), mat.rows, 1};
clEnqueueCopyBufferRect(*(cl_command_queue*)mat.clCxt->getOpenCLCommandQueuePtr(), (cl_mem)mat.data, devData, origin, origin,
regin, mat.step, 0, mat.cols * mat.elemSize(), 0, 0, NULL, NULL);
clFlush(*(cl_command_queue*)mat.clCxt->getOpenCLCommandQueuePtr());
}
else
{
devData = (cl_mem)mat.data;
}
clEnqueueCopyBufferToImage(*(cl_command_queue*)mat.clCxt->getOpenCLCommandQueuePtr(), devData, texture, 0, origin, region, 0, NULL, 0);
if ((mat.cols * mat.elemSize() != mat.step))
{
clFlush(*(cl_command_queue*)mat.clCxt->getOpenCLCommandQueuePtr());
clReleaseMemObject(devData);
}
openCLSafeCall(err);
return texture;
}
CV_IMPL void cvSetOpenGlContext(const char*)
{
CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support");
}
static inline void throw_nogpu() { CV_Error(CV_GpuNotSupported, "The library is compiled without GPU support"); }
CV_IMPL void cvUpdateWindow(const char*)
{
CV_Error(CV_OpenGlNotSupported, "The library is compiled without OpenGL support");
}
CV_IMPL CvKalman*
cvCreateKalman( int DP, int MP, int CP )
{
CvKalman *kalman = 0;
if( DP <= 0 || MP <= 0 )
CV_Error( CV_StsOutOfRange,
"state and measurement vectors must have positive number of dimensions" );
if( CP < 0 )
CP = DP;
/* allocating memory for the structure */
kalman = (CvKalman *)cvAlloc( sizeof( CvKalman ));
memset( kalman, 0, sizeof(*kalman));
kalman->DP = DP;
kalman->MP = MP;
kalman->CP = CP;
kalman->state_pre = cvCreateMat( DP, 1, CV_32FC1 );
cvZero( kalman->state_pre );
kalman->state_post = cvCreateMat( DP, 1, CV_32FC1 );
cvZero( kalman->state_post );
kalman->transition_matrix = cvCreateMat( DP, DP, CV_32FC1 );
cvSetIdentity( kalman->transition_matrix );
kalman->process_noise_cov = cvCreateMat( DP, DP, CV_32FC1 );
cvSetIdentity( kalman->process_noise_cov );
kalman->measurement_matrix = cvCreateMat( MP, DP, CV_32FC1 );
cvZero( kalman->measurement_matrix );
kalman->measurement_noise_cov = cvCreateMat( MP, MP, CV_32FC1 );
cvSetIdentity( kalman->measurement_noise_cov );
kalman->error_cov_pre = cvCreateMat( DP, DP, CV_32FC1 );
kalman->error_cov_post = cvCreateMat( DP, DP, CV_32FC1 );
cvZero( kalman->error_cov_post );
kalman->gain = cvCreateMat( DP, MP, CV_32FC1 );
if( CP > 0 )
{
kalman->control_matrix = cvCreateMat( DP, CP, CV_32FC1 );
cvZero( kalman->control_matrix );
}
kalman->temp1 = cvCreateMat( DP, DP, CV_32FC1 );
kalman->temp2 = cvCreateMat( MP, DP, CV_32FC1 );
kalman->temp3 = cvCreateMat( MP, MP, CV_32FC1 );
kalman->temp4 = cvCreateMat( MP, DP, CV_32FC1 );
kalman->temp5 = cvCreateMat( MP, 1, CV_32FC1 );
#if 1
kalman->PosterState = kalman->state_pre->data.fl;
kalman->PriorState = kalman->state_post->data.fl;
kalman->DynamMatr = kalman->transition_matrix->data.fl;
kalman->MeasurementMatr = kalman->measurement_matrix->data.fl;
kalman->MNCovariance = kalman->measurement_noise_cov->data.fl;
kalman->PNCovariance = kalman->process_noise_cov->data.fl;
kalman->KalmGainMatr = kalman->gain->data.fl;
kalman->PriorErrorCovariance = kalman->error_cov_pre->data.fl;
kalman->PosterErrorCovariance = kalman->error_cov_post->data.fl;
#endif
return kalman;
}
cv::QtFont cv::fontQt(const String&, int, Scalar, int, int, int)
{
CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
return QtFont();
}
static inline void throw_no_cuda() { CV_Error(cv::Error::StsNotImplemented, "The called functionality is disabled for current build or platform"); }
InferenceEngine::StatusCode InfEngineBackendNet::setBatchSize(const size_t size) noexcept
{
CV_Error(Error::StsNotImplemented, "");
return InferenceEngine::StatusCode::OK;
}
