mirror/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2025-07-26 07:07:37 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #26458 from asmorkalov:as/drop_c_core

Browse Source 
Drop C API in core
This commit is contained in:
Alexander Smorkalov 2024-11-14 17:27:36 +03:00 committed by GitHub
commit 77b45145d1
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
25 changed files with 60 additions and 12104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
modules/core/CMakeLists.txt
View File

@ -176,10 +176,6 @@ ocv_target_link_libraries(${the_module} PRIVATE
"${OPENCV_HAL_LINKER_LIBS}" "${OPENCV_HAL_LINKER_LIBS}"
) )
if(OPENCV_CORE_EXCLUDE_C_API)
ocv_target_compile_definitions(${the_module} PRIVATE "OPENCV_EXCLUDE_C_API=1")
endif()
if(OPENCV_DISABLE_THREAD_SUPPORT) if(OPENCV_DISABLE_THREAD_SUPPORT)
ocv_target_compile_definitions(${the_module} PUBLIC "OPENCV_DISABLE_THREAD_SUPPORT=1") ocv_target_compile_definitions(${the_module} PUBLIC "OPENCV_DISABLE_THREAD_SUPPORT=1")
endif() endif()

2263
modules/core/include/opencv2/core/core_c.h
View File

File diff suppressed because it is too large Load Diff

1910
modules/core/include/opencv2/core/types_c.h
View File

File diff suppressed because it is too large Load Diff

11
modules/core/src/alloc.cpp
View File

@ -236,15 +236,4 @@ void fastFree(void* ptr)
#endif // OPENCV_ALLOC_ENABLE_STATISTICS #endif // OPENCV_ALLOC_ENABLE_STATISTICS
} // namespace } // namespace
CV_IMPL void* cvAlloc( size_t size )
{
return cv::fastMalloc( size );
}
CV_IMPL void cvFree_( void* ptr )
{
cv::fastFree( ptr );
}
/* End of file. */ /* End of file. */

164
modules/core/src/arithm.cpp
View File

@ -2233,168 +2233,4 @@ void cv::inRange(InputArray _src, InputArray _lowerb,
} }
} }
} }
#ifndef OPENCV_EXCLUDE_C_API
/****************************************************************************************\
* Earlier API: cvAdd etc. *
\****************************************************************************************/
CV_IMPL void
cvNot( const CvArr* srcarr, CvArr* dstarr )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
CV_Assert( src.size == dst.size && src.type() == dst.type() );
cv::bitwise_not( src, dst );
}
CV_IMPL void
cvAnd( const CvArr* srcarr1, const CvArr* srcarr2, CvArr* dstarr, const CvArr* maskarr )
{
cv::Mat src1 = cv::cvarrToMat(srcarr1), src2 = cv::cvarrToMat(srcarr2),
dst = cv::cvarrToMat(dstarr), mask;
CV_Assert( src1.size == dst.size && src1.type() == dst.type() );
if( maskarr )
mask = cv::cvarrToMat(maskarr);
cv::bitwise_and( src1, src2, dst, mask );
}
CV_IMPL void
cvOr( const CvArr* srcarr1, const CvArr* srcarr2, CvArr* dstarr, const CvArr* maskarr )
{
cv::Mat src1 = cv::cvarrToMat(srcarr1), src2 = cv::cvarrToMat(srcarr2),
dst = cv::cvarrToMat(dstarr), mask;
CV_Assert( src1.size == dst.size && src1.type() == dst.type() );
if( maskarr )
mask = cv::cvarrToMat(maskarr);
cv::bitwise_or( src1, src2, dst, mask );
}
CV_IMPL void
cvXor( const CvArr* srcarr1, const CvArr* srcarr2, CvArr* dstarr, const CvArr* maskarr )
{
cv::Mat src1 = cv::cvarrToMat(srcarr1), src2 = cv::cvarrToMat(srcarr2),
dst = cv::cvarrToMat(dstarr), mask;
CV_Assert( src1.size == dst.size && src1.type() == dst.type() );
if( maskarr )
mask = cv::cvarrToMat(maskarr);
cv::bitwise_xor( src1, src2, dst, mask );
}
CV_IMPL void
cvAndS( const CvArr* srcarr, CvScalar s, CvArr* dstarr, const CvArr* maskarr )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr), mask;
CV_Assert( src.size == dst.size && src.type() == dst.type() );
if( maskarr )
mask = cv::cvarrToMat(maskarr);
cv::bitwise_and( src, (const cv::Scalar&)s, dst, mask );
}
CV_IMPL void
cvOrS( const CvArr* srcarr, CvScalar s, CvArr* dstarr, const CvArr* maskarr )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr), mask;
CV_Assert( src.size == dst.size && src.type() == dst.type() );
if( maskarr )
mask = cv::cvarrToMat(maskarr);
cv::bitwise_or( src, (const cv::Scalar&)s, dst, mask );
}
CV_IMPL void
cvXorS( const CvArr* srcarr, CvScalar s, CvArr* dstarr, const CvArr* maskarr )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr), mask;
CV_Assert( src.size == dst.size && src.type() == dst.type() );
if( maskarr )
mask = cv::cvarrToMat(maskarr);
cv::bitwise_xor( src, (const cv::Scalar&)s, dst, mask );
}
CV_IMPL void cvAdd( const CvArr* srcarr1, const CvArr* srcarr2, CvArr* dstarr, const CvArr* maskarr )
{
cv::Mat src1 = cv::cvarrToMat(srcarr1), src2 = cv::cvarrToMat(srcarr2),
dst = cv::cvarrToMat(dstarr), mask;
CV_Assert( src1.size == dst.size && src1.channels() == dst.channels() );
if( maskarr )
mask = cv::cvarrToMat(maskarr);
cv::add( src1, src2, dst, mask, dst.type() );
}
CV_IMPL void cvSub( const CvArr* srcarr1, const CvArr* srcarr2, CvArr* dstarr, const CvArr* maskarr )
{
cv::Mat src1 = cv::cvarrToMat(srcarr1), src2 = cv::cvarrToMat(srcarr2),
dst = cv::cvarrToMat(dstarr), mask;
CV_Assert( src1.size == dst.size && src1.channels() == dst.channels() );
if( maskarr )
mask = cv::cvarrToMat(maskarr);
cv::subtract( src1, src2, dst, mask, dst.type() );
}
CV_IMPL void cvAddS( const CvArr* srcarr1, CvScalar value, CvArr* dstarr, const CvArr* maskarr )
{
cv::Mat src1 = cv::cvarrToMat(srcarr1),
dst = cv::cvarrToMat(dstarr), mask;
CV_Assert( src1.size == dst.size && src1.channels() == dst.channels() );
if( maskarr )
mask = cv::cvarrToMat(maskarr);
cv::add( src1, (const cv::Scalar&)value, dst, mask, dst.type() );
}
CV_IMPL void cvSubRS( const CvArr* srcarr1, CvScalar value, CvArr* dstarr, const CvArr* maskarr )
{
cv::Mat src1 = cv::cvarrToMat(srcarr1),
dst = cv::cvarrToMat(dstarr), mask;
CV_Assert( src1.size == dst.size && src1.channels() == dst.channels() );
if( maskarr )
mask = cv::cvarrToMat(maskarr);
cv::subtract( (const cv::Scalar&)value, src1, dst, mask, dst.type() );
}
CV_IMPL void cvMul( const CvArr* srcarr1, const CvArr* srcarr2,
CvArr* dstarr, double scale )
{
cv::Mat src1 = cv::cvarrToMat(srcarr1), src2 = cv::cvarrToMat(srcarr2),
dst = cv::cvarrToMat(dstarr);
CV_Assert( src1.size == dst.size && src1.channels() == dst.channels() );
cv::multiply( src1, src2, dst, scale, dst.type() );
}
CV_IMPL void cvDiv( const CvArr* srcarr1, const CvArr* srcarr2,
CvArr* dstarr, double scale )
{
cv::Mat src2 = cv::cvarrToMat(srcarr2),
dst = cv::cvarrToMat(dstarr), mask;
CV_Assert( src2.size == dst.size && src2.channels() == dst.channels() );
if( srcarr1 )
cv::divide( cv::cvarrToMat(srcarr1), src2, dst, scale, dst.type() );
else
cv::divide( scale, src2, dst, dst.type() );
}
CV_IMPL void
cvCmpS( const void* srcarr1, double value, void* dstarr, int cmp_op )
{
cv::Mat src1 = cv::cvarrToMat(srcarr1), dst = cv::cvarrToMat(dstarr);
CV_Assert( src1.size == dst.size && dst.type() == CV_8U );
cv::compare( src1, value, dst, cmp_op );
}
#endif // OPENCV_EXCLUDE_C_API
/* End of file. */ /* End of file. */

2787
modules/core/src/array.cpp
View File

File diff suppressed because it is too large Load Diff

137
modules/core/src/convert_c.cpp
View File

@ -1,137 +0,0 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html
#include "precomp.hpp"
#ifndef OPENCV_EXCLUDE_C_API
CV_IMPL void
cvSplit( const void* srcarr, void* dstarr0, void* dstarr1, void* dstarr2, void* dstarr3 )
{
void* dptrs[] = { dstarr0, dstarr1, dstarr2, dstarr3 };
cv::Mat src = cv::cvarrToMat(srcarr);
int i, j, nz = 0;
for( i = 0; i < 4; i++ )
nz += dptrs[i] != 0;
CV_Assert( nz > 0 );
std::vector<cv::Mat> dvec(nz);
std::vector<int> pairs(nz*2);
for( i = j = 0; i < 4; i++ )
{
if( dptrs[i] != 0 )
{
dvec[j] = cv::cvarrToMat(dptrs[i]);
CV_Assert( dvec[j].size() == src.size() );
CV_Assert( dvec[j].depth() == src.depth() );
CV_Assert( dvec[j].channels() == 1 );
CV_Assert( i < src.channels() );
pairs[j*2] = i;
pairs[j*2+1] = j;
j++;
}
}
if( nz == src.channels() )
cv::split( src, dvec );
else
{
cv::mixChannels( &src, 1, &dvec[0], nz, &pairs[0], nz );
}
}
CV_IMPL void
cvMerge( const void* srcarr0, const void* srcarr1, const void* srcarr2,
const void* srcarr3, void* dstarr )
{
const void* sptrs[] = { srcarr0, srcarr1, srcarr2, srcarr3 };
cv::Mat dst = cv::cvarrToMat(dstarr);
int i, j, nz = 0;
for( i = 0; i < 4; i++ )
nz += sptrs[i] != 0;
CV_Assert( nz > 0 );
std::vector<cv::Mat> svec(nz);
std::vector<int> pairs(nz*2);
for( i = j = 0; i < 4; i++ )
{
if( sptrs[i] != 0 )
{
svec[j] = cv::cvarrToMat(sptrs[i]);
CV_Assert( svec[j].size == dst.size &&
svec[j].depth() == dst.depth() &&
svec[j].channels() == 1 && i < dst.channels() );
pairs[j*2] = j;
pairs[j*2+1] = i;
j++;
}
}
if( nz == dst.channels() )
cv::merge( svec, dst );
else
{
cv::mixChannels( &svec[0], nz, &dst, 1, &pairs[0], nz );
}
}
CV_IMPL void
cvMixChannels( const CvArr** src, int src_count,
CvArr** dst, int dst_count,
const int* from_to, int pair_count )
{
cv::AutoBuffer<cv::Mat> buf(src_count + dst_count);
int i;
for( i = 0; i < src_count; i++ )
buf[i] = cv::cvarrToMat(src[i]);
for( i = 0; i < dst_count; i++ )
buf[i+src_count] = cv::cvarrToMat(dst[i]);
cv::mixChannels(&buf[0], src_count, &buf[src_count], dst_count, from_to, pair_count);
}
CV_IMPL void
cvConvertScaleAbs( const void* srcarr, void* dstarr,
double scale, double shift )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
CV_Assert( src.size == dst.size && dst.type() == CV_8UC(src.channels()));
cv::convertScaleAbs( src, dst, scale, shift );
}
CV_IMPL void
cvConvertScale( const void* srcarr, void* dstarr,
double scale, double shift )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
CV_Assert( src.size == dst.size && src.channels() == dst.channels() );
src.convertTo(dst, dst.type(), scale, shift);
}
CV_IMPL void cvLUT( const void* srcarr, void* dstarr, const void* lutarr )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr), lut = cv::cvarrToMat(lutarr);
CV_Assert( dst.size() == src.size() && dst.type() == CV_MAKETYPE(lut.depth(), src.channels()) );
cv::LUT( src, lut, dst );
}
CV_IMPL void cvNormalize( const CvArr* srcarr, CvArr* dstarr,
double a, double b, int norm_type, const CvArr* maskarr )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr), mask;
if( maskarr )
mask = cv::cvarrToMat(maskarr);
CV_Assert( dst.size() == src.size() && src.channels() == dst.channels() );
cv::normalize( src, dst, a, b, norm_type, dst.type(), mask );
}
#endif // OPENCV_EXCLUDE_C_API

112
modules/core/src/copy.cpp
View File

@ -49,7 +49,6 @@
#include "precomp.hpp" #include "precomp.hpp"
#include "opencl_kernels_core.hpp" #include "opencl_kernels_core.hpp"
namespace cv namespace cv
{ {
@ -1129,115 +1128,4 @@ void cv::copyMakeBorder( InputArray _src, OutputArray _dst, int top, int bottom,
top, left, (int)src.elemSize(), (uchar*)buf.data() ); top, left, (int)src.elemSize(), (uchar*)buf.data() );
} }
} }
#ifndef OPENCV_EXCLUDE_C_API
/* dst = src */
CV_IMPL void
cvCopy( const void* srcarr, void* dstarr, const void* maskarr )
{
if( CV_IS_SPARSE_MAT(srcarr) && CV_IS_SPARSE_MAT(dstarr))
{
CV_Assert( maskarr == 0 );
CvSparseMat* src1 = (CvSparseMat*)srcarr;
CvSparseMat* dst1 = (CvSparseMat*)dstarr;
CvSparseMatIterator iterator;
CvSparseNode* node;
dst1->dims = src1->dims;
memcpy( dst1->size, src1->size, src1->dims*sizeof(src1->size[0]));
dst1->valoffset = src1->valoffset;
dst1->idxoffset = src1->idxoffset;
cvClearSet( dst1->heap );
if( src1->heap->active_count >= dst1->hashsize*CV_SPARSE_HASH_RATIO )
{
cvFree( &dst1->hashtable );
dst1->hashsize = src1->hashsize;
dst1->hashtable =
(void**)cvAlloc( dst1->hashsize*sizeof(dst1->hashtable[0]));
}
memset( dst1->hashtable, 0, dst1->hashsize*sizeof(dst1->hashtable[0]));
for( node = cvInitSparseMatIterator( src1, &iterator );
node != 0; node = cvGetNextSparseNode( &iterator ))
{
CvSparseNode* node_copy = (CvSparseNode*)cvSetNew( dst1->heap );
int tabidx = node->hashval & (dst1->hashsize - 1);
memcpy( node_copy, node, dst1->heap->elem_size );
node_copy->next = (CvSparseNode*)dst1->hashtable[tabidx];
dst1->hashtable[tabidx] = node_copy;
}
return;
}
cv::Mat src = cv::cvarrToMat(srcarr, false, true, 1), dst = cv::cvarrToMat(dstarr, false, true, 1);
CV_Assert( src.depth() == dst.depth() && src.size == dst.size );
int coi1 = 0, coi2 = 0;
if( CV_IS_IMAGE(srcarr) )
coi1 = cvGetImageCOI((const IplImage*)srcarr);
if( CV_IS_IMAGE(dstarr) )
coi2 = cvGetImageCOI((const IplImage*)dstarr);
if( coi1 || coi2 )
{
CV_Assert( (coi1 != 0 || src.channels() == 1) &&
(coi2 != 0 || dst.channels() == 1) );
int pair[] = { std::max(coi1-1, 0), std::max(coi2-1, 0) };
cv::mixChannels( &src, 1, &dst, 1, pair, 1 );
return;
}
else
CV_Assert( src.channels() == dst.channels() );
if( !maskarr )
src.copyTo(dst);
else
src.copyTo(dst, cv::cvarrToMat(maskarr));
}
CV_IMPL void
cvSet( void* arr, CvScalar value, const void* maskarr )
{
cv::Mat m = cv::cvarrToMat(arr);
if( !maskarr )
m = value;
else
m.setTo(cv::Scalar(value), cv::cvarrToMat(maskarr));
}
CV_IMPL void
cvSetZero( CvArr* arr )
{
if( CV_IS_SPARSE_MAT(arr) )
{
CvSparseMat* mat1 = (CvSparseMat*)arr;
cvClearSet( mat1->heap );
if( mat1->hashtable )
memset( mat1->hashtable, 0, mat1->hashsize*sizeof(mat1->hashtable[0]));
return;
}
cv::Mat m = cv::cvarrToMat(arr);
m = cv::Scalar(0);
}
CV_IMPL void
cvFlip( const CvArr* srcarr, CvArr* dstarr, int flip_mode )
{
cv::Mat src = cv::cvarrToMat(srcarr);
cv::Mat dst;
if (!dstarr)
dst = src;
else
dst = cv::cvarrToMat(dstarr);
CV_Assert( src.type() == dst.type() && src.size() == dst.size() );
cv::flip( src, dst, flip_mode );
}
#endif // OPENCV_EXCLUDE_C_API
/* End of file. */ /* End of file. */

3589
modules/core/src/datastructs.cpp
View File

File diff suppressed because it is too large Load Diff

60
modules/core/src/dxt.cpp
View File

@ -4639,64 +4639,4 @@ int cv::getOptimalDFTSize( int size0 )
return optimalDFTSizeTab[b]; return optimalDFTSizeTab[b];
} }
#ifndef OPENCV_EXCLUDE_C_API
CV_IMPL void
cvDFT( const CvArr* srcarr, CvArr* dstarr, int flags, int nonzero_rows )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst0 = cv::cvarrToMat(dstarr), dst = dst0;
int _flags = ((flags & CV_DXT_INVERSE) ? cv::DFT_INVERSE : 0) |
((flags & CV_DXT_SCALE) ? cv::DFT_SCALE : 0) |
((flags & CV_DXT_ROWS) ? cv::DFT_ROWS : 0);
CV_Assert( src.size == dst.size );
if( src.type() != dst.type() )
{
if( dst.channels() == 2 )
_flags |= cv::DFT_COMPLEX_OUTPUT;
else
_flags |= cv::DFT_REAL_OUTPUT;
}
cv::dft( src, dst, _flags, nonzero_rows );
CV_Assert( dst.data == dst0.data ); // otherwise it means that the destination size or type was incorrect
}
CV_IMPL void
cvMulSpectrums( const CvArr* srcAarr, const CvArr* srcBarr,
CvArr* dstarr, int flags )
{
cv::Mat srcA = cv::cvarrToMat(srcAarr),
srcB = cv::cvarrToMat(srcBarr),
dst = cv::cvarrToMat(dstarr);
CV_Assert( srcA.size == dst.size && srcA.type() == dst.type() );
cv::mulSpectrums(srcA, srcB, dst,
(flags & CV_DXT_ROWS) ? cv::DFT_ROWS : 0,
(flags & CV_DXT_MUL_CONJ) != 0 );
}
CV_IMPL void
cvDCT( const CvArr* srcarr, CvArr* dstarr, int flags )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
CV_Assert( src.size == dst.size && src.type() == dst.type() );
int _flags = ((flags & CV_DXT_INVERSE) ? cv::DCT_INVERSE : 0) |
((flags & CV_DXT_ROWS) ? cv::DCT_ROWS : 0);
cv::dct( src, dst, _flags );
}
CV_IMPL int
cvGetOptimalDFTSize( int size0 )
{
return cv::getOptimalDFTSize(size0);
}
#endif // OPENCV_EXCLUDE_C_API
/* End of file. */ /* End of file. */

197
modules/core/src/lapack.cpp
View File

@ -1548,200 +1548,3 @@ void cv::SVBackSubst(InputArray w, InputArray u, InputArray vt, InputArray rhs,
SVD::backSubst(w, u, vt, rhs, dst); SVD::backSubst(w, u, vt, rhs, dst);
} }
#ifndef OPENCV_EXCLUDE_C_API
CV_IMPL double
cvDet( const CvArr* arr )
{
if( CV_IS_MAT(arr) && ((CvMat*)arr)->rows <= 3 )
{
CvMat* mat = (CvMat*)arr;
int type = CV_MAT_TYPE(mat->type);
int rows = mat->rows;
uchar* m = mat->data.ptr;
int step = mat->step;
CV_Assert( rows == mat->cols );
#define Mf(y, x) ((float*)(m + y*step))[x]
#define Md(y, x) ((double*)(m + y*step))[x]
if( type == CV_32F )
{
if( rows == 2 )
return det2(Mf);
if( rows == 3 )
return det3(Mf);
}
else if( type == CV_64F )
{
if( rows == 2 )
return det2(Md);
if( rows == 3 )
return det3(Md);
}
}
return cv::determinant(cv::cvarrToMat(arr));
}
CV_IMPL double
cvInvert( const CvArr* srcarr, CvArr* dstarr, int method )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
CV_Assert( src.type() == dst.type() && src.rows == dst.cols && src.cols == dst.rows );
return cv::invert( src, dst, method == CV_CHOLESKY ? cv::DECOMP_CHOLESKY :
method == CV_SVD ? cv::DECOMP_SVD :
method == CV_SVD_SYM ? cv::DECOMP_EIG : cv::DECOMP_LU );
}
CV_IMPL int
cvSolve( const CvArr* Aarr, const CvArr* barr, CvArr* xarr, int method )
{
cv::Mat A = cv::cvarrToMat(Aarr), b = cv::cvarrToMat(barr), x = cv::cvarrToMat(xarr);
CV_Assert( A.type() == x.type() && A.cols == x.rows && x.cols == b.cols );
bool is_normal = (method & CV_NORMAL) != 0;
method &= ~CV_NORMAL;
return cv::solve( A, b, x, (method == CV_CHOLESKY ? cv::DECOMP_CHOLESKY :
method == CV_SVD ? cv::DECOMP_SVD :
method == CV_SVD_SYM ? cv::DECOMP_EIG :
A.rows > A.cols ? cv::DECOMP_QR : cv::DECOMP_LU) + (is_normal ? cv::DECOMP_NORMAL : 0) );
}
CV_IMPL void
cvEigenVV( CvArr* srcarr, CvArr* evectsarr, CvArr* evalsarr, double,
int, int )
{
cv::Mat src = cv::cvarrToMat(srcarr), evals0 = cv::cvarrToMat(evalsarr), evals = evals0;
if( evectsarr )
{
cv::Mat evects0 = cv::cvarrToMat(evectsarr), evects = evects0;
eigen(src, evals, evects);
if( evects0.data != evects.data )
{
const uchar* p = evects0.ptr();
evects.convertTo(evects0, evects0.type());
CV_Assert( p == evects0.ptr() );
}
}
else
eigen(src, evals);
if( evals0.data != evals.data )
{
const uchar* p = evals0.ptr();
if( evals0.size() == evals.size() )
evals.convertTo(evals0, evals0.type());
else if( evals0.type() == evals.type() )
cv::transpose(evals, evals0);
else
cv::Mat(evals.t()).convertTo(evals0, evals0.type());
CV_Assert( p == evals0.ptr() );
}
}
CV_IMPL void
cvSVD( CvArr* aarr, CvArr* warr, CvArr* uarr, CvArr* varr, int flags )
{
cv::Mat a = cv::cvarrToMat(aarr), w = cv::cvarrToMat(warr), u, v;
int m = a.rows, n = a.cols, type = a.type(), mn = std::max(m, n), nm = std::min(m, n);
CV_Assert( w.type() == type &&
(w.size() == cv::Size(nm,1) || w.size() == cv::Size(1, nm) ||
w.size() == cv::Size(nm, nm) || w.size() == cv::Size(n, m)) );
cv::SVD svd;
if( w.size() == cv::Size(nm, 1) )
svd.w = cv::Mat(nm, 1, type, w.ptr() );
else if( w.isContinuous() )
svd.w = w;
if( uarr )
{
u = cv::cvarrToMat(uarr);
CV_Assert( u.type() == type );
svd.u = u;
}
if( varr )
{
v = cv::cvarrToMat(varr);
CV_Assert( v.type() == type );
svd.vt = v;
}
svd(a, ((flags & CV_SVD_MODIFY_A) ? cv::SVD::MODIFY_A : 0) |
((!svd.u.data && !svd.vt.data) ? cv::SVD::NO_UV : 0) |
((m != n && (svd.u.size() == cv::Size(mn, mn) ||
svd.vt.size() == cv::Size(mn, mn))) ? cv::SVD::FULL_UV : 0));
if( !u.empty() )
{
if( flags & CV_SVD_U_T )
cv::transpose( svd.u, u );
else if( u.data != svd.u.data )
{
CV_Assert( u.size() == svd.u.size() );
svd.u.copyTo(u);
}
}
if( !v.empty() )
{
if( !(flags & CV_SVD_V_T) )
cv::transpose( svd.vt, v );
else if( v.data != svd.vt.data )
{
CV_Assert( v.size() == svd.vt.size() );
svd.vt.copyTo(v);
}
}
if( w.data != svd.w.data )
{
if( w.size() == svd.w.size() )
svd.w.copyTo(w);
else
{
w = cv::Scalar(0);
cv::Mat wd = w.diag();
svd.w.copyTo(wd);
}
}
}
CV_IMPL void
cvSVBkSb( const CvArr* warr, const CvArr* uarr,
const CvArr* varr, const CvArr* rhsarr,
CvArr* dstarr, int flags )
{
cv::Mat w = cv::cvarrToMat(warr), u = cv::cvarrToMat(uarr),
v = cv::cvarrToMat(varr), rhs,
dst = cv::cvarrToMat(dstarr), dst0 = dst;
if( flags & CV_SVD_U_T )
{
cv::Mat tmp;
transpose(u, tmp);
u = tmp;
}
if( !(flags & CV_SVD_V_T) )
{
cv::Mat tmp;
transpose(v, tmp);
v = tmp;
}
if( rhsarr )
rhs = cv::cvarrToMat(rhsarr);
cv::SVD::backSubst(w, u, v, rhs, dst);
CV_Assert( dst.data == dst0.data );
}
#endif // OPENCV_EXCLUDE_C_API

42
modules/core/src/mathfuncs.cpp
View File

@ -1607,33 +1607,6 @@ bool checkRange(InputArray _src, bool quiet, Point* pt, double minVal, double ma
} // namespace cv } // namespace cv
#ifndef OPENCV_EXCLUDE_C_API
CV_IMPL void cvExp( const CvArr* srcarr, CvArr* dstarr )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
CV_Assert( src.type() == dst.type() && src.size == dst.size );
cv::exp( src, dst );
}
CV_IMPL void cvPow( const CvArr* srcarr, CvArr* dstarr, double power )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
CV_Assert( src.type() == dst.type() && src.size == dst.size );
cv::pow( src, power, dst );
}
CV_IMPL int cvCheckArr( const CvArr* arr, int flags,
double minVal, double maxVal )
{
if( (flags & CV_CHECK_RANGE) == 0 )
minVal = -DBL_MAX, maxVal = DBL_MAX;
return cv::checkRange(cv::cvarrToMat(arr), (flags & CV_CHECK_QUIET) != 0, 0, minVal, maxVal );
}
#endif // OPENCV_EXCLUDE_C_API
/* /*
Finds real roots of cubic, quadratic or linear equation. Finds real roots of cubic, quadratic or linear equation.
The original code has been taken from Ken Turkowski web page The original code has been taken from Ken Turkowski web page
@ -1927,21 +1900,6 @@ double cv::solvePoly( InputArray _coeffs0, OutputArray _roots0, int maxIters )
return maxDiff; return maxDiff;
} }
#ifndef OPENCV_EXCLUDE_C_API
void cvSolvePoly(const CvMat* a, CvMat *r, int maxiter, int)
{
cv::Mat _a = cv::cvarrToMat(a);
cv::Mat _r = cv::cvarrToMat(r);
cv::Mat _r0 = _r;
cv::solvePoly(_a, _r, maxiter);
CV_Assert( _r.data == _r0.data ); // check that the array of roots was not reallocated
}
#endif // OPENCV_EXCLUDE_C_API
// Common constants for dispatched code // Common constants for dispatched code
namespace cv { namespace details { namespace cv { namespace details {

251
modules/core/src/matmul.dispatch.cpp
View File

@ -696,7 +696,7 @@ void calcCovarMatrix( const Mat* data, int nsamples, Mat& covar, Mat& _mean, int
Mat mean; Mat mean;
ctype = std::max(std::max(CV_MAT_DEPTH(ctype >= 0 ? ctype : type), _mean.depth()), CV_32F); ctype = std::max(std::max(CV_MAT_DEPTH(ctype >= 0 ? ctype : type), _mean.depth()), CV_32F);
if( (flags & CV_COVAR_USE_AVG) != 0 ) if( (flags & cv::COVAR_USE_AVG) != 0 )
{ {
CV_Assert( _mean.size() == size ); CV_Assert( _mean.size() == size );
if( _mean.isContinuous() && _mean.type() == ctype ) if( _mean.isContinuous() && _mean.type() == ctype )
@ -722,8 +722,8 @@ void calcCovarMatrix( const Mat* data, int nsamples, Mat& covar, Mat& _mean, int
} }
} }
calcCovarMatrix( _data, covar, mean, (flags & ~(CV_COVAR_ROWS|CV_COVAR_COLS)) | CV_COVAR_ROWS, ctype ); calcCovarMatrix( _data, covar, mean, (flags & ~(cv::COVAR_ROWS|cv::COVAR_COLS)) | cv::COVAR_ROWS, ctype );
if( (flags & CV_COVAR_USE_AVG) == 0 ) if( (flags & cv::COVAR_USE_AVG) == 0 )
_mean = mean.reshape(1, size.height); _mean = mean.reshape(1, size.height);
} }
@ -754,7 +754,7 @@ void calcCovarMatrix( InputArray _src, OutputArray _covar, InputOutputArray _mea
} }
Mat mean; Mat mean;
if( (flags & CV_COVAR_USE_AVG) != 0 ) if( (flags & cv::COVAR_USE_AVG) != 0 )
{ {
CV_Assert( _mean.size() == size ); CV_Assert( _mean.size() == size );
@ -770,9 +770,9 @@ void calcCovarMatrix( InputArray _src, OutputArray _covar, InputOutputArray _mea
mean = _mean.getMat().reshape(1, 1); mean = _mean.getMat().reshape(1, 1);
} }
calcCovarMatrix( _data, _covar, mean, (flags & ~(CV_COVAR_ROWS|CV_COVAR_COLS)) | CV_COVAR_ROWS, ctype ); calcCovarMatrix( _data, _covar, mean, (flags & ~(cv::COVAR_ROWS|cv::COVAR_COLS)) | cv::COVAR_ROWS, ctype );
if( (flags & CV_COVAR_USE_AVG) == 0 ) if( (flags & cv::COVAR_USE_AVG) == 0 )
{ {
mean = mean.reshape(1, size.height); mean = mean.reshape(1, size.height);
mean.copyTo(_mean); mean.copyTo(_mean);
@ -781,14 +781,14 @@ void calcCovarMatrix( InputArray _src, OutputArray _covar, InputOutputArray _mea
} }
Mat data = _src.getMat(), mean; Mat data = _src.getMat(), mean;
CV_Assert( ((flags & CV_COVAR_ROWS) != 0) ^ ((flags & CV_COVAR_COLS) != 0) ); CV_Assert( ((flags & cv::COVAR_ROWS) != 0) ^ ((flags & cv::COVAR_COLS) != 0) );
bool takeRows = (flags & CV_COVAR_ROWS) != 0; bool takeRows = (flags & cv::COVAR_ROWS) != 0;
int type = data.type(); int type = data.type();
int nsamples = takeRows ? data.rows : data.cols; int nsamples = takeRows ? data.rows : data.cols;
CV_Assert( nsamples > 0 ); CV_Assert( nsamples > 0 );
Size size = takeRows ? Size(data.cols, 1) : Size(1, data.rows); Size size = takeRows ? Size(data.cols, 1) : Size(1, data.rows);
if( (flags & CV_COVAR_USE_AVG) != 0 ) if( (flags & cv::COVAR_USE_AVG) != 0 )
{ {
mean = _mean.getMat(); mean = _mean.getMat();
ctype = std::max(std::max(CV_MAT_DEPTH(ctype >= 0 ? ctype : type), mean.depth()), CV_32F); ctype = std::max(std::max(CV_MAT_DEPTH(ctype >= 0 ? ctype : type), mean.depth()), CV_32F);
@ -808,8 +808,8 @@ void calcCovarMatrix( InputArray _src, OutputArray _covar, InputOutputArray _mea
mean = _mean.getMat(); mean = _mean.getMat();
} }
mulTransposed( data, _covar, ((flags & CV_COVAR_NORMAL) == 0) ^ takeRows, mulTransposed( data, _covar, ((flags & cv::COVAR_NORMAL) == 0) ^ takeRows,
mean, (flags & CV_COVAR_SCALE) != 0 ? 1./nsamples : 1, ctype ); mean, (flags & cv::COVAR_SCALE) != 0 ? 1./nsamples : 1, ctype );
} }
@ -1097,233 +1097,4 @@ double UMat::dot(InputArray m) const
} }
} // namespace cv:: } // namespace cv::
#ifndef OPENCV_EXCLUDE_C_API
/****************************************************************************************\
* Earlier API *
\****************************************************************************************/
CV_IMPL void cvGEMM( const CvArr* Aarr, const CvArr* Barr, double alpha,
const CvArr* Carr, double beta, CvArr* Darr, int flags )
{
cv::Mat A = cv::cvarrToMat(Aarr), B = cv::cvarrToMat(Barr);
cv::Mat C, D = cv::cvarrToMat(Darr);
if( Carr )
C = cv::cvarrToMat(Carr);
CV_Assert_N( (D.rows == ((flags & CV_GEMM_A_T) == 0 ? A.rows : A.cols)),
(D.cols == ((flags & CV_GEMM_B_T) == 0 ? B.cols : B.rows)),
D.type() == A.type() );
gemm( A, B, alpha, C, beta, D, flags );
}
CV_IMPL void
cvTransform( const CvArr* srcarr, CvArr* dstarr,
const CvMat* transmat, const CvMat* shiftvec )
{
cv::Mat m = cv::cvarrToMat(transmat), src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
if( shiftvec )
{
cv::Mat v = cv::cvarrToMat(shiftvec).reshape(1,m.rows),
_m(m.rows, m.cols + 1, m.type()), m1 = _m.colRange(0,m.cols), v1 = _m.col(m.cols);
m.convertTo(m1, m1.type());
v.convertTo(v1, v1.type());
m = _m;
}
CV_Assert_N( dst.depth() == src.depth(), dst.channels() == m.rows );
cv::transform( src, dst, m );
}
CV_IMPL void
cvPerspectiveTransform( const CvArr* srcarr, CvArr* dstarr, const CvMat* mat )
{
cv::Mat m = cv::cvarrToMat(mat), src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
CV_Assert_N( dst.type() == src.type(), dst.channels() == m.rows-1 );
cv::perspectiveTransform( src, dst, m );
}
CV_IMPL void cvScaleAdd( const CvArr* srcarr1, CvScalar scale,
const CvArr* srcarr2, CvArr* dstarr )
{
cv::Mat src1 = cv::cvarrToMat(srcarr1), dst = cv::cvarrToMat(dstarr);
CV_Assert_N( src1.size == dst.size, src1.type() == dst.type() );
cv::scaleAdd( src1, scale.val[0], cv::cvarrToMat(srcarr2), dst );
}
CV_IMPL void
cvCalcCovarMatrix( const CvArr** vecarr, int count,
CvArr* covarr, CvArr* avgarr, int flags )
{
cv::Mat cov0 = cv::cvarrToMat(covarr), cov = cov0, mean0, mean;
CV_Assert_N( vecarr != 0, count >= 1 );
if( avgarr )
mean = mean0 = cv::cvarrToMat(avgarr);
if( (flags & CV_COVAR_COLS) != 0 || (flags & CV_COVAR_ROWS) != 0 )
{
cv::Mat data = cv::cvarrToMat(vecarr[0]);
cv::calcCovarMatrix( data, cov, mean, flags, cov.type() );
}
else
{
std::vector<cv::Mat> data(count);
for( int i = 0; i < count; i++ )
data[i] = cv::cvarrToMat(vecarr[i]);
cv::calcCovarMatrix( &data[0], count, cov, mean, flags, cov.type() );
}
if( mean.data != mean0.data && mean0.data )
mean.convertTo(mean0, mean0.type());
if( cov.data != cov0.data )
cov.convertTo(cov0, cov0.type());
}
CV_IMPL double
cvMahalanobis( const CvArr* srcAarr, const CvArr* srcBarr, const CvArr* matarr )
{
return cv::Mahalanobis(cv::cvarrToMat(srcAarr),
cv::cvarrToMat(srcBarr), cv::cvarrToMat(matarr));
}
CV_IMPL void
cvMulTransposed( const CvArr* srcarr, CvArr* dstarr,
int order, const CvArr* deltaarr, double scale )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst0 = cv::cvarrToMat(dstarr), dst = dst0, delta;
if( deltaarr )
delta = cv::cvarrToMat(deltaarr);
cv::mulTransposed( src, dst, order != 0, delta, scale, dst.type());
if( dst.data != dst0.data )
dst.convertTo(dst0, dst0.type());
}
CV_IMPL double cvDotProduct( const CvArr* srcAarr, const CvArr* srcBarr )
{
return cv::cvarrToMat(srcAarr).dot(cv::cvarrToMat(srcBarr));
}
CV_IMPL void
cvCalcPCA( const CvArr* data_arr, CvArr* avg_arr, CvArr* eigenvals, CvArr* eigenvects, int flags )
{
cv::Mat data = cv::cvarrToMat(data_arr), mean0 = cv::cvarrToMat(avg_arr);
cv::Mat evals0 = cv::cvarrToMat(eigenvals), evects0 = cv::cvarrToMat(eigenvects);
cv::Mat mean = mean0, evals = evals0, evects = evects0;
cv::PCA pca;
pca.mean = mean;
pca.eigenvalues = evals;
pca.eigenvectors = evects;
pca(data, (flags & cv::PCA::USE_AVG) ? mean : cv::Mat(),
flags, !evals.empty() ? evals.rows + evals.cols - 1 : 0);
if( pca.mean.size() == mean.size() )
pca.mean.convertTo( mean, mean.type() );
else
{
cv::Mat temp; pca.mean.convertTo( temp, mean.type() );
transpose( temp, mean );
}
evals = pca.eigenvalues;
evects = pca.eigenvectors;
int ecount0 = evals0.cols + evals0.rows - 1;
int ecount = evals.cols + evals.rows - 1;
CV_Assert_N( (evals0.cols == 1 || evals0.rows == 1),
ecount0 <= ecount,
evects0.cols == evects.cols,
evects0.rows == ecount0 );
cv::Mat temp = evals0;
if( evals.rows == 1 )
evals.colRange(0, ecount0).convertTo(temp, evals0.type());
else
evals.rowRange(0, ecount0).convertTo(temp, evals0.type());
if( temp.data != evals0.data )
transpose(temp, evals0);
evects.rowRange(0, ecount0).convertTo( evects0, evects0.type() );
// otherwise some datatype's or size's were incorrect, so the output arrays have been reallocated
CV_Assert( mean0.data == mean.data );
}
CV_IMPL void
cvProjectPCA( const CvArr* data_arr, const CvArr* avg_arr,
const CvArr* eigenvects, CvArr* result_arr )
{
cv::Mat data = cv::cvarrToMat(data_arr), mean = cv::cvarrToMat(avg_arr);
cv::Mat evects = cv::cvarrToMat(eigenvects), dst0 = cv::cvarrToMat(result_arr), dst = dst0;
cv::PCA pca;
pca.mean = mean;
int n;
if( mean.rows == 1 )
{
CV_Assert_N(dst.cols <= evects.rows, dst.rows == data.rows);
n = dst.cols;
}
else
{
CV_Assert_N(dst.rows <= evects.rows, dst.cols == data.cols);
n = dst.rows;
}
pca.eigenvectors = evects.rowRange(0, n);
cv::Mat result = pca.project(data);
if( result.cols != dst.cols )
result = result.reshape(1, 1);
result.convertTo(dst, dst.type());
CV_Assert(dst0.data == dst.data);
}
CV_IMPL void
cvBackProjectPCA( const CvArr* proj_arr, const CvArr* avg_arr,
const CvArr* eigenvects, CvArr* result_arr )
{
cv::Mat data = cv::cvarrToMat(proj_arr), mean = cv::cvarrToMat(avg_arr);
cv::Mat evects = cv::cvarrToMat(eigenvects), dst0 = cv::cvarrToMat(result_arr), dst = dst0;
cv::PCA pca;
pca.mean = mean;
int n;
if( mean.rows == 1 )
{
CV_Assert_N(data.cols <= evects.rows, dst.rows == data.rows);
n = data.cols;
}
else
{
CV_Assert_N(data.rows <= evects.rows, dst.cols == data.cols);
n = data.rows;
}
pca.eigenvectors = evects.rowRange(0, n);
cv::Mat result = pca.backProject(data);
result.convertTo(dst, dst.type());
CV_Assert(dst0.data == dst.data);
}
#endif // OPENCV_EXCLUDE_C_API
/* End of file. */ /* End of file. */

328
modules/core/src/matrix_c.cpp
View File

@ -1,328 +0,0 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html
#include "precomp.hpp"
#include "opencv2/core/mat.hpp"
#include "opencv2/core/types_c.h"
#ifndef OPENCV_EXCLUDE_C_API
// glue
CvMatND cvMatND(const cv::Mat& m)
{
CvMatND self;
cvInitMatNDHeader(&self, m.dims, m.size, m.type(), m.data );
int i, d = m.dims;
for( i = 0; i < d; i++ )
self.dim[i].step = (int)m.step[i];
self.type |= m.flags & cv::Mat::CONTINUOUS_FLAG;
return self;
}
_IplImage cvIplImage(const cv::Mat& m)
{
_IplImage self;
CV_Assert( m.dims <= 2 );
cvInitImageHeader(&self, cvSize(m.size()), cvIplDepth(m.flags), m.channels());
cvSetData(&self, m.data, (int)m.step[0]);
return self;
}
namespace cv {
static Mat cvMatToMat(const CvMat* m, bool copyData)
{
Mat thiz;
if( !m )
return thiz;
if( !copyData )
{
thiz.flags = Mat::MAGIC_VAL + (m->type & (CV_MAT_TYPE_MASK|CV_MAT_CONT_FLAG));
thiz.dims = 2;
thiz.rows = m->rows;
thiz.cols = m->cols;
thiz.datastart = thiz.data = m->data.ptr;
size_t esz = CV_ELEM_SIZE(m->type), minstep = thiz.cols*esz, _step = m->step;
if( _step == 0 )
_step = minstep;
thiz.datalimit = thiz.datastart + _step*thiz.rows;
thiz.dataend = thiz.datalimit - _step + minstep;
thiz.step[0] = _step; thiz.step[1] = esz;
}
else
{
thiz.datastart = thiz.dataend = thiz.data = 0;
Mat(m->rows, m->cols, m->type, m->data.ptr, m->step).copyTo(thiz);
}
return thiz;
}
static Mat cvMatNDToMat(const CvMatND* m, bool copyData)
{
Mat thiz;
if( !m )
return thiz;
thiz.datastart = thiz.data = m->data.ptr;
thiz.flags |= CV_MAT_TYPE(m->type);
int _sizes[CV_MAX_DIM];
size_t _steps[CV_MAX_DIM];
int d = m->dims;
for( int i = 0; i < d; i++ )
{
_sizes[i] = m->dim[i].size;
_steps[i] = m->dim[i].step;
}
setSize(thiz, d, _sizes, _steps);
finalizeHdr(thiz);
if( copyData )
{
Mat temp(thiz);
thiz.release();
temp.copyTo(thiz);
}
return thiz;
}
static Mat iplImageToMat(const IplImage* img, bool copyData)
{
Mat m;
if( !img )
return m;
m.dims = 2;
CV_DbgAssert(CV_IS_IMAGE(img) && img->imageData != 0);
int imgdepth = IPL2CV_DEPTH(img->depth);
size_t esz;
m.step[0] = img->widthStep;
if(!img->roi)
{
CV_Assert(img->dataOrder == IPL_DATA_ORDER_PIXEL);
m.flags = Mat::MAGIC_VAL + CV_MAKETYPE(imgdepth, img->nChannels);
m.rows = img->height;
m.cols = img->width;
m.datastart = m.data = (uchar*)img->imageData;
esz = CV_ELEM_SIZE(m.flags);
}
else
{
CV_Assert(img->dataOrder == IPL_DATA_ORDER_PIXEL || img->roi->coi != 0);
bool selectedPlane = img->roi->coi && img->dataOrder == IPL_DATA_ORDER_PLANE;
m.flags = Mat::MAGIC_VAL + CV_MAKETYPE(imgdepth, selectedPlane ? 1 : img->nChannels);
m.rows = img->roi->height;
m.cols = img->roi->width;
esz = CV_ELEM_SIZE(m.flags);
m.datastart = m.data = (uchar*)img->imageData +
(selectedPlane ? (img->roi->coi - 1)*m.step*img->height : 0) +
img->roi->yOffset*m.step[0] + img->roi->xOffset*esz;
}
m.datalimit = m.datastart + m.step.p[0]*m.rows;
m.dataend = m.datastart + m.step.p[0]*(m.rows-1) + esz*m.cols;
m.step[1] = esz;
m.updateContinuityFlag();
if( copyData )
{
Mat m2 = m;
m.release();
if( !img->roi || !img->roi->coi ||
img->dataOrder == IPL_DATA_ORDER_PLANE)
m2.copyTo(m);
else
{
int ch[] = {img->roi->coi - 1, 0};
m.create(m2.rows, m2.cols, m2.type());
mixChannels(&m2, 1, &m, 1, ch, 1);
}
}
return m;
}
Mat cvarrToMat(const CvArr* arr, bool copyData,
bool /*allowND*/, int coiMode, AutoBuffer<double>* abuf )
{
if( !arr )
return Mat();
if( CV_IS_MAT_HDR_Z(arr) )
return cvMatToMat((const CvMat*)arr, copyData);
if( CV_IS_MATND(arr) )
return cvMatNDToMat((const CvMatND*)arr, copyData );
if( CV_IS_IMAGE(arr) )
{
const IplImage* iplimg = (const IplImage*)arr;
if( coiMode == 0 && iplimg->roi && iplimg->roi->coi > 0 )
CV_Error(cv::Error::BadCOI, "COI is not supported by the function");
return iplImageToMat(iplimg, copyData);
}
if( CV_IS_SEQ(arr) )
{
CvSeq* seq = (CvSeq*)arr;
int total = seq->total, type = CV_MAT_TYPE(seq->flags), esz = seq->elem_size;
if( total == 0 )
return Mat();
CV_Assert(total > 0 && CV_ELEM_SIZE(seq->flags) == esz);
if(!copyData && seq->first->next == seq->first)
return Mat(total, 1, type, seq->first->data);
if( abuf )
{
abuf->allocate(((size_t)total*esz + sizeof(double)-1)/sizeof(double));
double* bufdata = abuf->data();
cvCvtSeqToArray(seq, bufdata, CV_WHOLE_SEQ);
return Mat(total, 1, type, bufdata);
}
Mat buf(total, 1, type);
cvCvtSeqToArray(seq, buf.ptr(), CV_WHOLE_SEQ);
return buf;
}
CV_Error(cv::Error::StsBadArg, "Unknown array type");
}
void extractImageCOI(const CvArr* arr, OutputArray _ch, int coi)
{
Mat mat = cvarrToMat(arr, false, true, 1);
_ch.create(mat.dims, mat.size, mat.depth());
Mat ch = _ch.getMat();
if(coi < 0)
{
CV_Assert( CV_IS_IMAGE(arr) );
coi = cvGetImageCOI((const IplImage*)arr)-1;
}
CV_Assert(0 <= coi && coi < mat.channels());
int _pairs[] = { coi, 0 };
mixChannels( &mat, 1, &ch, 1, _pairs, 1 );
}
} // cv::
// operations
CV_IMPL void cvSetIdentity( CvArr* arr, CvScalar value )
{
cv::Mat m = cv::cvarrToMat(arr);
cv::setIdentity(m, value);
}
CV_IMPL CvScalar cvTrace( const CvArr* arr )
{
return cvScalar(cv::trace(cv::cvarrToMat(arr)));
}
CV_IMPL void cvTranspose( const CvArr* srcarr, CvArr* dstarr )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
CV_Assert( src.rows == dst.cols && src.cols == dst.rows && src.type() == dst.type() );
transpose( src, dst );
}
CV_IMPL void cvCompleteSymm( CvMat* matrix, int LtoR )
{
cv::Mat m = cv::cvarrToMat(matrix);
cv::completeSymm( m, LtoR != 0 );
}
CV_IMPL void cvCrossProduct( const CvArr* srcAarr, const CvArr* srcBarr, CvArr* dstarr )
{
cv::Mat srcA = cv::cvarrToMat(srcAarr), dst = cv::cvarrToMat(dstarr);
CV_Assert( srcA.size() == dst.size() && srcA.type() == dst.type() );
srcA.cross(cv::cvarrToMat(srcBarr)).copyTo(dst);
}
CV_IMPL void
cvReduce( const CvArr* srcarr, CvArr* dstarr, int dim, int op )
{
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
if( dim < 0 )
dim = src.rows > dst.rows ? 0 : src.cols > dst.cols ? 1 : dst.cols == 1;
if( dim > 1 )
CV_Error( cv::Error::StsOutOfRange, "The reduced dimensionality index is out of range" );
if( (dim == 0 && (dst.cols != src.cols || dst.rows != 1)) ||
(dim == 1 && (dst.rows != src.rows || dst.cols != 1)) )
CV_Error( cv::Error::StsBadSize, "The output array size is incorrect" );
if( src.channels() != dst.channels() )
CV_Error( cv::Error::StsUnmatchedFormats, "Input and output arrays must have the same number of channels" );
cv::reduce(src, dst, dim, op, dst.type());
}
CV_IMPL CvArr*
cvRange( CvArr* arr, double start, double end )
{
CvMat stub, *mat = (CvMat*)arr;
int step;
double val = start;
if( !CV_IS_MAT(mat) )
mat = cvGetMat( mat, &stub);
int rows = mat->rows;
int cols = mat->cols;
int type = CV_MAT_TYPE(mat->type);
double delta = (end-start)/(rows*cols);
if( CV_IS_MAT_CONT(mat->type) )
{
cols *= rows;
rows = 1;
step = 1;
}
else
step = mat->step / CV_ELEM_SIZE(type);
if( type == CV_32SC1 )
{
int* idata = mat->data.i;
int ival = cvRound(val), idelta = cvRound(delta);
if( fabs(val - ival) < DBL_EPSILON &&
fabs(delta - idelta) < DBL_EPSILON )
{
for( int i = 0; i < rows; i++, idata += step )
for( int j = 0; j < cols; j++, ival += idelta )
idata[j] = ival;
}
else
{
for( int i = 0; i < rows; i++, idata += step )
for( int j = 0; j < cols; j++, val += delta )
idata[j] = cvRound(val);
}
}
else if( type == CV_32FC1 )
{
float* fdata = mat->data.fl;
for( int i = 0; i < rows; i++, fdata += step )
for( int j = 0; j < cols; j++, val += delta )
fdata[j] = (float)val;
}
else
CV_Error( cv::Error::StsUnsupportedFormat, "The function only supports 32sC1 and 32fC1 datatypes" );
return arr;
}
#endif // OPENCV_EXCLUDE_C_API

54
modules/core/src/matrix_expressions.cpp
View File

@ -554,7 +554,7 @@ void MatOp::matmul(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
if( isT(e1) ) if( isT(e1) )
{ {
flags = CV_GEMM_A_T; flags = cv::GEMM_1_T;
scale = e1.alpha; scale = e1.alpha;
m1 = e1.a; m1 = e1.a;
} }
@ -568,7 +568,7 @@ void MatOp::matmul(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
if( isT(e2) ) if( isT(e2) )
{ {
flags |= CV_GEMM_B_T; flags |= cv::GEMM_2_T;
scale *= e2.alpha; scale *= e2.alpha;
m2 = e2.a; m2 = e2.a;
} }
@ -946,7 +946,7 @@ MatExpr operator < (const Mat& a, const Mat& b)
{ {
checkOperandsExist(a, b); checkOperandsExist(a, b);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_LT, a, b); MatOp_Cmp::makeExpr(e, cv::CMP_LT, a, b);
return e; return e;
} }
@ -954,7 +954,7 @@ MatExpr operator < (const Mat& a, double s)
{ {
checkOperandsExist(a); checkOperandsExist(a);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_LT, a, s); MatOp_Cmp::makeExpr(e, cv::CMP_LT, a, s);
return e; return e;
} }
@ -962,7 +962,7 @@ MatExpr operator < (double s, const Mat& a)
{ {
checkOperandsExist(a); checkOperandsExist(a);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_GT, a, s); MatOp_Cmp::makeExpr(e, cv::CMP_GT, a, s);
return e; return e;
} }
@ -970,7 +970,7 @@ MatExpr operator <= (const Mat& a, const Mat& b)
{ {
checkOperandsExist(a, b); checkOperandsExist(a, b);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_LE, a, b); MatOp_Cmp::makeExpr(e, cv::CMP_LE, a, b);
return e; return e;
} }
@ -978,7 +978,7 @@ MatExpr operator <= (const Mat& a, double s)
{ {
checkOperandsExist(a); checkOperandsExist(a);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_LE, a, s); MatOp_Cmp::makeExpr(e, cv::CMP_LE, a, s);
return e; return e;
} }
@ -986,7 +986,7 @@ MatExpr operator <= (double s, const Mat& a)
{ {
checkOperandsExist(a); checkOperandsExist(a);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_GE, a, s); MatOp_Cmp::makeExpr(e, cv::CMP_GE, a, s);
return e; return e;
} }
@ -994,7 +994,7 @@ MatExpr operator == (const Mat& a, const Mat& b)
{ {
checkOperandsExist(a, b); checkOperandsExist(a, b);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_EQ, a, b); MatOp_Cmp::makeExpr(e, cv::CMP_EQ, a, b);
return e; return e;
} }
@ -1002,7 +1002,7 @@ MatExpr operator == (const Mat& a, double s)
{ {
checkOperandsExist(a); checkOperandsExist(a);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_EQ, a, s); MatOp_Cmp::makeExpr(e, cv::CMP_EQ, a, s);
return e; return e;
} }
@ -1010,7 +1010,7 @@ MatExpr operator == (double s, const Mat& a)
{ {
checkOperandsExist(a); checkOperandsExist(a);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_EQ, a, s); MatOp_Cmp::makeExpr(e, cv::CMP_EQ, a, s);
return e; return e;
} }
@ -1018,7 +1018,7 @@ MatExpr operator != (const Mat& a, const Mat& b)
{ {
checkOperandsExist(a, b); checkOperandsExist(a, b);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_NE, a, b); MatOp_Cmp::makeExpr(e, cv::CMP_NE, a, b);
return e; return e;
} }
@ -1026,7 +1026,7 @@ MatExpr operator != (const Mat& a, double s)
{ {
checkOperandsExist(a); checkOperandsExist(a);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_NE, a, s); MatOp_Cmp::makeExpr(e, cv::CMP_NE, a, s);
return e; return e;
} }
@ -1034,7 +1034,7 @@ MatExpr operator != (double s, const Mat& a)
{ {
checkOperandsExist(a); checkOperandsExist(a);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_NE, a, s); MatOp_Cmp::makeExpr(e, cv::CMP_NE, a, s);
return e; return e;
} }
@ -1042,7 +1042,7 @@ MatExpr operator >= (const Mat& a, const Mat& b)
{ {
checkOperandsExist(a, b); checkOperandsExist(a, b);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_GE, a, b); MatOp_Cmp::makeExpr(e, cv::CMP_GE, a, b);
return e; return e;
} }
@ -1050,7 +1050,7 @@ MatExpr operator >= (const Mat& a, double s)
{ {
checkOperandsExist(a); checkOperandsExist(a);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_GE, a, s); MatOp_Cmp::makeExpr(e, cv::CMP_GE, a, s);
return e; return e;
} }
@ -1058,7 +1058,7 @@ MatExpr operator >= (double s, const Mat& a)
{ {
checkOperandsExist(a); checkOperandsExist(a);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_LE, a, s); MatOp_Cmp::makeExpr(e, cv::CMP_LE, a, s);
return e; return e;
} }
@ -1066,7 +1066,7 @@ MatExpr operator > (const Mat& a, const Mat& b)
{ {
checkOperandsExist(a, b); checkOperandsExist(a, b);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_GT, a, b); MatOp_Cmp::makeExpr(e, cv::CMP_GT, a, b);
return e; return e;
} }
@ -1074,7 +1074,7 @@ MatExpr operator > (const Mat& a, double s)
{ {
checkOperandsExist(a); checkOperandsExist(a);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_GT, a, s); MatOp_Cmp::makeExpr(e, cv::CMP_GT, a, s);
return e; return e;
} }
@ -1082,7 +1082,7 @@ MatExpr operator > (double s, const Mat& a)
{ {
checkOperandsExist(a); checkOperandsExist(a);
MatExpr e; MatExpr e;
MatOp_Cmp::makeExpr(e, CV_CMP_LT, a, s); MatOp_Cmp::makeExpr(e, cv::CMP_LT, a, s);
return e; return e;
} }
@ -1574,10 +1574,10 @@ void MatOp_GEMM::add(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
double alpha1 = i1 ? 1 : e1.alpha, alpha2 = i2 ? 1 : e2.alpha; double alpha1 = i1 ? 1 : e1.alpha, alpha2 = i2 ? 1 : e2.alpha;
if( isMatProd(e1) && (i2 || isScaled(e2) || isT(e2)) ) if( isMatProd(e1) && (i2 || isScaled(e2) || isT(e2)) )
MatOp_GEMM::makeExpr(res, (e1.flags & ~CV_GEMM_C_T)|(isT(e2) ? CV_GEMM_C_T : 0), MatOp_GEMM::makeExpr(res, (e1.flags & ~cv::GEMM_3_T)|(isT(e2) ? cv::GEMM_3_T : 0),
e1.a, e1.b, alpha1, e2.a, alpha2); e1.a, e1.b, alpha1, e2.a, alpha2);
else if( isMatProd(e2) && (i1 || isScaled(e1) || isT(e1)) ) else if( isMatProd(e2) && (i1 || isScaled(e1) || isT(e1)) )
MatOp_GEMM::makeExpr(res, (e2.flags & ~CV_GEMM_C_T)|(isT(e1) ? CV_GEMM_C_T : 0), MatOp_GEMM::makeExpr(res, (e2.flags & ~cv::GEMM_3_T)|(isT(e1) ? cv::GEMM_3_T : 0),
e2.a, e2.b, alpha2, e1.a, alpha1); e2.a, e2.b, alpha2, e1.a, alpha1);
else if( this == e2.op ) else if( this == e2.op )
MatOp::add(e1, e2, res); MatOp::add(e1, e2, res);
@ -1593,10 +1593,10 @@ void MatOp_GEMM::subtract(const MatExpr& e1, const MatExpr& e2, MatExpr& res) co
double alpha1 = i1 ? 1 : e1.alpha, alpha2 = i2 ? 1 : e2.alpha; double alpha1 = i1 ? 1 : e1.alpha, alpha2 = i2 ? 1 : e2.alpha;
if( isMatProd(e1) && (i2 || isScaled(e2) || isT(e2)) ) if( isMatProd(e1) && (i2 || isScaled(e2) || isT(e2)) )
MatOp_GEMM::makeExpr(res, (e1.flags & ~CV_GEMM_C_T)|(isT(e2) ? CV_GEMM_C_T : 0), MatOp_GEMM::makeExpr(res, (e1.flags & ~cv::GEMM_3_T)|(isT(e2) ? cv::GEMM_3_T : 0),
e1.a, e1.b, alpha1, e2.a, -alpha2); e1.a, e1.b, alpha1, e2.a, -alpha2);
else if( isMatProd(e2) && (i1 || isScaled(e1) || isT(e1)) ) else if( isMatProd(e2) && (i1 || isScaled(e1) || isT(e1)) )
MatOp_GEMM::makeExpr(res, (e2.flags & ~CV_GEMM_C_T)|(isT(e1) ? CV_GEMM_C_T : 0), MatOp_GEMM::makeExpr(res, (e2.flags & ~cv::GEMM_3_T)|(isT(e1) ? cv::GEMM_3_T : 0),
e2.a, e2.b, -alpha2, e1.a, alpha1); e2.a, e2.b, -alpha2, e1.a, alpha1);
else if( this == e2.op ) else if( this == e2.op )
MatOp::subtract(e1, e2, res); MatOp::subtract(e1, e2, res);
@ -1618,9 +1618,9 @@ void MatOp_GEMM::transpose(const MatExpr& e, MatExpr& res) const
CV_INSTRUMENT_REGION(); CV_INSTRUMENT_REGION();
res = e; res = e;
res.flags = (!(e.flags & CV_GEMM_A_T) ? CV_GEMM_B_T : 0) | res.flags = (!(e.flags & cv::GEMM_1_T) ? cv::GEMM_2_T : 0) |
(!(e.flags & CV_GEMM_B_T) ? CV_GEMM_A_T : 0) | (!(e.flags & cv::GEMM_2_T) ? cv::GEMM_1_T : 0) |
(!(e.flags & CV_GEMM_C_T) ? CV_GEMM_C_T : 0); (!(e.flags & cv::GEMM_3_T) ? cv::GEMM_3_T : 0);
swap(res.a, res.b); swap(res.a, res.b);
} }

1
modules/core/src/matrix_operations.cpp
View File

@ -4,7 +4,6 @@
#include "precomp.hpp" #include "precomp.hpp"
#include "opencv2/core/mat.hpp" #include "opencv2/core/mat.hpp"
#include "opencv2/core/types_c.h"
#include "opencl_kernels_core.hpp" #include "opencl_kernels_core.hpp"
#undef HAVE_IPP #undef HAVE_IPP

39
modules/core/src/matrix_sparse.cpp
View File

@ -4,7 +4,6 @@
#include "precomp.hpp" #include "precomp.hpp"
#include "opencv2/core/mat.hpp" #include "opencv2/core/mat.hpp"
#include "opencv2/core/types_c.h"
namespace cv { namespace cv {
@ -851,41 +850,3 @@ void normalize( const SparseMat& src, SparseMat& dst, double a, int norm_type )
} }
} // cv:: } // cv::
//
// C-API glue
//
CvSparseMat* cvCreateSparseMat(const cv::SparseMat& sm)
{
if( !sm.hdr || sm.hdr->dims > (int)cv::SparseMat::MAX_DIM)
return 0;
CvSparseMat* m = cvCreateSparseMat(sm.hdr->dims, sm.hdr->size, sm.type());
cv::SparseMatConstIterator from = sm.begin();
size_t i, N = sm.nzcount(), esz = sm.elemSize();
for( i = 0; i < N; i++, ++from )
{
const cv::SparseMat::Node* n = from.node();
uchar* to = cvPtrND(m, n->idx, 0, -2, 0);
cv::copyElem(from.ptr, to, esz);
}
return m;
}
void CvSparseMat::copyToSparseMat(cv::SparseMat& m) const
{
m.create( dims, &size[0], type );
CvSparseMatIterator it;
CvSparseNode* n = cvInitSparseMatIterator(this, &it);
size_t esz = m.elemSize();
for( ; n != 0; n = cvGetNextSparseNode(&it) )
{
const int* idx = CV_NODE_IDX(this, n);
uchar* to = m.newNode(idx, m.hash(idx));
cv::copyElem((const uchar*)CV_NODE_VAL(this, n), to, esz);
}
}

6
modules/core/src/norm.cpp
View File

@ -1026,7 +1026,7 @@ static bool ipp_norm(InputArray _src1, InputArray _src2, int normType, InputArra
#if IPP_VERSION_X100 >= 700 #if IPP_VERSION_X100 >= 700
Mat src1 = _src1.getMat(), src2 = _src2.getMat(), mask = _mask.getMat(); Mat src1 = _src1.getMat(), src2 = _src2.getMat(), mask = _mask.getMat();
if( normType & CV_RELATIVE ) if( normType & NORM_RELATIVE )
{ {
normType &= NORM_TYPE_MASK; normType &= NORM_TYPE_MASK;
@ -1257,9 +1257,9 @@ double norm( InputArray _src1, InputArray _src2, int normType, InputArray _mask
CV_IPP_RUN(IPP_VERSION_X100 >= 700, ipp_norm(_src1, _src2, normType, _mask, _result), _result); CV_IPP_RUN(IPP_VERSION_X100 >= 700, ipp_norm(_src1, _src2, normType, _mask, _result), _result);
if( normType & CV_RELATIVE ) if( normType & NORM_RELATIVE )
{ {
return norm(_src1, _src2, normType & ~CV_RELATIVE, _mask)/(norm(_src2, normType, _mask) + DBL_EPSILON); return norm(_src1, _src2, normType & ~NORM_RELATIVE, _mask)/(norm(_src2, normType, _mask) + DBL_EPSILON);
} }
Mat src1 = _src1.getMat(), src2 = _src2.getMat(), mask = _mask.getMat(); Mat src1 = _src1.getMat(), src2 = _src2.getMat(), mask = _mask.getMat();

28
modules/core/src/pca.cpp
View File

@ -65,7 +65,7 @@ PCA::PCA(InputArray data, InputArray _mean, int flags, double retainedVariance)
PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, int maxComponents) PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, int maxComponents)
{ {
Mat data = _data.getMat(), _mean = __mean.getMat(); Mat data = _data.getMat(), _mean = __mean.getMat();
int covar_flags = CV_COVAR_SCALE; int covar_flags = cv::COVAR_SCALE;
int len, in_count; int len, in_count;
Size mean_sz; Size mean_sz;
@ -74,14 +74,14 @@ PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, int maxComp
{ {
len = data.rows; len = data.rows;
in_count = data.cols; in_count = data.cols;
covar_flags |= CV_COVAR_COLS; covar_flags |= cv::COVAR_COLS;
mean_sz = Size(1, len); mean_sz = Size(1, len);
} }
else else
{ {
len = data.cols; len = data.cols;
in_count = data.rows; in_count = data.rows;
covar_flags |= CV_COVAR_ROWS; covar_flags |= cv::COVAR_ROWS;
mean_sz = Size(len, 1); mean_sz = Size(len, 1);
} }
@ -92,7 +92,7 @@ PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, int maxComp
// "scrambled" way to compute PCA (when cols(A)>rows(A)): // "scrambled" way to compute PCA (when cols(A)>rows(A)):
// B = A'A; B*x=b*x; C = AA'; C*y=c*y -> AA'*y=c*y -> A'A*(A'*y)=c*(A'*y) -> c = b, x=A'*y // B = A'A; B*x=b*x; C = AA'; C*y=c*y -> AA'*y=c*y -> A'A*(A'*y)=c*(A'*y) -> c = b, x=A'*y
if( len <= in_count ) if( len <= in_count )
covar_flags |= CV_COVAR_NORMAL; covar_flags |= cv::COVAR_NORMAL;
int ctype = std::max(CV_32F, data.depth()); int ctype = std::max(CV_32F, data.depth());
mean.create( mean_sz, ctype ); mean.create( mean_sz, ctype );
@ -103,13 +103,13 @@ PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, int maxComp
{ {
CV_Assert( _mean.size() == mean_sz ); CV_Assert( _mean.size() == mean_sz );
_mean.convertTo(mean, ctype); _mean.convertTo(mean, ctype);
covar_flags |= CV_COVAR_USE_AVG; covar_flags |= cv::COVAR_USE_AVG;
} }
calcCovarMatrix( data, covar, mean, covar_flags, ctype ); calcCovarMatrix( data, covar, mean, covar_flags, ctype );
eigen( covar, eigenvalues, eigenvectors ); eigen( covar, eigenvalues, eigenvectors );
if( !(covar_flags & CV_COVAR_NORMAL) ) if( !(covar_flags & cv::COVAR_NORMAL) )
{ {
// PCA::DATA_AS_ROW: cols(A)>rows(A). x=A'*y -> x'=y'*A // PCA::DATA_AS_ROW: cols(A)>rows(A). x=A'*y -> x'=y'*A
// PCA::DATA_AS_COL: rows(A)>cols(A). x=A''*y -> x'=y'*A' // PCA::DATA_AS_COL: rows(A)>cols(A). x=A''*y -> x'=y'*A'
@ -127,7 +127,7 @@ PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, int maxComp
Mat evects1(count, len, ctype); Mat evects1(count, len, ctype);
gemm( eigenvectors, tmp_data, 1, Mat(), 0, evects1, gemm( eigenvectors, tmp_data, 1, Mat(), 0, evects1,
(flags & PCA::DATA_AS_COL) ? CV_GEMM_B_T : 0); (flags & PCA::DATA_AS_COL) ? cv::GEMM_2_T : 0);
eigenvectors = evects1; eigenvectors = evects1;
// normalize eigenvectors // normalize eigenvectors
@ -201,7 +201,7 @@ int computeCumulativeEnergy(const Mat& eigenvalues, double retainedVariance)
PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, double retainedVariance) PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, double retainedVariance)
{ {
Mat data = _data.getMat(), _mean = __mean.getMat(); Mat data = _data.getMat(), _mean = __mean.getMat();
int covar_flags = CV_COVAR_SCALE; int covar_flags = cv::COVAR_SCALE;
int len, in_count; int len, in_count;
Size mean_sz; Size mean_sz;
@ -210,14 +210,14 @@ PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, double reta
{ {
len = data.rows; len = data.rows;
in_count = data.cols; in_count = data.cols;
covar_flags |= CV_COVAR_COLS; covar_flags |= cv::COVAR_COLS;
mean_sz = Size(1, len); mean_sz = Size(1, len);
} }
else else
{ {
len = data.cols; len = data.cols;
in_count = data.rows; in_count = data.rows;
covar_flags |= CV_COVAR_ROWS; covar_flags |= cv::COVAR_ROWS;
mean_sz = Size(len, 1); mean_sz = Size(len, 1);
} }
@ -228,7 +228,7 @@ PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, double reta
// "scrambled" way to compute PCA (when cols(A)>rows(A)): // "scrambled" way to compute PCA (when cols(A)>rows(A)):
// B = A'A; B*x=b*x; C = AA'; C*y=c*y -> AA'*y=c*y -> A'A*(A'*y)=c*(A'*y) -> c = b, x=A'*y // B = A'A; B*x=b*x; C = AA'; C*y=c*y -> AA'*y=c*y -> A'A*(A'*y)=c*(A'*y) -> c = b, x=A'*y
if( len <= in_count ) if( len <= in_count )
covar_flags |= CV_COVAR_NORMAL; covar_flags |= cv::COVAR_NORMAL;
int ctype = std::max(CV_32F, data.depth()); int ctype = std::max(CV_32F, data.depth());
mean.create( mean_sz, ctype ); mean.create( mean_sz, ctype );
@ -239,13 +239,13 @@ PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, double reta
{ {
CV_Assert( _mean.size() == mean_sz ); CV_Assert( _mean.size() == mean_sz );
_mean.convertTo(mean, ctype); _mean.convertTo(mean, ctype);
covar_flags |= CV_COVAR_USE_AVG; covar_flags |= cv::COVAR_USE_AVG;
} }
calcCovarMatrix( data, covar, mean, covar_flags, ctype ); calcCovarMatrix( data, covar, mean, covar_flags, ctype );
eigen( covar, eigenvalues, eigenvectors ); eigen( covar, eigenvalues, eigenvectors );
if( !(covar_flags & CV_COVAR_NORMAL) ) if( !(covar_flags & cv::COVAR_NORMAL) )
{ {
// PCA::DATA_AS_ROW: cols(A)>rows(A). x=A'*y -> x'=y'*A // PCA::DATA_AS_ROW: cols(A)>rows(A). x=A'*y -> x'=y'*A
// PCA::DATA_AS_COL: rows(A)>cols(A). x=A''*y -> x'=y'*A' // PCA::DATA_AS_COL: rows(A)>cols(A). x=A''*y -> x'=y'*A'
@ -263,7 +263,7 @@ PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, double reta
Mat evects1(count, len, ctype); Mat evects1(count, len, ctype);
gemm( eigenvectors, tmp_data, 1, Mat(), 0, evects1, gemm( eigenvectors, tmp_data, 1, Mat(), 0, evects1,
(flags & PCA::DATA_AS_COL) ? CV_GEMM_B_T : 0); (flags & PCA::DATA_AS_COL) ? cv::GEMM_2_T : 0);
eigenvectors = evects1; eigenvectors = evects1;
// normalize all eigenvectors // normalize all eigenvectors

2
modules/core/src/persistence.cpp
View File

@ -11,6 +11,8 @@
#include <opencv2/core/utils/logger.hpp> #include <opencv2/core/utils/logger.hpp>
#define CV_SEQ_ELTYPE_PTR CV_MAKE_TYPE(CV_8U, 8 /*sizeof(void*)*/)
namespace cv namespace cv
{ {

1
modules/core/src/persistence.hpp
View File

@ -6,7 +6,6 @@
#ifndef SRC_PERSISTENCE_HPP #ifndef SRC_PERSISTENCE_HPP
#define SRC_PERSISTENCE_HPP #define SRC_PERSISTENCE_HPP
#include "opencv2/core/types_c.h"
#include <deque> #include <deque>
#include <sstream> #include <sstream>
#include <string> #include <string>

1
modules/core/src/precomp.hpp
View File

@ -56,7 +56,6 @@
#include "cvconfig.h" #include "cvconfig.h"
#include "opencv2/core/utility.hpp" #include "opencv2/core/utility.hpp"
#include "opencv2/core/core_c.h"
#include "opencv2/core/cuda.hpp" #include "opencv2/core/cuda.hpp"
#include "opencv2/core/opengl.hpp" #include "opencv2/core/opengl.hpp"
#include "opencv2/core/va_intel.hpp" #include "opencv2/core/va_intel.hpp"

2
modules/core/src/rand.cpp
View File

@ -47,6 +47,8 @@ namespace cv
///////////////////////////// Functions Declaration ////////////////////////////////////// ///////////////////////////// Functions Declaration //////////////////////////////////////
#define CV_RNG_COEFF 4164903690U
/* /*
Multiply-with-carry generator is used here: Multiply-with-carry generator is used here:
temp = ( A*X(n) + carry ) temp = ( A*X(n) + carry )

123
modules/core/src/stat_c.cpp
View File

@ -1,123 +0,0 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html
#include "precomp.hpp"
#ifndef OPENCV_EXCLUDE_C_API
CV_IMPL CvScalar cvSum( const CvArr* srcarr )
{
cv::Scalar sum = cv::sum(cv::cvarrToMat(srcarr, false, true, 1));
if( CV_IS_IMAGE(srcarr) )
{
int coi = cvGetImageCOI((IplImage*)srcarr);
if( coi )
{
CV_Assert( 0 < coi && coi <= 4 );
sum = cv::Scalar(sum[coi-1]);
}
}
return cvScalar(sum);
}
CV_IMPL int cvCountNonZero( const CvArr* imgarr )
{
cv::Mat img = cv::cvarrToMat(imgarr, false, true, 1);
if( img.channels() > 1 )
cv::extractImageCOI(imgarr, img);
return countNonZero(img);
}
CV_IMPL CvScalar
cvAvg( const void* imgarr, const void* maskarr )
{
cv::Mat img = cv::cvarrToMat(imgarr, false, true, 1);
cv::Scalar mean = !maskarr ? cv::mean(img) : cv::mean(img, cv::cvarrToMat(maskarr));
if( CV_IS_IMAGE(imgarr) )
{
int coi = cvGetImageCOI((IplImage*)imgarr);
if( coi )
{
CV_Assert( 0 < coi && coi <= 4 );
mean = cv::Scalar(mean[coi-1]);
}
}
return cvScalar(mean);
}
CV_IMPL void
cvAvgSdv( const CvArr* imgarr, CvScalar* _mean, CvScalar* _sdv, const void* maskarr )
{
cv::Scalar mean, sdv;
cv::Mat mask;
if( maskarr )
mask = cv::cvarrToMat(maskarr);
cv::meanStdDev(cv::cvarrToMat(imgarr, false, true, 1), mean, sdv, mask );
if( CV_IS_IMAGE(imgarr) )
{
int coi = cvGetImageCOI((IplImage*)imgarr);
if( coi )
{
CV_Assert( 0 < coi && coi <= 4 );
mean = cv::Scalar(mean[coi-1]);
sdv = cv::Scalar(sdv[coi-1]);
}
}
if( _mean )
*(cv::Scalar*)_mean = mean;
if( _sdv )
*(cv::Scalar*)_sdv = sdv;
}
CV_IMPL void
cvMinMaxLoc( const void* imgarr, double* _minVal, double* _maxVal,
CvPoint* _minLoc, CvPoint* _maxLoc, const void* maskarr )
{
cv::Mat mask, img = cv::cvarrToMat(imgarr, false, true, 1);
if( maskarr )
mask = cv::cvarrToMat(maskarr);
if( img.channels() > 1 )
cv::extractImageCOI(imgarr, img);
cv::minMaxLoc( img, _minVal, _maxVal,
(cv::Point*)_minLoc, (cv::Point*)_maxLoc, mask );
}
CV_IMPL double
cvNorm( const void* imgA, const void* imgB, int normType, const void* maskarr )
{
cv::Mat a, mask;
if( !imgA )
{
imgA = imgB;
imgB = 0;
}
a = cv::cvarrToMat(imgA, false, true, 1);
if( maskarr )
mask = cv::cvarrToMat(maskarr);
if( a.channels() > 1 && CV_IS_IMAGE(imgA) && cvGetImageCOI((const IplImage*)imgA) > 0 )
cv::extractImageCOI(imgA, a);
if( !imgB )
return !maskarr ? cv::norm(a, normType) : cv::norm(a, normType, mask);
cv::Mat b = cv::cvarrToMat(imgB, false, true, 1);
if( b.channels() > 1 && CV_IS_IMAGE(imgB) && cvGetImageCOI((const IplImage*)imgB) > 0 )
cv::extractImageCOI(imgB, b);
return !maskarr ? cv::norm(a, b, normType) : cv::norm(a, b, normType, mask);
}
#endif // OPENCV_EXCLUDE_C_API

52
modules/core/src/system.cpp
View File

@ -42,6 +42,7 @@
//M*/ //M*/
#include "precomp.hpp" #include "precomp.hpp"
//#include "opencv2/core/core_c.h"
#include <atomic> #include <atomic>
#include <iostream> #include <iostream>
#include <ostream> #include <ostream>
@ -1380,57 +1381,6 @@ void terminate(Error::Code _code, const String& _err, const char* _func, const c
} }
CV_IMPL int cvGetErrMode(void)
{
return 0;
}
CV_IMPL int cvSetErrMode(int)
{
return 0;
}
CV_IMPL int cvGetErrStatus(void)
{
return 0;
}
CV_IMPL void cvSetErrStatus(int)
{
}
/* function, which converts int to int */
CV_IMPL int
cvErrorFromIppStatus( int status )
{
switch (status)
{
case CV_BADSIZE_ERR: return cv::Error::StsBadSize;
case CV_BADMEMBLOCK_ERR: return cv::Error::StsBadMemBlock;
case CV_NULLPTR_ERR: return cv::Error::StsNullPtr;
case CV_DIV_BY_ZERO_ERR: return cv::Error::StsDivByZero;
case CV_BADSTEP_ERR: return cv::Error::BadStep;
case CV_OUTOFMEM_ERR: return cv::Error::StsNoMem;
case CV_BADARG_ERR: return cv::Error::StsBadArg;
case CV_NOTDEFINED_ERR: return cv::Error::StsError;
case CV_INPLACE_NOT_SUPPORTED_ERR: return cv::Error::StsInplaceNotSupported;
case CV_NOTFOUND_ERR: return cv::Error::StsObjectNotFound;
case CV_BADCONVERGENCE_ERR: return cv::Error::StsNoConv;
case CV_BADDEPTH_ERR: return cv::Error::BadDepth;
case CV_UNMATCHED_FORMATS_ERR: return cv::Error::StsUnmatchedFormats;
case CV_UNSUPPORTED_COI_ERR: return cv::Error::BadCOI;
case CV_UNSUPPORTED_CHANNELS_ERR: return cv::Error::BadNumChannels;
case CV_BADFLAG_ERR: return cv::Error::StsBadFlag;
case CV_BADRANGE_ERR: return cv::Error::StsBadArg;
case CV_BADCOEF_ERR: return cv::Error::StsBadArg;
case CV_BADFACTOR_ERR: return cv::Error::StsBadArg;
case CV_BADPOINT_ERR: return cv::Error::StsBadPoint;
default:
return cv::Error::StsError;
}
}
namespace cv { namespace cv {
bool __termination = false; bool __termination = false;