generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Warning fixes continued

Browse Source
This commit is contained in:
Andrey Kamaev 2012-06-09 15:00:04 +00:00
parent f6b451c607
commit f2d3b9b4a1
127 changed files with 6298 additions and 6277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmake/OpenCVCompilerOptions.cmake
View File

@ -75,7 +75,7 @@ if(CMAKE_COMPILER_IS_GNUCXX)
#add_extra_compiler_option(-Wcast-align) #add_extra_compiler_option(-Wcast-align)
#add_extra_compiler_option(-Wstrict-aliasing=2) #add_extra_compiler_option(-Wstrict-aliasing=2)
#add_extra_compiler_option(-Wshadow) #add_extra_compiler_option(-Wshadow)
add_extra_compiler_option(-Wno-unnamed-type-template-args) #add_extra_compiler_option(-Wno-unnamed-type-template-args)
# The -Wno-long-long is required in 64bit systems when including sytem headers. # The -Wno-long-long is required in 64bit systems when including sytem headers.
if(X86_64) if(X86_64)

4
cmake/OpenCVDetectTBB.cmake
View File

@ -10,7 +10,7 @@ elseif(UNIX AND NOT APPLE)
if(TBB_FOUND) if(TBB_FOUND)
set(HAVE_TBB 1) set(HAVE_TBB 1)
if(NOT ${TBB_INCLUDE_DIRS} STREQUAL "") if(NOT ${TBB_INCLUDE_DIRS} STREQUAL "")
include_directories(SYSTEM ${TBB_INCLUDE_DIRS}) ocv_include_directories(${TBB_INCLUDE_DIRS})
endif() endif()
link_directories(${TBB_LIBRARY_DIRS}) link_directories(${TBB_LIBRARY_DIRS})
set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${TBB_LIBRARIES}) set(OPENCV_LINKER_LIBS ${OPENCV_LINKER_LIBS} ${TBB_LIBRARIES})
@ -63,7 +63,7 @@ if(NOT HAVE_TBB)
set(HAVE_TBB 1) set(HAVE_TBB 1)
if(NOT "${TBB_INCLUDE_DIRS}" STREQUAL "") if(NOT "${TBB_INCLUDE_DIRS}" STREQUAL "")
include_directories(SYSTEM "${TBB_INCLUDE_DIRS}") ocv_include_directories("${TBB_INCLUDE_DIRS}")
endif() endif()
endif(TBB_INCLUDE_DIRS) endif(TBB_INCLUDE_DIRS)
endif(NOT HAVE_TBB) endif(NOT HAVE_TBB)

2
cmake/OpenCVUtils.cmake
View File

@ -19,7 +19,7 @@ function(ocv_include_directories)
if("${__abs_dir}" MATCHES "^${OpenCV_SOURCE_DIR}" OR "${__abs_dir}" MATCHES "^${OpenCV_BINARY_DIR}") if("${__abs_dir}" MATCHES "^${OpenCV_SOURCE_DIR}" OR "${__abs_dir}" MATCHES "^${OpenCV_BINARY_DIR}")
list(APPEND __add_before "${dir}") list(APPEND __add_before "${dir}")
else() else()
include_directories(AFTER "${dir}") include_directories(AFTER SYSTEM "${dir}")
endif() endif()
endforeach() endforeach()
include_directories(BEFORE ${__add_before}) include_directories(BEFORE ${__add_before})

21
modules/calib3d/src/calibinit.cpp
View File

@ -255,7 +255,7 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
IplImage _img; IplImage _img;
int check_chessboard_result; int check_chessboard_result;
int quad_count = 0, group_idx = 0, i = 0, dilations = 0; int quad_count = 0, group_idx = 0, dilations = 0;
img = cvGetMat( img, &stub ); img = cvGetMat( img, &stub );
//debug_img = img; //debug_img = img;
@ -378,7 +378,7 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
cvCopy(dbg_img, dbg1_img); cvCopy(dbg_img, dbg1_img);
cvNamedWindow("all_quads", 1); cvNamedWindow("all_quads", 1);
// copy corners to temp array // copy corners to temp array
for( i = 0; i < quad_count; i++ ) for(int i = 0; i < quad_count; i++ )
{ {
for (int k=0; k<4; k++) for (int k=0; k<4; k++)
{ {
@ -432,7 +432,7 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
cvCopy(dbg_img,dbg2_img); cvCopy(dbg_img,dbg2_img);
cvNamedWindow("connected_group", 1); cvNamedWindow("connected_group", 1);
// copy corners to temp array // copy corners to temp array
for( i = 0; i < quad_count; i++ ) for(int i = 0; i < quad_count; i++ )
{ {
if (quads[i].group_idx == group_idx) if (quads[i].group_idx == group_idx)
for (int k=0; k<4; k++) for (int k=0; k<4; k++)
@ -472,7 +472,7 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
float sum_dist = 0; float sum_dist = 0;
int total = 0; int total = 0;
for( i = 0; i < n; i++ ) for(int i = 0; i < n; i++ )
{ {
int ni = 0; int ni = 0;
float avgi = corner_group[i]->meanDist(&ni); float avgi = corner_group[i]->meanDist(&ni);
@ -484,7 +484,7 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
if( count > 0 || (out_corner_count && -count > *out_corner_count) ) if( count > 0 || (out_corner_count && -count > *out_corner_count) )
{ {
// copy corners to output array // copy corners to output array
for( i = 0; i < n; i++ ) for(int i = 0; i < n; i++ )
out_corners[i] = corner_group[i]->pt; out_corners[i] = corner_group[i]->pt;
if( out_corner_count ) if( out_corner_count )
@ -525,8 +525,8 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
double dy0 = out_corners[last_row].y - out_corners[0].y; double dy0 = out_corners[last_row].y - out_corners[0].y;
if( dy0 < 0 ) if( dy0 < 0 )
{ {
int i, n = pattern_size.width*pattern_size.height; int n = pattern_size.width*pattern_size.height;
for( i = 0; i < n/2; i++ ) for(int i = 0; i < n/2; i++ )
{ {
CvPoint2D32f temp; CvPoint2D32f temp;
CV_SWAP(out_corners[i], out_corners[n-i-1], temp); CV_SWAP(out_corners[i], out_corners[n-i-1], temp);
@ -627,11 +627,10 @@ icvOrderFoundConnectedQuads( int quad_count, CvCBQuad **quads,
{ {
cv::Ptr<CvMemStorage> temp_storage = cvCreateChildMemStorage( storage ); cv::Ptr<CvMemStorage> temp_storage = cvCreateChildMemStorage( storage );
CvSeq* stack = cvCreateSeq( 0, sizeof(*stack), sizeof(void*), temp_storage ); CvSeq* stack = cvCreateSeq( 0, sizeof(*stack), sizeof(void*), temp_storage );
int i;
// first find an interior quad // first find an interior quad
CvCBQuad *start = NULL; CvCBQuad *start = NULL;
for (i=0; i<quad_count; i++) for (int i=0; i<quad_count; i++)
{ {
if (quads[i]->count == 4) if (quads[i]->count == 4)
{ {
@ -700,7 +699,7 @@ icvOrderFoundConnectedQuads( int quad_count, CvCBQuad **quads,
} }
} }
for (i=col_min; i<=col_max; i++) for (int i=col_min; i<=col_max; i++)
PRINTF("HIST[%d] = %d\n", i, col_hist[i]); PRINTF("HIST[%d] = %d\n", i, col_hist[i]);
// analyze inner quad structure // analyze inner quad structure
@ -763,7 +762,7 @@ icvOrderFoundConnectedQuads( int quad_count, CvCBQuad **quads,
// if there is an outer quad missing, fill it in // if there is an outer quad missing, fill it in
// first order all inner quads // first order all inner quads
int found = 0; int found = 0;
for (i=0; i<quad_count; i++) for (int i=0; i<quad_count; i++)
{ {
if (quads[i]->count == 4) if (quads[i]->count == 4)
{ // ok, look at neighbors { // ok, look at neighbors

2
modules/calib3d/src/calibration.cpp
View File

@ -1153,7 +1153,7 @@ CV_IMPL void cvFindExtrinsicCameraParams2( const CvMat* objectPoints,
int useExtrinsicGuess ) int useExtrinsicGuess )
{ {
const int max_iter = 20; const int max_iter = 20;
Ptr<CvMat> matM, _Mxy, _m, _mn, matL, matJ; Ptr<CvMat> matM, _Mxy, _m, _mn, matL;
int i, count; int i, count;
double a[9], ar[9]={1,0,0,0,1,0,0,0,1}, R[9]; double a[9], ar[9]={1,0,0,0,1,0,0,0,1}, R[9];

12
modules/calib3d/src/circlesgrid.cpp
View File

@ -65,14 +65,14 @@ void drawPoints(const vector<Point2f> &points, Mat &outImage, int radius = 2, S
} }
#endif #endif
void CirclesGridClusterFinder::hierarchicalClustering(const vector<Point2f> points, const Size &patternSize, vector<Point2f> &patternPoints) void CirclesGridClusterFinder::hierarchicalClustering(const vector<Point2f> points, const Size &patternSz, vector<Point2f> &patternPoints)
{ {
#ifdef HAVE_TEGRA_OPTIMIZATION #ifdef HAVE_TEGRA_OPTIMIZATION
if(tegra::hierarchicalClustering(points, patternSize, patternPoints)) if(tegra::hierarchicalClustering(points, patternSz, patternPoints))
return; return;
#endif #endif
int i, j, n = (int)points.size(); int j, n = (int)points.size();
size_t pn = static_cast<size_t>(patternSize.area()); size_t pn = static_cast<size_t>(patternSz.area());
patternPoints.clear(); patternPoints.clear();
if (pn >= points.size()) if (pn >= points.size())
@ -84,7 +84,7 @@ void CirclesGridClusterFinder::hierarchicalClustering(const vector<Point2f> poin
Mat dists(n, n, CV_32FC1, Scalar(0)); Mat dists(n, n, CV_32FC1, Scalar(0));
Mat distsMask(dists.size(), CV_8UC1, Scalar(0)); Mat distsMask(dists.size(), CV_8UC1, Scalar(0));
for(i = 0; i < n; i++) for(int i = 0; i < n; i++)
{ {
for(j = i+1; j < n; j++) for(j = i+1; j < n; j++)
{ {
@ -122,7 +122,7 @@ void CirclesGridClusterFinder::hierarchicalClustering(const vector<Point2f> poin
} }
//the largest cluster can have more than pn points -- we need to filter out such situations //the largest cluster can have more than pn points -- we need to filter out such situations
if(clusters[patternClusterIdx].size() != static_cast<size_t>(patternSize.area())) if(clusters[patternClusterIdx].size() != static_cast<size_t>(patternSz.area()))
{ {
return; return;
} }

68
modules/calib3d/src/epnp.cpp
View File

@ -500,8 +500,7 @@ void epnp::compute_A_and_b_gauss_newton(const double * l_6x10, const double * rh
} }
} }
void epnp::gauss_newton(const CvMat * L_6x10, const CvMat * Rho, void epnp::gauss_newton(const CvMat * L_6x10, const CvMat * Rho, double betas[4])
double betas[4])
{ {
const int iterations_number = 5; const int iterations_number = 5;
@ -510,7 +509,8 @@ void epnp::gauss_newton(const CvMat * L_6x10, const CvMat * Rho,
CvMat B = cvMat(6, 1, CV_64F, b); CvMat B = cvMat(6, 1, CV_64F, b);
CvMat X = cvMat(4, 1, CV_64F, x); CvMat X = cvMat(4, 1, CV_64F, x);
for(int k = 0; k < iterations_number; k++) { for(int k = 0; k < iterations_number; k++)
{
compute_A_and_b_gauss_newton(L_6x10->data.db, Rho->data.db, compute_A_and_b_gauss_newton(L_6x10->data.db, Rho->data.db,
betas, &A, &B); betas, &A, &B);
qr_solve(&A, &B, &X); qr_solve(&A, &B, &X);
@ -524,50 +524,61 @@ void epnp::qr_solve(CvMat * A, CvMat * b, CvMat * X)
const int nr = A->rows; const int nr = A->rows;
const int nc = A->cols; const int nc = A->cols;
if (max_nr != 0 && max_nr < nr) { if (max_nr != 0 && max_nr < nr)
{
delete [] A1; delete [] A1;
delete [] A2; delete [] A2;
} }
if (max_nr < nr) { if (max_nr < nr)
{
max_nr = nr; max_nr = nr;
A1 = new double[nr]; A1 = new double[nr];
A2 = new double[nr]; A2 = new double[nr];
} }
double * pA = A->data.db, * ppAkk = pA; double * pA = A->data.db, * ppAkk = pA;
for(int k = 0; k < nc; k++) { for(int k = 0; k < nc; k++)
double * ppAik = ppAkk, eta = fabs(*ppAik); {
for(int i = k + 1; i < nr; i++) { double * ppAik1 = ppAkk, eta = fabs(*ppAik1);
double elt = fabs(*ppAik); for(int i = k + 1; i < nr; i++)
{
double elt = fabs(*ppAik1);
if (eta < elt) eta = elt; if (eta < elt) eta = elt;
ppAik += nc; ppAik1 += nc;
} }
if (eta == 0) { if (eta == 0)
{
A1[k] = A2[k] = 0.0; A1[k] = A2[k] = 0.0;
//cerr << "God damnit, A is singular, this shouldn't happen." << endl; //cerr << "God damnit, A is singular, this shouldn't happen." << endl;
return; return;
} else {
double * ppAik = ppAkk, sum = 0.0, inv_eta = 1. / eta;
for(int i = k; i < nr; i++) {
*ppAik *= inv_eta;
sum += *ppAik * *ppAik;
ppAik += nc;
} }
double sigma = sqrt(sum); else
{
double * ppAik2 = ppAkk, sum2 = 0.0, inv_eta = 1. / eta;
for(int i = k; i < nr; i++)
{
*ppAik2 *= inv_eta;
sum2 += *ppAik2 * *ppAik2;
ppAik2 += nc;
}
double sigma = sqrt(sum2);
if (*ppAkk < 0) if (*ppAkk < 0)
sigma = -sigma; sigma = -sigma;
*ppAkk += sigma; *ppAkk += sigma;
A1[k] = sigma * *ppAkk; A1[k] = sigma * *ppAkk;
A2[k] = -eta * sigma; A2[k] = -eta * sigma;
for(int j = k + 1; j < nc; j++) { for(int j = k + 1; j < nc; j++)
{
double * ppAik = ppAkk, sum = 0; double * ppAik = ppAkk, sum = 0;
for(int i = k; i < nr; i++) { for(int i = k; i < nr; i++)
{
sum += *ppAik * ppAik[j - k]; sum += *ppAik * ppAik[j - k];
ppAik += nc; ppAik += nc;
} }
double tau = sum / A1[k]; double tau = sum / A1[k];
ppAik = ppAkk; ppAik = ppAkk;
for(int i = k; i < nr; i++) { for(int i = k; i < nr; i++)
{
ppAik[j - k] -= tau * *ppAik; ppAik[j - k] -= tau * *ppAik;
ppAik += nc; ppAik += nc;
} }
@ -578,15 +589,18 @@ void epnp::qr_solve(CvMat * A, CvMat * b, CvMat * X)
// b <- Qt b // b <- Qt b
double * ppAjj = pA, * pb = b->data.db; double * ppAjj = pA, * pb = b->data.db;
for(int j = 0; j < nc; j++) { for(int j = 0; j < nc; j++)
{
double * ppAij = ppAjj, tau = 0; double * ppAij = ppAjj, tau = 0;
for(int i = j; i < nr; i++) { for(int i = j; i < nr; i++)
{
tau += *ppAij * pb[i]; tau += *ppAij * pb[i];
ppAij += nc; ppAij += nc;
} }
tau /= A1[j]; tau /= A1[j];
ppAij = ppAjj; ppAij = ppAjj;
for(int i = j; i < nr; i++) { for(int i = j; i < nr; i++)
{
pb[i] -= tau * *ppAij; pb[i] -= tau * *ppAij;
ppAij += nc; ppAij += nc;
} }
@ -596,10 +610,12 @@ void epnp::qr_solve(CvMat * A, CvMat * b, CvMat * X)
// X = R-1 b // X = R-1 b
double * pX = X->data.db; double * pX = X->data.db;
pX[nc - 1] = pb[nc - 1] / A2[nc - 1]; pX[nc - 1] = pb[nc - 1] / A2[nc - 1];
for(int i = nc - 2; i >= 0; i--) { for(int i = nc - 2; i >= 0; i--)
{
double * ppAij = pA + i * nc + (i + 1), sum = 0; double * ppAij = pA + i * nc + (i + 1), sum = 0;
for(int j = i + 1; j < nc; j++) { for(int j = i + 1; j < nc; j++)
{
sum += *ppAij * pX[j]; sum += *ppAij * pX[j];
ppAij++; ppAij++;
} }

18
modules/calib3d/src/p3p.cpp
View File

@ -362,20 +362,20 @@ bool p3p::jacobi_4x4(double * A, double * D, double * U)
if ( iter > 3 && fabs(D[i]) + eps_machine == fabs(D[i]) && fabs(D[j]) + eps_machine == fabs(D[j]) ) if ( iter > 3 && fabs(D[i]) + eps_machine == fabs(D[i]) && fabs(D[j]) + eps_machine == fabs(D[j]) )
*pAij = 0.0; *pAij = 0.0;
else if (fabs(Aij) > tresh) { else if (fabs(Aij) > tresh) {
double h = D[j] - D[i], t; double hh = D[j] - D[i], t;
if (fabs(h) + eps_machine == fabs(h)) if (fabs(hh) + eps_machine == fabs(hh))
t = Aij / h; t = Aij / hh;
else { else {
double theta = 0.5 * h / Aij; double theta = 0.5 * hh / Aij;
t = 1.0 / (fabs(theta) + sqrt(1.0 + theta * theta)); t = 1.0 / (fabs(theta) + sqrt(1.0 + theta * theta));
if (theta < 0.0) t = -t; if (theta < 0.0) t = -t;
} }
h = t * Aij; hh = t * Aij;
Z[i] -= h; Z[i] -= hh;
Z[j] += h; Z[j] += hh;
D[i] -= h; D[i] -= hh;
D[j] += h; D[j] += hh;
*pAij = 0.0; *pAij = 0.0;
double c = 1.0 / sqrt(1 + t * t); double c = 1.0 / sqrt(1 + t * t);

8
modules/calib3d/src/solvepnp.cpp
View File

@ -253,10 +253,10 @@ namespace cv
} }
} }
} }
PnPSolver(const Mat& objectPoints, const Mat& imagePoints, const Parameters& parameters, PnPSolver(const Mat& _objectPoints, const Mat& _imagePoints, const Parameters& _parameters,
Mat& rvec, Mat& tvec, vector<int>& inliers): Mat& _rvec, Mat& _tvec, vector<int>& _inliers):
objectPoints(objectPoints), imagePoints(imagePoints), parameters(parameters), objectPoints(_objectPoints), imagePoints(_imagePoints), parameters(_parameters),
rvec(rvec), tvec(tvec), inliers(inliers) rvec(_rvec), tvec(_tvec), inliers(_inliers)
{ {
rvec.copyTo(initRvec); rvec.copyTo(initRvec);
tvec.copyTo(initTvec); tvec.copyTo(initTvec);

13
modules/calib3d/src/stereobm.cpp
View File

@ -336,7 +336,7 @@ static void findStereoCorrespondenceBM_SSE2( const Mat& left, const Mat& right,
short* costptr = cost.data ? (short*)cost.data + lofs + x : &costbuf; short* costptr = cost.data ? (short*)cost.data + lofs + x : &costbuf;
int x0 = x - wsz2 - 1, x1 = x + wsz2; int x0 = x - wsz2 - 1, x1 = x + wsz2;
const uchar* cbuf_sub = cbuf0 + ((x0 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp; const uchar* cbuf_sub = cbuf0 + ((x0 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp;
uchar* cbuf = cbuf0 + ((x1 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp; cbuf = cbuf0 + ((x1 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp;
hsad = hsad0 - dy0*ndisp; hsad = hsad0 - dy0*ndisp;
lptr_sub = lptr0 + MIN(MAX(x0, -lofs), width-1-lofs) - dy0*sstep; lptr_sub = lptr0 + MIN(MAX(x0, -lofs), width-1-lofs) - dy0*sstep;
lptr = lptr0 + MIN(MAX(x1, -lofs), width-1-lofs) - dy0*sstep; lptr = lptr0 + MIN(MAX(x1, -lofs), width-1-lofs) - dy0*sstep;
@ -463,7 +463,8 @@ static void findStereoCorrespondenceBM_SSE2( const Mat& left, const Mat& right,
int thresh = minsad + ((minsad * uniquenessRatio) >> 8); int thresh = minsad + ((minsad * uniquenessRatio) >> 8);
__m128i thresh8 = _mm_set1_epi16((short)(thresh + 1)); __m128i thresh8 = _mm_set1_epi16((short)(thresh + 1));
__m128i d1 = _mm_set1_epi16((short)(mind-1)), d2 = _mm_set1_epi16((short)(mind+1)); __m128i d1 = _mm_set1_epi16((short)(mind-1)), d2 = _mm_set1_epi16((short)(mind+1));
__m128i dd_16 = _mm_add_epi16(dd_8, dd_8), d8 = _mm_sub_epi16(d0_8, dd_16); __m128i dd_16 = _mm_add_epi16(dd_8, dd_8);
d8 = _mm_sub_epi16(d0_8, dd_16);
for( d = 0; d < ndisp; d += 16 ) for( d = 0; d < ndisp; d += 16 )
{ {
@ -492,7 +493,8 @@ static void findStereoCorrespondenceBM_SSE2( const Mat& left, const Mat& right,
if( 0 < mind && mind < ndisp - 1 ) if( 0 < mind && mind < ndisp - 1 )
{ {
int p = sad[mind+1], n = sad[mind-1], d = p + n - 2*sad[mind] + std::abs(p - n); int p = sad[mind+1], n = sad[mind-1];
d = p + n - 2*sad[mind] + std::abs(p - n);
dptr[y*dstep] = (short)(((ndisp - mind - 1 + mindisp)*256 + (d != 0 ? (p-n)*256/d : 0) + 15) >> 4); dptr[y*dstep] = (short)(((ndisp - mind - 1 + mindisp)*256 + (d != 0 ? (p-n)*256/d : 0) + 15) >> 4);
} }
else else
@ -583,7 +585,7 @@ findStereoCorrespondenceBM( const Mat& left, const Mat& right,
int* costptr = cost.data ? (int*)cost.data + lofs + x : &costbuf; int* costptr = cost.data ? (int*)cost.data + lofs + x : &costbuf;
int x0 = x - wsz2 - 1, x1 = x + wsz2; int x0 = x - wsz2 - 1, x1 = x + wsz2;
const uchar* cbuf_sub = cbuf0 + ((x0 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp; const uchar* cbuf_sub = cbuf0 + ((x0 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp;
uchar* cbuf = cbuf0 + ((x1 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp; cbuf = cbuf0 + ((x1 + wsz2 + 1) % (wsz + 1))*cstep - dy0*ndisp;
hsad = hsad0 - dy0*ndisp; hsad = hsad0 - dy0*ndisp;
lptr_sub = lptr0 + MIN(MAX(x0, -lofs), width-1-lofs) - dy0*sstep; lptr_sub = lptr0 + MIN(MAX(x0, -lofs), width-1-lofs) - dy0*sstep;
lptr = lptr0 + MIN(MAX(x1, -lofs), width-1-lofs) - dy0*sstep; lptr = lptr0 + MIN(MAX(x1, -lofs), width-1-lofs) - dy0*sstep;
@ -662,7 +664,8 @@ findStereoCorrespondenceBM( const Mat& left, const Mat& right,
{ {
sad[-1] = sad[1]; sad[-1] = sad[1];
sad[ndisp] = sad[ndisp-2]; sad[ndisp] = sad[ndisp-2];
int p = sad[mind+1], n = sad[mind-1], d = p + n - 2*sad[mind] + std::abs(p - n); int p = sad[mind+1], n = sad[mind-1];
d = p + n - 2*sad[mind] + std::abs(p - n);
dptr[y*dstep] = (short)(((ndisp - mind - 1 + mindisp)*256 + (d != 0 ? (p-n)*256/d : 0) + 15) >> 4); dptr[y*dstep] = (short)(((ndisp - mind - 1 + mindisp)*256 + (d != 0 ? (p-n)*256/d : 0) + 15) >> 4);
costptr[y*coststep] = sad[mind]; costptr[y*coststep] = sad[mind];
} }

16
modules/calib3d/src/stereosgbm.cpp
View File

@ -773,11 +773,11 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
if( d < D ) if( d < D )
continue; continue;
d = bestDisp; d = bestDisp;
int x2 = x + minX1 - d - minD; int _x2 = x + minX1 - d - minD;
if( disp2cost[x2] > minS ) if( disp2cost[_x2] > minS )
{ {
disp2cost[x2] = (CostType)minS; disp2cost[_x2] = (CostType)minS;
disp2ptr[x2] = (DispType)(d + minD); disp2ptr[_x2] = (DispType)(d + minD);
} }
if( 0 < d && d < D-1 ) if( 0 < d && d < D-1 )
@ -798,11 +798,11 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
// we round the computed disparity both towards -inf and +inf and check // we round the computed disparity both towards -inf and +inf and check
// if either of the corresponding disparities in disp2 is consistent. // if either of the corresponding disparities in disp2 is consistent.
// This is to give the computed disparity a chance to look valid if it is. // This is to give the computed disparity a chance to look valid if it is.
int d = disp1ptr[x]; int d1 = disp1ptr[x];
if( d == INVALID_DISP_SCALED ) if( d1 == INVALID_DISP_SCALED )
continue; continue;
int _d = d >> DISP_SHIFT; int _d = d1 >> DISP_SHIFT;
int d_ = (d + DISP_SCALE-1) >> DISP_SHIFT; int d_ = (d1 + DISP_SCALE-1) >> DISP_SHIFT;
int _x = x - _d, x_ = x - d_; int _x = x - _d, x_ = x - d_;
if( 0 <= _x && _x < width && disp2ptr[_x] >= minD && std::abs(disp2ptr[_x] - _d) > disp12MaxDiff && if( 0 <= _x && _x < width && disp2ptr[_x] >= minD && std::abs(disp2ptr[_x] - _d) > disp12MaxDiff &&
0 <= x_ && x_ < width && disp2ptr[x_] >= minD && std::abs(disp2ptr[x_] - d_) > disp12MaxDiff ) 0 <= x_ && x_ < width && disp2ptr[x_] >= minD && std::abs(disp2ptr[x_] - d_) > disp12MaxDiff )

8
modules/calib3d/test/test_cameracalibration.cpp
View File

@ -529,14 +529,14 @@ void CV_CameraCalibrationTest::run( int start_from )
/* ---- Reproject points to the image ---- */ /* ---- Reproject points to the image ---- */
for( currImage = 0; currImage < numImages; currImage++ ) for( currImage = 0; currImage < numImages; currImage++ )
{ {
int numPoints = etalonSize.width * etalonSize.height; int nPoints = etalonSize.width * etalonSize.height;
project( numPoints, project( nPoints,
objectPoints + currImage * numPoints, objectPoints + currImage * nPoints,
rotMatrs + currImage * 9, rotMatrs + currImage * 9,
transVects + currImage * 3, transVects + currImage * 3,
cameraMatrix, cameraMatrix,
distortion, distortion,
reprojectPoints + currImage * numPoints); reprojectPoints + currImage * nPoints);
} }
/* ----- Compute reprojection error ----- */ /* ----- Compute reprojection error ----- */

8
modules/calib3d/test/test_cameracalibration_artificial.cpp
View File

@ -221,19 +221,19 @@ protected:
} }
} }
double reprojectErrorWithoutIntrinsics(const vector<Point3f>& cb3d, const vector<Mat>& rvecs_exp, const vector<Mat>& tvecs_exp, double reprojectErrorWithoutIntrinsics(const vector<Point3f>& cb3d, const vector<Mat>& _rvecs_exp, const vector<Mat>& _tvecs_exp,
const vector<Mat>& rvecs_est, const vector<Mat>& tvecs_est) const vector<Mat>& rvecs_est, const vector<Mat>& tvecs_est)
{ {
const static Mat eye33 = Mat::eye(3, 3, CV_64F); const static Mat eye33 = Mat::eye(3, 3, CV_64F);
const static Mat zero15 = Mat::zeros(1, 5, CV_64F); const static Mat zero15 = Mat::zeros(1, 5, CV_64F);
Mat chessboard3D(cb3d); Mat _chessboard3D(cb3d);
vector<Point2f> uv_exp, uv_est; vector<Point2f> uv_exp, uv_est;
double res = 0; double res = 0;
for(size_t i = 0; i < rvecs_exp.size(); ++i) for(size_t i = 0; i < rvecs_exp.size(); ++i)
{ {
projectPoints(chessboard3D, rvecs_exp[i], tvecs_exp[i], eye33, zero15, uv_exp); projectPoints(_chessboard3D, _rvecs_exp[i], _tvecs_exp[i], eye33, zero15, uv_exp);
projectPoints(chessboard3D, rvecs_est[i], tvecs_est[i], eye33, zero15, uv_est); projectPoints(_chessboard3D, rvecs_est[i], tvecs_est[i], eye33, zero15, uv_est);
for(size_t j = 0; j < cb3d.size(); ++j) for(size_t j = 0; j < cb3d.size(); ++j)
res += norm(uv_exp[i] - uv_est[i]); res += norm(uv_exp[i] - uv_est[i]);
} }

55
modules/calib3d/test/test_chesscorners.cpp
View File

@ -137,8 +137,7 @@ const double precise_success_error_level = 2;
/* ///////////////////// chess_corner_test ///////////////////////// */ /* ///////////////////// chess_corner_test ///////////////////////// */
void CV_ChessboardDetectorTest::run( int /*start_from */) void CV_ChessboardDetectorTest::run( int /*start_from */)
{ {
cvtest::TS& ts = *this->ts; ts->set_failed_test_info( cvtest::TS::OK );
ts.set_failed_test_info( cvtest::TS::OK );
/*if (!checkByGenerator()) /*if (!checkByGenerator())
return;*/ return;*/
@ -146,19 +145,19 @@ void CV_ChessboardDetectorTest::run( int /*start_from */)
{ {
case CHESSBOARD: case CHESSBOARD:
checkByGenerator(); checkByGenerator();
if (ts.get_err_code() != cvtest::TS::OK) if (ts->get_err_code() != cvtest::TS::OK)
{ {
break; break;
} }
run_batch("negative_list.dat"); run_batch("negative_list.dat");
if (ts.get_err_code() != cvtest::TS::OK) if (ts->get_err_code() != cvtest::TS::OK)
{ {
break; break;
} }
run_batch("chessboard_list.dat"); run_batch("chessboard_list.dat");
if (ts.get_err_code() != cvtest::TS::OK) if (ts->get_err_code() != cvtest::TS::OK)
{ {
break; break;
} }
@ -176,9 +175,7 @@ void CV_ChessboardDetectorTest::run( int /*start_from */)
void CV_ChessboardDetectorTest::run_batch( const string& filename ) void CV_ChessboardDetectorTest::run_batch( const string& filename )
{ {
cvtest::TS& ts = *this->ts; ts->printf(cvtest::TS::LOG, "\nRunning batch %s\n", filename.c_str());
ts.printf(cvtest::TS::LOG, "\nRunning batch %s\n", filename.c_str());
//#define WRITE_POINTS 1 //#define WRITE_POINTS 1
#ifndef WRITE_POINTS #ifndef WRITE_POINTS
double max_rough_error = 0, max_precise_error = 0; double max_rough_error = 0, max_precise_error = 0;
@ -187,13 +184,13 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
switch( pattern ) switch( pattern )
{ {
case CHESSBOARD: case CHESSBOARD:
folder = string(ts.get_data_path()) + "cameracalibration/"; folder = string(ts->get_data_path()) + "cameracalibration/";
break; break;
case CIRCLES_GRID: case CIRCLES_GRID:
folder = string(ts.get_data_path()) + "cameracalibration/circles/"; folder = string(ts->get_data_path()) + "cameracalibration/circles/";
break; break;
case ASYMMETRIC_CIRCLES_GRID: case ASYMMETRIC_CIRCLES_GRID:
folder = string(ts.get_data_path()) + "cameracalibration/asymmetric_circles/"; folder = string(ts->get_data_path()) + "cameracalibration/asymmetric_circles/";
break; break;
} }
@ -202,10 +199,10 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
if( !fs.isOpened() || board_list.empty() || !board_list.isSeq() || board_list.size() % 2 != 0 ) if( !fs.isOpened() || board_list.empty() || !board_list.isSeq() || board_list.size() % 2 != 0 )
{ {
ts.printf( cvtest::TS::LOG, "%s can not be readed or is not valid\n", (folder + filename).c_str() ); ts->printf( cvtest::TS::LOG, "%s can not be readed or is not valid\n", (folder + filename).c_str() );
ts.printf( cvtest::TS::LOG, "fs.isOpened=%d, board_list.empty=%d, board_list.isSeq=%d,board_list.size()%2=%d\n", ts->printf( cvtest::TS::LOG, "fs.isOpened=%d, board_list.empty=%d, board_list.isSeq=%d,board_list.size()%2=%d\n",
fs.isOpened(), (int)board_list.empty(), board_list.isSeq(), board_list.size()%2); fs.isOpened(), (int)board_list.empty(), board_list.isSeq(), board_list.size()%2);
ts.set_failed_test_info( cvtest::TS::FAIL_MISSING_TEST_DATA ); ts->set_failed_test_info( cvtest::TS::FAIL_MISSING_TEST_DATA );
return; return;
} }
@ -216,7 +213,7 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
for(int idx = 0; idx < max_idx; ++idx ) for(int idx = 0; idx < max_idx; ++idx )
{ {
ts.update_context( this, idx, true ); ts->update_context( this, idx, true );
/* read the image */ /* read the image */
string img_file = board_list[idx * 2]; string img_file = board_list[idx * 2];
@ -224,19 +221,19 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
if( gray.empty() ) if( gray.empty() )
{ {
ts.printf( cvtest::TS::LOG, "one of chessboard images can't be read: %s\n", img_file.c_str() ); ts->printf( cvtest::TS::LOG, "one of chessboard images can't be read: %s\n", img_file.c_str() );
ts.set_failed_test_info( cvtest::TS::FAIL_MISSING_TEST_DATA ); ts->set_failed_test_info( cvtest::TS::FAIL_MISSING_TEST_DATA );
return; return;
} }
string filename = folder + (string)board_list[idx * 2 + 1]; string _filename = folder + (string)board_list[idx * 2 + 1];
bool doesContatinChessboard; bool doesContatinChessboard;
Mat expected; Mat expected;
{ {
FileStorage fs(filename, FileStorage::READ); FileStorage fs1(_filename, FileStorage::READ);
fs["corners"] >> expected; fs1["corners"] >> expected;
fs["isFound"] >> doesContatinChessboard; fs1["isFound"] >> doesContatinChessboard;
fs.release(); fs1.release();
} }
size_t count_exp = static_cast<size_t>(expected.cols * expected.rows); size_t count_exp = static_cast<size_t>(expected.cols * expected.rows);
Size pattern_size = expected.size(); Size pattern_size = expected.size();
@ -259,8 +256,8 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
if( result ^ doesContatinChessboard || v.size() != count_exp ) if( result ^ doesContatinChessboard || v.size() != count_exp )
{ {
ts.printf( cvtest::TS::LOG, "chessboard is detected incorrectly in %s\n", img_file.c_str() ); ts->printf( cvtest::TS::LOG, "chessboard is detected incorrectly in %s\n", img_file.c_str() );
ts.set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT ); ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
return; return;
} }
@ -291,19 +288,19 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
#if 1 #if 1
if( err > precise_success_error_level ) if( err > precise_success_error_level )
{ {
ts.printf( cvtest::TS::LOG, "Image %s: bad accuracy of adjusted corners %f\n", img_file.c_str(), err ); ts->printf( cvtest::TS::LOG, "Image %s: bad accuracy of adjusted corners %f\n", img_file.c_str(), err );
ts.set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY ); ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return; return;
} }
#endif #endif
ts.printf(cvtest::TS::LOG, "Error on %s is %f\n", img_file.c_str(), err); ts->printf(cvtest::TS::LOG, "Error on %s is %f\n", img_file.c_str(), err);
max_precise_error = MAX( max_precise_error, err ); max_precise_error = MAX( max_precise_error, err );
#endif #endif
} }
#ifdef WRITE_POINTS #ifdef WRITE_POINTS
Mat mat_v(pattern_size, CV_32FC2, (void*)&v[0]); Mat mat_v(pattern_size, CV_32FC2, (void*)&v[0]);
FileStorage fs(filename, FileStorage::WRITE); FileStorage fs(_filename, FileStorage::WRITE);
fs << "isFound" << result; fs << "isFound" << result;
fs << "corners" << mat_v; fs << "corners" << mat_v;
fs.release(); fs.release();
@ -312,7 +309,7 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
} }
sum_error /= count; sum_error /= count;
ts.printf(cvtest::TS::LOG, "Average error is %f\n", sum_error); ts->printf(cvtest::TS::LOG, "Average error is %f\n", sum_error);
} }
double calcErrorMinError(const Size& cornSz, const vector<Point2f>& corners_found, const vector<Point2f>& corners_generated) double calcErrorMinError(const Size& cornSz, const vector<Point2f>& corners_found, const vector<Point2f>& corners_generated)

21
modules/calib3d/test/test_compose_rt.cpp
View File

@ -139,8 +139,7 @@ protected:
void run(int) void run(int)
{ {
cvtest::TS& ts = *this->ts; ts->set_failed_test_info(cvtest::TS::OK);
ts.set_failed_test_info(cvtest::TS::OK);
Mat_<double> rvec1(3, 1), tvec1(3, 1), rvec2(3, 1), tvec2(3, 1); Mat_<double> rvec1(3, 1), tvec1(3, 1), rvec2(3, 1), tvec2(3, 1);
@ -164,7 +163,7 @@ protected:
const double thres = 1e-5; const double thres = 1e-5;
if (norm(rvec3_exp, rvec3) > thres || norm(tvec3_exp, tvec3) > thres) if (norm(rvec3_exp, rvec3) > thres || norm(tvec3_exp, tvec3) > thres)
ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
const double eps = 1e-3; const double eps = 1e-3;
Differential diff(eps, rvec1, tvec1, rvec2, tvec2); Differential diff(eps, rvec1, tvec1, rvec2, tvec2);
@ -179,8 +178,8 @@ protected:
if (norm(dr3_dr1, dr3dr1) > thres || norm(dt3_dr1, dt3dr1) > thres) if (norm(dr3_dr1, dr3dr1) > thres || norm(dt3_dr1, dt3dr1) > thres)
{ {
ts.printf( cvtest::TS::LOG, "Invalid derivates by r1\n" ); ts->printf( cvtest::TS::LOG, "Invalid derivates by r1\n" );
ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
} }
Mat_<double> dr3_dr2, dt3_dr2; Mat_<double> dr3_dr2, dt3_dr2;
@ -188,8 +187,8 @@ protected:
if (norm(dr3_dr2, dr3dr2) > thres || norm(dt3_dr2, dt3dr2) > thres) if (norm(dr3_dr2, dr3dr2) > thres || norm(dt3_dr2, dt3dr2) > thres)
{ {
ts.printf( cvtest::TS::LOG, "Invalid derivates by r2\n" ); ts->printf( cvtest::TS::LOG, "Invalid derivates by r2\n" );
ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
} }
Mat_<double> dr3_dt1, dt3_dt1; Mat_<double> dr3_dt1, dt3_dt1;
@ -197,8 +196,8 @@ protected:
if (norm(dr3_dt1, dr3dt1) > thres || norm(dt3_dt1, dt3dt1) > thres) if (norm(dr3_dt1, dr3dt1) > thres || norm(dt3_dt1, dt3dt1) > thres)
{ {
ts.printf( cvtest::TS::LOG, "Invalid derivates by t1\n" ); ts->printf( cvtest::TS::LOG, "Invalid derivates by t1\n" );
ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
} }
Mat_<double> dr3_dt2, dt3_dt2; Mat_<double> dr3_dt2, dt3_dt2;
@ -206,8 +205,8 @@ protected:
if (norm(dr3_dt2, dr3dt2) > thres || norm(dt3_dt2, dt3dt2) > thres) if (norm(dr3_dt2, dr3dt2) > thres || norm(dt3_dt2, dt3dt2) > thres)
{ {
ts.printf( cvtest::TS::LOG, "Invalid derivates by t2\n" ); ts->printf( cvtest::TS::LOG, "Invalid derivates by t2\n" );
ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
} }
} }
}; };

16
modules/calib3d/test/test_homography.cpp
View File

@ -138,25 +138,25 @@ int CV_HomographyTest::check_ransac_mask_2(const Mat& original_mask, const Mat&
return 0; return 0;
} }
void CV_HomographyTest::print_information_1(int j, int N, int method, const Mat& H) void CV_HomographyTest::print_information_1(int j, int N, int _method, const Mat& H)
{ {
cout << endl; cout << "Checking for homography matrix sizes..." << endl; cout << endl; cout << endl; cout << "Checking for homography matrix sizes..." << endl; cout << endl;
cout << "Type of srcPoints: "; if ((j>-1) && (j<2)) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << "Type of srcPoints: "; if ((j>-1) && (j<2)) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>";
cout << " Type of dstPoints: "; if (j % 2 == 0) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << endl; cout << " Type of dstPoints: "; if (j % 2 == 0) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << endl;
cout << "Count of points: " << N << endl; cout << endl; cout << "Count of points: " << N << endl; cout << endl;
cout << "Method: "; if (method == 0) cout << 0; else if (method == 8) cout << "RANSAC"; else cout << "LMEDS"; cout << endl; cout << "Method: "; if (_method == 0) cout << 0; else if (_method == 8) cout << "RANSAC"; else cout << "LMEDS"; cout << endl;
cout << "Homography matrix:" << endl; cout << endl; cout << "Homography matrix:" << endl; cout << endl;
cout << H << endl; cout << endl; cout << H << endl; cout << endl;
cout << "Number of rows: " << H.rows << " Number of cols: " << H.cols << endl; cout << endl; cout << "Number of rows: " << H.rows << " Number of cols: " << H.cols << endl; cout << endl;
} }
void CV_HomographyTest::print_information_2(int j, int N, int method, const Mat& H, const Mat& H_res, int k, double diff) void CV_HomographyTest::print_information_2(int j, int N, int _method, const Mat& H, const Mat& H_res, int k, double diff)
{ {
cout << endl; cout << "Checking for accuracy of homography matrix computing..." << endl; cout << endl; cout << endl; cout << "Checking for accuracy of homography matrix computing..." << endl; cout << endl;
cout << "Type of srcPoints: "; if ((j>-1) && (j<2)) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << "Type of srcPoints: "; if ((j>-1) && (j<2)) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>";
cout << " Type of dstPoints: "; if (j % 2 == 0) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << endl; cout << " Type of dstPoints: "; if (j % 2 == 0) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << endl;
cout << "Count of points: " << N << endl; cout << endl; cout << "Count of points: " << N << endl; cout << endl;
cout << "Method: "; if (method == 0) cout << 0; else if (method == 8) cout << "RANSAC"; else cout << "LMEDS"; cout << endl; cout << "Method: "; if (_method == 0) cout << 0; else if (_method == 8) cout << "RANSAC"; else cout << "LMEDS"; cout << endl;
cout << "Original matrix:" << endl; cout << endl; cout << "Original matrix:" << endl; cout << endl;
cout << H << endl; cout << endl; cout << H << endl; cout << endl;
cout << "Found matrix:" << endl; cout << endl; cout << "Found matrix:" << endl; cout << endl;
@ -178,10 +178,10 @@ void CV_HomographyTest::print_information_3(int j, int N, const Mat& mask)
cout << "Number of rows: " << mask.rows << " Number of cols: " << mask.cols << endl; cout << endl; cout << "Number of rows: " << mask.rows << " Number of cols: " << mask.cols << endl; cout << endl;
} }
void CV_HomographyTest::print_information_4(int method, int j, int N, int k, int l, double diff) void CV_HomographyTest::print_information_4(int _method, int j, int N, int k, int l, double diff)
{ {
cout << endl; cout << "Checking for accuracy of reprojection error computing..." << endl; cout << endl; cout << endl; cout << "Checking for accuracy of reprojection error computing..." << endl; cout << endl;
cout << "Method: "; if (method == 0) cout << 0 << endl; else cout << "CV_LMEDS" << endl; cout << "Method: "; if (_method == 0) cout << 0 << endl; else cout << "CV_LMEDS" << endl;
cout << "Type of srcPoints: "; if ((j>-1) && (j<2)) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << "Type of srcPoints: "; if ((j>-1) && (j<2)) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>";
cout << " Type of dstPoints: "; if (j % 2 == 0) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << endl; cout << " Type of dstPoints: "; if (j % 2 == 0) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << endl;
cout << "Sigma of normal noise: " << sigma << endl; cout << "Sigma of normal noise: " << sigma << endl;
@ -192,10 +192,10 @@ void CV_HomographyTest::print_information_4(int method, int j, int N, int k, int
cout << "Maxumum allowed difference: " << max_2diff << endl; cout << endl; cout << "Maxumum allowed difference: " << max_2diff << endl; cout << endl;
} }
void CV_HomographyTest::print_information_5(int method, int j, int N, int l, double diff) void CV_HomographyTest::print_information_5(int _method, int j, int N, int l, double diff)
{ {
cout << endl; cout << "Checking for accuracy of reprojection error computing..." << endl; cout << endl; cout << endl; cout << "Checking for accuracy of reprojection error computing..." << endl; cout << endl;
cout << "Method: "; if (method == 0) cout << 0 << endl; else cout << "CV_LMEDS" << endl; cout << "Method: "; if (_method == 0) cout << 0 << endl; else cout << "CV_LMEDS" << endl;
cout << "Type of srcPoints: "; if ((j>-1) && (j<2)) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << "Type of srcPoints: "; if ((j>-1) && (j<2)) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>";
cout << " Type of dstPoints: "; if (j % 2 == 0) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << endl; cout << " Type of dstPoints: "; if (j % 2 == 0) cout << "Mat of CV_32FC2"; else cout << "vector <Point2f>"; cout << endl;
cout << "Sigma of normal noise: " << sigma << endl; cout << "Sigma of normal noise: " << sigma << endl;

17
modules/calib3d/test/test_solvepnp_ransac.cpp
View File

@ -106,7 +106,7 @@ protected:
} }
} }
virtual bool runTest(RNG& rng, int mode, int method, const vector<Point3f>& points, const double* eps, double& maxError) virtual bool runTest(RNG& rng, int mode, int method, const vector<Point3f>& points, const double* epsilon, double& maxError)
{ {
Mat rvec, tvec; Mat rvec, tvec;
vector<int> inliers; vector<int> inliers;
@ -136,7 +136,7 @@ protected:
bool isTestSuccess = inliers.size() >= points.size()*0.95; bool isTestSuccess = inliers.size() >= points.size()*0.95;
double rvecDiff = norm(rvec-trueRvec), tvecDiff = norm(tvec-trueTvec); double rvecDiff = norm(rvec-trueRvec), tvecDiff = norm(tvec-trueTvec);
isTestSuccess = isTestSuccess && rvecDiff < eps[method] && tvecDiff < eps[method]; isTestSuccess = isTestSuccess && rvecDiff < epsilon[method] && tvecDiff < epsilon[method];
double error = rvecDiff > tvecDiff ? rvecDiff : tvecDiff; double error = rvecDiff > tvecDiff ? rvecDiff : tvecDiff;
//cout << error << " " << inliers.size() << " " << eps[method] << endl; //cout << error << " " << inliers.size() << " " << eps[method] << endl;
if (error > maxError) if (error > maxError)
@ -147,8 +147,7 @@ protected:
void run(int) void run(int)
{ {
cvtest::TS& ts = *this->ts; ts->set_failed_test_info(cvtest::TS::OK);
ts.set_failed_test_info(cvtest::TS::OK);
vector<Point3f> points; vector<Point3f> points;
const int pointsCount = 500; const int pointsCount = 500;
@ -157,7 +156,7 @@ protected:
const int methodsCount = 3; const int methodsCount = 3;
RNG rng = ts.get_rng(); RNG rng = ts->get_rng();
for (int mode = 0; mode < 2; mode++) for (int mode = 0; mode < 2; mode++)
@ -174,9 +173,9 @@ protected:
//cout << maxError << " " << successfulTestsCount << endl; //cout << maxError << " " << successfulTestsCount << endl;
if (successfulTestsCount < 0.7*totalTestsCount) if (successfulTestsCount < 0.7*totalTestsCount)
{ {
ts.printf( cvtest::TS::LOG, "Invalid accuracy for method %d, failed %d tests from %d, maximum error equals %f, distortion mode equals %d\n", ts->printf( cvtest::TS::LOG, "Invalid accuracy for method %d, failed %d tests from %d, maximum error equals %f, distortion mode equals %d\n",
method, totalTestsCount - successfulTestsCount, totalTestsCount, maxError, mode); method, totalTestsCount - successfulTestsCount, totalTestsCount, maxError, mode);
ts.set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
} }
} }
} }
@ -198,7 +197,7 @@ public:
~CV_solvePnP_Test() {} ~CV_solvePnP_Test() {}
protected: protected:
virtual bool runTest(RNG& rng, int mode, int method, const vector<Point3f>& points, const double* eps, double& maxError) virtual bool runTest(RNG& rng, int mode, int method, const vector<Point3f>& points, const double* epsilon, double& maxError)
{ {
Mat rvec, tvec; Mat rvec, tvec;
Mat trueRvec, trueTvec; Mat trueRvec, trueTvec;
@ -226,7 +225,7 @@ protected:
false, method); false, method);
double rvecDiff = norm(rvec-trueRvec), tvecDiff = norm(tvec-trueTvec); double rvecDiff = norm(rvec-trueRvec), tvecDiff = norm(tvec-trueTvec);
bool isTestSuccess = rvecDiff < eps[method] && tvecDiff < eps[method]; bool isTestSuccess = rvecDiff < epsilon[method] && tvecDiff < epsilon[method];
double error = rvecDiff > tvecDiff ? rvecDiff : tvecDiff; double error = rvecDiff > tvecDiff ? rvecDiff : tvecDiff;
if (error > maxError) if (error > maxError)

4
modules/calib3d/test/test_stereomatching.cpp
View File

@ -593,11 +593,11 @@ int CV_StereoMatchingTest::readDatasetsParams( FileStorage& fs )
assert(fn.isSeq()); assert(fn.isSeq());
for( int i = 0; i < (int)fn.size(); i+=3 ) for( int i = 0; i < (int)fn.size(); i+=3 )
{ {
string name = fn[i]; string _name = fn[i];
DatasetParams params; DatasetParams params;
string sf = fn[i+1]; params.dispScaleFactor = atoi(sf.c_str()); string sf = fn[i+1]; params.dispScaleFactor = atoi(sf.c_str());
string uv = fn[i+2]; params.dispUnknVal = atoi(uv.c_str()); string uv = fn[i+2]; params.dispUnknVal = atoi(uv.c_str());
datasetsParams[name] = params; datasetsParams[_name] = params;
} }
return cvtest::TS::OK; return cvtest::TS::OK;
} }

6
modules/contrib/include/opencv2/contrib/hybridtracker.hpp
View File

@ -86,10 +86,10 @@ struct CV_EXPORTS CvMeanShiftTrackerParams
struct CV_EXPORTS CvFeatureTrackerParams struct CV_EXPORTS CvFeatureTrackerParams
{ {
enum { SIFT = 0, SURF = 1, OPTICAL_FLOW = 2 }; enum { SIFT = 0, SURF = 1, OPTICAL_FLOW = 2 };
CvFeatureTrackerParams(int feature_type = 0, int window_size = 0) CvFeatureTrackerParams(int featureType = 0, int windowSize = 0)
{ {
feature_type = 0; featureType = 0;
window_size = 0; windowSize = 0;
} }
int feature_type; // Feature type to use int feature_type; // Feature type to use

18
modules/contrib/src/ba.cpp
View File

@ -67,15 +67,15 @@ LevMarqSparse::LevMarqSparse(int npoints, // number of points
// 1 - point is visible for the camera, 0 - invisible // 1 - point is visible for the camera, 0 - invisible
Mat& P0, // starting vector of parameters, first cameras then points Mat& P0, // starting vector of parameters, first cameras then points
Mat& X_, // measurements, in order of visibility. non visible cases are skipped Mat& X_, // measurements, in order of visibility. non visible cases are skipped
TermCriteria criteria, // termination criteria TermCriteria _criteria, // termination criteria
// callback for estimation of Jacobian matrices // callback for estimation of Jacobian matrices
void (CV_CDECL * fjac)(int i, int j, Mat& point_params, void (CV_CDECL * _fjac)(int i, int j, Mat& point_params,
Mat& cam_params, Mat& A, Mat& B, void* data), Mat& cam_params, Mat& A, Mat& B, void* data),
// callback for estimation of backprojection errors // callback for estimation of backprojection errors
void (CV_CDECL * func)(int i, int j, Mat& point_params, void (CV_CDECL * _func)(int i, int j, Mat& point_params,
Mat& cam_params, Mat& estim, void* data), Mat& cam_params, Mat& estim, void* data),
void* data, // user-specific data passed to the callbacks void* _data, // user-specific data passed to the callbacks
BundleAdjustCallback _cb, void* _user_data BundleAdjustCallback _cb, void* _user_data
) { ) {
Vis_index = X = prevP = P = deltaP = err = JtJ_diag = S = hX = NULL; Vis_index = X = prevP = P = deltaP = err = JtJ_diag = S = hX = NULL;
@ -86,7 +86,7 @@ LevMarqSparse::LevMarqSparse(int npoints, // number of points
user_data = _user_data; user_data = _user_data;
run(npoints, ncameras, nPointParams, nCameraParams, nErrParams, visibility, run(npoints, ncameras, nPointParams, nCameraParams, nErrParams, visibility,
P0, X_, criteria, fjac, func, data); P0, X_, _criteria, _fjac, _func, _data);
} }
void LevMarqSparse::clear() { void LevMarqSparse::clear() {
@ -443,9 +443,11 @@ void LevMarqSparse::optimize(CvMat &_vis) { //main function that runs minimizati
} //U_j and ea_j computed for all j } //U_j and ea_j computed for all j
// if (!(iters%100)) // if (!(iters%100))
{
int nviz = X->rows / num_err_param; int nviz = X->rows / num_err_param;
double e2 = prevErrNorm*prevErrNorm, e2n = e2 / nviz; double e2 = prevErrNorm*prevErrNorm, e2n = e2 / nviz;
std::cerr<<"Iteration: "<<iters<<", normError: "<<e2<<" ("<<e2n<<")"<<std::endl; std::cerr<<"Iteration: "<<iters<<", normError: "<<e2<<" ("<<e2n<<")"<<std::endl;
}
if (cb) if (cb)
cb(iters, prevErrNorm, user_data); cb(iters, prevErrNorm, user_data);
//compute V_i and eb_i //compute V_i and eb_i
@ -676,10 +678,12 @@ void LevMarqSparse::optimize(CvMat &_vis) { //main function that runs minimizati
errNorm > prevErrNorm ) { //step was not accepted errNorm > prevErrNorm ) { //step was not accepted
//increase lambda and reject change //increase lambda and reject change
lambda *= 10; lambda *= 10;
{
int nviz = X->rows / num_err_param; int nviz = X->rows / num_err_param;
double e2 = errNorm*errNorm, e2_prev = prevErrNorm*prevErrNorm; double e2 = errNorm*errNorm, e2_prev = prevErrNorm*prevErrNorm;
double e2n = e2/nviz, e2n_prev = e2_prev/nviz; double e2n = e2/nviz, e2n_prev = e2_prev/nviz;
std::cerr<<"move failed: lambda = "<<lambda<<", e2 = "<<e2<<" ("<<e2n<<") > "<<e2_prev<<" ("<<e2n_prev<<")"<<std::endl; std::cerr<<"move failed: lambda = "<<lambda<<", e2 = "<<e2<<" ("<<e2n<<") > "<<e2_prev<<" ("<<e2n_prev<<")"<<std::endl;
}
//restore diagonal from backup //restore diagonal from backup
{ {
@ -886,9 +890,9 @@ static void fjac(int /*i*/, int /*j*/, CvMat *point_params, CvMat* cam_params, C
double c[4] = { g+2*p1*y_strike+4*p2*x_strike, 2*p1*x_strike, double c[4] = { g+2*p1*y_strike+4*p2*x_strike, 2*p1*x_strike,
2*p2*y_strike, g+2*p2*x_strike + 4*p1*y_strike }; 2*p2*y_strike, g+2*p2*x_strike + 4*p1*y_strike };
CvMat coeffmat = cvMat(2,2,CV_64F, c ); CvMat coeffmat2 = cvMat(2,2,CV_64F, c );
cvMatMul(&coeffmat, dstrike_dbig, dstrike2_dbig ); cvMatMul(&coeffmat2, dstrike_dbig, dstrike2_dbig );
cvGEMM( &strike, dg_dbig, 1, NULL, 0, tmp, CV_GEMM_A_T ); cvGEMM( &strike, dg_dbig, 1, NULL, 0, tmp, CV_GEMM_A_T );
cvAdd( dstrike2_dbig, tmp, dstrike2_dbig ); cvAdd( dstrike2_dbig, tmp, dstrike2_dbig );

16
modules/contrib/src/basicretinafilter.cpp
View File

@ -180,13 +180,13 @@ void BasicRetinaFilter::setLPfilterParameters(const float beta, const float tau,
} }
float _temp = (1.0f+_beta)/(2.0f*_mu*_alpha); float _temp = (1.0f+_beta)/(2.0f*_mu*_alpha);
float _a = _filteringCoeficientsTable[tableOffset] = 1.0f + _temp - (float)sqrt( (1.0f+_temp)*(1.0f+_temp) - 1.0f); float a = _filteringCoeficientsTable[tableOffset] = 1.0f + _temp - (float)sqrt( (1.0f+_temp)*(1.0f+_temp) - 1.0f);
_filteringCoeficientsTable[1+tableOffset]=(1.0f-_a)*(1.0f-_a)*(1.0f-_a)*(1.0f-_a)/(1.0f+_beta); _filteringCoeficientsTable[1+tableOffset]=(1.0f-a)*(1.0f-a)*(1.0f-a)*(1.0f-a)/(1.0f+_beta);
_filteringCoeficientsTable[2+tableOffset] =tau; _filteringCoeficientsTable[2+tableOffset] =tau;
//std::cout<<"BasicRetinaFilter::normal:"<<(1.0-_a)*(1.0-_a)*(1.0-_a)*(1.0-_a)/(1.0+_beta)<<" -> old:"<<(1-_a)*(1-_a)*(1-_a)*(1-_a)/(1+_beta)<<std::endl; //std::cout<<"BasicRetinaFilter::normal:"<<(1.0-a)*(1.0-a)*(1.0-a)*(1.0-a)/(1.0+_beta)<<" -> old:"<<(1-a)*(1-a)*(1-a)*(1-a)/(1+_beta)<<std::endl;
//std::cout<<"BasicRetinaFilter::_a="<<_a<<", gain="<<_filteringCoeficientsTable[1+tableOffset]<<", tau="<<tau<<std::endl; //std::cout<<"BasicRetinaFilter::a="<<a<<", gain="<<_filteringCoeficientsTable[1+tableOffset]<<", tau="<<tau<<std::endl;
} }
void BasicRetinaFilter::setProgressiveFilterConstants_CentredAccuracy(const float beta, const float tau, const float alpha0, const unsigned int filterIndex) void BasicRetinaFilter::setProgressiveFilterConstants_CentredAccuracy(const float beta, const float tau, const float alpha0, const unsigned int filterIndex)
@ -210,8 +210,8 @@ void BasicRetinaFilter::setProgressiveFilterConstants_CentredAccuracy(const floa
float _alpha=0.8f; float _alpha=0.8f;
float _temp = (1.0f+_beta)/(2.0f*_mu*_alpha); float _temp = (1.0f+_beta)/(2.0f*_mu*_alpha);
float _a=_filteringCoeficientsTable[tableOffset] = 1.0f + _temp - (float)sqrt( (1.0f+_temp)*(1.0f+_temp) - 1.0f); float a=_filteringCoeficientsTable[tableOffset] = 1.0f + _temp - (float)sqrt( (1.0f+_temp)*(1.0f+_temp) - 1.0f);
_filteringCoeficientsTable[tableOffset+1]=(1.0f-_a)*(1.0f-_a)*(1.0f-_a)*(1.0f-_a)/(1.0f+_beta); _filteringCoeficientsTable[tableOffset+1]=(1.0f-a)*(1.0f-a)*(1.0f-a)*(1.0f-a)/(1.0f+_beta);
_filteringCoeficientsTable[tableOffset+2] =tau; _filteringCoeficientsTable[tableOffset+2] =tau;
float commonFactor=alpha0/(float)sqrt(_halfNBcolumns*_halfNBcolumns+_halfNBrows*_halfNBrows+1.0f); float commonFactor=alpha0/(float)sqrt(_halfNBcolumns*_halfNBcolumns+_halfNBrows*_halfNBrows+1.0f);
@ -266,8 +266,8 @@ void BasicRetinaFilter::setProgressiveFilterConstants_CustomAccuracy(const float
} }
unsigned int tableOffset=filterIndex*3; unsigned int tableOffset=filterIndex*3;
float _temp = (1.0f+_beta)/(2.0f*_mu*_alpha); float _temp = (1.0f+_beta)/(2.0f*_mu*_alpha);
float _a=_filteringCoeficientsTable[tableOffset] = 1.0f + _temp - (float)sqrt( (1.0f+_temp)*(1.0f+_temp) - 1.0f); float a=_filteringCoeficientsTable[tableOffset] = 1.0f + _temp - (float)sqrt( (1.0f+_temp)*(1.0f+_temp) - 1.0f);
_filteringCoeficientsTable[tableOffset+1]=(1.0f-_a)*(1.0f-_a)*(1.0f-_a)*(1.0f-_a)/(1.0f+_beta); _filteringCoeficientsTable[tableOffset+1]=(1.0f-a)*(1.0f-a)*(1.0f-a)*(1.0f-a)/(1.0f+_beta);
_filteringCoeficientsTable[tableOffset+2] =tau; _filteringCoeficientsTable[tableOffset+2] =tau;
//memset(_progressiveSpatialConstant, 255, _filterOutput.getNBpixels()); //memset(_progressiveSpatialConstant, 255, _filterOutput.getNBpixels());

4
modules/contrib/src/colortracker.cpp
View File

@ -68,10 +68,10 @@ void CvMeanShiftTracker::newTrackingWindow(Mat image, Rect selection)
mixChannels(&hsv, 1, &hue, 1, channels, 2); mixChannels(&hsv, 1, &hue, 1, channels, 2);
Mat roi(hue, selection); Mat roi(hue, selection);
Mat maskroi(mask, selection); Mat mskroi(mask, selection);
int ch[] = {0, 1}; int ch[] = {0, 1};
int chsize[] = {32, 32}; int chsize[] = {32, 32};
calcHist(&roi, 1, ch, maskroi, hist, 1, chsize, ranges); calcHist(&roi, 1, ch, mskroi, hist, 1, chsize, ranges);
normalize(hist, hist, 0, 255, CV_MINMAX); normalize(hist, hist, 0, 255, CV_MINMAX);
prev_trackwindow = selection; prev_trackwindow = selection;

22
modules/contrib/src/facerec.cpp
View File

@ -208,11 +208,11 @@ public:
// //
// radius, neighbors are used in the local binary patterns creation. // radius, neighbors are used in the local binary patterns creation.
// grid_x, grid_y control the grid size of the spatial histograms. // grid_x, grid_y control the grid size of the spatial histograms.
LBPH(int radius=1, int neighbors=8, int grid_x=8, int grid_y=8) : LBPH(int radius_=1, int neighbors_=8, int grid_x_=8, int grid_y_=8) :
_grid_x(grid_x), _grid_x(grid_x_),
_grid_y(grid_y), _grid_y(grid_y_),
_radius(radius), _radius(radius_),
_neighbors(neighbors) {} _neighbors(neighbors_) {}
// Initializes and computes this LBPH Model. The current implementation is // Initializes and computes this LBPH Model. The current implementation is
// rather fixed as it uses the Extended Local Binary Patterns per default. // rather fixed as it uses the Extended Local Binary Patterns per default.
@ -221,12 +221,12 @@ public:
// (grid_x=8), (grid_y=8) controls the grid size of the spatial histograms. // (grid_x=8), (grid_y=8) controls the grid size of the spatial histograms.
LBPH(InputArray src, LBPH(InputArray src,
InputArray labels, InputArray labels,
int radius=1, int neighbors=8, int radius_=1, int neighbors_=8,
int grid_x=8, int grid_y=8) : int grid_x_=8, int grid_y_=8) :
_grid_x(grid_x), _grid_x(grid_x_),
_grid_y(grid_y), _grid_y(grid_y_),
_radius(radius), _radius(radius_),
_neighbors(neighbors) { _neighbors(neighbors_) {
train(src, labels); train(src, labels);
} }

208
modules/contrib/src/lda.cpp
View File

@ -235,19 +235,19 @@ private:
// Allocates memory. // Allocates memory.
template<typename _Tp> template<typename _Tp>
_Tp **alloc_2d(int m, int n) { _Tp **alloc_2d(int m, int _n) {
_Tp **arr = new _Tp*[m]; _Tp **arr = new _Tp*[m];
for (int i = 0; i < m; i++) for (int i = 0; i < m; i++)
arr[i] = new _Tp[n]; arr[i] = new _Tp[_n];
return arr; return arr;
} }
// Allocates memory. // Allocates memory.
template<typename _Tp> template<typename _Tp>
_Tp **alloc_2d(int m, int n, _Tp val) { _Tp **alloc_2d(int m, int _n, _Tp val) {
_Tp **arr = alloc_2d<_Tp> (m, n); _Tp **arr = alloc_2d<_Tp> (m, _n);
for (int i = 0; i < m; i++) { for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) { for (int j = 0; j < _n; j++) {
arr[i][j] = val; arr[i][j] = val;
} }
} }
@ -255,17 +255,17 @@ private:
} }
void cdiv(double xr, double xi, double yr, double yi) { void cdiv(double xr, double xi, double yr, double yi) {
double r, d; double r, dv;
if (std::abs(yr) > std::abs(yi)) { if (std::abs(yr) > std::abs(yi)) {
r = yi / yr; r = yi / yr;
d = yr + r * yi; dv = yr + r * yi;
cdivr = (xr + r * xi) / d; cdivr = (xr + r * xi) / dv;
cdivi = (xi - r * xr) / d; cdivi = (xi - r * xr) / dv;
} else { } else {
r = yr / yi; r = yr / yi;
d = yi + r * yr; dv = yi + r * yr;
cdivr = (r * xr + xi) / d; cdivr = (r * xr + xi) / dv;
cdivi = (r * xi - xr) / d; cdivi = (r * xi - xr) / dv;
} }
} }
@ -280,7 +280,7 @@ private:
// Initialize // Initialize
int nn = this->n; int nn = this->n;
int n = nn - 1; int n1 = nn - 1;
int low = 0; int low = 0;
int high = nn - 1; int high = nn - 1;
double eps = pow(2.0, -52.0); double eps = pow(2.0, -52.0);
@ -302,10 +302,10 @@ private:
// Outer loop over eigenvalue index // Outer loop over eigenvalue index
int iter = 0; int iter = 0;
while (n >= low) { while (n1 >= low) {
// Look for single small sub-diagonal element // Look for single small sub-diagonal element
int l = n; int l = n1;
while (l > low) { while (l > low) {
s = std::abs(H[l - 1][l - 1]) + std::abs(H[l][l]); s = std::abs(H[l - 1][l - 1]) + std::abs(H[l][l]);
if (s == 0.0) { if (s == 0.0) {
@ -320,23 +320,23 @@ private:
// Check for convergence // Check for convergence
// One root found // One root found
if (l == n) { if (l == n1) {
H[n][n] = H[n][n] + exshift; H[n1][n1] = H[n1][n1] + exshift;
d[n] = H[n][n]; d[n1] = H[n1][n1];
e[n] = 0.0; e[n1] = 0.0;
n--; n1--;
iter = 0; iter = 0;
// Two roots found // Two roots found
} else if (l == n - 1) { } else if (l == n1 - 1) {
w = H[n][n - 1] * H[n - 1][n]; w = H[n1][n1 - 1] * H[n1 - 1][n1];
p = (H[n - 1][n - 1] - H[n][n]) / 2.0; p = (H[n1 - 1][n1 - 1] - H[n1][n1]) / 2.0;
q = p * p + w; q = p * p + w;
z = sqrt(std::abs(q)); z = sqrt(std::abs(q));
H[n][n] = H[n][n] + exshift; H[n1][n1] = H[n1][n1] + exshift;
H[n - 1][n - 1] = H[n - 1][n - 1] + exshift; H[n1 - 1][n1 - 1] = H[n1 - 1][n1 - 1] + exshift;
x = H[n][n]; x = H[n1][n1];
// Real pair // Real pair
@ -346,14 +346,14 @@ private:
} else { } else {
z = p - z; z = p - z;
} }
d[n - 1] = x + z; d[n1 - 1] = x + z;
d[n] = d[n - 1]; d[n1] = d[n1 - 1];
if (z != 0.0) { if (z != 0.0) {
d[n] = x - w / z; d[n1] = x - w / z;
} }
e[n - 1] = 0.0; e[n1 - 1] = 0.0;
e[n] = 0.0; e[n1] = 0.0;
x = H[n][n - 1]; x = H[n1][n1 - 1];
s = std::abs(x) + std::abs(z); s = std::abs(x) + std::abs(z);
p = x / s; p = x / s;
q = z / s; q = z / s;
@ -363,37 +363,37 @@ private:
// Row modification // Row modification
for (int j = n - 1; j < nn; j++) { for (int j = n1 - 1; j < nn; j++) {
z = H[n - 1][j]; z = H[n1 - 1][j];
H[n - 1][j] = q * z + p * H[n][j]; H[n1 - 1][j] = q * z + p * H[n1][j];
H[n][j] = q * H[n][j] - p * z; H[n1][j] = q * H[n1][j] - p * z;
} }
// Column modification // Column modification
for (int i = 0; i <= n; i++) { for (int i = 0; i <= n1; i++) {
z = H[i][n - 1]; z = H[i][n1 - 1];
H[i][n - 1] = q * z + p * H[i][n]; H[i][n1 - 1] = q * z + p * H[i][n1];
H[i][n] = q * H[i][n] - p * z; H[i][n1] = q * H[i][n1] - p * z;
} }
// Accumulate transformations // Accumulate transformations
for (int i = low; i <= high; i++) { for (int i = low; i <= high; i++) {
z = V[i][n - 1]; z = V[i][n1 - 1];
V[i][n - 1] = q * z + p * V[i][n]; V[i][n1 - 1] = q * z + p * V[i][n1];
V[i][n] = q * V[i][n] - p * z; V[i][n1] = q * V[i][n1] - p * z;
} }
// Complex pair // Complex pair
} else { } else {
d[n - 1] = x + p; d[n1 - 1] = x + p;
d[n] = x + p; d[n1] = x + p;
e[n - 1] = z; e[n1 - 1] = z;
e[n] = -z; e[n1] = -z;
} }
n = n - 2; n1 = n1 - 2;
iter = 0; iter = 0;
// No convergence yet // No convergence yet
@ -402,22 +402,22 @@ private:
// Form shift // Form shift
x = H[n][n]; x = H[n1][n1];
y = 0.0; y = 0.0;
w = 0.0; w = 0.0;
if (l < n) { if (l < n1) {
y = H[n - 1][n - 1]; y = H[n1 - 1][n1 - 1];
w = H[n][n - 1] * H[n - 1][n]; w = H[n1][n1 - 1] * H[n1 - 1][n1];
} }
// Wilkinson's original ad hoc shift // Wilkinson's original ad hoc shift
if (iter == 10) { if (iter == 10) {
exshift += x; exshift += x;
for (int i = low; i <= n; i++) { for (int i = low; i <= n1; i++) {
H[i][i] -= x; H[i][i] -= x;
} }
s = std::abs(H[n][n - 1]) + std::abs(H[n - 1][n - 2]); s = std::abs(H[n1][n1 - 1]) + std::abs(H[n1 - 1][n1 - 2]);
x = y = 0.75 * s; x = y = 0.75 * s;
w = -0.4375 * s * s; w = -0.4375 * s * s;
} }
@ -433,7 +433,7 @@ private:
s = -s; s = -s;
} }
s = x - w / ((y - x) / 2.0 + s); s = x - w / ((y - x) / 2.0 + s);
for (int i = low; i <= n; i++) { for (int i = low; i <= n1; i++) {
H[i][i] -= s; H[i][i] -= s;
} }
exshift += s; exshift += s;
@ -444,7 +444,7 @@ private:
iter = iter + 1; // (Could check iteration count here.) iter = iter + 1; // (Could check iteration count here.)
// Look for two consecutive small sub-diagonal elements // Look for two consecutive small sub-diagonal elements
int m = n - 2; int m = n1 - 2;
while (m >= l) { while (m >= l) {
z = H[m][m]; z = H[m][m];
r = x - z; r = x - z;
@ -467,7 +467,7 @@ private:
m--; m--;
} }
for (int i = m + 2; i <= n; i++) { for (int i = m + 2; i <= n1; i++) {
H[i][i - 2] = 0.0; H[i][i - 2] = 0.0;
if (i > m + 2) { if (i > m + 2) {
H[i][i - 3] = 0.0; H[i][i - 3] = 0.0;
@ -476,8 +476,8 @@ private:
// Double QR step involving rows l:n and columns m:n // Double QR step involving rows l:n and columns m:n
for (int k = m; k <= n - 1; k++) { for (int k = m; k <= n1 - 1; k++) {
bool notlast = (k != n - 1); bool notlast = (k != n1 - 1);
if (k != m) { if (k != m) {
p = H[k][k - 1]; p = H[k][k - 1];
q = H[k + 1][k - 1]; q = H[k + 1][k - 1];
@ -523,7 +523,7 @@ private:
// Column modification // Column modification
for (int i = 0; i <= min(n, k + 3); i++) { for (int i = 0; i <= min(n1, k + 3); i++) {
p = x * H[i][k] + y * H[i][k + 1]; p = x * H[i][k] + y * H[i][k + 1];
if (notlast) { if (notlast) {
p = p + z * H[i][k + 2]; p = p + z * H[i][k + 2];
@ -547,7 +547,7 @@ private:
} // (s != 0) } // (s != 0)
} // k loop } // k loop
} // check convergence } // check convergence
} // while (n >= low) } // while (n1 >= low)
// Backsubstitute to find vectors of upper triangular form // Backsubstitute to find vectors of upper triangular form
@ -555,20 +555,20 @@ private:
return; return;
} }
for (n = nn - 1; n >= 0; n--) { for (n1 = nn - 1; n1 >= 0; n1--) {
p = d[n]; p = d[n1];
q = e[n]; q = e[n1];
// Real vector // Real vector
if (q == 0) { if (q == 0) {
int l = n; int l = n1;
H[n][n] = 1.0; H[n1][n1] = 1.0;
for (int i = n - 1; i >= 0; i--) { for (int i = n1 - 1; i >= 0; i--) {
w = H[i][i] - p; w = H[i][i] - p;
r = 0.0; r = 0.0;
for (int j = l; j <= n; j++) { for (int j = l; j <= n1; j++) {
r = r + H[i][j] * H[j][n]; r = r + H[i][j] * H[j][n1];
} }
if (e[i] < 0.0) { if (e[i] < 0.0) {
z = w; z = w;
@ -577,9 +577,9 @@ private:
l = i; l = i;
if (e[i] == 0.0) { if (e[i] == 0.0) {
if (w != 0.0) { if (w != 0.0) {
H[i][n] = -r / w; H[i][n1] = -r / w;
} else { } else {
H[i][n] = -r / (eps * norm); H[i][n1] = -r / (eps * norm);
} }
// Solve real equations // Solve real equations
@ -589,20 +589,20 @@ private:
y = H[i + 1][i]; y = H[i + 1][i];
q = (d[i] - p) * (d[i] - p) + e[i] * e[i]; q = (d[i] - p) * (d[i] - p) + e[i] * e[i];
t = (x * s - z * r) / q; t = (x * s - z * r) / q;
H[i][n] = t; H[i][n1] = t;
if (std::abs(x) > std::abs(z)) { if (std::abs(x) > std::abs(z)) {
H[i + 1][n] = (-r - w * t) / x; H[i + 1][n1] = (-r - w * t) / x;
} else { } else {
H[i + 1][n] = (-s - y * t) / z; H[i + 1][n1] = (-s - y * t) / z;
} }
} }
// Overflow control // Overflow control
t = std::abs(H[i][n]); t = std::abs(H[i][n1]);
if ((eps * t) * t > 1) { if ((eps * t) * t > 1) {
for (int j = i; j <= n; j++) { for (int j = i; j <= n1; j++) {
H[j][n] = H[j][n] / t; H[j][n1] = H[j][n1] / t;
} }
} }
} }
@ -611,27 +611,27 @@ private:
// Complex vector // Complex vector
} else if (q < 0) { } else if (q < 0) {
int l = n - 1; int l = n1 - 1;
// Last vector component imaginary so matrix is triangular // Last vector component imaginary so matrix is triangular
if (std::abs(H[n][n - 1]) > std::abs(H[n - 1][n])) { if (std::abs(H[n1][n1 - 1]) > std::abs(H[n1 - 1][n1])) {
H[n - 1][n - 1] = q / H[n][n - 1]; H[n1 - 1][n1 - 1] = q / H[n1][n1 - 1];
H[n - 1][n] = -(H[n][n] - p) / H[n][n - 1]; H[n1 - 1][n1] = -(H[n1][n1] - p) / H[n1][n1 - 1];
} else { } else {
cdiv(0.0, -H[n - 1][n], H[n - 1][n - 1] - p, q); cdiv(0.0, -H[n1 - 1][n1], H[n1 - 1][n1 - 1] - p, q);
H[n - 1][n - 1] = cdivr; H[n1 - 1][n1 - 1] = cdivr;
H[n - 1][n] = cdivi; H[n1 - 1][n1] = cdivi;
} }
H[n][n - 1] = 0.0; H[n1][n1 - 1] = 0.0;
H[n][n] = 1.0; H[n1][n1] = 1.0;
for (int i = n - 2; i >= 0; i--) { for (int i = n1 - 2; i >= 0; i--) {
double ra, sa, vr, vi; double ra, sa, vr, vi;
ra = 0.0; ra = 0.0;
sa = 0.0; sa = 0.0;
for (int j = l; j <= n; j++) { for (int j = l; j <= n1; j++) {
ra = ra + H[i][j] * H[j][n - 1]; ra = ra + H[i][j] * H[j][n1 - 1];
sa = sa + H[i][j] * H[j][n]; sa = sa + H[i][j] * H[j][n1];
} }
w = H[i][i] - p; w = H[i][i] - p;
@ -643,8 +643,8 @@ private:
l = i; l = i;
if (e[i] == 0) { if (e[i] == 0) {
cdiv(-ra, -sa, w, q); cdiv(-ra, -sa, w, q);
H[i][n - 1] = cdivr; H[i][n1 - 1] = cdivr;
H[i][n] = cdivi; H[i][n1] = cdivi;
} else { } else {
// Solve complex equations // Solve complex equations
@ -659,28 +659,28 @@ private:
} }
cdiv(x * r - z * ra + q * sa, cdiv(x * r - z * ra + q * sa,
x * s - z * sa - q * ra, vr, vi); x * s - z * sa - q * ra, vr, vi);
H[i][n - 1] = cdivr; H[i][n1 - 1] = cdivr;
H[i][n] = cdivi; H[i][n1] = cdivi;
if (std::abs(x) > (std::abs(z) + std::abs(q))) { if (std::abs(x) > (std::abs(z) + std::abs(q))) {
H[i + 1][n - 1] = (-ra - w * H[i][n - 1] + q H[i + 1][n1 - 1] = (-ra - w * H[i][n1 - 1] + q
* H[i][n]) / x; * H[i][n1]) / x;
H[i + 1][n] = (-sa - w * H[i][n] - q * H[i][n H[i + 1][n1] = (-sa - w * H[i][n1] - q * H[i][n1
- 1]) / x; - 1]) / x;
} else { } else {
cdiv(-r - y * H[i][n - 1], -s - y * H[i][n], z, cdiv(-r - y * H[i][n1 - 1], -s - y * H[i][n1], z,
q); q);
H[i + 1][n - 1] = cdivr; H[i + 1][n1 - 1] = cdivr;
H[i + 1][n] = cdivi; H[i + 1][n1] = cdivi;
} }
} }
// Overflow control // Overflow control
t = max(std::abs(H[i][n - 1]), std::abs(H[i][n])); t = max(std::abs(H[i][n1 - 1]), std::abs(H[i][n1]));
if ((eps * t) * t > 1) { if ((eps * t) * t > 1) {
for (int j = i; j <= n; j++) { for (int j = i; j <= n1; j++) {
H[j][n - 1] = H[j][n - 1] / t; H[j][n1 - 1] = H[j][n1 - 1] / t;
H[j][n] = H[j][n] / t; H[j][n1] = H[j][n1] / t;
} }
} }
} }

68
modules/contrib/src/logpolar_bsm.cpp
View File

@ -62,7 +62,7 @@ namespace cv
{ {
//------------------------------------interp------------------------------------------- //------------------------------------interp-------------------------------------------
LogPolar_Interp::LogPolar_Interp(int w, int h, Point2i center, int R, double ro0, int interp, int full, int S, int sp) LogPolar_Interp::LogPolar_Interp(int w, int h, Point2i center, int _R, double _ro0, int _interp, int full, int _S, int sp)
{ {
if ( (center.x!=w/2 || center.y!=h/2) && full==0) full=1; if ( (center.x!=w/2 || center.y!=h/2) && full==0) full=1;
@ -97,23 +97,23 @@ LogPolar_Interp::LogPolar_Interp(int w, int h, Point2i center, int R, double ro0
if (sp){ if (sp){
int jc=M/2-1, ic=N/2-1; int jc=M/2-1, ic=N/2-1;
int romax=min(ic, jc); int _romax=min(ic, jc);
double a=exp(log((double)(romax/2-1)/(double)ro0)/(double)R); double _a=exp(log((double)(_romax/2-1)/(double)ro0)/(double)R);
S=(int) floor(2*CV_PI/(a-1)+0.5); S=(int) floor(2*CV_PI/(_a-1)+0.5);
} }
this->interp=interp; interp=_interp;
create_map(M, N, R, S, ro0); create_map(M, N, _R, _S, _ro0);
} }
void LogPolar_Interp::create_map(int M, int N, int R, int S, double ro0) void LogPolar_Interp::create_map(int _M, int _N, int _R, int _S, double _ro0)
{ {
this->M=M; M=_M;
this->N=N; N=_N;
this->R=R; R=_R;
this->S=S; S=_S;
this->ro0=ro0; ro0=_ro0;
int jc=N/2-1, ic=M/2-1; int jc=N/2-1, ic=M/2-1;
romax=min(ic, jc); romax=min(ic, jc);
@ -208,7 +208,7 @@ LogPolar_Interp::~LogPolar_Interp()
//------------------------------------overlapping---------------------------------- //------------------------------------overlapping----------------------------------
LogPolar_Overlapping::LogPolar_Overlapping(int w, int h, Point2i center, int R, double ro0, int full, int S, int sp) LogPolar_Overlapping::LogPolar_Overlapping(int w, int h, Point2i center, int _R, double _ro0, int full, int _S, int sp)
{ {
if ( (center.x!=w/2 || center.y!=h/2) && full==0) full=1; if ( (center.x!=w/2 || center.y!=h/2) && full==0) full=1;
@ -244,21 +244,21 @@ LogPolar_Overlapping::LogPolar_Overlapping(int w, int h, Point2i center, int R,
if (sp){ if (sp){
int jc=M/2-1, ic=N/2-1; int jc=M/2-1, ic=N/2-1;
int romax=min(ic, jc); int _romax=min(ic, jc);
double a=exp(log((double)(romax/2-1)/(double)ro0)/(double)R); double _a=exp(log((double)(_romax/2-1)/(double)ro0)/(double)R);
S=(int) floor(2*CV_PI/(a-1)+0.5); S=(int) floor(2*CV_PI/(_a-1)+0.5);
} }
create_map(M, N, R, S, ro0); create_map(M, N, _R, _S, _ro0);
} }
void LogPolar_Overlapping::create_map(int M, int N, int R, int S, double ro0) void LogPolar_Overlapping::create_map(int _M, int _N, int _R, int _S, double _ro0)
{ {
this->M=M; M=_M;
this->N=N; N=_N;
this->R=R; R=_R;
this->S=S; S=_S;
this->ro0=ro0; ro0=_ro0;
int jc=N/2-1, ic=M/2-1; int jc=N/2-1, ic=M/2-1;
romax=min(ic, jc); romax=min(ic, jc);
@ -433,7 +433,7 @@ LogPolar_Overlapping::~LogPolar_Overlapping()
//----------------------------------------adjacent--------------------------------------- //----------------------------------------adjacent---------------------------------------
LogPolar_Adjacent::LogPolar_Adjacent(int w, int h, Point2i center, int R, double ro0, double smin, int full, int S, int sp) LogPolar_Adjacent::LogPolar_Adjacent(int w, int h, Point2i center, int _R, double _ro0, double smin, int full, int _S, int sp)
{ {
if ( (center.x!=w/2 || center.y!=h/2) && full==0) full=1; if ( (center.x!=w/2 || center.y!=h/2) && full==0) full=1;
@ -468,22 +468,22 @@ LogPolar_Adjacent::LogPolar_Adjacent(int w, int h, Point2i center, int R, double
if (sp){ if (sp){
int jc=M/2-1, ic=N/2-1; int jc=M/2-1, ic=N/2-1;
int romax=min(ic, jc); int _romax=min(ic, jc);
double a=exp(log((double)(romax/2-1)/(double)ro0)/(double)R); double _a=exp(log((double)(_romax/2-1)/(double)ro0)/(double)R);
S=(int) floor(2*CV_PI/(a-1)+0.5); S=(int) floor(2*CV_PI/(_a-1)+0.5);
} }
create_map(M, N, R, S, ro0, smin); create_map(M, N, _R, _S, _ro0, smin);
} }
void LogPolar_Adjacent::create_map(int M, int N, int R, int S, double ro0, double smin) void LogPolar_Adjacent::create_map(int _M, int _N, int _R, int _S, double _ro0, double smin)
{ {
LogPolar_Adjacent::M=M; M=_M;
LogPolar_Adjacent::N=N; N=_N;
LogPolar_Adjacent::R=R; R=_R;
LogPolar_Adjacent::S=S; S=_S;
LogPolar_Adjacent::ro0=ro0; ro0=_ro0;
romax=min(M/2.0, N/2.0); romax=min(M/2.0, N/2.0);
a=exp(log(romax/ro0)/(double)R); a=exp(log(romax/ro0)/(double)R);

10
modules/contrib/src/octree.cpp
View File

@ -171,9 +171,9 @@ namespace cv
{ {
} }
Octree::Octree(const vector<Point3f>& points3d, int maxLevels, int minPoints) Octree::Octree(const vector<Point3f>& points3d, int maxLevels, int _minPoints)
{ {
buildTree(points3d, maxLevels, minPoints); buildTree(points3d, maxLevels, _minPoints);
} }
Octree::~Octree() Octree::~Octree()
@ -256,12 +256,12 @@ namespace cv
} }
} }
void Octree::buildTree(const vector<Point3f>& points3d, int maxLevels, int minPoints) void Octree::buildTree(const vector<Point3f>& points3d, int maxLevels, int _minPoints)
{ {
assert((size_t)maxLevels * 8 < MAX_STACK_SIZE); assert((size_t)maxLevels * 8 < MAX_STACK_SIZE);
points.resize(points3d.size()); points.resize(points3d.size());
std::copy(points3d.begin(), points3d.end(), points.begin()); std::copy(points3d.begin(), points3d.end(), points.begin());
this->minPoints = minPoints; minPoints = _minPoints;
nodes.clear(); nodes.clear();
nodes.push_back(Node()); nodes.push_back(Node());
@ -275,7 +275,7 @@ namespace cv
for (size_t i = 0; i < MAX_LEAFS; i++) for (size_t i = 0; i < MAX_LEAFS; i++)
root.children[i] = 0; root.children[i] = 0;
if (maxLevels != 1 && (root.end - root.begin) > minPoints) if (maxLevels != 1 && (root.end - root.begin) > _minPoints)
{ {
root.isLeaf = false; root.isLeaf = false;
buildNext(0); buildNext(0);

16
modules/contrib/src/retina.cpp
View File

@ -75,16 +75,16 @@
namespace cv namespace cv
{ {
Retina::Retina(const cv::Size inputSize) Retina::Retina(const cv::Size inputSz)
{ {
_retinaFilter = 0; _retinaFilter = 0;
_init(inputSize, true, RETINA_COLOR_BAYER, false); _init(inputSz, true, RETINA_COLOR_BAYER, false);
} }
Retina::Retina(const cv::Size inputSize, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod, const bool useRetinaLogSampling, const double reductionFactor, const double samplingStrenght) Retina::Retina(const cv::Size inputSz, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod, const bool useRetinaLogSampling, const double reductionFactor, const double samplingStrenght)
{ {
_retinaFilter = 0; _retinaFilter = 0;
_init(inputSize, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght); _init(inputSz, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght);
}; };
Retina::~Retina() Retina::~Retina()
@ -342,20 +342,20 @@ const std::valarray<float> & Retina::getMagno() const {return _retinaFilter->get
const std::valarray<float> & Retina::getParvo() const {if (_retinaFilter->getColorMode())return _retinaFilter->getColorOutput(); /* implicite else */return _retinaFilter->getContours();} const std::valarray<float> & Retina::getParvo() const {if (_retinaFilter->getColorMode())return _retinaFilter->getColorOutput(); /* implicite else */return _retinaFilter->getContours();}
// private method called by constructirs // private method called by constructirs
void Retina::_init(const cv::Size inputSize, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod, const bool useRetinaLogSampling, const double reductionFactor, const double samplingStrenght) void Retina::_init(const cv::Size inputSz, const bool colorMode, RETINA_COLORSAMPLINGMETHOD colorSamplingMethod, const bool useRetinaLogSampling, const double reductionFactor, const double samplingStrenght)
{ {
// basic error check // basic error check
if (inputSize.height*inputSize.width <= 0) if (inputSz.height*inputSz.width <= 0)
throw cv::Exception(-1, "Bad retina size setup : size height and with must be superior to zero", "Retina::setup", "Retina.h", 0); throw cv::Exception(-1, "Bad retina size setup : size height and with must be superior to zero", "Retina::setup", "Retina.h", 0);
unsigned int nbPixels=inputSize.height*inputSize.width; unsigned int nbPixels=inputSz.height*inputSz.width;
// resize buffers if size does not match // resize buffers if size does not match
_inputBuffer.resize(nbPixels*3); // buffer supports gray images but also 3 channels color buffers... (larger is better...) _inputBuffer.resize(nbPixels*3); // buffer supports gray images but also 3 channels color buffers... (larger is better...)
// allocate the retina model // allocate the retina model
if (_retinaFilter) if (_retinaFilter)
delete _retinaFilter; delete _retinaFilter;
_retinaFilter = new RetinaFilter(inputSize.height, inputSize.width, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght); _retinaFilter = new RetinaFilter(inputSz.height, inputSz.width, colorMode, colorSamplingMethod, useRetinaLogSampling, reductionFactor, samplingStrenght);
// prepare the default parameter XML file with default setup // prepare the default parameter XML file with default setup
setup(_retinaParameters); setup(_retinaParameters);

6
modules/contrib/src/retinacolor.cpp
View File

@ -325,15 +325,15 @@ void RetinaColor::runColorDemultiplexing(const std::valarray<float> &multiplexed
}else }else
{ {
register const float *multiplexedColorFramePTR= get_data(multiplexedColorFrame); register const float *multiplexedColorFramePTR1= get_data(multiplexedColorFrame);
for (unsigned int indexc=0; indexc<_filterOutput.getNBpixels() ; ++indexc, ++chrominancePTR, ++colorLocalDensityPTR, ++luminance, ++multiplexedColorFramePTR) for (unsigned int indexc=0; indexc<_filterOutput.getNBpixels() ; ++indexc, ++chrominancePTR, ++colorLocalDensityPTR, ++luminance, ++multiplexedColorFramePTR1)
{ {
// normalize by photoreceptors density // normalize by photoreceptors density
float Cr=*(chrominancePTR)*_colorLocalDensity[indexc]; float Cr=*(chrominancePTR)*_colorLocalDensity[indexc];
float Cg=*(chrominancePTR+_filterOutput.getNBpixels())*_colorLocalDensity[indexc+_filterOutput.getNBpixels()]; float Cg=*(chrominancePTR+_filterOutput.getNBpixels())*_colorLocalDensity[indexc+_filterOutput.getNBpixels()];
float Cb=*(chrominancePTR+_filterOutput.getDoubleNBpixels())*_colorLocalDensity[indexc+_filterOutput.getDoubleNBpixels()]; float Cb=*(chrominancePTR+_filterOutput.getDoubleNBpixels())*_colorLocalDensity[indexc+_filterOutput.getDoubleNBpixels()];
*luminance=(Cr+Cg+Cb)*_pG; *luminance=(Cr+Cg+Cb)*_pG;
_demultiplexedTempBuffer[_colorSampling[indexc]] = *multiplexedColorFramePTR - *luminance; _demultiplexedTempBuffer[_colorSampling[indexc]] = *multiplexedColorFramePTR1 - *luminance;
} }

20
modules/contrib/src/spinimages.cpp
View File

@ -336,18 +336,18 @@ void computeSpinImages( const Octree& Octree, const vector<Point3f>& points, con
__m128 f1f2 = _mm_mul_ps(f1, f2); // f1 * f2 __m128 f1f2 = _mm_mul_ps(f1, f2); // f1 * f2
__m128 omf1omf2 = _mm_add_ps(_mm_sub_ps(_mm_sub_ps(one4f, f2), f1), f1f2); // (1-f1) * (1-f2) __m128 omf1omf2 = _mm_add_ps(_mm_sub_ps(_mm_sub_ps(one4f, f2), f1), f1f2); // (1-f1) * (1-f2)
__m128i mask = _mm_and_si128( __m128i _mask = _mm_and_si128(
_mm_andnot_si128(_mm_cmpgt_epi32(zero4, n1), _mm_cmpgt_epi32(height4m1, n1)), _mm_andnot_si128(_mm_cmpgt_epi32(zero4, n1), _mm_cmpgt_epi32(height4m1, n1)),
_mm_andnot_si128(_mm_cmpgt_epi32(zero4, n2), _mm_cmpgt_epi32(width4m1, n2))); _mm_andnot_si128(_mm_cmpgt_epi32(zero4, n2), _mm_cmpgt_epi32(width4m1, n2)));
__m128 maskf = _mm_cmpneq_ps(_mm_cvtepi32_ps(mask), zero4f); __m128 maskf = _mm_cmpneq_ps(_mm_cvtepi32_ps(_mask), zero4f);
__m128 v00 = _mm_and_ps( omf1omf2 , maskf); // a00 b00 c00 d00 __m128 v00 = _mm_and_ps( omf1omf2 , maskf); // a00 b00 c00 d00
__m128 v01 = _mm_and_ps( _mm_sub_ps( f2, f1f2 ), maskf); // a01 b01 c01 d01 __m128 v01 = _mm_and_ps( _mm_sub_ps( f2, f1f2 ), maskf); // a01 b01 c01 d01
__m128 v10 = _mm_and_ps( _mm_sub_ps( f1, f1f2 ), maskf); // a10 b10 c10 d10 __m128 v10 = _mm_and_ps( _mm_sub_ps( f1, f1f2 ), maskf); // a10 b10 c10 d10
__m128 v11 = _mm_and_ps( f1f2 , maskf); // a11 b11 c11 d11 __m128 v11 = _mm_and_ps( f1f2 , maskf); // a11 b11 c11 d11
__m128i ofs4 = _mm_and_si128(_mm_add_epi32(_mm_mullo_epi32_emul(n1, step4), n2), mask); __m128i ofs4 = _mm_and_si128(_mm_add_epi32(_mm_mullo_epi32_emul(n1, step4), n2), _mask);
_mm_store_si128((__m128i*)o, ofs4); _mm_store_si128((__m128i*)o, ofs4);
__m128 t0 = _mm_unpacklo_ps(v00, v01); // a00 a01 b00 b01 __m128 t0 = _mm_unpacklo_ps(v00, v01); // a00 a01 b00 b01
@ -823,21 +823,21 @@ void cv::SpinImageModel::setSubset(const vector<int>& ss)
subset = ss; subset = ss;
} }
void cv::SpinImageModel::repackSpinImages(const vector<uchar>& mask, Mat& spinImages, bool reAlloc) const void cv::SpinImageModel::repackSpinImages(const vector<uchar>& mask, Mat& _spinImages, bool reAlloc) const
{ {
if (reAlloc) if (reAlloc)
{ {
size_t spinCount = mask.size() - count(mask.begin(), mask.end(), (uchar)0); size_t spinCount = mask.size() - count(mask.begin(), mask.end(), (uchar)0);
Mat newImgs((int)spinCount, spinImages.cols, spinImages.type()); Mat newImgs((int)spinCount, _spinImages.cols, _spinImages.type());
int pos = 0; int pos = 0;
for(size_t t = 0; t < mask.size(); ++t) for(size_t t = 0; t < mask.size(); ++t)
if (mask[t]) if (mask[t])
{ {
Mat row = newImgs.row(pos++); Mat row = newImgs.row(pos++);
spinImages.row((int)t).copyTo(row); _spinImages.row((int)t).copyTo(row);
} }
spinImages = newImgs; _spinImages = newImgs;
} }
else else
{ {
@ -851,11 +851,11 @@ void cv::SpinImageModel::repackSpinImages(const vector<uchar>& mask, Mat& spinIm
for (; first != last; ++first) for (; first != last; ++first)
if (mask[first] != 0) if (mask[first] != 0)
{ {
Mat row = spinImages.row(dest); Mat row = _spinImages.row(dest);
spinImages.row(first).copyTo(row); _spinImages.row(first).copyTo(row);
++dest; ++dest;
} }
spinImages = spinImages.rowRange(0, dest); _spinImages = _spinImages.rowRange(0, dest);
} }
} }

10
modules/contrib/src/stereovar.cpp
View File

@ -204,10 +204,10 @@ void StereoVar::VariationalSolver(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level)
break; break;
} }
float fi = Fi; float _fi = Fi;
if (maxDisp > minDisp) { if (maxDisp > minDisp) {
if (pU[x] > maxDisp * scale) {fi *= 1000; pU[x] = static_cast<float>(maxDisp * scale);} if (pU[x] > maxDisp * scale) {_fi *= 1000; pU[x] = static_cast<float>(maxDisp * scale);}
if (pU[x] < minDisp * scale) {fi *= 1000; pU[x] = static_cast<float>(minDisp * scale);} if (pU[x] < minDisp * scale) {_fi *= 1000; pU[x] = static_cast<float>(minDisp * scale);}
} }
int A = static_cast<int>(pU[x]); int A = static_cast<int>(pU[x]);
@ -219,8 +219,8 @@ void StereoVar::VariationalSolver(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level)
pu[x] = pU[- A + 2]; pu[x] = pU[- A + 2];
else { else {
pu[x] = A + (pI2x[x + A + neg] * (pI1[x] - pI2[x + A]) pu[x] = A + (pI2x[x + A + neg] * (pI1[x] - pI2[x + A])
+ fi * (gr * pU[x + 1] + gl * pU[x - 1] + gu * pUu[x] + gd * pUd[x] - gc * A)) + _fi * (gr * pU[x + 1] + gl * pU[x - 1] + gu * pUu[x] + gd * pUd[x] - gc * A))
/ (pI2x[x + A + neg] * pI2x[x + A + neg] + gc * fi) ; / (pI2x[x + A + neg] * pI2x[x + A + neg] + gc * _fi) ;
} }
}// x }// x
pu[0] = pu[1]; pu[0] = pu[1];

6
modules/core/CMakeLists.txt
View File

@ -5,12 +5,10 @@ ocv_module_include_directories(${ZLIB_INCLUDE_DIR})
if(HAVE_CUDA) if(HAVE_CUDA)
file(GLOB lib_cuda "src/cuda/*.cu") file(GLOB lib_cuda "src/cuda/*.cu")
source_group("Cuda" FILES "${lib_cuda}") source_group("Cuda" FILES "${lib_cuda}")
include_directories(AFTER SYSTEM ${CUDA_INCLUDE_DIRS})
ocv_include_directories("${OpenCV_SOURCE_DIR}/modules/gpu/src" "${OpenCV_SOURCE_DIR}/modules/gpu/src/cuda")
ocv_include_directories("${OpenCV_SOURCE_DIR}/modules/gpu/src" "${OpenCV_SOURCE_DIR}/modules/gpu/src/cuda" ${CUDA_INCLUDE_DIRS})
ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef) ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef)
ocv_cuda_compile(cuda_objs ${lib_cuda})
OCV_CUDA_COMPILE(cuda_objs ${lib_cuda})
set(cuda_link_libs ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY}) set(cuda_link_libs ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
else() else()

10
modules/core/include/opencv2/core/gpumat.hpp
View File

@ -366,12 +366,12 @@ namespace cv { namespace gpu
return m; return m;
} }
inline void GpuMat::assignTo(GpuMat& m, int type) const inline void GpuMat::assignTo(GpuMat& m, int _type) const
{ {
if (type < 0) if (_type < 0)
m = *this; m = *this;
else else
convertTo(m, type); convertTo(m, _type);
} }
inline size_t GpuMat::step1() const inline size_t GpuMat::step1() const
@ -434,9 +434,9 @@ namespace cv { namespace gpu
create(size_.height, size_.width, type_); create(size_.height, size_.width, type_);
} }
inline GpuMat GpuMat::operator()(Range rowRange, Range colRange) const inline GpuMat GpuMat::operator()(Range _rowRange, Range _colRange) const
{ {
return GpuMat(*this, rowRange, colRange); return GpuMat(*this, _rowRange, _colRange);
} }
inline GpuMat GpuMat::operator()(Rect roi) const inline GpuMat GpuMat::operator()(Rect roi) const

24
modules/core/include/opencv2/core/mat.hpp
View File

@ -336,12 +336,12 @@ inline Mat Mat::clone() const
return m; return m;
} }
inline void Mat::assignTo( Mat& m, int type ) const inline void Mat::assignTo( Mat& m, int _type ) const
{ {
if( type < 0 ) if( _type < 0 )
m = *this; m = *this;
else else
convertTo(m, type); convertTo(m, _type);
} }
inline void Mat::create(int _rows, int _cols, int _type) inline void Mat::create(int _rows, int _cols, int _type)
@ -370,9 +370,9 @@ inline void Mat::release()
refcount = 0; refcount = 0;
} }
inline Mat Mat::operator()( Range rowRange, Range colRange ) const inline Mat Mat::operator()( Range _rowRange, Range _colRange ) const
{ {
return Mat(*this, rowRange, colRange); return Mat(*this, _rowRange, _colRange);
} }
inline Mat Mat::operator()( const Rect& roi ) const inline Mat Mat::operator()( const Rect& roi ) const
@ -829,8 +829,8 @@ template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m)
template<typename _Tp> inline Mat_<_Tp>::Mat_(int _rows, int _cols, _Tp* _data, size_t steps) template<typename _Tp> inline Mat_<_Tp>::Mat_(int _rows, int _cols, _Tp* _data, size_t steps)
: Mat(_rows, _cols, DataType<_Tp>::type, _data, steps) {} : Mat(_rows, _cols, DataType<_Tp>::type, _data, steps) {}
template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m, const Range& rowRange, const Range& colRange) template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m, const Range& _rowRange, const Range& _colRange)
: Mat(m, rowRange, colRange) {} : Mat(m, _rowRange, _colRange) {}
template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m, const Rect& roi) template<typename _Tp> inline Mat_<_Tp>::Mat_(const Mat_& m, const Rect& roi)
: Mat(m, roi) {} : Mat(m, roi) {}
@ -967,8 +967,8 @@ template<typename _Tp> inline size_t Mat_<_Tp>::step1(int i) const { return step
template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::adjustROI( int dtop, int dbottom, int dleft, int dright ) template<typename _Tp> inline Mat_<_Tp>& Mat_<_Tp>::adjustROI( int dtop, int dbottom, int dleft, int dright )
{ return (Mat_<_Tp>&)(Mat::adjustROI(dtop, dbottom, dleft, dright)); } { return (Mat_<_Tp>&)(Mat::adjustROI(dtop, dbottom, dleft, dright)); }
template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Range& rowRange, const Range& colRange ) const template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Range& _rowRange, const Range& _colRange ) const
{ return Mat_<_Tp>(*this, rowRange, colRange); } { return Mat_<_Tp>(*this, _rowRange, _colRange); }
template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Rect& roi ) const template<typename _Tp> inline Mat_<_Tp> Mat_<_Tp>::operator()( const Rect& roi ) const
{ return Mat_<_Tp>(*this, roi); } { return Mat_<_Tp>(*this, roi); }
@ -2123,12 +2123,12 @@ inline SparseMat SparseMat::clone() const
} }
inline void SparseMat::assignTo( SparseMat& m, int type ) const inline void SparseMat::assignTo( SparseMat& m, int _type ) const
{ {
if( type < 0 ) if( _type < 0 )
m = *this; m = *this;
else else
convertTo(m, type); convertTo(m, _type);
} }
inline void SparseMat::addref() inline void SparseMat::addref()

101
modules/core/include/opencv2/core/opengl_interop.hpp
View File

@ -49,10 +49,10 @@
namespace cv namespace cv
{ {
//! Smart pointer for OpenGL buffer memory with reference counting. //! Smart pointer for OpenGL buffer memory with reference counting.
class CV_EXPORTS GlBuffer class CV_EXPORTS GlBuffer
{ {
public: public:
enum Usage enum Usage
{ {
ARRAY_BUFFER = 0x8892, // buffer will use for OpenGL arrays (vertices, colors, normals, etc) ARRAY_BUFFER = 0x8892, // buffer will use for OpenGL arrays (vertices, colors, normals, etc)
@ -70,9 +70,9 @@ namespace cv
GlBuffer(InputArray mat, Usage usage); GlBuffer(InputArray mat, Usage usage);
void create(int rows, int cols, int type, Usage usage); void create(int rows, int cols, int type, Usage usage);
inline void create(Size size, int type, Usage usage) { create(size.height, size.width, type, usage); } void create(Size size, int type, Usage usage);
inline void create(int rows, int cols, int type) { create(rows, cols, type, usage()); } void create(int rows, int cols, int type);
inline void create(Size size, int type) { create(size.height, size.width, type, usage()); } void create(Size size, int type);
void release(); void release();
@ -104,21 +104,21 @@ namespace cv
inline Usage usage() const { return usage_; } inline Usage usage() const { return usage_; }
class Impl; class Impl;
private: private:
int rows_; int rows_;
int cols_; int cols_;
int type_; int type_;
Usage usage_; Usage usage_;
Ptr<Impl> impl_; Ptr<Impl> impl_;
}; };
template <> CV_EXPORTS void Ptr<GlBuffer::Impl>::delete_obj(); template <> CV_EXPORTS void Ptr<GlBuffer::Impl>::delete_obj();
//! Smart pointer for OpenGL 2d texture memory with reference counting. //! Smart pointer for OpenGL 2d texture memory with reference counting.
class CV_EXPORTS GlTexture class CV_EXPORTS GlTexture
{ {
public: public:
//! create empty texture //! create empty texture
GlTexture(); GlTexture();
@ -130,7 +130,7 @@ namespace cv
explicit GlTexture(InputArray mat, bool bgra = true); explicit GlTexture(InputArray mat, bool bgra = true);
void create(int rows, int cols, int type); void create(int rows, int cols, int type);
inline void create(Size size, int type) { create(size.height, size.width, type); } void create(Size size, int type);
void release(); void release();
//! copy from host/device memory //! copy from host/device memory
@ -151,21 +151,21 @@ namespace cv
inline int elemSize1() const { return CV_ELEM_SIZE1(type_); } inline int elemSize1() const { return CV_ELEM_SIZE1(type_); }
class Impl; class Impl;
private: private:
int rows_; int rows_;
int cols_; int cols_;
int type_; int type_;
Ptr<Impl> impl_; Ptr<Impl> impl_;
GlBuffer buf_; GlBuffer buf_;
}; };
template <> CV_EXPORTS void Ptr<GlTexture::Impl>::delete_obj(); template <> CV_EXPORTS void Ptr<GlTexture::Impl>::delete_obj();
//! OpenGL Arrays //! OpenGL Arrays
class CV_EXPORTS GlArrays class CV_EXPORTS GlArrays
{ {
public: public:
inline GlArrays() inline GlArrays()
: vertex_(GlBuffer::ARRAY_BUFFER), color_(GlBuffer::ARRAY_BUFFER), bgra_(true), normal_(GlBuffer::ARRAY_BUFFER), texCoord_(GlBuffer::ARRAY_BUFFER) : vertex_(GlBuffer::ARRAY_BUFFER), color_(GlBuffer::ARRAY_BUFFER), bgra_(true), normal_(GlBuffer::ARRAY_BUFFER), texCoord_(GlBuffer::ARRAY_BUFFER)
{ {
@ -191,18 +191,18 @@ namespace cv
inline Size size() const { return vertex_.size(); } inline Size size() const { return vertex_.size(); }
inline bool empty() const { return vertex_.empty(); } inline bool empty() const { return vertex_.empty(); }
private: private:
GlBuffer vertex_; GlBuffer vertex_;
GlBuffer color_; GlBuffer color_;
bool bgra_; bool bgra_;
GlBuffer normal_; GlBuffer normal_;
GlBuffer texCoord_; GlBuffer texCoord_;
}; };
//! OpenGL Font //! OpenGL Font
class CV_EXPORTS GlFont class CV_EXPORTS GlFont
{ {
public: public:
enum Weight enum Weight
{ {
WEIGHT_LIGHT = 300, WEIGHT_LIGHT = 300,
@ -228,7 +228,7 @@ namespace cv
inline Weight weight() const { return weight_; } inline Weight weight() const { return weight_; }
inline Style style() const { return style_; } inline Style style() const { return style_; }
private: private:
GlFont(const std::string& family, int height, Weight weight, Style style); GlFont(const std::string& family, int height, Weight weight, Style style);
std::string family_; std::string family_;
@ -240,17 +240,17 @@ namespace cv
GlFont(const GlFont&); GlFont(const GlFont&);
GlFont& operator =(const GlFont&); GlFont& operator =(const GlFont&);
}; };
//! render functions //! render functions
//! render texture rectangle in window //! render texture rectangle in window
CV_EXPORTS void render(const GlTexture& tex, CV_EXPORTS void render(const GlTexture& tex,
Rect_<double> wndRect = Rect_<double>(0.0, 0.0, 1.0, 1.0), Rect_<double> wndRect = Rect_<double>(0.0, 0.0, 1.0, 1.0),
Rect_<double> texRect = Rect_<double>(0.0, 0.0, 1.0, 1.0)); Rect_<double> texRect = Rect_<double>(0.0, 0.0, 1.0, 1.0));
//! render mode //! render mode
namespace RenderMode { namespace RenderMode {
enum { enum {
POINTS = 0x0000, POINTS = 0x0000,
LINES = 0x0001, LINES = 0x0001,
@ -263,17 +263,17 @@ namespace cv
QUAD_STRIP = 0x0008, QUAD_STRIP = 0x0008,
POLYGON = 0x0009 POLYGON = 0x0009
}; };
} }
//! render OpenGL arrays //! render OpenGL arrays
CV_EXPORTS void render(const GlArrays& arr, int mode = RenderMode::POINTS, Scalar color = Scalar::all(255)); CV_EXPORTS void render(const GlArrays& arr, int mode = RenderMode::POINTS, Scalar color = Scalar::all(255));
CV_EXPORTS void render(const std::string& str, const Ptr<GlFont>& font, Scalar color, Point2d pos); CV_EXPORTS void render(const std::string& str, const Ptr<GlFont>& font, Scalar color, Point2d pos);
//! OpenGL camera //! OpenGL camera
class CV_EXPORTS GlCamera class CV_EXPORTS GlCamera
{ {
public: public:
GlCamera(); GlCamera();
void lookAt(Point3d eye, Point3d center, Point3d up); void lookAt(Point3d eye, Point3d center, Point3d up);
@ -288,7 +288,7 @@ namespace cv
void setupProjectionMatrix() const; void setupProjectionMatrix() const;
void setupModelViewMatrix() const; void setupModelViewMatrix() const;
private: private:
Point3d eye_; Point3d eye_;
Point3d center_; Point3d center_;
Point3d up_; Point3d up_;
@ -316,13 +316,18 @@ namespace cv
double zFar_; double zFar_;
bool perspectiveProjection_; bool perspectiveProjection_;
}; };
namespace gpu inline void GlBuffer::create(Size _size, int _type, Usage _usage) { create(_size.height, _size.width, _type, _usage); }
{ inline void GlBuffer::create(int _rows, int _cols, int _type) { create(_rows, _cols, _type, usage()); }
inline void GlBuffer::create(Size _size, int _type) { create(_size.height, _size.width, _type, usage()); }
inline void GlTexture::create(Size _size, int _type) { create(_size.height, _size.width, _type); }
namespace gpu
{
//! set a CUDA device to use OpenGL interoperability //! set a CUDA device to use OpenGL interoperability
CV_EXPORTS void setGlDevice(int device = 0); CV_EXPORTS void setGlDevice(int device = 0);
} }
} // namespace cv } // namespace cv
#endif // __cplusplus #endif // __cplusplus

26
modules/core/include/opencv2/core/operations.hpp
View File

@ -2616,20 +2616,20 @@ template<typename _Tp> inline void Ptr<_Tp>::delete_obj()
template<typename _Tp> inline Ptr<_Tp>::~Ptr() { release(); } template<typename _Tp> inline Ptr<_Tp>::~Ptr() { release(); }
template<typename _Tp> inline Ptr<_Tp>::Ptr(const Ptr<_Tp>& ptr) template<typename _Tp> inline Ptr<_Tp>::Ptr(const Ptr<_Tp>& _ptr)
{ {
obj = ptr.obj; obj = _ptr.obj;
refcount = ptr.refcount; refcount = _ptr.refcount;
addref(); addref();
} }
template<typename _Tp> inline Ptr<_Tp>& Ptr<_Tp>::operator = (const Ptr<_Tp>& ptr) template<typename _Tp> inline Ptr<_Tp>& Ptr<_Tp>::operator = (const Ptr<_Tp>& _ptr)
{ {
int* _refcount = ptr.refcount; int* _refcount = _ptr.refcount;
if( _refcount ) if( _refcount )
CV_XADD(_refcount, 1); CV_XADD(_refcount, 1);
release(); release();
obj = ptr.obj; obj = _ptr.obj;
refcount = _refcount; refcount = _refcount;
return *this; return *this;
} }
@ -3593,10 +3593,10 @@ template<typename _Tp> inline Seq<_Tp>::operator vector<_Tp>() const
template<typename _Tp> inline SeqIterator<_Tp>::SeqIterator() template<typename _Tp> inline SeqIterator<_Tp>::SeqIterator()
{ memset(this, 0, sizeof(*this)); } { memset(this, 0, sizeof(*this)); }
template<typename _Tp> inline SeqIterator<_Tp>::SeqIterator(const Seq<_Tp>& seq, bool seekEnd) template<typename _Tp> inline SeqIterator<_Tp>::SeqIterator(const Seq<_Tp>& _seq, bool seekEnd)
{ {
cvStartReadSeq(seq.seq, this); cvStartReadSeq(_seq.seq, this);
index = seekEnd ? seq.seq->total : 0; index = seekEnd ? _seq.seq->total : 0;
} }
template<typename _Tp> inline void SeqIterator<_Tp>::seek(size_t pos) template<typename _Tp> inline void SeqIterator<_Tp>::seek(size_t pos)
@ -3842,17 +3842,17 @@ template<typename _Tp> inline Ptr<_Tp> Algorithm::create(const string& name)
return _create(name).ptr<_Tp>(); return _create(name).ptr<_Tp>();
} }
template<typename _Tp> inline typename ParamType<_Tp>::member_type Algorithm::get(const string& name) const template<typename _Tp> inline typename ParamType<_Tp>::member_type Algorithm::get(const string& _name) const
{ {
typename ParamType<_Tp>::member_type value; typename ParamType<_Tp>::member_type value;
info()->get(this, name.c_str(), ParamType<_Tp>::type, &value); info()->get(this, _name.c_str(), ParamType<_Tp>::type, &value);
return value; return value;
} }
template<typename _Tp> inline typename ParamType<_Tp>::member_type Algorithm::get(const char* name) const template<typename _Tp> inline typename ParamType<_Tp>::member_type Algorithm::get(const char* _name) const
{ {
typename ParamType<_Tp>::member_type value; typename ParamType<_Tp>::member_type value;
info()->get(this, name, ParamType<_Tp>::type, &value); info()->get(this, _name, ParamType<_Tp>::type, &value);
return value; return value;
} }

154
modules/core/src/algorithm.cpp
View File

@ -181,124 +181,124 @@ string Algorithm::name() const
return info()->name(); return info()->name();
} }
void Algorithm::set(const string& name, int value) void Algorithm::set(const string& parameter, int value)
{ {
info()->set(this, name.c_str(), ParamType<int>::type, &value); info()->set(this, parameter.c_str(), ParamType<int>::type, &value);
} }
void Algorithm::set(const string& name, double value) void Algorithm::set(const string& parameter, double value)
{ {
info()->set(this, name.c_str(), ParamType<double>::type, &value); info()->set(this, parameter.c_str(), ParamType<double>::type, &value);
} }
void Algorithm::set(const string& name, bool value) void Algorithm::set(const string& parameter, bool value)
{ {
info()->set(this, name.c_str(), ParamType<bool>::type, &value); info()->set(this, parameter.c_str(), ParamType<bool>::type, &value);
} }
void Algorithm::set(const string& name, const string& value) void Algorithm::set(const string& parameter, const string& value)
{ {
info()->set(this, name.c_str(), ParamType<string>::type, &value); info()->set(this, parameter.c_str(), ParamType<string>::type, &value);
} }
void Algorithm::set(const string& name, const Mat& value) void Algorithm::set(const string& parameter, const Mat& value)
{ {
info()->set(this, name.c_str(), ParamType<Mat>::type, &value); info()->set(this, parameter.c_str(), ParamType<Mat>::type, &value);
} }
void Algorithm::set(const string& name, const vector<Mat>& value) void Algorithm::set(const string& parameter, const vector<Mat>& value)
{ {
info()->set(this, name.c_str(), ParamType<vector<Mat> >::type, &value); info()->set(this, parameter.c_str(), ParamType<vector<Mat> >::type, &value);
} }
void Algorithm::set(const string& name, const Ptr<Algorithm>& value) void Algorithm::set(const string& parameter, const Ptr<Algorithm>& value)
{ {
info()->set(this, name.c_str(), ParamType<Algorithm>::type, &value); info()->set(this, parameter.c_str(), ParamType<Algorithm>::type, &value);
} }
void Algorithm::set(const char* name, int value) void Algorithm::set(const char* parameter, int value)
{ {
info()->set(this, name, ParamType<int>::type, &value); info()->set(this, parameter, ParamType<int>::type, &value);
} }
void Algorithm::set(const char* name, double value) void Algorithm::set(const char* parameter, double value)
{ {
info()->set(this, name, ParamType<double>::type, &value); info()->set(this, parameter, ParamType<double>::type, &value);
} }
void Algorithm::set(const char* name, bool value) void Algorithm::set(const char* parameter, bool value)
{ {
info()->set(this, name, ParamType<bool>::type, &value); info()->set(this, parameter, ParamType<bool>::type, &value);
} }
void Algorithm::set(const char* name, const string& value) void Algorithm::set(const char* parameter, const string& value)
{ {
info()->set(this, name, ParamType<string>::type, &value); info()->set(this, parameter, ParamType<string>::type, &value);
} }
void Algorithm::set(const char* name, const Mat& value) void Algorithm::set(const char* parameter, const Mat& value)
{ {
info()->set(this, name, ParamType<Mat>::type, &value); info()->set(this, parameter, ParamType<Mat>::type, &value);
} }
void Algorithm::set(const char* name, const vector<Mat>& value) void Algorithm::set(const char* parameter, const vector<Mat>& value)
{ {
info()->set(this, name, ParamType<vector<Mat> >::type, &value); info()->set(this, parameter, ParamType<vector<Mat> >::type, &value);
} }
void Algorithm::set(const char* name, const Ptr<Algorithm>& value) void Algorithm::set(const char* parameter, const Ptr<Algorithm>& value)
{ {
info()->set(this, name, ParamType<Algorithm>::type, &value); info()->set(this, parameter, ParamType<Algorithm>::type, &value);
} }
int Algorithm::getInt(const string& name) const int Algorithm::getInt(const string& parameter) const
{ {
return get<int>(name); return get<int>(parameter);
} }
double Algorithm::getDouble(const string& name) const double Algorithm::getDouble(const string& parameter) const
{ {
return get<double>(name); return get<double>(parameter);
} }
bool Algorithm::getBool(const string& name) const bool Algorithm::getBool(const string& parameter) const
{ {
return get<bool>(name); return get<bool>(parameter);
} }
string Algorithm::getString(const string& name) const string Algorithm::getString(const string& parameter) const
{ {
return get<string>(name); return get<string>(parameter);
} }
Mat Algorithm::getMat(const string& name) const Mat Algorithm::getMat(const string& parameter) const
{ {
return get<Mat>(name); return get<Mat>(parameter);
} }
vector<Mat> Algorithm::getMatVector(const string& name) const vector<Mat> Algorithm::getMatVector(const string& parameter) const
{ {
return get<vector<Mat> >(name); return get<vector<Mat> >(parameter);
} }
Ptr<Algorithm> Algorithm::getAlgorithm(const string& name) const Ptr<Algorithm> Algorithm::getAlgorithm(const string& parameter) const
{ {
return get<Algorithm>(name); return get<Algorithm>(parameter);
} }
string Algorithm::paramHelp(const string& name) const string Algorithm::paramHelp(const string& parameter) const
{ {
return info()->paramHelp(name.c_str()); return info()->paramHelp(parameter.c_str());
} }
int Algorithm::paramType(const string& name) const int Algorithm::paramType(const string& parameter) const
{ {
return info()->paramType(name.c_str()); return info()->paramType(parameter.c_str());
} }
int Algorithm::paramType(const char* name) const int Algorithm::paramType(const char* parameter) const
{ {
return info()->paramType(name); return info()->paramType(parameter);
} }
void Algorithm::getParams(vector<string>& names) const void Algorithm::getParams(vector<string>& names) const
@ -440,15 +440,15 @@ union GetSetParam
void (Algorithm::*set_algo)(const Ptr<Algorithm>&); void (Algorithm::*set_algo)(const Ptr<Algorithm>&);
}; };
void AlgorithmInfo::set(Algorithm* algo, const char* name, int argType, const void* value, bool force) const void AlgorithmInfo::set(Algorithm* algo, const char* parameter, int argType, const void* value, bool force) const
{ {
const Param* p = findstr(data->params, name); const Param* p = findstr(data->params, parameter);
if( !p ) if( !p )
CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", name ? name : "<NULL>") ); CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", parameter ? parameter : "<NULL>") );
if( !force && p->readonly ) if( !force && p->readonly )
CV_Error_( CV_StsError, ("Parameter '%s' is readonly", name)); CV_Error_( CV_StsError, ("Parameter '%s' is readonly", parameter));
GetSetParam f; GetSetParam f;
f.set_int = p->setter; f.set_int = p->setter;
@ -532,11 +532,11 @@ void AlgorithmInfo::set(Algorithm* algo, const char* name, int argType, const vo
CV_Error(CV_StsBadArg, "Unknown/unsupported parameter type"); CV_Error(CV_StsBadArg, "Unknown/unsupported parameter type");
} }
void AlgorithmInfo::get(const Algorithm* algo, const char* name, int argType, void* value) const void AlgorithmInfo::get(const Algorithm* algo, const char* parameter, int argType, void* value) const
{ {
const Param* p = findstr(data->params, name); const Param* p = findstr(data->params, parameter);
if( !p ) if( !p )
CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", name ? name : "<NULL>") ); CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", parameter ? parameter : "<NULL>") );
GetSetParam f; GetSetParam f;
f.get_int = p->getter; f.get_int = p->getter;
@ -606,20 +606,20 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* name, int argType, vo
} }
int AlgorithmInfo::paramType(const char* name) const int AlgorithmInfo::paramType(const char* parameter) const
{ {
const Param* p = findstr(data->params, name); const Param* p = findstr(data->params, parameter);
if( !p ) if( !p )
CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", name ? name : "<NULL>") ); CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", parameter ? parameter : "<NULL>") );
return p->type; return p->type;
} }
string AlgorithmInfo::paramHelp(const char* name) const string AlgorithmInfo::paramHelp(const char* parameter) const
{ {
const Param* p = findstr(data->params, name); const Param* p = findstr(data->params, parameter);
if( !p ) if( !p )
CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", name ? name : "<NULL>") ); CV_Error_( CV_StsBadArg, ("No parameter '%s' is found", parameter ? parameter : "<NULL>") );
return p->help; return p->help;
} }
@ -630,7 +630,7 @@ void AlgorithmInfo::getParams(vector<string>& names) const
} }
void AlgorithmInfo::addParam_(Algorithm& algo, const char* name, int argType, void AlgorithmInfo::addParam_(Algorithm& algo, const char* parameter, int argType,
void* value, bool readOnly, void* value, bool readOnly,
Algorithm::Getter getter, Algorithm::Setter setter, Algorithm::Getter getter, Algorithm::Setter setter,
const string& help) const string& help)
@ -639,79 +639,79 @@ void AlgorithmInfo::addParam_(Algorithm& algo, const char* name, int argType,
argType == Param::REAL || argType == Param::STRING || argType == Param::REAL || argType == Param::STRING ||
argType == Param::MAT || argType == Param::MAT_VECTOR || argType == Param::MAT || argType == Param::MAT_VECTOR ||
argType == Param::ALGORITHM ); argType == Param::ALGORITHM );
data->params.add(string(name), Param(argType, readOnly, data->params.add(string(parameter), Param(argType, readOnly,
(int)((size_t)value - (size_t)(void*)&algo), (int)((size_t)value - (size_t)(void*)&algo),
getter, setter, help)); getter, setter, help));
} }
void AlgorithmInfo::addParam(Algorithm& algo, const char* name, void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
int& value, bool readOnly, int& value, bool readOnly,
int (Algorithm::*getter)(), int (Algorithm::*getter)(),
void (Algorithm::*setter)(int), void (Algorithm::*setter)(int),
const string& help) const string& help)
{ {
addParam_(algo, name, ParamType<int>::type, &value, readOnly, addParam_(algo, parameter, ParamType<int>::type, &value, readOnly,
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help); (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
} }
void AlgorithmInfo::addParam(Algorithm& algo, const char* name, void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
bool& value, bool readOnly, bool& value, bool readOnly,
int (Algorithm::*getter)(), int (Algorithm::*getter)(),
void (Algorithm::*setter)(int), void (Algorithm::*setter)(int),
const string& help) const string& help)
{ {
addParam_(algo, name, ParamType<bool>::type, &value, readOnly, addParam_(algo, parameter, ParamType<bool>::type, &value, readOnly,
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help); (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
} }
void AlgorithmInfo::addParam(Algorithm& algo, const char* name, void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
double& value, bool readOnly, double& value, bool readOnly,
double (Algorithm::*getter)(), double (Algorithm::*getter)(),
void (Algorithm::*setter)(double), void (Algorithm::*setter)(double),
const string& help) const string& help)
{ {
addParam_(algo, name, ParamType<double>::type, &value, readOnly, addParam_(algo, parameter, ParamType<double>::type, &value, readOnly,
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help); (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
} }
void AlgorithmInfo::addParam(Algorithm& algo, const char* name, void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
string& value, bool readOnly, string& value, bool readOnly,
string (Algorithm::*getter)(), string (Algorithm::*getter)(),
void (Algorithm::*setter)(const string&), void (Algorithm::*setter)(const string&),
const string& help) const string& help)
{ {
addParam_(algo, name, ParamType<string>::type, &value, readOnly, addParam_(algo, parameter, ParamType<string>::type, &value, readOnly,
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help); (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
} }
void AlgorithmInfo::addParam(Algorithm& algo, const char* name, void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
Mat& value, bool readOnly, Mat& value, bool readOnly,
Mat (Algorithm::*getter)(), Mat (Algorithm::*getter)(),
void (Algorithm::*setter)(const Mat&), void (Algorithm::*setter)(const Mat&),
const string& help) const string& help)
{ {
addParam_(algo, name, ParamType<Mat>::type, &value, readOnly, addParam_(algo, parameter, ParamType<Mat>::type, &value, readOnly,
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help); (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
} }
void AlgorithmInfo::addParam(Algorithm& algo, const char* name, void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
vector<Mat>& value, bool readOnly, vector<Mat>& value, bool readOnly,
vector<Mat> (Algorithm::*getter)(), vector<Mat> (Algorithm::*getter)(),
void (Algorithm::*setter)(const vector<Mat>&), void (Algorithm::*setter)(const vector<Mat>&),
const string& help) const string& help)
{ {
addParam_(algo, name, ParamType<vector<Mat> >::type, &value, readOnly, addParam_(algo, parameter, ParamType<vector<Mat> >::type, &value, readOnly,
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help); (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
} }
void AlgorithmInfo::addParam(Algorithm& algo, const char* name, void AlgorithmInfo::addParam(Algorithm& algo, const char* parameter,
Ptr<Algorithm>& value, bool readOnly, Ptr<Algorithm>& value, bool readOnly,
Ptr<Algorithm> (Algorithm::*getter)(), Ptr<Algorithm> (Algorithm::*getter)(),
void (Algorithm::*setter)(const Ptr<Algorithm>&), void (Algorithm::*setter)(const Ptr<Algorithm>&),
const string& help) const string& help)
{ {
addParam_(algo, name, ParamType<Algorithm>::type, &value, readOnly, addParam_(algo, parameter, ParamType<Algorithm>::type, &value, readOnly,
(Algorithm::Getter)getter, (Algorithm::Setter)setter, help); (Algorithm::Getter)getter, (Algorithm::Setter)setter, help);
} }

10
modules/core/src/convert.cpp
View File

@ -335,8 +335,8 @@ void cv::merge(const Mat* mv, size_t n, OutputArray _dst)
if( j + blocksize < total ) if( j + blocksize < total )
{ {
ptrs[0] += bsz*esz; ptrs[0] += bsz*esz;
for( int k = 0; k < cn; k++ ) for( int t = 0; t < cn; t++ )
ptrs[k+1] += bsz*esz1; ptrs[t+1] += bsz*esz1;
} }
} }
} }
@ -489,12 +489,12 @@ void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, cons
dsts[k] = ptrs[tab[k*4+2]] + tab[k*4+3]; dsts[k] = ptrs[tab[k*4+2]] + tab[k*4+3];
} }
for( int j = 0; j < total; j += blocksize ) for( int t = 0; t < total; t += blocksize )
{ {
int bsz = std::min(total - j, blocksize); int bsz = std::min(total - t, blocksize);
func( srcs, sdelta, dsts, ddelta, bsz, (int)npairs ); func( srcs, sdelta, dsts, ddelta, bsz, (int)npairs );
if( j + blocksize < total ) if( t + blocksize < total )
for( k = 0; k < npairs; k++ ) for( k = 0; k < npairs; k++ )
{ {
srcs[k] += blocksize*sdelta[k]*esz1; srcs[k] += blocksize*sdelta[k]*esz1;

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

@ -193,10 +193,10 @@ void Mat::copyTo( OutputArray _dst ) const
const Mat* arrays[] = { this, &dst }; const Mat* arrays[] = { this, &dst };
uchar* ptrs[2]; uchar* ptrs[2];
NAryMatIterator it(arrays, ptrs, 2); NAryMatIterator it(arrays, ptrs, 2);
size_t size = it.size*elemSize(); size_t sz = it.size*elemSize();
for( size_t i = 0; i < it.nplanes; i++, ++it ) for( size_t i = 0; i < it.nplanes; i++, ++it )
memcpy(ptrs[1], ptrs[0], size); memcpy(ptrs[1], ptrs[0], sz);
} }
} }
@ -242,14 +242,14 @@ void Mat::copyTo( OutputArray _dst, InputArray _mask ) const
Mat& Mat::operator = (const Scalar& s) Mat& Mat::operator = (const Scalar& s)
{ {
const Mat* arrays[] = { this }; const Mat* arrays[] = { this };
uchar* ptr; uchar* dptr;
NAryMatIterator it(arrays, &ptr, 1); NAryMatIterator it(arrays, &dptr, 1);
size_t size = it.size*elemSize(); size_t elsize = it.size*elemSize();
if( s[0] == 0 && s[1] == 0 && s[2] == 0 && s[3] == 0 ) if( s[0] == 0 && s[1] == 0 && s[2] == 0 && s[3] == 0 )
{ {
for( size_t i = 0; i < it.nplanes; i++, ++it ) for( size_t i = 0; i < it.nplanes; i++, ++it )
memset( ptr, 0, size ); memset( dptr, 0, elsize );
} }
else else
{ {
@ -259,17 +259,17 @@ Mat& Mat::operator = (const Scalar& s)
scalarToRawData(s, scalar, type(), 12); scalarToRawData(s, scalar, type(), 12);
size_t blockSize = 12*elemSize1(); size_t blockSize = 12*elemSize1();
for( size_t j = 0; j < size; j += blockSize ) for( size_t j = 0; j < elsize; j += blockSize )
{ {
size_t sz = MIN(blockSize, size - j); size_t sz = MIN(blockSize, elsize - j);
memcpy( ptr + j, scalar, sz ); memcpy( dptr + j, scalar, sz );
} }
} }
for( size_t i = 1; i < it.nplanes; i++ ) for( size_t i = 1; i < it.nplanes; i++ )
{ {
++it; ++it;
memcpy( ptr, data, size ); memcpy( dptr, data, elsize );
} }
} }
return *this; return *this;
@ -292,16 +292,16 @@ Mat& Mat::setTo(InputArray _value, InputArray _mask)
const Mat* arrays[] = { this, !mask.empty() ? &mask : 0, 0 }; const Mat* arrays[] = { this, !mask.empty() ? &mask : 0, 0 };
uchar* ptrs[2]={0,0}; uchar* ptrs[2]={0,0};
NAryMatIterator it(arrays, ptrs); NAryMatIterator it(arrays, ptrs);
int total = (int)it.size, blockSize0 = std::min(total, (int)((BLOCK_SIZE + esz-1)/esz)); int totalsz = (int)it.size, blockSize0 = std::min(totalsz, (int)((BLOCK_SIZE + esz-1)/esz));
AutoBuffer<uchar> _scbuf(blockSize0*esz + 32); AutoBuffer<uchar> _scbuf(blockSize0*esz + 32);
uchar* scbuf = alignPtr((uchar*)_scbuf, (int)sizeof(double)); uchar* scbuf = alignPtr((uchar*)_scbuf, (int)sizeof(double));
convertAndUnrollScalar( value, type(), scbuf, blockSize0 ); convertAndUnrollScalar( value, type(), scbuf, blockSize0 );
for( size_t i = 0; i < it.nplanes; i++, ++it ) for( size_t i = 0; i < it.nplanes; i++, ++it )
{ {
for( int j = 0; j < total; j += blockSize0 ) for( int j = 0; j < totalsz; j += blockSize0 )
{ {
Size sz(std::min(blockSize0, total - j), 1); Size sz(std::min(blockSize0, totalsz - j), 1);
size_t blockSize = sz.width*esz; size_t blockSize = sz.width*esz;
if( ptrs[1] ) if( ptrs[1] )
{ {

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

@ -3653,7 +3653,7 @@ void KDTree::build(InputArray __points, InputArray __labels, bool _copyData)
points.create(_points.size(), _points.type()); points.create(_points.size(), _points.type());
} }
int i, j, n = _points.rows, dims = _points.cols, top = 0; int i, j, n = _points.rows, ptdims = _points.cols, top = 0;
const float* data = _points.ptr<float>(0); const float* data = _points.ptr<float>(0);
float* dstdata = points.ptr<float>(0); float* dstdata = points.ptr<float>(0);
size_t step = _points.step1(); size_t step = _points.step1();
@ -3669,7 +3669,7 @@ void KDTree::build(InputArray __points, InputArray __labels, bool _copyData)
_labels_data = (const int*)_labels.data; _labels_data = (const int*)_labels.data;
} }
Mat sumstack(MAX_TREE_DEPTH*2, dims*2, CV_64F); Mat sumstack(MAX_TREE_DEPTH*2, ptdims*2, CV_64F);
SubTree stack[MAX_TREE_DEPTH*2]; SubTree stack[MAX_TREE_DEPTH*2];
vector<size_t> _ptofs(n); vector<size_t> _ptofs(n);
@ -3700,7 +3700,7 @@ void KDTree::build(InputArray __points, InputArray __labels, bool _copyData)
{ {
const float* src = data + ptofs[first]; const float* src = data + ptofs[first];
float* dst = dstdata + idx*dstep; float* dst = dstdata + idx*dstep;
for( j = 0; j < dims; j++ ) for( j = 0; j < ptdims; j++ )
dst[j] = src[j]; dst[j] = src[j];
} }
labels[idx] = _labels_data ? _labels_data[idx0] : idx0; labels[idx] = _labels_data ? _labels_data[idx0] : idx0;
@ -3709,7 +3709,7 @@ void KDTree::build(InputArray __points, InputArray __labels, bool _copyData)
} }
// find the dimensionality with the biggest variance // find the dimensionality with the biggest variance
for( j = 0; j < dims; j++ ) for( j = 0; j < ptdims; j++ )
{ {
double m = sums[j*2]*invCount; double m = sums[j*2]*invCount;
double varj = sums[j*2+1]*invCount - m*m; double varj = sums[j*2+1]*invCount - m*m;
@ -3729,9 +3729,9 @@ void KDTree::build(InputArray __points, InputArray __labels, bool _copyData)
nodes[nidx].boundary = medianPartition(ptofs, first, last, data + dim); nodes[nidx].boundary = medianPartition(ptofs, first, last, data + dim);
int middle = (first + last)/2; int middle = (first + last)/2;
double *lsums = (double*)sums, *rsums = lsums + dims*2; double *lsums = (double*)sums, *rsums = lsums + ptdims*2;
computeSums(points, ptofs, middle+1, last, rsums); computeSums(points, ptofs, middle+1, last, rsums);
for( j = 0; j < dims*2; j++ ) for( j = 0; j < ptdims*2; j++ )
lsums[j] = sums[j] - rsums[j]; lsums[j] = sums[j] - rsums[j];
stack[top++] = SubTree(first, middle, left, depth+1); stack[top++] = SubTree(first, middle, left, depth+1);
stack[top++] = SubTree(middle+1, last, right, depth+1); stack[top++] = SubTree(middle+1, last, right, depth+1);
@ -3758,7 +3758,7 @@ int KDTree::findNearest(InputArray _vec, int K, int emax,
CV_Assert( vecmat.isContinuous() && vecmat.type() == CV_32F && vecmat.total() == (size_t)points.cols ); CV_Assert( vecmat.isContinuous() && vecmat.type() == CV_32F && vecmat.total() == (size_t)points.cols );
const float* vec = vecmat.ptr<float>(); const float* vec = vecmat.ptr<float>();
K = std::min(K, points.rows); K = std::min(K, points.rows);
int dims = points.cols; int ptdims = points.cols;
CV_Assert(K > 0 && (normType == NORM_L2 || normType == NORM_L1)); CV_Assert(K > 0 && (normType == NORM_L2 || normType == NORM_L1));
@ -3819,13 +3819,13 @@ int KDTree::findNearest(InputArray _vec, int K, int emax,
i = ~n.idx; i = ~n.idx;
const float* row = points.ptr<float>(i); const float* row = points.ptr<float>(i);
if( normType == NORM_L2 ) if( normType == NORM_L2 )
for( j = 0, d = 0.f; j < dims; j++ ) for( j = 0, d = 0.f; j < ptdims; j++ )
{ {
float t = vec[j] - row[j]; float t = vec[j] - row[j];
d += t*t; d += t*t;
} }
else else
for( j = 0, d = 0.f; j < dims; j++ ) for( j = 0, d = 0.f; j < ptdims; j++ )
d += std::abs(vec[j] - row[j]); d += std::abs(vec[j] - row[j]);
dist[ncount] = d; dist[ncount] = d;
@ -3898,14 +3898,14 @@ void KDTree::findOrthoRange(InputArray _lowerBound,
OutputArray _neighbors, OutputArray _neighbors,
OutputArray _labels ) const OutputArray _labels ) const
{ {
int dims = points.cols; int ptdims = points.cols;
Mat lowerBound = _lowerBound.getMat(), upperBound = _upperBound.getMat(); Mat lowerBound = _lowerBound.getMat(), upperBound = _upperBound.getMat();
CV_Assert( lowerBound.size == upperBound.size && CV_Assert( lowerBound.size == upperBound.size &&
lowerBound.isContinuous() && lowerBound.isContinuous() &&
upperBound.isContinuous() && upperBound.isContinuous() &&
lowerBound.type() == upperBound.type() && lowerBound.type() == upperBound.type() &&
lowerBound.type() == CV_32F && lowerBound.type() == CV_32F &&
lowerBound.total() == (size_t)dims ); lowerBound.total() == (size_t)ptdims );
const float* L = lowerBound.ptr<float>(); const float* L = lowerBound.ptr<float>();
const float* R = upperBound.ptr<float>(); const float* R = upperBound.ptr<float>();
@ -3926,10 +3926,10 @@ void KDTree::findOrthoRange(InputArray _lowerBound,
{ {
int j, i = ~n.idx; int j, i = ~n.idx;
const float* row = points.ptr<float>(i); const float* row = points.ptr<float>(i);
for( j = 0; j < dims; j++ ) for( j = 0; j < ptdims; j++ )
if( row[j] < L[j] || row[j] >= R[j] ) if( row[j] < L[j] || row[j] >= R[j] )
break; break;
if( j == dims ) if( j == ptdims )
idx.push_back(i); idx.push_back(i);
continue; continue;
} }
@ -3957,7 +3957,7 @@ void KDTree::getPoints(InputArray _idx, OutputArray _pts, OutputArray _labels) c
const int* idx = idxmat.ptr<int>(); const int* idx = idxmat.ptr<int>();
int* dstlabels = 0; int* dstlabels = 0;
int dims = points.cols; int ptdims = points.cols;
int i, nidx = (int)idxmat.total(); int i, nidx = (int)idxmat.total();
if( nidx == 0 ) if( nidx == 0 )
{ {
@ -3968,7 +3968,7 @@ void KDTree::getPoints(InputArray _idx, OutputArray _pts, OutputArray _labels) c
if( _pts.needed() ) if( _pts.needed() )
{ {
_pts.create( nidx, dims, points.type()); _pts.create( nidx, ptdims, points.type());
pts = _pts.getMat(); pts = _pts.getMat();
} }
@ -3987,7 +3987,7 @@ void KDTree::getPoints(InputArray _idx, OutputArray _pts, OutputArray _labels) c
CV_Assert( (unsigned)k < (unsigned)points.rows ); CV_Assert( (unsigned)k < (unsigned)points.rows );
const float* src = points.ptr<float>(k); const float* src = points.ptr<float>(k);
if( pts.data ) if( pts.data )
std::copy(src, src + dims, pts.ptr<float>(i)); std::copy(src, src + ptdims, pts.ptr<float>(i));
if( dstlabels ) if( dstlabels )
dstlabels[i] = srclabels ? srclabels[k] : k; dstlabels[i] = srclabels ? srclabels[k] : k;
} }

16
modules/core/src/drawing.cpp
View File

@ -169,7 +169,7 @@ LineIterator::LineIterator(const Mat& img, Point pt1, Point pt2,
} }
int bt_pix0 = (int)img.elemSize(), bt_pix = bt_pix0; int bt_pix0 = (int)img.elemSize(), bt_pix = bt_pix0;
size_t step = img.step; size_t istep = img.step;
int dx = pt2.x - pt1.x; int dx = pt2.x - pt1.x;
int dy = pt2.y - pt1.y; int dy = pt2.y - pt1.y;
@ -188,11 +188,11 @@ LineIterator::LineIterator(const Mat& img, Point pt1, Point pt2,
bt_pix = (bt_pix ^ s) - s; bt_pix = (bt_pix ^ s) - s;
} }
ptr = (uchar*)(img.data + pt1.y * step + pt1.x * bt_pix0); ptr = (uchar*)(img.data + pt1.y * istep + pt1.x * bt_pix0);
s = dy < 0 ? -1 : 0; s = dy < 0 ? -1 : 0;
dy = (dy ^ s) - s; dy = (dy ^ s) - s;
step = (step ^ s) - s; istep = (istep ^ s) - s;
s = dy > dx ? -1 : 0; s = dy > dx ? -1 : 0;
@ -201,9 +201,9 @@ LineIterator::LineIterator(const Mat& img, Point pt1, Point pt2,
dy ^= dx & s; dy ^= dx & s;
dx ^= dy & s; dx ^= dy & s;
bt_pix ^= step & s; bt_pix ^= istep & s;
step ^= bt_pix & s; istep ^= bt_pix & s;
bt_pix ^= step & s; bt_pix ^= istep & s;
if( connectivity == 8 ) if( connectivity == 8 )
{ {
@ -212,7 +212,7 @@ LineIterator::LineIterator(const Mat& img, Point pt1, Point pt2,
err = dx - (dy + dy); err = dx - (dy + dy);
plusDelta = dx + dx; plusDelta = dx + dx;
minusDelta = -(dy + dy); minusDelta = -(dy + dy);
plusStep = (int)step; plusStep = (int)istep;
minusStep = bt_pix; minusStep = bt_pix;
count = dx + 1; count = dx + 1;
} }
@ -223,7 +223,7 @@ LineIterator::LineIterator(const Mat& img, Point pt1, Point pt2,
err = 0; err = 0;
plusDelta = (dx + dx) + (dy + dy); plusDelta = (dx + dx) + (dy + dy);
minusDelta = -(dy + dy); minusDelta = -(dy + dy);
plusStep = (int)step - bt_pix; plusStep = (int)istep - bt_pix;
minusStep = bt_pix; minusStep = bt_pix;
count = dx + dy + 1; count = dx + dy + 1;
} }

18
modules/core/src/gpumat.cpp
View File

@ -524,30 +524,30 @@ cv::gpu::GpuMat::GpuMat(Size size_, int type_, void* data_, size_t step_) :
dataend += step * (rows - 1) + minstep; dataend += step * (rows - 1) + minstep;
} }
cv::gpu::GpuMat::GpuMat(const GpuMat& m, Range rowRange, Range colRange) cv::gpu::GpuMat::GpuMat(const GpuMat& m, Range _rowRange, Range _colRange)
{ {
flags = m.flags; flags = m.flags;
step = m.step; refcount = m.refcount; step = m.step; refcount = m.refcount;
data = m.data; datastart = m.datastart; dataend = m.dataend; data = m.data; datastart = m.datastart; dataend = m.dataend;
if (rowRange == Range::all()) if (_rowRange == Range::all())
rows = m.rows; rows = m.rows;
else else
{ {
CV_Assert(0 <= rowRange.start && rowRange.start <= rowRange.end && rowRange.end <= m.rows); CV_Assert(0 <= _rowRange.start && _rowRange.start <= _rowRange.end && _rowRange.end <= m.rows);
rows = rowRange.size(); rows = _rowRange.size();
data += step*rowRange.start; data += step*_rowRange.start;
} }
if (colRange == Range::all()) if (_colRange == Range::all())
cols = m.cols; cols = m.cols;
else else
{ {
CV_Assert(0 <= colRange.start && colRange.start <= colRange.end && colRange.end <= m.cols); CV_Assert(0 <= _colRange.start && _colRange.start <= _colRange.end && _colRange.end <= m.cols);
cols = colRange.size(); cols = _colRange.size();
data += colRange.start*elemSize(); data += _colRange.start*elemSize();
flags &= cols < m.cols ? ~Mat::CONTINUOUS_FLAG : -1; flags &= cols < m.cols ? ~Mat::CONTINUOUS_FLAG : -1;
} }

20
modules/core/src/matmul.cpp
View File

@ -696,7 +696,7 @@ static void GEMMStore_64fc( const Complexd* c_data, size_t c_step,
} }
void cv::gemm( InputArray matA, InputArray matB, double alpha, void cv::gemm( InputArray matA, InputArray matB, double alpha,
InputArray matC, double beta, OutputArray matD, int flags ) InputArray matC, double beta, OutputArray _matD, int flags )
{ {
const int block_lin_size = 128; const int block_lin_size = 128;
const int block_size = block_lin_size * block_lin_size; const int block_size = block_lin_size * block_lin_size;
@ -741,8 +741,8 @@ void cv::gemm( InputArray matA, InputArray matB, double alpha,
((flags&GEMM_3_T) != 0 && C.rows == d_size.width && C.cols == d_size.height))); ((flags&GEMM_3_T) != 0 && C.rows == d_size.width && C.cols == d_size.height)));
} }
matD.create( d_size.height, d_size.width, type ); _matD.create( d_size.height, d_size.width, type );
Mat D = matD.getMat(); Mat D = _matD.getMat();
if( (flags & GEMM_3_T) != 0 && C.data == D.data ) if( (flags & GEMM_3_T) != 0 && C.data == D.data )
{ {
transpose( C, C ); transpose( C, C );
@ -2134,12 +2134,12 @@ void cv::calcCovarMatrix( const Mat* data, int nsamples, Mat& covar, Mat& _mean,
_mean = mean.reshape(1, size.height); _mean = mean.reshape(1, size.height);
} }
void cv::calcCovarMatrix( InputArray _data, OutputArray _covar, InputOutputArray _mean, int flags, int ctype ) void cv::calcCovarMatrix( InputArray _src, OutputArray _covar, InputOutputArray _mean, int flags, int ctype )
{ {
if(_data.kind() == _InputArray::STD_VECTOR_MAT) if(_src.kind() == _InputArray::STD_VECTOR_MAT)
{ {
std::vector<cv::Mat> src; std::vector<cv::Mat> src;
_data.getMatVector(src); _src.getMatVector(src);
CV_Assert( src.size() > 0 ); CV_Assert( src.size() > 0 );
@ -2185,7 +2185,7 @@ void cv::calcCovarMatrix( InputArray _data, OutputArray _covar, InputOutputArray
return; return;
} }
Mat data = _data.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();
@ -2209,7 +2209,7 @@ void cv::calcCovarMatrix( InputArray _data, OutputArray _covar, InputOutputArray
else else
{ {
ctype = std::max(CV_MAT_DEPTH(ctype >= 0 ? ctype : type), CV_32F); ctype = std::max(CV_MAT_DEPTH(ctype >= 0 ? ctype : type), CV_32F);
reduce( _data, _mean, takeRows ? 0 : 1, CV_REDUCE_AVG, ctype ); reduce( _src, _mean, takeRows ? 0 : 1, CV_REDUCE_AVG, ctype );
mean = _mean.getMat(); mean = _mean.getMat();
} }
@ -2806,9 +2806,9 @@ double Mat::dot(InputArray _mat) const
PCA::PCA() {} PCA::PCA() {}
PCA::PCA(InputArray data, InputArray mean, int flags, int maxComponents) PCA::PCA(InputArray data, InputArray _mean, int flags, int maxComponents)
{ {
operator()(data, mean, flags, maxComponents); operator()(data, _mean, flags, maxComponents);
} }
PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, int maxComponents) PCA& PCA::operator()(InputArray _data, InputArray __mean, int flags, int maxComponents)

58
modules/core/src/matop.cpp
View File

@ -1181,14 +1181,14 @@ int MatExpr::type() const
///////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_Identity::assign(const MatExpr& e, Mat& m, int type) const void MatOp_Identity::assign(const MatExpr& e, Mat& m, int _type) const
{ {
if( type == -1 || type == e.a.type() ) if( _type == -1 || _type == e.a.type() )
m = e.a; m = e.a;
else else
{ {
CV_Assert( CV_MAT_CN(type) == e.a.channels() ); CV_Assert( CV_MAT_CN(_type) == e.a.channels() );
e.a.convertTo(m, type); e.a.convertTo(m, _type);
} }
} }
@ -1199,9 +1199,9 @@ inline void MatOp_Identity::makeExpr(MatExpr& res, const Mat& m)
///////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_AddEx::assign(const MatExpr& e, Mat& m, int type) const void MatOp_AddEx::assign(const MatExpr& e, Mat& m, int _type) const
{ {
Mat temp, &dst = type == -1 || e.a.type() == type ? m : temp; Mat temp, &dst = _type == -1 || e.a.type() == _type ? m : temp;
if( e.b.data ) if( e.b.data )
{ {
if( e.s == Scalar() || !e.s.isReal() ) if( e.s == Scalar() || !e.s.isReal() )
@ -1233,7 +1233,7 @@ void MatOp_AddEx::assign(const MatExpr& e, Mat& m, int type) const
} }
else if( e.s.isReal() && (dst.data != m.data || fabs(e.alpha) != 1)) else if( e.s.isReal() && (dst.data != m.data || fabs(e.alpha) != 1))
{ {
e.a.convertTo(m, type, e.alpha, e.s[0]); e.a.convertTo(m, _type, e.alpha, e.s[0]);
return; return;
} }
else if( e.alpha == 1 ) else if( e.alpha == 1 )
@ -1308,9 +1308,9 @@ inline void MatOp_AddEx::makeExpr(MatExpr& res, const Mat& a, const Mat& b, doub
////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_Bin::assign(const MatExpr& e, Mat& m, int type) const void MatOp_Bin::assign(const MatExpr& e, Mat& m, int _type) const
{ {
Mat temp, &dst = type == -1 || e.a.type() == type ? m : temp; Mat temp, &dst = _type == -1 || e.a.type() == _type ? m : temp;
if( e.flags == '*' ) if( e.flags == '*' )
cv::multiply(e.a, e.b, dst, e.alpha); cv::multiply(e.a, e.b, dst, e.alpha);
@ -1348,7 +1348,7 @@ void MatOp_Bin::assign(const MatExpr& e, Mat& m, int type) const
CV_Error(CV_StsError, "Unknown operation"); CV_Error(CV_StsError, "Unknown operation");
if( dst.data != m.data ) if( dst.data != m.data )
dst.convertTo(m, type); dst.convertTo(m, _type);
} }
void MatOp_Bin::multiply(const MatExpr& e, double s, MatExpr& res) const void MatOp_Bin::multiply(const MatExpr& e, double s, MatExpr& res) const
@ -1382,9 +1382,9 @@ inline void MatOp_Bin::makeExpr(MatExpr& res, char op, const Mat& a, const Scala
/////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_Cmp::assign(const MatExpr& e, Mat& m, int type) const void MatOp_Cmp::assign(const MatExpr& e, Mat& m, int _type) const
{ {
Mat temp, &dst = type == -1 || type == CV_8U ? m : temp; Mat temp, &dst = _type == -1 || _type == CV_8U ? m : temp;
if( e.b.data ) if( e.b.data )
cv::compare(e.a, e.b, dst, e.flags); cv::compare(e.a, e.b, dst, e.flags);
@ -1392,7 +1392,7 @@ void MatOp_Cmp::assign(const MatExpr& e, Mat& m, int type) const
cv::compare(e.a, e.alpha, dst, e.flags); cv::compare(e.a, e.alpha, dst, e.flags);
if( dst.data != m.data ) if( dst.data != m.data )
dst.convertTo(m, type); dst.convertTo(m, _type);
} }
inline void MatOp_Cmp::makeExpr(MatExpr& res, int cmpop, const Mat& a, const Mat& b) inline void MatOp_Cmp::makeExpr(MatExpr& res, int cmpop, const Mat& a, const Mat& b)
@ -1407,14 +1407,14 @@ inline void MatOp_Cmp::makeExpr(MatExpr& res, int cmpop, const Mat& a, double al
///////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_T::assign(const MatExpr& e, Mat& m, int type) const void MatOp_T::assign(const MatExpr& e, Mat& m, int _type) const
{ {
Mat temp, &dst = type == -1 || type == e.a.type() ? m : temp; Mat temp, &dst = _type == -1 || _type == e.a.type() ? m : temp;
cv::transpose(e.a, dst); cv::transpose(e.a, dst);
if( dst.data != m.data || e.alpha != 1 ) if( dst.data != m.data || e.alpha != 1 )
dst.convertTo(m, type, e.alpha); dst.convertTo(m, _type, e.alpha);
} }
void MatOp_T::multiply(const MatExpr& e, double s, MatExpr& res) const void MatOp_T::multiply(const MatExpr& e, double s, MatExpr& res) const
@ -1438,13 +1438,13 @@ inline void MatOp_T::makeExpr(MatExpr& res, const Mat& a, double alpha)
///////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_GEMM::assign(const MatExpr& e, Mat& m, int type) const void MatOp_GEMM::assign(const MatExpr& e, Mat& m, int _type) const
{ {
Mat temp, &dst = type == -1 || type == e.a.type() ? m : temp; Mat temp, &dst = _type == -1 || _type == e.a.type() ? m : temp;
cv::gemm(e.a, e.b, e.alpha, e.c, e.beta, dst, e.flags); cv::gemm(e.a, e.b, e.alpha, e.c, e.beta, dst, e.flags);
if( dst.data != m.data ) if( dst.data != m.data )
dst.convertTo(m, type); dst.convertTo(m, _type);
} }
void MatOp_GEMM::add(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const void MatOp_GEMM::add(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
@ -1503,13 +1503,13 @@ inline void MatOp_GEMM::makeExpr(MatExpr& res, int flags, const Mat& a, const Ma
/////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_Invert::assign(const MatExpr& e, Mat& m, int type) const void MatOp_Invert::assign(const MatExpr& e, Mat& m, int _type) const
{ {
Mat temp, &dst = type == -1 || type == e.a.type() ? m : temp; Mat temp, &dst = _type == -1 || _type == e.a.type() ? m : temp;
cv::invert(e.a, dst, e.flags); cv::invert(e.a, dst, e.flags);
if( dst.data != m.data ) if( dst.data != m.data )
dst.convertTo(m, type); dst.convertTo(m, _type);
} }
void MatOp_Invert::matmul(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const void MatOp_Invert::matmul(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
@ -1529,13 +1529,13 @@ inline void MatOp_Invert::makeExpr(MatExpr& res, int method, const Mat& m)
///////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_Solve::assign(const MatExpr& e, Mat& m, int type) const void MatOp_Solve::assign(const MatExpr& e, Mat& m, int _type) const
{ {
Mat temp, &dst = type == -1 || type == e.a.type() ? m : temp; Mat temp, &dst = _type == -1 || _type == e.a.type() ? m : temp;
cv::solve(e.a, e.b, dst, e.flags); cv::solve(e.a, e.b, dst, e.flags);
if( dst.data != m.data ) if( dst.data != m.data )
dst.convertTo(m, type); dst.convertTo(m, _type);
} }
inline void MatOp_Solve::makeExpr(MatExpr& res, int method, const Mat& a, const Mat& b) inline void MatOp_Solve::makeExpr(MatExpr& res, int method, const Mat& a, const Mat& b)
@ -1545,11 +1545,11 @@ inline void MatOp_Solve::makeExpr(MatExpr& res, int method, const Mat& a, const
////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////
void MatOp_Initializer::assign(const MatExpr& e, Mat& m, int type) const void MatOp_Initializer::assign(const MatExpr& e, Mat& m, int _type) const
{ {
if( type == -1 ) if( _type == -1 )
type = e.a.type(); _type = e.a.type();
m.create(e.a.size(), type); m.create(e.a.size(), _type);
if( e.flags == 'I' ) if( e.flags == 'I' )
setIdentity(m, Scalar(e.alpha)); setIdentity(m, Scalar(e.alpha));
else if( e.flags == '0' ) else if( e.flags == '0' )

122
modules/core/src/matrix.cpp
View File

@ -210,9 +210,9 @@ void Mat::create(int d, const int* _sizes, int _type)
#endif #endif
if( !allocator ) if( !allocator )
{ {
size_t total = alignSize(step.p[0]*size.p[0], (int)sizeof(*refcount)); size_t totalsize = alignSize(step.p[0]*size.p[0], (int)sizeof(*refcount));
data = datastart = (uchar*)fastMalloc(total + (int)sizeof(*refcount)); data = datastart = (uchar*)fastMalloc(totalsize + (int)sizeof(*refcount));
refcount = (int*)(data + total); refcount = (int*)(data + totalsize);
*refcount = 1; *refcount = 1;
} }
else else
@ -262,15 +262,15 @@ void Mat::deallocate()
} }
Mat::Mat(const Mat& m, const Range& rowRange, const Range& colRange) : size(&rows) Mat::Mat(const Mat& m, const Range& _rowRange, const Range& _colRange) : size(&rows)
{ {
initEmpty(); initEmpty();
CV_Assert( m.dims >= 2 ); CV_Assert( m.dims >= 2 );
if( m.dims > 2 ) if( m.dims > 2 )
{ {
AutoBuffer<Range> rs(m.dims); AutoBuffer<Range> rs(m.dims);
rs[0] = rowRange; rs[0] = _rowRange;
rs[1] = colRange; rs[1] = _colRange;
for( int i = 2; i < m.dims; i++ ) for( int i = 2; i < m.dims; i++ )
rs[i] = Range::all(); rs[i] = Range::all();
*this = m(rs); *this = m(rs);
@ -278,19 +278,19 @@ Mat::Mat(const Mat& m, const Range& rowRange, const Range& colRange) : size(&row
} }
*this = m; *this = m;
if( rowRange != Range::all() && rowRange != Range(0,rows) ) if( _rowRange != Range::all() && _rowRange != Range(0,rows) )
{ {
CV_Assert( 0 <= rowRange.start && rowRange.start <= rowRange.end && rowRange.end <= m.rows ); CV_Assert( 0 <= _rowRange.start && _rowRange.start <= _rowRange.end && _rowRange.end <= m.rows );
rows = rowRange.size(); rows = _rowRange.size();
data += step*rowRange.start; data += step*_rowRange.start;
flags |= SUBMATRIX_FLAG; flags |= SUBMATRIX_FLAG;
} }
if( colRange != Range::all() && colRange != Range(0,cols) ) if( _colRange != Range::all() && _colRange != Range(0,cols) )
{ {
CV_Assert( 0 <= colRange.start && colRange.start <= colRange.end && colRange.end <= m.cols ); CV_Assert( 0 <= _colRange.start && _colRange.start <= _colRange.end && _colRange.end <= m.cols );
cols = colRange.size(); cols = _colRange.size();
data += colRange.start*elemSize(); data += _colRange.start*elemSize();
flags &= cols < m.cols ? ~CONTINUOUS_FLAG : -1; flags &= cols < m.cols ? ~CONTINUOUS_FLAG : -1;
flags |= SUBMATRIX_FLAG; flags |= SUBMATRIX_FLAG;
} }
@ -473,14 +473,14 @@ Mat::Mat(const IplImage* img, bool copyData) : size(&rows)
dims = 2; dims = 2;
CV_DbgAssert(CV_IS_IMAGE(img) && img->imageData != 0); CV_DbgAssert(CV_IS_IMAGE(img) && img->imageData != 0);
int depth = IPL2CV_DEPTH(img->depth); int imgdepth = IPL2CV_DEPTH(img->depth);
size_t esz; size_t esz;
step[0] = img->widthStep; step[0] = img->widthStep;
if(!img->roi) if(!img->roi)
{ {
CV_Assert(img->dataOrder == IPL_DATA_ORDER_PIXEL); CV_Assert(img->dataOrder == IPL_DATA_ORDER_PIXEL);
flags = MAGIC_VAL + CV_MAKETYPE(depth, img->nChannels); flags = MAGIC_VAL + CV_MAKETYPE(imgdepth, img->nChannels);
rows = img->height; cols = img->width; rows = img->height; cols = img->width;
datastart = data = (uchar*)img->imageData; datastart = data = (uchar*)img->imageData;
esz = CV_ELEM_SIZE(flags); esz = CV_ELEM_SIZE(flags);
@ -489,7 +489,7 @@ Mat::Mat(const IplImage* img, bool copyData) : size(&rows)
{ {
CV_Assert(img->dataOrder == IPL_DATA_ORDER_PIXEL || img->roi->coi != 0); CV_Assert(img->dataOrder == IPL_DATA_ORDER_PIXEL || img->roi->coi != 0);
bool selectedPlane = img->roi->coi && img->dataOrder == IPL_DATA_ORDER_PLANE; bool selectedPlane = img->roi->coi && img->dataOrder == IPL_DATA_ORDER_PLANE;
flags = MAGIC_VAL + CV_MAKETYPE(depth, selectedPlane ? 1 : img->nChannels); flags = MAGIC_VAL + CV_MAKETYPE(imgdepth, selectedPlane ? 1 : img->nChannels);
rows = img->roi->height; cols = img->roi->width; rows = img->roi->height; cols = img->roi->width;
esz = CV_ELEM_SIZE(flags); esz = CV_ELEM_SIZE(flags);
data = datastart = (uchar*)img->imageData + data = datastart = (uchar*)img->imageData +
@ -1299,38 +1299,38 @@ bool _OutputArray::fixedType() const
return (flags & FIXED_TYPE) == FIXED_TYPE; return (flags & FIXED_TYPE) == FIXED_TYPE;
} }
void _OutputArray::create(Size _sz, int type, int i, bool allowTransposed, int fixedDepthMask) const void _OutputArray::create(Size _sz, int mtype, int i, bool allowTransposed, int fixedDepthMask) const
{ {
int k = kind(); int k = kind();
if( k == MAT && i < 0 && !allowTransposed && fixedDepthMask == 0 ) if( k == MAT && i < 0 && !allowTransposed && fixedDepthMask == 0 )
{ {
CV_Assert(!fixedSize() || ((Mat*)obj)->size.operator()() == _sz); CV_Assert(!fixedSize() || ((Mat*)obj)->size.operator()() == _sz);
CV_Assert(!fixedType() || ((Mat*)obj)->type() == type); CV_Assert(!fixedType() || ((Mat*)obj)->type() == mtype);
((Mat*)obj)->create(_sz, type); ((Mat*)obj)->create(_sz, mtype);
return; return;
} }
int sz[] = {_sz.height, _sz.width}; int sizes[] = {_sz.height, _sz.width};
create(2, sz, type, i, allowTransposed, fixedDepthMask); create(2, sizes, mtype, i, allowTransposed, fixedDepthMask);
} }
void _OutputArray::create(int rows, int cols, int type, int i, bool allowTransposed, int fixedDepthMask) const void _OutputArray::create(int rows, int cols, int mtype, int i, bool allowTransposed, int fixedDepthMask) const
{ {
int k = kind(); int k = kind();
if( k == MAT && i < 0 && !allowTransposed && fixedDepthMask == 0 ) if( k == MAT && i < 0 && !allowTransposed && fixedDepthMask == 0 )
{ {
CV_Assert(!fixedSize() || ((Mat*)obj)->size.operator()() == Size(cols, rows)); CV_Assert(!fixedSize() || ((Mat*)obj)->size.operator()() == Size(cols, rows));
CV_Assert(!fixedType() || ((Mat*)obj)->type() == type); CV_Assert(!fixedType() || ((Mat*)obj)->type() == mtype);
((Mat*)obj)->create(rows, cols, type); ((Mat*)obj)->create(rows, cols, mtype);
return; return;
} }
int sz[] = {rows, cols}; int sizes[] = {rows, cols};
create(2, sz, type, i, allowTransposed, fixedDepthMask); create(2, sizes, mtype, i, allowTransposed, fixedDepthMask);
} }
void _OutputArray::create(int dims, const int* size, int type, int i, bool allowTransposed, int fixedDepthMask) const void _OutputArray::create(int dims, const int* sizes, int mtype, int i, bool allowTransposed, int fixedDepthMask) const
{ {
int k = kind(); int k = kind();
type = CV_MAT_TYPE(type); mtype = CV_MAT_TYPE(mtype);
if( k == MAT ) if( k == MAT )
{ {
@ -1345,24 +1345,24 @@ void _OutputArray::create(int dims, const int* size, int type, int i, bool allow
} }
if( dims == 2 && m.dims == 2 && m.data && if( dims == 2 && m.dims == 2 && m.data &&
m.type() == type && m.rows == size[1] && m.cols == size[0] ) m.type() == mtype && m.rows == sizes[1] && m.cols == sizes[0] )
return; return;
} }
if(fixedType()) if(fixedType())
{ {
if(CV_MAT_CN(type) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0 ) if(CV_MAT_CN(mtype) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0 )
type = m.type(); mtype = m.type();
else else
CV_Assert(CV_MAT_TYPE(type) == m.type()); CV_Assert(CV_MAT_TYPE(mtype) == m.type());
} }
if(fixedSize()) if(fixedSize())
{ {
CV_Assert(m.dims == dims); CV_Assert(m.dims == dims);
for(int j = 0; j < dims; ++j) for(int j = 0; j < dims; ++j)
CV_Assert(m.size[j] == size[j]); CV_Assert(m.size[j] == sizes[j]);
} }
m.create(dims, size, type); m.create(dims, sizes, mtype);
return; return;
} }
@ -1370,16 +1370,16 @@ void _OutputArray::create(int dims, const int* size, int type, int i, bool allow
{ {
CV_Assert( i < 0 ); CV_Assert( i < 0 );
int type0 = CV_MAT_TYPE(flags); int type0 = CV_MAT_TYPE(flags);
CV_Assert( type == type0 || (CV_MAT_CN(type) == 1 && ((1 << type0) & fixedDepthMask) != 0) ); CV_Assert( mtype == type0 || (CV_MAT_CN(mtype) == 1 && ((1 << type0) & fixedDepthMask) != 0) );
CV_Assert( dims == 2 && ((size[0] == sz.height && size[1] == sz.width) || CV_Assert( dims == 2 && ((sizes[0] == sz.height && sizes[1] == sz.width) ||
(allowTransposed && size[0] == sz.width && size[1] == sz.height))); (allowTransposed && sizes[0] == sz.width && sizes[1] == sz.height)));
return; return;
} }
if( k == STD_VECTOR || k == STD_VECTOR_VECTOR ) if( k == STD_VECTOR || k == STD_VECTOR_VECTOR )
{ {
CV_Assert( dims == 2 && (size[0] == 1 || size[1] == 1 || size[0]*size[1] == 0) ); CV_Assert( dims == 2 && (sizes[0] == 1 || sizes[1] == 1 || sizes[0]*sizes[1] == 0) );
size_t len = size[0]*size[1] > 0 ? size[0] + size[1] - 1 : 0; size_t len = sizes[0]*sizes[1] > 0 ? sizes[0] + sizes[1] - 1 : 0;
vector<uchar>* v = (vector<uchar>*)obj; vector<uchar>* v = (vector<uchar>*)obj;
if( k == STD_VECTOR_VECTOR ) if( k == STD_VECTOR_VECTOR )
@ -1398,7 +1398,7 @@ void _OutputArray::create(int dims, const int* size, int type, int i, bool allow
CV_Assert( i < 0 ); CV_Assert( i < 0 );
int type0 = CV_MAT_TYPE(flags); int type0 = CV_MAT_TYPE(flags);
CV_Assert( type == type0 || (CV_MAT_CN(type) == CV_MAT_CN(type0) && ((1 << type0) & fixedDepthMask) != 0) ); CV_Assert( mtype == type0 || (CV_MAT_CN(mtype) == CV_MAT_CN(type0) && ((1 << type0) & fixedDepthMask) != 0) );
int esz = CV_ELEM_SIZE(type0); int esz = CV_ELEM_SIZE(type0);
CV_Assert(!fixedSize() || len == ((vector<uchar>*)v)->size() / esz); CV_Assert(!fixedSize() || len == ((vector<uchar>*)v)->size() / esz);
@ -1471,20 +1471,20 @@ void _OutputArray::create(int dims, const int* size, int type, int i, bool allow
if( i < 0 ) if( i < 0 )
{ {
CV_Assert( dims == 2 && (size[0] == 1 || size[1] == 1 || size[0]*size[1] == 0) ); CV_Assert( dims == 2 && (sizes[0] == 1 || sizes[1] == 1 || sizes[0]*sizes[1] == 0) );
size_t len = size[0]*size[1] > 0 ? size[0] + size[1] - 1 : 0, len0 = v.size(); size_t len = sizes[0]*sizes[1] > 0 ? sizes[0] + sizes[1] - 1 : 0, len0 = v.size();
CV_Assert(!fixedSize() || len == len0); CV_Assert(!fixedSize() || len == len0);
v.resize(len); v.resize(len);
if( fixedType() ) if( fixedType() )
{ {
int type = CV_MAT_TYPE(flags); int _type = CV_MAT_TYPE(flags);
for( size_t j = len0; j < len; j++ ) for( size_t j = len0; j < len; j++ )
{ {
if( v[i].type() == type ) if( v[i].type() == _type )
continue; continue;
CV_Assert( v[i].empty() ); CV_Assert( v[i].empty() );
v[i].flags = (v[i].flags & ~CV_MAT_TYPE_MASK) | type; v[i].flags = (v[i].flags & ~CV_MAT_TYPE_MASK) | _type;
} }
} }
return; return;
@ -1502,25 +1502,25 @@ void _OutputArray::create(int dims, const int* size, int type, int i, bool allow
} }
if( dims == 2 && m.dims == 2 && m.data && if( dims == 2 && m.dims == 2 && m.data &&
m.type() == type && m.rows == size[1] && m.cols == size[0] ) m.type() == mtype && m.rows == sizes[1] && m.cols == sizes[0] )
return; return;
} }
if(fixedType()) if(fixedType())
{ {
if(CV_MAT_CN(type) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0 ) if(CV_MAT_CN(mtype) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0 )
type = m.type(); mtype = m.type();
else else
CV_Assert(!fixedType() || (CV_MAT_CN(type) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0)); CV_Assert(!fixedType() || (CV_MAT_CN(mtype) == m.channels() && ((1 << CV_MAT_TYPE(flags)) & fixedDepthMask) != 0));
} }
if(fixedSize()) if(fixedSize())
{ {
CV_Assert(m.dims == dims); CV_Assert(m.dims == dims);
for(int j = 0; j < dims; ++j) for(int j = 0; j < dims; ++j)
CV_Assert(m.size[j] == size[j]); CV_Assert(m.size[j] == sizes[j]);
} }
m.create(dims, size, type); m.create(dims, sizes, mtype);
} }
} }
@ -1929,10 +1929,10 @@ void cv::completeSymm( InputOutputArray _m, bool LtoR )
cv::Mat cv::Mat::cross(InputArray _m) const cv::Mat cv::Mat::cross(InputArray _m) const
{ {
Mat m = _m.getMat(); Mat m = _m.getMat();
int t = type(), d = CV_MAT_DEPTH(t); int tp = type(), d = CV_MAT_DEPTH(tp);
CV_Assert( dims <= 2 && m.dims <= 2 && size() == m.size() && t == m.type() && CV_Assert( dims <= 2 && m.dims <= 2 && size() == m.size() && tp == m.type() &&
((rows == 3 && cols == 1) || (cols*channels() == 3 && rows == 1))); ((rows == 3 && cols == 1) || (cols*channels() == 3 && rows == 1)));
Mat result(rows, cols, t); Mat result(rows, cols, tp);
if( d == CV_32F ) if( d == CV_32F )
{ {
@ -2845,7 +2845,7 @@ cvRange( CvArr* arr, double start, double end )
CV_IMPL void CV_IMPL void
cvSort( const CvArr* _src, CvArr* _dst, CvArr* _idx, int flags ) cvSort( const CvArr* _src, CvArr* _dst, CvArr* _idx, int flags )
{ {
cv::Mat src = cv::cvarrToMat(_src), dst, idx; cv::Mat src = cv::cvarrToMat(_src);
if( _idx ) if( _idx )
{ {
@ -3410,22 +3410,22 @@ SparseMat::SparseMat(const Mat& m)
int i, idx[CV_MAX_DIM] = {0}, d = m.dims, lastSize = m.size[d - 1]; int i, idx[CV_MAX_DIM] = {0}, d = m.dims, lastSize = m.size[d - 1];
size_t esz = m.elemSize(); size_t esz = m.elemSize();
uchar* ptr = m.data; uchar* dptr = m.data;
for(;;) for(;;)
{ {
for( i = 0; i < lastSize; i++, ptr += esz ) for( i = 0; i < lastSize; i++, dptr += esz )
{ {
if( isZeroElem(ptr, esz) ) if( isZeroElem(dptr, esz) )
continue; continue;
idx[d-1] = i; idx[d-1] = i;
uchar* to = newNode(idx, hash(idx)); uchar* to = newNode(idx, hash(idx));
copyElem( ptr, to, esz ); copyElem( dptr, to, esz );
} }
for( i = d - 2; i >= 0; i-- ) for( i = d - 2; i >= 0; i-- )
{ {
ptr += m.step[i] - m.size[i+1]*m.step[i+1]; dptr += m.step[i] - m.size[i+1]*m.step[i+1];
if( ++idx[i] < m.size[i] ) if( ++idx[i] < m.size[i] )
break; break;
idx[i] = 0; idx[i] = 0;

154
modules/core/src/opengl_interop.cpp
View File

@ -484,57 +484,57 @@ inline void cv::GlBuffer::Impl::unmapDevice(cudaStream_t stream)
#endif // HAVE_OPENGL #endif // HAVE_OPENGL
cv::GlBuffer::GlBuffer(Usage usage) : rows_(0), cols_(0), type_(0), usage_(usage) cv::GlBuffer::GlBuffer(Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)usage; (void)_usage;
throw_nogl; throw_nogl;
#else #else
impl_ = Impl::empty(); impl_ = Impl::empty();
#endif #endif
} }
cv::GlBuffer::GlBuffer(int rows, int cols, int type, Usage usage) : rows_(0), cols_(0), type_(0), usage_(usage) cv::GlBuffer::GlBuffer(int _rows, int _cols, int _type, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)rows; (void)_rows;
(void)cols; (void)_cols;
(void)type; (void)_type;
(void)usage; (void)_usage;
throw_nogl; throw_nogl;
#else #else
impl_ = new Impl(rows, cols, type, usage); impl_ = new Impl(_rows, _cols, _type, _usage);
rows_ = rows; rows_ = _rows;
cols_ = cols; cols_ = _cols;
type_ = type; type_ = _type;
#endif #endif
} }
cv::GlBuffer::GlBuffer(Size size, int type, Usage usage) : rows_(0), cols_(0), type_(0), usage_(usage) cv::GlBuffer::GlBuffer(Size _size, int _type, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)size; (void)_size;
(void)type; (void)_type;
(void)usage; (void)_usage;
throw_nogl; throw_nogl;
#else #else
impl_ = new Impl(size.height, size.width, type, usage); impl_ = new Impl(_size.height, _size.width, _type, _usage);
rows_ = size.height; rows_ = _size.height;
cols_ = size.width; cols_ = _size.width;
type_ = type; type_ = _type;
#endif #endif
} }
cv::GlBuffer::GlBuffer(InputArray mat_, Usage usage) : rows_(0), cols_(0), type_(0), usage_(usage) cv::GlBuffer::GlBuffer(InputArray mat_, Usage _usage) : rows_(0), cols_(0), type_(0), usage_(_usage)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)mat_; (void)mat_;
(void)usage; (void)_usage;
throw_nogl; throw_nogl;
#else #else
int kind = mat_.kind(); int kind = mat_.kind();
Size size = mat_.size(); Size _size = mat_.size();
int type = mat_.type(); int _type = mat_.type();
if (kind == _InputArray::GPU_MAT) if (kind == _InputArray::GPU_MAT)
{ {
@ -542,38 +542,38 @@ cv::GlBuffer::GlBuffer(InputArray mat_, Usage usage) : rows_(0), cols_(0), type_
throw_nocuda; throw_nocuda;
#else #else
GpuMat d_mat = mat_.getGpuMat(); GpuMat d_mat = mat_.getGpuMat();
impl_ = new Impl(d_mat.rows, d_mat.cols, d_mat.type(), usage); impl_ = new Impl(d_mat.rows, d_mat.cols, d_mat.type(), _usage);
impl_->copyFrom(d_mat); impl_->copyFrom(d_mat);
#endif #endif
} }
else else
{ {
Mat mat = mat_.getMat(); Mat mat = mat_.getMat();
impl_ = new Impl(mat, usage); impl_ = new Impl(mat, _usage);
} }
rows_ = size.height; rows_ = _size.height;
cols_ = size.width; cols_ = _size.width;
type_ = type; type_ = _type;
#endif #endif
} }
void cv::GlBuffer::create(int rows, int cols, int type, Usage usage) void cv::GlBuffer::create(int _rows, int _cols, int _type, Usage _usage)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)rows; (void)_rows;
(void)cols; (void)_cols;
(void)type; (void)_type;
(void)usage; (void)_usage;
throw_nogl; throw_nogl;
#else #else
if (rows_ != rows || cols_ != cols || type_ != type || usage_ != usage) if (rows_ != _rows || cols_ != _cols || type_ != _type || usage_ != _usage)
{ {
impl_ = new Impl(rows, cols, type, usage); impl_ = new Impl(_rows, _cols, _type, _usage);
rows_ = rows; rows_ = _rows;
cols_ = cols; cols_ = _cols;
type_ = type; type_ = _type;
usage_ = usage; usage_ = _usage;
} }
#endif #endif
} }
@ -594,10 +594,10 @@ void cv::GlBuffer::copyFrom(InputArray mat_)
throw_nogl; throw_nogl;
#else #else
int kind = mat_.kind(); int kind = mat_.kind();
Size size = mat_.size(); Size _size = mat_.size();
int type = mat_.type(); int _type = mat_.type();
create(size, type); create(_size, _type);
switch (kind) switch (kind)
{ {
@ -926,32 +926,32 @@ cv::GlTexture::GlTexture() : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTUR
#endif #endif
} }
cv::GlTexture::GlTexture(int rows, int cols, int type) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER) cv::GlTexture::GlTexture(int _rows, int _cols, int _type) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)rows; (void)_rows;
(void)cols; (void)_cols;
(void)type; (void)_type;
throw_nogl; throw_nogl;
#else #else
impl_ = new Impl(rows, cols, type); impl_ = new Impl(_rows, _cols, _type);
rows_ = rows; rows_ = _rows;
cols_ = cols; cols_ = _cols;
type_ = type; type_ = _type;
#endif #endif
} }
cv::GlTexture::GlTexture(Size size, int type) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER) cv::GlTexture::GlTexture(Size _size, int _type) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)size; (void)_size;
(void)type; (void)_type;
throw_nogl; throw_nogl;
#else #else
impl_ = new Impl(size.height, size.width, type); impl_ = new Impl(_size.height, _size.width, _type);
rows_ = size.height; rows_ = _size.height;
cols_ = size.width; cols_ = _size.width;
type_ = type; type_ = _type;
#endif #endif
} }
@ -963,8 +963,8 @@ cv::GlTexture::GlTexture(InputArray mat_, bool bgra) : rows_(0), cols_(0), type_
throw_nogl; throw_nogl;
#else #else
int kind = mat_.kind(); int kind = mat_.kind();
Size size = mat_.size(); Size _size = mat_.size();
int type = mat_.type(); int _type = mat_.type();
switch (kind) switch (kind)
{ {
@ -994,26 +994,26 @@ cv::GlTexture::GlTexture(InputArray mat_, bool bgra) : rows_(0), cols_(0), type_
} }
} }
rows_ = size.height; rows_ = _size.height;
cols_ = size.width; cols_ = _size.width;
type_ = type; type_ = _type;
#endif #endif
} }
void cv::GlTexture::create(int rows, int cols, int type) void cv::GlTexture::create(int _rows, int _cols, int _type)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)rows; (void)_rows;
(void)cols; (void)_cols;
(void)type; (void)_type;
throw_nogl; throw_nogl;
#else #else
if (rows_ != rows || cols_ != cols || type_ != type) if (rows_ != _rows || cols_ != _cols || type_ != _type)
{ {
impl_ = new Impl(rows, cols, type); impl_ = new Impl(_rows, _cols, _type);
rows_ = rows; rows_ = _rows;
cols_ = cols; cols_ = _cols;
type_ = type; type_ = _type;
} }
#endif #endif
} }
@ -1035,10 +1035,10 @@ void cv::GlTexture::copyFrom(InputArray mat_, bool bgra)
throw_nogl; throw_nogl;
#else #else
int kind = mat_.kind(); int kind = mat_.kind();
Size size = mat_.size(); Size _size = mat_.size();
int type = mat_.type(); int _type = mat_.type();
create(size, type); create(_size, _type);
switch(kind) switch(kind)
{ {
@ -1244,8 +1244,8 @@ void cv::GlArrays::unbind() const
//////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////
// GlFont // GlFont
cv::GlFont::GlFont(const string& family, int height, Weight weight, Style style) cv::GlFont::GlFont(const string& _family, int _height, Weight _weight, Style _style)
: family_(family), height_(height), weight_(weight), style_(style), base_(0) : family_(_family), height_(_height), weight_(_weight), style_(_style), base_(0)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
throw_nogl; throw_nogl;
@ -1253,7 +1253,7 @@ cv::GlFont::GlFont(const string& family, int height, Weight weight, Style style)
base_ = glGenLists(256); base_ = glGenLists(256);
CV_CheckGlError(); CV_CheckGlError();
glFuncTab()->generateBitmapFont(family, height, weight, (style & STYLE_ITALIC) != 0, (style & STYLE_UNDERLINE) != 0, 0, 256, base_); glFuncTab()->generateBitmapFont(family_, height_, weight_, (style_ & STYLE_ITALIC) != 0, (style_ & STYLE_UNDERLINE) != 0, 0, 256, base_);
#endif #endif
} }

8
modules/core/test/test_ds.cpp
View File

@ -1262,7 +1262,7 @@ int Core_SetTest::test_set_ops( int iters )
if( iter > iters/10 && cvtest::randInt(rng)%200 == 0 ) // clear set if( iter > iters/10 && cvtest::randInt(rng)%200 == 0 ) // clear set
{ {
int prev_count = cvset->total; prev_count = cvset->total;
cvClearSet( cvset ); cvClearSet( cvset );
cvTsClearSimpleSet( sset ); cvTsClearSimpleSet( sset );
@ -1482,19 +1482,19 @@ int Core_GraphTest::test_graph_ops( int iters )
if( cvtest::randInt(rng) % 200 == 0 ) // clear graph if( cvtest::randInt(rng) % 200 == 0 ) // clear graph
{ {
int prev_vtx_count = graph->total, prev_edge_count = graph->edges->total; int prev_vtx_count2 = graph->total, prev_edge_count2 = graph->edges->total;
cvClearGraph( graph ); cvClearGraph( graph );
cvTsClearSimpleGraph( sgraph ); cvTsClearSimpleGraph( sgraph );
CV_TS_SEQ_CHECK_CONDITION( graph->active_count == 0 && graph->total == 0 && CV_TS_SEQ_CHECK_CONDITION( graph->active_count == 0 && graph->total == 0 &&
graph->first == 0 && graph->free_elems == 0 && graph->first == 0 && graph->free_elems == 0 &&
(graph->free_blocks != 0 || prev_vtx_count == 0), (graph->free_blocks != 0 || prev_vtx_count2 == 0),
"The graph is not empty after clearing" ); "The graph is not empty after clearing" );
CV_TS_SEQ_CHECK_CONDITION( edges->active_count == 0 && edges->total == 0 && CV_TS_SEQ_CHECK_CONDITION( edges->active_count == 0 && edges->total == 0 &&
edges->first == 0 && edges->free_elems == 0 && edges->first == 0 && edges->free_elems == 0 &&
(edges->free_blocks != 0 || prev_edge_count == 0), (edges->free_blocks != 0 || prev_edge_count2 == 0),
"The graph is not empty after clearing" ); "The graph is not empty after clearing" );
} }
else if( op == 0 ) // add vertex else if( op == 0 ) // add vertex

4
modules/core/test/test_mat.cpp
View File

@ -284,8 +284,6 @@ void Core_ReduceTest::run( int )
#define CHECK_C #define CHECK_C
Size sz(200, 500);
class Core_PCATest : public cvtest::BaseTest class Core_PCATest : public cvtest::BaseTest
{ {
public: public:
@ -293,6 +291,8 @@ public:
protected: protected:
void run(int) void run(int)
{ {
const Size sz(200, 500);
double diffPrjEps, diffBackPrjEps, double diffPrjEps, diffBackPrjEps,
prjEps, backPrjEps, prjEps, backPrjEps,
evalEps, evecEps; evalEps, evecEps;

14
modules/core/test/test_rand.cpp
View File

@ -54,17 +54,17 @@ bool Core_RandTest::check_pdf(const Mat& hist, double scale,
} }
else else
{ {
double sum = 0, r = (hsz-1.)/2; double sum2 = 0, r = (hsz-1.)/2;
double alpha = 2*sqrt(2.)/r, beta = -alpha*r; double alpha = 2*sqrt(2.)/r, beta = -alpha*r;
for( i = 0; i < hsz; i++ ) for( i = 0; i < hsz; i++ )
{ {
double x = i*alpha + beta; double x = i*alpha + beta;
H0[i] = (float)exp(-x*x); H0[i] = (float)exp(-x*x);
sum += H0[i]; sum2 += H0[i];
} }
sum = 1./sum; sum2 = 1./sum2;
for( i = 0; i < hsz; i++ ) for( i = 0; i < hsz; i++ )
H0[i] = (float)(H0[i]*sum); H0[i] = (float)(H0[i]*sum2);
} }
double chi2 = 0; double chi2 = 0;
@ -253,7 +253,7 @@ void Core_RandTest::run( int )
if( do_sphere_test ) if( do_sphere_test )
{ {
int SDIM = cvtest::randInt(rng) % (MAX_SDIM-1) + 2; int SDIM = cvtest::randInt(rng) % (MAX_SDIM-1) + 2;
int N0 = (SZ*cn/SDIM), N = 0; int N0 = (SZ*cn/SDIM), n = 0;
double r2 = 0; double r2 = 0;
const uchar* data = arr[0].data; const uchar* data = arr[0].data;
double scale[4], delta[4]; double scale[4], delta[4];
@ -276,13 +276,13 @@ void Core_RandTest::run( int )
r2 += val*val; r2 += val*val;
if( k == SDIM-1 ) if( k == SDIM-1 )
{ {
N += r2 <= 1; n += r2 <= 1;
r2 = 0; r2 = 0;
k = -1; k = -1;
} }
} }
double V = ((double)N/N0)*(1 << SDIM); double V = ((double)n/N0)*(1 << SDIM);
// the theoretically computed volume // the theoretically computed volume
int sdim = SDIM % 2; int sdim = SDIM % 2;

4
modules/features2d/src/bagofwords.cpp
View File

@ -110,10 +110,10 @@ Mat BOWKMeansTrainer::cluster() const
BOWKMeansTrainer::~BOWKMeansTrainer() BOWKMeansTrainer::~BOWKMeansTrainer()
{} {}
Mat BOWKMeansTrainer::cluster( const Mat& descriptors ) const Mat BOWKMeansTrainer::cluster( const Mat& _descriptors ) const
{ {
Mat labels, vocabulary; Mat labels, vocabulary;
kmeans( descriptors, clusterCount, labels, termcrit, attempts, flags, vocabulary ); kmeans( _descriptors, clusterCount, labels, termcrit, attempts, flags, vocabulary );
return vocabulary; return vocabulary;
} }

6
modules/features2d/src/brief.cpp
View File

@ -127,8 +127,8 @@ int BriefDescriptorExtractor::descriptorType() const
void BriefDescriptorExtractor::read( const FileNode& fn) void BriefDescriptorExtractor::read( const FileNode& fn)
{ {
int descriptorSize = fn["descriptorSize"]; int dSize = fn["descriptorSize"];
switch (descriptorSize) switch (dSize)
{ {
case 16: case 16:
test_fn_ = pixelTests16; test_fn_ = pixelTests16;
@ -142,7 +142,7 @@ void BriefDescriptorExtractor::read( const FileNode& fn)
default: default:
CV_Error(CV_StsBadArg, "descriptorSize must be 16, 32, or 64"); CV_Error(CV_StsBadArg, "descriptorSize must be 16, 32, or 64");
} }
bytes_ = descriptorSize; bytes_ = dSize;
} }
void BriefDescriptorExtractor::write( FileStorage& fs) const void BriefDescriptorExtractor::write( FileStorage& fs) const

6
modules/features2d/src/descriptors.cpp
View File

@ -223,8 +223,8 @@ void OpponentColorDescriptorExtractor::computeImpl( const Mat& bgrImage, vector<
vector<KeyPoint> outKeypoints; vector<KeyPoint> outKeypoints;
outKeypoints.reserve( keypoints.size() ); outKeypoints.reserve( keypoints.size() );
int descriptorSize = descriptorExtractor->descriptorSize(); int dSize = descriptorExtractor->descriptorSize();
Mat mergedDescriptors( maxKeypointsCount, 3*descriptorSize, descriptorExtractor->descriptorType() ); Mat mergedDescriptors( maxKeypointsCount, 3*dSize, descriptorExtractor->descriptorType() );
int mergedCount = 0; int mergedCount = 0;
// cp - current channel position // cp - current channel position
size_t cp[] = {0, 0, 0}; size_t cp[] = {0, 0, 0};
@ -250,7 +250,7 @@ void OpponentColorDescriptorExtractor::computeImpl( const Mat& bgrImage, vector<
// merge descriptors // merge descriptors
for( int ci = 0; ci < N; ci++ ) for( int ci = 0; ci < N; ci++ )
{ {
Mat dst = mergedDescriptors(Range(mergedCount, mergedCount+1), Range(ci*descriptorSize, (ci+1)*descriptorSize)); Mat dst = mergedDescriptors(Range(mergedCount, mergedCount+1), Range(ci*dSize, (ci+1)*dSize));
channelDescriptors[ci].row( idxs[ci][cp[ci]] ).copyTo( dst ); channelDescriptors[ci].row( idxs[ci][cp[ci]] ).copyTo( dst );
cp[ci]++; cp[ci]++;
} }

8
modules/features2d/src/draw.cpp
View File

@ -156,11 +156,11 @@ static void _prepareImgAndDrawKeypoints( const Mat& img1, const vector<KeyPoint>
// draw keypoints // draw keypoints
if( !(flags & DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS) ) if( !(flags & DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS) )
{ {
Mat outImg1 = outImg( Rect(0, 0, img1.cols, img1.rows) ); Mat _outImg1 = outImg( Rect(0, 0, img1.cols, img1.rows) );
drawKeypoints( outImg1, keypoints1, outImg1, singlePointColor, flags + DrawMatchesFlags::DRAW_OVER_OUTIMG ); drawKeypoints( _outImg1, keypoints1, _outImg1, singlePointColor, flags + DrawMatchesFlags::DRAW_OVER_OUTIMG );
Mat outImg2 = outImg( Rect(img1.cols, 0, img2.cols, img2.rows) ); Mat _outImg2 = outImg( Rect(img1.cols, 0, img2.cols, img2.rows) );
drawKeypoints( outImg2, keypoints2, outImg2, singlePointColor, flags + DrawMatchesFlags::DRAW_OVER_OUTIMG ); drawKeypoints( _outImg2, keypoints2, _outImg2, singlePointColor, flags + DrawMatchesFlags::DRAW_OVER_OUTIMG );
} }
} }

7
modules/features2d/src/features2d_init.cpp
View File

@ -109,11 +109,14 @@ class CV_EXPORTS HarrisDetector : public GFTTDetector
{ {
public: public:
HarrisDetector( int maxCorners=1000, double qualityLevel=0.01, double minDistance=1, HarrisDetector( int maxCorners=1000, double qualityLevel=0.01, double minDistance=1,
int blockSize=3, bool useHarrisDetector=true, double k=0.04 ) int blockSize=3, bool useHarrisDetector=true, double k=0.04 );
: GFTTDetector( maxCorners, qualityLevel, minDistance, blockSize, useHarrisDetector, k ) {}
AlgorithmInfo* info() const; AlgorithmInfo* info() const;
}; };
inline HarrisDetector::HarrisDetector( int _maxCorners, double _qualityLevel, double _minDistance,
int _blockSize, bool _useHarrisDetector, double _k )
: GFTTDetector( _maxCorners, _qualityLevel, _minDistance, _blockSize, _useHarrisDetector, _k ) {}
CV_INIT_ALGORITHM(HarrisDetector, "Feature2D.HARRIS", CV_INIT_ALGORITHM(HarrisDetector, "Feature2D.HARRIS",
obj.info()->addParam(obj, "nfeatures", obj.nfeatures); obj.info()->addParam(obj, "nfeatures", obj.nfeatures);
obj.info()->addParam(obj, "qualityLevel", obj.qualityLevel); obj.info()->addParam(obj, "qualityLevel", obj.qualityLevel);

24
modules/features2d/src/matchers.cpp
View File

@ -539,7 +539,7 @@ void FlannBasedMatcher::read( const FileNode& fn)
for(int i = 0; i < (int)ip.size(); ++i) for(int i = 0; i < (int)ip.size(); ++i)
{ {
CV_Assert(ip[i].type() == FileNode::MAP); CV_Assert(ip[i].type() == FileNode::MAP);
std::string name = (std::string)ip[i]["name"]; std::string _name = (std::string)ip[i]["name"];
int type = (int)ip[i]["type"]; int type = (int)ip[i]["type"];
switch(type) switch(type)
@ -549,19 +549,19 @@ void FlannBasedMatcher::read( const FileNode& fn)
case CV_16U: case CV_16U:
case CV_16S: case CV_16S:
case CV_32S: case CV_32S:
indexParams->setInt(name, (int) ip[i]["value"]); indexParams->setInt(_name, (int) ip[i]["value"]);
break; break;
case CV_32F: case CV_32F:
indexParams->setFloat(name, (float) ip[i]["value"]); indexParams->setFloat(_name, (float) ip[i]["value"]);
break; break;
case CV_64F: case CV_64F:
indexParams->setDouble(name, (double) ip[i]["value"]); indexParams->setDouble(_name, (double) ip[i]["value"]);
break; break;
case CV_USRTYPE1: case CV_USRTYPE1:
indexParams->setString(name, (std::string) ip[i]["value"]); indexParams->setString(_name, (std::string) ip[i]["value"]);
break; break;
case CV_MAKETYPE(CV_USRTYPE1,2): case CV_MAKETYPE(CV_USRTYPE1,2):
indexParams->setBool(name, (int) ip[i]["value"] != 0); indexParams->setBool(_name, (int) ip[i]["value"] != 0);
break; break;
case CV_MAKETYPE(CV_USRTYPE1,3): case CV_MAKETYPE(CV_USRTYPE1,3):
indexParams->setAlgorithm((int) ip[i]["value"]); indexParams->setAlgorithm((int) ip[i]["value"]);
@ -578,7 +578,7 @@ void FlannBasedMatcher::read( const FileNode& fn)
for(int i = 0; i < (int)sp.size(); ++i) for(int i = 0; i < (int)sp.size(); ++i)
{ {
CV_Assert(sp[i].type() == FileNode::MAP); CV_Assert(sp[i].type() == FileNode::MAP);
std::string name = (std::string)sp[i]["name"]; std::string _name = (std::string)sp[i]["name"];
int type = (int)sp[i]["type"]; int type = (int)sp[i]["type"];
switch(type) switch(type)
@ -588,19 +588,19 @@ void FlannBasedMatcher::read( const FileNode& fn)
case CV_16U: case CV_16U:
case CV_16S: case CV_16S:
case CV_32S: case CV_32S:
searchParams->setInt(name, (int) sp[i]["value"]); searchParams->setInt(_name, (int) sp[i]["value"]);
break; break;
case CV_32F: case CV_32F:
searchParams->setFloat(name, (float) ip[i]["value"]); searchParams->setFloat(_name, (float) ip[i]["value"]);
break; break;
case CV_64F: case CV_64F:
searchParams->setDouble(name, (double) ip[i]["value"]); searchParams->setDouble(_name, (double) ip[i]["value"]);
break; break;
case CV_USRTYPE1: case CV_USRTYPE1:
searchParams->setString(name, (std::string) ip[i]["value"]); searchParams->setString(_name, (std::string) ip[i]["value"]);
break; break;
case CV_MAKETYPE(CV_USRTYPE1,2): case CV_MAKETYPE(CV_USRTYPE1,2):
searchParams->setBool(name, (int) ip[i]["value"] != 0); searchParams->setBool(_name, (int) ip[i]["value"] != 0);
break; break;
case CV_MAKETYPE(CV_USRTYPE1,3): case CV_MAKETYPE(CV_USRTYPE1,3):
searchParams->setAlgorithm((int) ip[i]["value"]); searchParams->setAlgorithm((int) ip[i]["value"]);

4
modules/features2d/src/mser.cpp
View File

@ -539,8 +539,8 @@ static void extractMSER_8UC1_Pass( int* ioptr,
} }
*imgptr += 0x10000; *imgptr += 0x10000;
} }
int i = (int)(imgptr-ioptr); int imsk = (int)(imgptr-ioptr);
ptsptr->pt = cvPoint( i&stepmask, i>>stepgap ); ptsptr->pt = cvPoint( imsk&stepmask, imsk>>stepgap );
// get the current location // get the current location
accumulateMSERComp( comptr, ptsptr ); accumulateMSERComp( comptr, ptsptr );
ptsptr++; ptsptr++;

32
modules/features2d/src/orb.cpp
View File

@ -555,9 +555,9 @@ static inline float getScale(int level, int firstLevel, double scaleFactor)
* @param detector_params parameters to use * @param detector_params parameters to use
*/ */
ORB::ORB(int _nfeatures, float _scaleFactor, int _nlevels, int _edgeThreshold, ORB::ORB(int _nfeatures, float _scaleFactor, int _nlevels, int _edgeThreshold,
int _firstLevel, int WTA_K, int _scoreType, int _patchSize) : int _firstLevel, int _WTA_K, int _scoreType, int _patchSize) :
nfeatures(_nfeatures), scaleFactor(_scaleFactor), nlevels(_nlevels), nfeatures(_nfeatures), scaleFactor(_scaleFactor), nlevels(_nlevels),
edgeThreshold(_edgeThreshold), firstLevel(_firstLevel), WTA_K(WTA_K), edgeThreshold(_edgeThreshold), firstLevel(_firstLevel), WTA_K(_WTA_K),
scoreType(_scoreType), patchSize(_patchSize) scoreType(_scoreType), patchSize(_patchSize)
{} {}
@ -653,8 +653,8 @@ static void computeKeyPoints(const vector<Mat>& imagePyramid,
for (int level = 0; level < nlevels; ++level) for (int level = 0; level < nlevels; ++level)
{ {
int nfeatures = nfeaturesPerLevel[level]; int featuresNum = nfeaturesPerLevel[level];
allKeypoints[level].reserve(nfeatures*2); allKeypoints[level].reserve(featuresNum*2);
vector<KeyPoint> & keypoints = allKeypoints[level]; vector<KeyPoint> & keypoints = allKeypoints[level];
@ -668,14 +668,14 @@ static void computeKeyPoints(const vector<Mat>& imagePyramid,
if( scoreType == ORB::HARRIS_SCORE ) if( scoreType == ORB::HARRIS_SCORE )
{ {
// Keep more points than necessary as FAST does not give amazing corners // Keep more points than necessary as FAST does not give amazing corners
KeyPointsFilter::retainBest(keypoints, 2 * nfeatures); KeyPointsFilter::retainBest(keypoints, 2 * featuresNum);
// Compute the Harris cornerness (better scoring than FAST) // Compute the Harris cornerness (better scoring than FAST)
HarrisResponses(imagePyramid[level], keypoints, 7, HARRIS_K); HarrisResponses(imagePyramid[level], keypoints, 7, HARRIS_K);
} }
//cull to the final desired level, using the new Harris scores or the original FAST scores. //cull to the final desired level, using the new Harris scores or the original FAST scores.
KeyPointsFilter::retainBest(keypoints, nfeatures); KeyPointsFilter::retainBest(keypoints, featuresNum);
float sf = getScale(level, firstLevel, scaleFactor); float sf = getScale(level, firstLevel, scaleFactor);
@ -738,7 +738,7 @@ void ORB::operator()( InputArray _image, InputArray _mask, vector<KeyPoint>& _ke
if( image.type() != CV_8UC1 ) if( image.type() != CV_8UC1 )
cvtColor(_image, image, CV_BGR2GRAY); cvtColor(_image, image, CV_BGR2GRAY);
int nlevels = this->nlevels; int levelsNum = this->nlevels;
if( !do_keypoints ) if( !do_keypoints )
{ {
@ -751,15 +751,15 @@ void ORB::operator()( InputArray _image, InputArray _mask, vector<KeyPoint>& _ke
// //
// In short, ultimately the descriptor should // In short, ultimately the descriptor should
// ignore octave parameter and deal only with the keypoint size. // ignore octave parameter and deal only with the keypoint size.
nlevels = 0; levelsNum = 0;
for( size_t i = 0; i < _keypoints.size(); i++ ) for( size_t i = 0; i < _keypoints.size(); i++ )
nlevels = std::max(nlevels, std::max(_keypoints[i].octave, 0)); levelsNum = std::max(levelsNum, std::max(_keypoints[i].octave, 0));
nlevels++; levelsNum++;
} }
// Pre-compute the scale pyramids // Pre-compute the scale pyramids
vector<Mat> imagePyramid(nlevels), maskPyramid(nlevels); vector<Mat> imagePyramid(levelsNum), maskPyramid(levelsNum);
for (int level = 0; level < nlevels; ++level) for (int level = 0; level < levelsNum; ++level)
{ {
float scale = 1/getScale(level, firstLevel, scaleFactor); float scale = 1/getScale(level, firstLevel, scaleFactor);
Size sz(cvRound(image.cols*scale), cvRound(image.rows*scale)); Size sz(cvRound(image.cols*scale), cvRound(image.rows*scale));
@ -839,13 +839,13 @@ void ORB::operator()( InputArray _image, InputArray _mask, vector<KeyPoint>& _ke
KeyPointsFilter::runByImageBorder(_keypoints, image.size(), edgeThreshold); KeyPointsFilter::runByImageBorder(_keypoints, image.size(), edgeThreshold);
// Cluster the input keypoints depending on the level they were computed at // Cluster the input keypoints depending on the level they were computed at
allKeypoints.resize(nlevels); allKeypoints.resize(levelsNum);
for (vector<KeyPoint>::iterator keypoint = _keypoints.begin(), for (vector<KeyPoint>::iterator keypoint = _keypoints.begin(),
keypointEnd = _keypoints.end(); keypoint != keypointEnd; ++keypoint) keypointEnd = _keypoints.end(); keypoint != keypointEnd; ++keypoint)
allKeypoints[keypoint->octave].push_back(*keypoint); allKeypoints[keypoint->octave].push_back(*keypoint);
// Make sure we rescale the coordinates // Make sure we rescale the coordinates
for (int level = 0; level < nlevels; ++level) for (int level = 0; level < levelsNum; ++level)
{ {
if (level == firstLevel) if (level == firstLevel)
continue; continue;
@ -864,7 +864,7 @@ void ORB::operator()( InputArray _image, InputArray _mask, vector<KeyPoint>& _ke
if( do_descriptors ) if( do_descriptors )
{ {
int nkeypoints = 0; int nkeypoints = 0;
for (int level = 0; level < nlevels; ++level) for (int level = 0; level < levelsNum; ++level)
nkeypoints += (int)allKeypoints[level].size(); nkeypoints += (int)allKeypoints[level].size();
if( nkeypoints == 0 ) if( nkeypoints == 0 )
_descriptors.release(); _descriptors.release();
@ -897,7 +897,7 @@ void ORB::operator()( InputArray _image, InputArray _mask, vector<KeyPoint>& _ke
_keypoints.clear(); _keypoints.clear();
int offset = 0; int offset = 0;
for (int level = 0; level < nlevels; ++level) for (int level = 0; level < levelsNum; ++level)
{ {
// Get the features and compute their orientation // Get the features and compute their orientation
vector<KeyPoint>& keypoints = allKeypoints[level]; vector<KeyPoint>& keypoints = allKeypoints[level];

29
modules/features2d/src/stardetector.cpp
View File

@ -121,7 +121,7 @@ StarDetectorComputeResponses( const Mat& img, Mat& responses, Mat& sizes, int ma
StarFeature f[MAX_PATTERN]; StarFeature f[MAX_PATTERN];
Mat sum, tilted, flatTilted; Mat sum, tilted, flatTilted;
int y, i=0, rows = img.rows, cols = img.cols; int y, rows = img.rows, cols = img.cols;
int border, npatterns=0, maxIdx=0; int border, npatterns=0, maxIdx=0;
CV_Assert( img.type() == CV_8UC1 ); CV_Assert( img.type() == CV_8UC1 );
@ -129,21 +129,20 @@ StarDetectorComputeResponses( const Mat& img, Mat& responses, Mat& sizes, int ma
responses.create( img.size(), CV_32F ); responses.create( img.size(), CV_32F );
sizes.create( img.size(), CV_16S ); sizes.create( img.size(), CV_16S );
while( pairs[i][0] >= 0 && ! while( pairs[npatterns][0] >= 0 && !
( sizes0[pairs[i][0]] >= maxSize ( sizes0[pairs[npatterns][0]] >= maxSize
|| sizes0[pairs[i+1][0]] + sizes0[pairs[i+1][0]]/2 >= std::min(rows, cols) ) ) || sizes0[pairs[npatterns+1][0]] + sizes0[pairs[npatterns+1][0]]/2 >= std::min(rows, cols) ) )
{ {
++i; ++npatterns;
} }
npatterns = i;
npatterns += (pairs[npatterns-1][0] >= 0); npatterns += (pairs[npatterns-1][0] >= 0);
maxIdx = pairs[npatterns-1][0]; maxIdx = pairs[npatterns-1][0];
computeIntegralImages( img, sum, tilted, flatTilted ); computeIntegralImages( img, sum, tilted, flatTilted );
int step = (int)(sum.step/sum.elemSize()); int step = (int)(sum.step/sum.elemSize());
for( i = 0; i <= maxIdx; i++ ) for(int i = 0; i <= maxIdx; i++ )
{ {
int ur_size = sizes0[i], t_size = sizes0[i] + sizes0[i]/2; int ur_size = sizes0[i], t_size = sizes0[i] + sizes0[i]/2;
int ur_area = (2*ur_size + 1)*(2*ur_size + 1); int ur_area = (2*ur_size + 1)*(2*ur_size + 1);
@ -169,7 +168,7 @@ StarDetectorComputeResponses( const Mat& img, Mat& responses, Mat& sizes, int ma
sizes1[maxIdx] = -sizes1[maxIdx]; sizes1[maxIdx] = -sizes1[maxIdx];
border = sizes0[maxIdx] + sizes0[maxIdx]/2; border = sizes0[maxIdx] + sizes0[maxIdx]/2;
for( i = 0; i < npatterns; i++ ) for(int i = 0; i < npatterns; i++ )
{ {
int innerArea = f[pairs[i][1]].area; int innerArea = f[pairs[i][1]].area;
int outerArea = f[pairs[i][0]].area - innerArea; int outerArea = f[pairs[i][0]].area - innerArea;
@ -180,13 +179,13 @@ StarDetectorComputeResponses( const Mat& img, Mat& responses, Mat& sizes, int ma
#if CV_SSE2 #if CV_SSE2
if( useSIMD ) if( useSIMD )
{ {
for( i = 0; i < npatterns; i++ ) for(int i = 0; i < npatterns; i++ )
{ {
_mm_store_ps((float*)&invSizes4[i][0], _mm_set1_ps(invSizes[i][0])); _mm_store_ps((float*)&invSizes4[i][0], _mm_set1_ps(invSizes[i][0]));
_mm_store_ps((float*)&invSizes4[i][1], _mm_set1_ps(invSizes[i][1])); _mm_store_ps((float*)&invSizes4[i][1], _mm_set1_ps(invSizes[i][1]));
} }
for( i = 0; i <= maxIdx; i++ ) for(int i = 0; i <= maxIdx; i++ )
_mm_store_ps((float*)&sizes1_4[i], _mm_set1_ps((float)sizes1[i])); _mm_store_ps((float*)&sizes1_4[i], _mm_set1_ps((float)sizes1[i]));
} }
#endif #endif
@ -206,7 +205,7 @@ StarDetectorComputeResponses( const Mat& img, Mat& responses, Mat& sizes, int ma
for( y = border; y < rows - border; y++ ) for( y = border; y < rows - border; y++ )
{ {
int x = border, i; int x = border;
float* r_ptr = responses.ptr<float>(y); float* r_ptr = responses.ptr<float>(y);
short* s_ptr = sizes.ptr<short>(y); short* s_ptr = sizes.ptr<short>(y);
@ -226,7 +225,7 @@ StarDetectorComputeResponses( const Mat& img, Mat& responses, Mat& sizes, int ma
__m128 bestResponse = _mm_setzero_ps(); __m128 bestResponse = _mm_setzero_ps();
__m128 bestSize = _mm_setzero_ps(); __m128 bestSize = _mm_setzero_ps();
for( i = 0; i <= maxIdx; i++ ) for(int i = 0; i <= maxIdx; i++ )
{ {
const int** p = (const int**)&f[i].p[0]; const int** p = (const int**)&f[i].p[0];
__m128i r0 = _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(p[0]+ofs)), __m128i r0 = _mm_sub_epi32(_mm_loadu_si128((const __m128i*)(p[0]+ofs)),
@ -241,7 +240,7 @@ StarDetectorComputeResponses( const Mat& img, Mat& responses, Mat& sizes, int ma
_mm_store_ps((float*)&vals[i], _mm_cvtepi32_ps(r0)); _mm_store_ps((float*)&vals[i], _mm_cvtepi32_ps(r0));
} }
for( i = 0; i < npatterns; i++ ) for(int i = 0; i < npatterns; i++ )
{ {
__m128 inner_sum = vals[pairs[i][1]]; __m128 inner_sum = vals[pairs[i][1]];
__m128 outer_sum = _mm_sub_ps(vals[pairs[i][0]], inner_sum); __m128 outer_sum = _mm_sub_ps(vals[pairs[i][0]], inner_sum);
@ -268,13 +267,13 @@ StarDetectorComputeResponses( const Mat& img, Mat& responses, Mat& sizes, int ma
float bestResponse = 0; float bestResponse = 0;
int bestSize = 0; int bestSize = 0;
for( i = 0; i <= maxIdx; i++ ) for(int i = 0; i <= maxIdx; i++ )
{ {
const int** p = (const int**)&f[i].p[0]; const int** p = (const int**)&f[i].p[0];
vals[i] = p[0][ofs] - p[1][ofs] - p[2][ofs] + p[3][ofs] + vals[i] = p[0][ofs] - p[1][ofs] - p[2][ofs] + p[3][ofs] +
p[4][ofs] - p[5][ofs] - p[6][ofs] + p[7][ofs]; p[4][ofs] - p[5][ofs] - p[6][ofs] + p[7][ofs];
} }
for( i = 0; i < npatterns; i++ ) for(int i = 0; i < npatterns; i++ )
{ {
int inner_sum = vals[pairs[i][1]]; int inner_sum = vals[pairs[i][1]];
int outer_sum = vals[pairs[i][0]] - inner_sum; int outer_sum = vals[pairs[i][0]] - inner_sum;

12
modules/flann/include/opencv2/flann/allocator.h
View File

@ -92,9 +92,9 @@ public:
/** /**
Default constructor. Initializes a new pool. Default constructor. Initializes a new pool.
*/ */
PooledAllocator(int blocksize = BLOCKSIZE) PooledAllocator(int blockSize = BLOCKSIZE)
{ {
this->blocksize = blocksize; blocksize = blockSize;
remaining = 0; remaining = 0;
base = NULL; base = NULL;
@ -122,7 +122,7 @@ public:
*/ */
void* allocateMemory(int size) void* allocateMemory(int size)
{ {
int blocksize; int blockSize;
/* Round size up to a multiple of wordsize. The following expression /* Round size up to a multiple of wordsize. The following expression
only works for WORDSIZE that is a power of 2, by masking last bits of only works for WORDSIZE that is a power of 2, by masking last bits of
@ -138,11 +138,11 @@ public:
wastedMemory += remaining; wastedMemory += remaining;
/* Allocate new storage. */ /* Allocate new storage. */
blocksize = (size + sizeof(void*) + (WORDSIZE-1) > BLOCKSIZE) ? blockSize = (size + sizeof(void*) + (WORDSIZE-1) > BLOCKSIZE) ?
size + sizeof(void*) + (WORDSIZE-1) : BLOCKSIZE; size + sizeof(void*) + (WORDSIZE-1) : BLOCKSIZE;
// use the standard C malloc to allocate memory // use the standard C malloc to allocate memory
void* m = ::malloc(blocksize); void* m = ::malloc(blockSize);
if (!m) { if (!m) {
fprintf(stderr,"Failed to allocate memory.\n"); fprintf(stderr,"Failed to allocate memory.\n");
return NULL; return NULL;
@ -155,7 +155,7 @@ public:
int shift = 0; int shift = 0;
//int shift = (WORDSIZE - ( (((size_t)m) + sizeof(void*)) & (WORDSIZE-1))) & (WORDSIZE-1); //int shift = (WORDSIZE - ( (((size_t)m) + sizeof(void*)) & (WORDSIZE-1))) & (WORDSIZE-1);
remaining = blocksize - sizeof(void*) - shift; remaining = blockSize - sizeof(void*) - shift;
loc = ((char*)m + sizeof(void*) + shift); loc = ((char*)m + sizeof(void*) + shift);
} }
void* rloc = loc; void* rloc = loc;

10
modules/flann/include/opencv2/flann/dynamic_bitset.h
View File

@ -66,9 +66,9 @@ public:
/** @param only constructor we use in our code /** @param only constructor we use in our code
* @param the size of the bitset (in bits) * @param the size of the bitset (in bits)
*/ */
DynamicBitset(size_t size) DynamicBitset(size_t sz)
{ {
resize(size); resize(sz);
reset(); reset();
} }
@ -116,10 +116,10 @@ public:
/** @param resize the bitset so that it contains at least size bits /** @param resize the bitset so that it contains at least size bits
* @param size * @param size
*/ */
void resize(size_t size) void resize(size_t sz)
{ {
size_ = size; size_ = sz;
bitset_.resize(size / cell_bit_size_ + 1); bitset_.resize(sz / cell_bit_size_ + 1);
} }
/** @param set a bit to true /** @param set a bit to true

6
modules/flann/include/opencv2/flann/heap.h
View File

@ -67,12 +67,12 @@ public:
* Constructor. * Constructor.
* *
* Params: * Params:
* size = heap size * sz = heap size
*/ */
Heap(int size) Heap(int sz)
{ {
length = size; length = sz;
heap.reserve(length); heap.reserve(length);
count = 0; count = 0;
} }

44
modules/flann/include/opencv2/flann/hierarchical_clustering_index.h
View File

@ -106,7 +106,7 @@ private:
* indices_length = length of indices vector * indices_length = length of indices vector
* *
*/ */
void chooseCentersRandom(int k, int* indices, int indices_length, int* centers, int& centers_length) void chooseCentersRandom(int k, int* dsindices, int indices_length, int* centers, int& centers_length)
{ {
UniqueRandom r(indices_length); UniqueRandom r(indices_length);
@ -122,7 +122,7 @@ private:
return; return;
} }
centers[index] = indices[rnd]; centers[index] = dsindices[rnd];
for (int j=0; j<index; ++j) { for (int j=0; j<index; ++j) {
DistanceType sq = distance(dataset[centers[index]], dataset[centers[j]], dataset.cols); DistanceType sq = distance(dataset[centers[index]], dataset[centers[j]], dataset.cols);
@ -147,14 +147,14 @@ private:
* indices = indices in the dataset * indices = indices in the dataset
* Returns: * Returns:
*/ */
void chooseCentersGonzales(int k, int* indices, int indices_length, int* centers, int& centers_length) void chooseCentersGonzales(int k, int* dsindices, int indices_length, int* centers, int& centers_length)
{ {
int n = indices_length; int n = indices_length;
int rnd = rand_int(n); int rnd = rand_int(n);
assert(rnd >=0 && rnd < n); assert(rnd >=0 && rnd < n);
centers[0] = indices[rnd]; centers[0] = dsindices[rnd];
int index; int index;
for (index=1; index<k; ++index) { for (index=1; index<k; ++index) {
@ -162,9 +162,9 @@ private:
int best_index = -1; int best_index = -1;
DistanceType best_val = 0; DistanceType best_val = 0;
for (int j=0; j<n; ++j) { for (int j=0; j<n; ++j) {
DistanceType dist = distance(dataset[centers[0]],dataset[indices[j]],dataset.cols); DistanceType dist = distance(dataset[centers[0]],dataset[dsindices[j]],dataset.cols);
for (int i=1; i<index; ++i) { for (int i=1; i<index; ++i) {
DistanceType tmp_dist = distance(dataset[centers[i]],dataset[indices[j]],dataset.cols); DistanceType tmp_dist = distance(dataset[centers[i]],dataset[dsindices[j]],dataset.cols);
if (tmp_dist<dist) { if (tmp_dist<dist) {
dist = tmp_dist; dist = tmp_dist;
} }
@ -175,7 +175,7 @@ private:
} }
} }
if (best_index!=-1) { if (best_index!=-1) {
centers[index] = indices[best_index]; centers[index] = dsindices[best_index];
} }
else { else {
break; break;
@ -198,7 +198,7 @@ private:
* indices = indices in the dataset * indices = indices in the dataset
* Returns: * Returns:
*/ */
void chooseCentersKMeanspp(int k, int* indices, int indices_length, int* centers, int& centers_length) void chooseCentersKMeanspp(int k, int* dsindices, int indices_length, int* centers, int& centers_length)
{ {
int n = indices_length; int n = indices_length;
@ -208,10 +208,10 @@ private:
// Choose one random center and set the closestDistSq values // Choose one random center and set the closestDistSq values
int index = rand_int(n); int index = rand_int(n);
assert(index >=0 && index < n); assert(index >=0 && index < n);
centers[0] = indices[index]; centers[0] = dsindices[index];
for (int i = 0; i < n; i++) { for (int i = 0; i < n; i++) {
closestDistSq[i] = distance(dataset[indices[i]], dataset[indices[index]], dataset.cols); closestDistSq[i] = distance(dataset[dsindices[i]], dataset[dsindices[index]], dataset.cols);
currentPot += closestDistSq[i]; currentPot += closestDistSq[i];
} }
@ -237,7 +237,7 @@ private:
// Compute the new potential // Compute the new potential
double newPot = 0; double newPot = 0;
for (int i = 0; i < n; i++) newPot += std::min( distance(dataset[indices[i]], dataset[indices[index]], dataset.cols), closestDistSq[i] ); for (int i = 0; i < n; i++) newPot += std::min( distance(dataset[dsindices[i]], dataset[dsindices[index]], dataset.cols), closestDistSq[i] );
// Store the best result // Store the best result
if ((bestNewPot < 0)||(newPot < bestNewPot)) { if ((bestNewPot < 0)||(newPot < bestNewPot)) {
@ -247,9 +247,9 @@ private:
} }
// Add the appropriate center // Add the appropriate center
centers[centerCount] = indices[bestNewIndex]; centers[centerCount] = dsindices[bestNewIndex];
currentPot = bestNewPot; currentPot = bestNewPot;
for (int i = 0; i < n; i++) closestDistSq[i] = std::min( distance(dataset[indices[i]], dataset[indices[bestNewIndex]], dataset.cols), closestDistSq[i] ); for (int i = 0; i < n; i++) closestDistSq[i] = std::min( distance(dataset[dsindices[i]], dataset[dsindices[bestNewIndex]], dataset.cols), closestDistSq[i] );
} }
centers_length = centerCount; centers_length = centerCount;
@ -518,11 +518,11 @@ private:
void computeLabels(int* indices, int indices_length, int* centers, int centers_length, int* labels, DistanceType& cost) void computeLabels(int* dsindices, int indices_length, int* centers, int centers_length, int* labels, DistanceType& cost)
{ {
cost = 0; cost = 0;
for (int i=0; i<indices_length; ++i) { for (int i=0; i<indices_length; ++i) {
ElementType* point = dataset[indices[i]]; ElementType* point = dataset[dsindices[i]];
DistanceType dist = distance(point, dataset[centers[0]], veclen_); DistanceType dist = distance(point, dataset[centers[0]], veclen_);
labels[i] = 0; labels[i] = 0;
for (int j=1; j<centers_length; ++j) { for (int j=1; j<centers_length; ++j) {
@ -547,13 +547,13 @@ private:
* *
* TODO: for 1-sized clusters don't store a cluster center (it's the same as the single cluster point) * TODO: for 1-sized clusters don't store a cluster center (it's the same as the single cluster point)
*/ */
void computeClustering(NodePtr node, int* indices, int indices_length, int branching, int level) void computeClustering(NodePtr node, int* dsindices, int indices_length, int branching, int level)
{ {
node->size = indices_length; node->size = indices_length;
node->level = level; node->level = level;
if (indices_length < leaf_size_) { // leaf node if (indices_length < leaf_size_) { // leaf node
node->indices = indices; node->indices = dsindices;
std::sort(node->indices,node->indices+indices_length); std::sort(node->indices,node->indices+indices_length);
node->childs = NULL; node->childs = NULL;
return; return;
@ -563,10 +563,10 @@ private:
std::vector<int> labels(indices_length); std::vector<int> labels(indices_length);
int centers_length; int centers_length;
(this->*chooseCenters)(branching, indices, indices_length, &centers[0], centers_length); (this->*chooseCenters)(branching, dsindices, indices_length, &centers[0], centers_length);
if (centers_length<branching) { if (centers_length<branching) {
node->indices = indices; node->indices = dsindices;
std::sort(node->indices,node->indices+indices_length); std::sort(node->indices,node->indices+indices_length);
node->childs = NULL; node->childs = NULL;
return; return;
@ -575,7 +575,7 @@ private:
// assign points to clusters // assign points to clusters
DistanceType cost; DistanceType cost;
computeLabels(indices, indices_length, &centers[0], centers_length, &labels[0], cost); computeLabels(dsindices, indices_length, &centers[0], centers_length, &labels[0], cost);
node->childs = pool.allocate<NodePtr>(branching); node->childs = pool.allocate<NodePtr>(branching);
int start = 0; int start = 0;
@ -583,7 +583,7 @@ private:
for (int i=0; i<branching; ++i) { for (int i=0; i<branching; ++i) {
for (int j=0; j<indices_length; ++j) { for (int j=0; j<indices_length; ++j) {
if (labels[j]==i) { if (labels[j]==i) {
std::swap(indices[j],indices[end]); std::swap(dsindices[j],dsindices[end]);
std::swap(labels[j],labels[end]); std::swap(labels[j],labels[end]);
end++; end++;
} }
@ -592,7 +592,7 @@ private:
node->childs[i] = pool.allocate<Node>(); node->childs[i] = pool.allocate<Node>();
node->childs[i]->pivot = centers[i]; node->childs[i]->pivot = centers[i];
node->childs[i]->indices = NULL; node->childs[i]->indices = NULL;
computeClustering(node->childs[i],indices+start, end-start, branching, level+1); computeClustering(node->childs[i],dsindices+start, end-start, branching, level+1);
start=end; start=end;
} }
} }

17
modules/gpu/CMakeLists.txt
View File

@ -5,9 +5,7 @@ endif()
set(the_description "GPU-accelerated Computer Vision") set(the_description "GPU-accelerated Computer Vision")
ocv_add_module(gpu opencv_imgproc opencv_calib3d opencv_objdetect opencv_video opencv_nonfree opencv_legacy) ocv_add_module(gpu opencv_imgproc opencv_calib3d opencv_objdetect opencv_video opencv_nonfree opencv_legacy)
ocv_module_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/cuda") ocv_module_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src/cuda" "${CMAKE_CURRENT_SOURCE_DIR}/../highgui/src")
ocv_module_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/../highgui/src")
file(GLOB lib_hdrs "include/opencv2/${name}/*.hpp" "include/opencv2/${name}/*.h") file(GLOB lib_hdrs "include/opencv2/${name}/*.hpp" "include/opencv2/${name}/*.h")
file(GLOB lib_int_hdrs "src/*.hpp" "src/*.h") file(GLOB lib_int_hdrs "src/*.hpp" "src/*.h")
@ -30,17 +28,14 @@ if (HAVE_CUDA)
set(ncv_files ${ncv_srcs} ${ncv_hdrs} ${ncv_cuda}) set(ncv_files ${ncv_srcs} ${ncv_hdrs} ${ncv_cuda})
source_group("Src\\NVidia" FILES ${ncv_files}) source_group("Src\\NVidia" FILES ${ncv_files})
include_directories(AFTER SYSTEM ${CUDA_INCLUDE_DIRS}) ocv_include_directories("src/nvidia" "src/nvidia/core" "src/nvidia/NPP_staging" ${CUDA_INCLUDE_DIRS})
ocv_include_directories("src/nvidia" "src/nvidia/core" "src/nvidia/NPP_staging") ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef /wd4211 /wd4201 /wd4100 /wd4505 /wd4408)
ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef)
#set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-keep") #set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-keep")
#set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xcompiler;/EHsc-;") #set (CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xcompiler;/EHsc-;")
if(MSVC) if(MSVC)
if(NOT ENABLE_NOISY_WARNINGS) if(NOT ENABLE_NOISY_WARNINGS)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4211 /wd4201 /wd4100 /wd4505 /wd4408")
foreach(var CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG) foreach(var CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG)
string(REPLACE "/W4" "/W3" ${var} "${${var}}") string(REPLACE "/W4" "/W3" ${var} "${${var}}")
endforeach() endforeach()
@ -52,10 +47,8 @@ if (HAVE_CUDA)
ocv_cuda_compile(cuda_objs ${lib_cuda} ${ncv_cuda}) ocv_cuda_compile(cuda_objs ${lib_cuda} ${ncv_cuda})
#CUDA_BUILD_CLEAN_TARGET() #CUDA_BUILD_CLEAN_TARGET()
set(cuda_link_libs ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY}) set(cuda_link_libs ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
if(NOT APPLE) if(NOT APPLE)
unset(CUDA_nvcuvid_LIBRARY CACHE) unset(CUDA_nvcuvid_LIBRARY CACHE)
find_cuda_helper_libs(nvcuvid) find_cuda_helper_libs(nvcuvid)
@ -106,11 +99,11 @@ ocv_add_precompiled_headers(${the_module})
################################################################################################################ ################################################################################################################
file(GLOB test_srcs "test/*.cpp") file(GLOB test_srcs "test/*.cpp")
file(GLOB test_hdrs "test/*.hpp" "test/*.h") file(GLOB test_hdrs "test/*.hpp" "test/*.h")
set(nvidia "")
if(HAVE_CUDA) if(HAVE_CUDA)
file(GLOB nvidia "test/nvidia/*.cpp" "test/nvidia/*.hpp" "test/nvidia/*.h") file(GLOB nvidia "test/nvidia/*.cpp" "test/nvidia/*.hpp" "test/nvidia/*.h")
set(nvidia FILES "Src\\\\\\\\NVidia" ${nvidia}) # 8 ugly backslashes :'( set(nvidia FILES "Src\\\\\\\\NVidia" ${nvidia}) # 8 ugly backslashes :'(
else()
set(nvidia "")
endif() endif()
ocv_add_accuracy_tests(FILES "Include" ${test_hdrs} ocv_add_accuracy_tests(FILES "Include" ${test_hdrs}

2
modules/highgui/CMakeLists.txt
View File

@ -134,7 +134,7 @@ endif()
if(HAVE_OPENNI) if(HAVE_OPENNI)
list(APPEND highgui_srcs src/cap_openni.cpp) list(APPEND highgui_srcs src/cap_openni.cpp)
include_directories(AFTER SYSTEM ${OPENNI_INCLUDE_DIR}) ocv_include_directories(${OPENNI_INCLUDE_DIR})
list(APPEND HIGHGUI_LIBRARIES ${OPENNI_LIBRARY}) list(APPEND HIGHGUI_LIBRARIES ${OPENNI_LIBRARY})
endif(HAVE_OPENNI) endif(HAVE_OPENNI)

8
modules/highgui/src/cap_gstreamer.cpp
View File

@ -381,16 +381,12 @@ bool CvCapture_GStreamer::open( int type, const char* filename )
gst_app_sink_set_max_buffers (GST_APP_SINK(sink), 1); gst_app_sink_set_max_buffers (GST_APP_SINK(sink), 1);
gst_app_sink_set_drop (GST_APP_SINK(sink), stream); gst_app_sink_set_drop (GST_APP_SINK(sink), stream);
{ gst_app_sink_set_caps(GST_APP_SINK(sink), gst_caps_new_simple("video/x-raw-rgb",
GstCaps* caps;
caps = gst_caps_new_simple("video/x-raw-rgb",
"red_mask", G_TYPE_INT, 0x0000FF, "red_mask", G_TYPE_INT, 0x0000FF,
"green_mask", G_TYPE_INT, 0x00FF00, "green_mask", G_TYPE_INT, 0x00FF00,
"blue_mask", G_TYPE_INT, 0xFF0000, "blue_mask", G_TYPE_INT, 0xFF0000,
NULL); NULL));
gst_app_sink_set_caps(GST_APP_SINK(sink), caps);
gst_caps_unref(caps); gst_caps_unref(caps);
}
if(gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_READY) == if(gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_READY) ==
GST_STATE_CHANGE_FAILURE) { GST_STATE_CHANGE_FAILURE) {

4
modules/highgui/src/cap_libv4l.cpp
View File

@ -1688,8 +1688,8 @@ static void icvCloseCAM_V4L( CvCaptureCAM_V4L* capture ){
if (xioctl(capture->deviceHandle, VIDIOC_STREAMOFF, &capture->type) < 0) { if (xioctl(capture->deviceHandle, VIDIOC_STREAMOFF, &capture->type) < 0) {
perror ("Unable to stop the stream."); perror ("Unable to stop the stream.");
} }
for (unsigned int n_buffers = 0; n_buffers < capture->req.count; ++n_buffers) { for (unsigned int n_buffers2 = 0; n_buffers2 < capture->req.count; ++n_buffers2) {
if (-1 == v4l2_munmap (capture->buffers[n_buffers].start, capture->buffers[n_buffers].length)) { if (-1 == v4l2_munmap (capture->buffers[n_buffers2].start, capture->buffers[n_buffers2].length)) {
perror ("munmap"); perror ("munmap");
} }
} }

8
modules/highgui/src/grfmt_png.cpp
View File

@ -157,16 +157,16 @@ bool PngDecoder::readHeader()
if( !m_buf.empty() || m_f ) if( !m_buf.empty() || m_f )
{ {
png_uint_32 width, height; png_uint_32 wdth, hght;
int bit_depth, color_type; int bit_depth, color_type;
png_read_info( png_ptr, info_ptr ); png_read_info( png_ptr, info_ptr );
png_get_IHDR( png_ptr, info_ptr, &width, &height, png_get_IHDR( png_ptr, info_ptr, &wdth, &hght,
&bit_depth, &color_type, 0, 0, 0 ); &bit_depth, &color_type, 0, 0, 0 );
m_width = (int)width; m_width = (int)wdth;
m_height = (int)height; m_height = (int)hght;
m_color_type = color_type; m_color_type = color_type;
m_bit_depth = bit_depth; m_bit_depth = bit_depth;

10
modules/highgui/src/grfmt_tiff.cpp
View File

@ -115,19 +115,19 @@ bool TiffDecoder::readHeader()
if( tif ) if( tif )
{ {
int width = 0, height = 0, photometric = 0; int wdth = 0, hght = 0, photometric = 0;
m_tif = tif; m_tif = tif;
if( TIFFGetField( tif, TIFFTAG_IMAGEWIDTH, &width ) && if( TIFFGetField( tif, TIFFTAG_IMAGEWIDTH, &wdth ) &&
TIFFGetField( tif, TIFFTAG_IMAGELENGTH, &height ) && TIFFGetField( tif, TIFFTAG_IMAGELENGTH, &hght ) &&
TIFFGetField( tif, TIFFTAG_PHOTOMETRIC, &photometric )) TIFFGetField( tif, TIFFTAG_PHOTOMETRIC, &photometric ))
{ {
int bpp=8, ncn = photometric > 1 ? 3 : 1; int bpp=8, ncn = photometric > 1 ? 3 : 1;
TIFFGetField( tif, TIFFTAG_BITSPERSAMPLE, &bpp ); TIFFGetField( tif, TIFFTAG_BITSPERSAMPLE, &bpp );
TIFFGetField( tif, TIFFTAG_SAMPLESPERPIXEL, &ncn ); TIFFGetField( tif, TIFFTAG_SAMPLESPERPIXEL, &ncn );
m_width = width; m_width = wdth;
m_height = height; m_height = hght;
if( bpp > 8 && if( bpp > 8 &&
((photometric != 2 && photometric != 1) || ((photometric != 2 && photometric != 1) ||
(ncn != 1 && ncn != 3 && ncn != 4))) (ncn != 1 && ncn != 3 && ncn != 4)))

4
modules/highgui/test/test_drawing.cpp
View File

@ -60,9 +60,9 @@ protected:
void CV_DrawingTest::run( int ) void CV_DrawingTest::run( int )
{ {
Mat testImg, valImg; Mat testImg, valImg;
const string name = "drawing/image.jpg"; const string fname = "drawing/image.jpg";
string path = ts->get_data_path(), filename; string path = ts->get_data_path(), filename;
filename = path + name; filename = path + fname;
draw( testImg ); draw( testImg );

2
modules/highgui/test/test_video_io.cpp
View File

@ -403,7 +403,7 @@ void CV_HighGuiTest::SpecificVideoTest(const string& dir, const cvtest::VideoFor
if (!writer.isOpened()) if (!writer.isOpened())
{ {
// call it repeatedly for easier debugging // call it repeatedly for easier debugging
VideoWriter writer(video_file, fourcc, 25, frame_size, true); VideoWriter writer2(video_file, fourcc, 25, frame_size, true);
ts->printf(ts->LOG, "Creating a video in %s...\n", video_file.c_str()); ts->printf(ts->LOG, "Creating a video in %s...\n", video_file.c_str());
ts->printf(ts->LOG, "Cannot create VideoWriter object with codec %s.\n", fourcc_str.c_str()); ts->printf(ts->LOG, "Cannot create VideoWriter object with codec %s.\n", fourcc_str.c_str());
ts->set_failed_test_info(ts->FAIL_MISMATCH); ts->set_failed_test_info(ts->FAIL_MISMATCH);

22
modules/imgproc/src/color.cpp
View File

@ -434,7 +434,7 @@ template<> struct RGB2Gray<uchar>
for(int i = 0; i < n; i++, src += scn) for(int i = 0; i < n; i++, src += scn)
dst[i] = (uchar)((_tab[src[0]] + _tab[src[1]+256] + _tab[src[2]+512]) >> yuv_shift); dst[i] = (uchar)((_tab[src[0]] + _tab[src[1]+256] + _tab[src[2]+512]) >> yuv_shift);
} }
int srccn, blueIdx; int srccn;
int tab[256*3]; int tab[256*3];
}; };
@ -3510,8 +3510,8 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
// http://www.fourcc.org/yuv.php#NV12 -> a plane of 8 bit Y samples followed by an interleaved U/V plane containing 8 bit 2x2 subsampled colour difference samples // http://www.fourcc.org/yuv.php#NV12 -> a plane of 8 bit Y samples followed by an interleaved U/V plane containing 8 bit 2x2 subsampled colour difference samples
if (dcn <= 0) dcn = (code==CV_YUV420sp2BGRA || code==CV_YUV420sp2RGBA || code==CV_YUV2BGRA_NV12 || code==CV_YUV2RGBA_NV12) ? 4 : 3; if (dcn <= 0) dcn = (code==CV_YUV420sp2BGRA || code==CV_YUV420sp2RGBA || code==CV_YUV2BGRA_NV12 || code==CV_YUV2RGBA_NV12) ? 4 : 3;
const int bidx = (code==CV_YUV2BGR_NV21 || code==CV_YUV2BGRA_NV21 || code==CV_YUV2BGR_NV12 || code==CV_YUV2BGRA_NV12) ? 0 : 2; const int bIdx = (code==CV_YUV2BGR_NV21 || code==CV_YUV2BGRA_NV21 || code==CV_YUV2BGR_NV12 || code==CV_YUV2BGRA_NV12) ? 0 : 2;
const int uidx = (code==CV_YUV2BGR_NV21 || code==CV_YUV2BGRA_NV21 || code==CV_YUV2RGB_NV21 || code==CV_YUV2RGBA_NV21) ? 1 : 0; const int uIdx = (code==CV_YUV2BGR_NV21 || code==CV_YUV2BGRA_NV21 || code==CV_YUV2RGB_NV21 || code==CV_YUV2RGBA_NV21) ? 1 : 0;
CV_Assert( dcn == 3 || dcn == 4 ); CV_Assert( dcn == 3 || dcn == 4 );
CV_Assert( sz.width % 2 == 0 && sz.height % 3 == 0 && depth == CV_8U ); CV_Assert( sz.width % 2 == 0 && sz.height % 3 == 0 && depth == CV_8U );
@ -3524,7 +3524,7 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
const uchar* y = src.ptr(); const uchar* y = src.ptr();
const uchar* uv = y + srcstep * dstSz.height; const uchar* uv = y + srcstep * dstSz.height;
switch(dcn*100 + bidx * 10 + uidx) switch(dcn*100 + bIdx * 10 + uIdx)
{ {
case 300: cvtYUV420sp2RGB<0, 0> (dst, srcstep, y, uv); break; case 300: cvtYUV420sp2RGB<0, 0> (dst, srcstep, y, uv); break;
case 301: cvtYUV420sp2RGB<0, 1> (dst, srcstep, y, uv); break; case 301: cvtYUV420sp2RGB<0, 1> (dst, srcstep, y, uv); break;
@ -3545,8 +3545,8 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
//http://www.fourcc.org/yuv.php#IYUV == I420 -> It comprises an NxN Y plane followed by (N/2)x(N/2) U and V planes //http://www.fourcc.org/yuv.php#IYUV == I420 -> It comprises an NxN Y plane followed by (N/2)x(N/2) U and V planes
if (dcn <= 0) dcn = (code==CV_YUV2BGRA_YV12 || code==CV_YUV2RGBA_YV12 || code==CV_YUV2RGBA_IYUV || code==CV_YUV2BGRA_IYUV) ? 4 : 3; if (dcn <= 0) dcn = (code==CV_YUV2BGRA_YV12 || code==CV_YUV2RGBA_YV12 || code==CV_YUV2RGBA_IYUV || code==CV_YUV2BGRA_IYUV) ? 4 : 3;
const int bidx = (code==CV_YUV2BGR_YV12 || code==CV_YUV2BGRA_YV12 || code==CV_YUV2BGR_IYUV || code==CV_YUV2BGRA_IYUV) ? 0 : 2; const int bIdx = (code==CV_YUV2BGR_YV12 || code==CV_YUV2BGRA_YV12 || code==CV_YUV2BGR_IYUV || code==CV_YUV2BGRA_IYUV) ? 0 : 2;
const int uidx = (code==CV_YUV2BGR_YV12 || code==CV_YUV2RGB_YV12 || code==CV_YUV2BGRA_YV12 || code==CV_YUV2RGBA_YV12) ? 1 : 0; const int uIdx = (code==CV_YUV2BGR_YV12 || code==CV_YUV2RGB_YV12 || code==CV_YUV2BGRA_YV12 || code==CV_YUV2RGBA_YV12) ? 1 : 0;
CV_Assert( dcn == 3 || dcn == 4 ); CV_Assert( dcn == 3 || dcn == 4 );
CV_Assert( sz.width % 2 == 0 && sz.height % 3 == 0 && depth == CV_8U ); CV_Assert( sz.width % 2 == 0 && sz.height % 3 == 0 && depth == CV_8U );
@ -3563,9 +3563,9 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
int ustepIdx = 0; int ustepIdx = 0;
int vstepIdx = dstSz.height % 4 == 2 ? 1 : 0; int vstepIdx = dstSz.height % 4 == 2 ? 1 : 0;
if(uidx == 1) { std::swap(u ,v), std::swap(ustepIdx, vstepIdx); }; if(uIdx == 1) { std::swap(u ,v), std::swap(ustepIdx, vstepIdx); };
switch(dcn*10 + bidx) switch(dcn*10 + bIdx)
{ {
case 30: cvtYUV420p2RGB<0>(dst, srcstep, y, u, v, ustepIdx, vstepIdx); break; case 30: cvtYUV420p2RGB<0>(dst, srcstep, y, u, v, ustepIdx, vstepIdx); break;
case 32: cvtYUV420p2RGB<2>(dst, srcstep, y, u, v, ustepIdx, vstepIdx); break; case 32: cvtYUV420p2RGB<2>(dst, srcstep, y, u, v, ustepIdx, vstepIdx); break;
@ -3598,9 +3598,9 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
//http://www.fourcc.org/yuv.php#YVYU //http://www.fourcc.org/yuv.php#YVYU
if (dcn <= 0) dcn = (code==CV_YUV2RGBA_UYVY || code==CV_YUV2BGRA_UYVY || code==CV_YUV2RGBA_YUY2 || code==CV_YUV2BGRA_YUY2 || code==CV_YUV2RGBA_YVYU || code==CV_YUV2BGRA_YVYU) ? 4 : 3; if (dcn <= 0) dcn = (code==CV_YUV2RGBA_UYVY || code==CV_YUV2BGRA_UYVY || code==CV_YUV2RGBA_YUY2 || code==CV_YUV2BGRA_YUY2 || code==CV_YUV2RGBA_YVYU || code==CV_YUV2BGRA_YVYU) ? 4 : 3;
const int bidx = (code==CV_YUV2BGR_UYVY || code==CV_YUV2BGRA_UYVY || code==CV_YUV2BGR_YUY2 || code==CV_YUV2BGRA_YUY2 || code==CV_YUV2BGR_YVYU || code==CV_YUV2BGRA_YVYU) ? 0 : 2; const int bIdx = (code==CV_YUV2BGR_UYVY || code==CV_YUV2BGRA_UYVY || code==CV_YUV2BGR_YUY2 || code==CV_YUV2BGRA_YUY2 || code==CV_YUV2BGR_YVYU || code==CV_YUV2BGRA_YVYU) ? 0 : 2;
const int ycn = (code==CV_YUV2RGB_UYVY || code==CV_YUV2BGR_UYVY || code==CV_YUV2RGBA_UYVY || code==CV_YUV2BGRA_UYVY) ? 1 : 0; const int ycn = (code==CV_YUV2RGB_UYVY || code==CV_YUV2BGR_UYVY || code==CV_YUV2RGBA_UYVY || code==CV_YUV2BGRA_UYVY) ? 1 : 0;
const int uidx = (code==CV_YUV2RGB_YVYU || code==CV_YUV2BGR_YVYU || code==CV_YUV2RGBA_YVYU || code==CV_YUV2BGRA_YVYU) ? 1 : 0; const int uIdx = (code==CV_YUV2RGB_YVYU || code==CV_YUV2BGR_YVYU || code==CV_YUV2RGBA_YVYU || code==CV_YUV2BGRA_YVYU) ? 1 : 0;
CV_Assert( dcn == 3 || dcn == 4 ); CV_Assert( dcn == 3 || dcn == 4 );
CV_Assert( scn == 2 && depth == CV_8U ); CV_Assert( scn == 2 && depth == CV_8U );
@ -3608,7 +3608,7 @@ void cv::cvtColor( InputArray _src, OutputArray _dst, int code, int dcn )
_dst.create(sz, CV_8UC(dcn)); _dst.create(sz, CV_8UC(dcn));
dst = _dst.getMat(); dst = _dst.getMat();
switch(dcn*1000 + bidx*100 + uidx*10 + ycn) switch(dcn*1000 + bIdx*100 + uIdx*10 + ycn)
{ {
case 3000: cvtYUV422toRGB<0,0,0>(dst, (int)src.step, src.ptr<uchar>()); break; case 3000: cvtYUV422toRGB<0,0,0>(dst, (int)src.step, src.ptr<uchar>()); break;
case 3001: cvtYUV422toRGB<0,0,1>(dst, (int)src.step, src.ptr<uchar>()); break; case 3001: cvtYUV422toRGB<0,0,1>(dst, (int)src.step, src.ptr<uchar>()); break;

6
modules/imgproc/src/filter.cpp
View File

@ -311,10 +311,10 @@ int FilterEngine::start(const Mat& src, const Rect& _srcRoi,
srcRoi.y + srcRoi.height <= src.rows ); srcRoi.y + srcRoi.height <= src.rows );
Point ofs; Point ofs;
Size wholeSize(src.cols, src.rows); Size wsz(src.cols, src.rows);
if( !isolated ) if( !isolated )
src.locateROI( wholeSize, ofs ); src.locateROI( wsz, ofs );
start( wholeSize, srcRoi + ofs, maxBufRows ); start( wsz, srcRoi + ofs, maxBufRows );
return startY - ofs.y; return startY - ofs.y;
} }

18
modules/imgproc/src/gcgraph.hpp
View File

@ -290,14 +290,14 @@ TWeight GCGraph<TWeight>::maxFlow()
curr_ts++; curr_ts++;
while( !orphans.empty() ) while( !orphans.empty() )
{ {
Vtx* v = orphans.back(); Vtx* v2 = orphans.back();
orphans.pop_back(); orphans.pop_back();
int d, minDist = INT_MAX; int d, minDist = INT_MAX;
e0 = 0; e0 = 0;
vt = v->t; vt = v2->t;
for( ei = v->first; ei != 0; ei = edgePtr[ei].next ) for( ei = v2->first; ei != 0; ei = edgePtr[ei].next )
{ {
if( edgePtr[ei^(vt^1)].weight == 0 ) if( edgePtr[ei^(vt^1)].weight == 0 )
continue; continue;
@ -344,16 +344,16 @@ TWeight GCGraph<TWeight>::maxFlow()
} }
} }
if( (v->parent = e0) > 0 ) if( (v2->parent = e0) > 0 )
{ {
v->ts = curr_ts; v2->ts = curr_ts;
v->dist = minDist; v2->dist = minDist;
continue; continue;
} }
/* no parent is found */ /* no parent is found */
v->ts = 0; v2->ts = 0;
for( ei = v->first; ei != 0; ei = edgePtr[ei].next ) for( ei = v2->first; ei != 0; ei = edgePtr[ei].next )
{ {
u = vtxPtr+edgePtr[ei].dst; u = vtxPtr+edgePtr[ei].dst;
ej = u->parent; ej = u->parent;
@ -364,7 +364,7 @@ TWeight GCGraph<TWeight>::maxFlow()
u->next = nilNode; u->next = nilNode;
last = last->next = u; last = last->next = u;
} }
if( ej > 0 && vtxPtr+edgePtr[ej].dst == v ) if( ej > 0 && vtxPtr+edgePtr[ej].dst == v2 )
{ {
orphans.push_back(u); orphans.push_back(u);
u->parent = ORPHAN; u->parent = ORPHAN;

26
modules/imgproc/src/histogram.cpp
View File

@ -198,9 +198,9 @@ static void histPrepareImages( const Mat* images, int nimages, const int* channe
{ {
for( i = 0; i < dims; i++ ) for( i = 0; i < dims; i++ )
{ {
size_t j, n = histSize[i]; size_t n = histSize[i];
for( j = 0; j < n; j++ ) for(size_t k = 0; k < n; k++ )
CV_Assert( ranges[i][j] < ranges[i][j+1] ); CV_Assert( ranges[i][k] < ranges[i][k+1] );
} }
} }
} }
@ -431,7 +431,7 @@ calcHist_8u( vector<uchar*>& _ptrs, const vector<int>& _deltas,
uchar** ptrs = &_ptrs[0]; uchar** ptrs = &_ptrs[0];
const int* deltas = &_deltas[0]; const int* deltas = &_deltas[0];
uchar* H = hist.data; uchar* H = hist.data;
int i, x; int x;
const uchar* mask = _ptrs[dims]; const uchar* mask = _ptrs[dims];
int mstep = _deltas[dims*2 + 1]; int mstep = _deltas[dims*2 + 1];
vector<size_t> _tab; vector<size_t> _tab;
@ -480,7 +480,7 @@ calcHist_8u( vector<uchar*>& _ptrs, const vector<int>& _deltas,
matH[*p0]++; matH[*p0]++;
} }
for( i = 0; i < 256; i++ ) for(int i = 0; i < 256; i++ )
{ {
size_t hidx = tab[i]; size_t hidx = tab[i];
if( hidx < OUT_OF_RANGE ) if( hidx < OUT_OF_RANGE )
@ -548,7 +548,8 @@ calcHist_8u( vector<uchar*>& _ptrs, const vector<int>& _deltas,
for( x = 0; x < imsize.width; x++ ) for( x = 0; x < imsize.width; x++ )
{ {
uchar* Hptr = H; uchar* Hptr = H;
for( i = 0; i < dims; i++ ) int i = 0;
for( ; i < dims; i++ )
{ {
size_t idx = tab[*ptrs[i] + i*256]; size_t idx = tab[*ptrs[i] + i*256];
if( idx >= OUT_OF_RANGE ) if( idx >= OUT_OF_RANGE )
@ -584,7 +585,7 @@ calcHist_8u( vector<uchar*>& _ptrs, const vector<int>& _deltas,
for( ; i < dims; i++ ) for( ; i < dims; i++ )
ptrs[i] += deltas[i*2]; ptrs[i] += deltas[i*2];
} }
for( i = 0; i < dims; i++ ) for(int i = 0; i < dims; i++ )
ptrs[i] += deltas[i*2 + 1]; ptrs[i] += deltas[i*2 + 1];
} }
} }
@ -729,7 +730,7 @@ calcSparseHist_8u( vector<uchar*>& _ptrs, const vector<int>& _deltas,
{ {
uchar** ptrs = (uchar**)&_ptrs[0]; uchar** ptrs = (uchar**)&_ptrs[0];
const int* deltas = &_deltas[0]; const int* deltas = &_deltas[0];
int i, x; int x;
const uchar* mask = _ptrs[dims]; const uchar* mask = _ptrs[dims];
int mstep = _deltas[dims*2 + 1]; int mstep = _deltas[dims*2 + 1];
int idx[CV_MAX_DIM]; int idx[CV_MAX_DIM];
@ -759,7 +760,7 @@ calcSparseHist_8u( vector<uchar*>& _ptrs, const vector<int>& _deltas,
for( ; i < dims; i++ ) for( ; i < dims; i++ )
ptrs[i] += deltas[i*2]; ptrs[i] += deltas[i*2];
} }
for( i = 0; i < dims; i++ ) for(int i = 0; i < dims; i++ )
ptrs[i] += deltas[i*2 + 1]; ptrs[i] += deltas[i*2 + 1];
} }
} }
@ -1749,7 +1750,7 @@ cvGetMinMaxHistValue( const CvHistogram* hist,
int* idx_min, int* idx_max ) int* idx_min, int* idx_max )
{ {
double minVal, maxVal; double minVal, maxVal;
int i, dims, size[CV_MAX_DIM]; int dims, size[CV_MAX_DIM];
if( !CV_IS_HIST(hist) ) if( !CV_IS_HIST(hist) )
CV_Error( CV_StsBadArg, "Invalid histogram header" ); CV_Error( CV_StsBadArg, "Invalid histogram header" );
@ -1782,9 +1783,8 @@ cvGetMinMaxHistValue( const CvHistogram* hist,
{ {
int imin = minPt.y*mat.cols + minPt.x; int imin = minPt.y*mat.cols + minPt.x;
int imax = maxPt.y*mat.cols + maxPt.x; int imax = maxPt.y*mat.cols + maxPt.x;
int i;
for( i = dims - 1; i >= 0; i-- ) for(int i = dims - 1; i >= 0; i-- )
{ {
if( idx_min ) if( idx_min )
{ {
@ -1844,7 +1844,7 @@ cvGetMinMaxHistValue( const CvHistogram* hist,
minVal = maxVal = 0; minVal = maxVal = 0;
} }
for( i = 0; i < dims; i++ ) for(int i = 0; i < dims; i++ )
{ {
if( idx_min ) if( idx_min )
idx_min[i] = _idx_min ? _idx_min[i] : -1; idx_min[i] = _idx_min ? _idx_min[i] : -1;

28
modules/imgproc/src/hough.cpp
View File

@ -92,8 +92,6 @@ icvHoughLinesStandard( const CvMat* img, float rho, float theta,
int step, width, height; int step, width, height;
int numangle, numrho; int numangle, numrho;
int total = 0; int total = 0;
float ang;
int r, n;
int i, j; int i, j;
float irho = 1 / rho; float irho = 1 / rho;
double scale; double scale;
@ -117,7 +115,8 @@ icvHoughLinesStandard( const CvMat* img, float rho, float theta,
memset( accum, 0, sizeof(accum[0]) * (numangle+2) * (numrho+2) ); memset( accum, 0, sizeof(accum[0]) * (numangle+2) * (numrho+2) );
for( ang = 0, n = 0; n < numangle; ang += theta, n++ ) float ang = 0;
for(int n = 0; n < numangle; ang += theta, n++ )
{ {
tabSin[n] = (float)(sin(ang) * irho); tabSin[n] = (float)(sin(ang) * irho);
tabCos[n] = (float)(cos(ang) * irho); tabCos[n] = (float)(cos(ang) * irho);
@ -128,17 +127,17 @@ icvHoughLinesStandard( const CvMat* img, float rho, float theta,
for( j = 0; j < width; j++ ) for( j = 0; j < width; j++ )
{ {
if( image[i * step + j] != 0 ) if( image[i * step + j] != 0 )
for( n = 0; n < numangle; n++ ) for(int n = 0; n < numangle; n++ )
{ {
r = cvRound( j * tabCos[n] + i * tabSin[n] ); int r = cvRound( j * tabCos[n] + i * tabSin[n] );
r += (numrho - 1) / 2; r += (numrho - 1) / 2;
accum[(n+1) * (numrho+2) + r+1]++; accum[(n+1) * (numrho+2) + r+1]++;
} }
} }
// stage 2. find local maximums // stage 2. find local maximums
for( r = 0; r < numrho; r++ ) for(int r = 0; r < numrho; r++ )
for( n = 0; n < numangle; n++ ) for(int n = 0; n < numangle; n++ )
{ {
int base = (n+1) * (numrho+2) + r+1; int base = (n+1) * (numrho+2) + r+1;
if( accum[base] > threshold && if( accum[base] > threshold &&
@ -529,7 +528,7 @@ icvHoughLinesProbabilistic( CvMat* image,
// choose random point out of the remaining ones // choose random point out of the remaining ones
int idx = cvRandInt(&rng) % count; int idx = cvRandInt(&rng) % count;
int max_val = threshold-1, max_n = 0; int max_val = threshold-1, max_n = 0;
CvPoint* pt = (CvPoint*)cvGetSeqElem( seq, idx ); CvPoint* point = (CvPoint*)cvGetSeqElem( seq, idx );
CvPoint line_end[2] = {{0,0}, {0,0}}; CvPoint line_end[2] = {{0,0}, {0,0}};
float a, b; float a, b;
int* adata = (int*)accum.data; int* adata = (int*)accum.data;
@ -537,11 +536,11 @@ icvHoughLinesProbabilistic( CvMat* image,
int good_line; int good_line;
const int shift = 16; const int shift = 16;
i = pt->y; i = point->y;
j = pt->x; j = point->x;
// "remove" it by overriding it with the last element // "remove" it by overriding it with the last element
*pt = *(CvPoint*)cvGetSeqElem( seq, count-1 ); *point = *(CvPoint*)cvGetSeqElem( seq, count-1 );
// check if it has been excluded already (i.e. belongs to some other line) // check if it has been excluded already (i.e. belongs to some other line)
if( !mdata0[i*width + j] ) if( !mdata0[i*width + j] )
@ -852,7 +851,7 @@ icvHoughCirclesGradient( CvMat* img, float dp, float min_dist,
for( x = 0; x < cols; x++ ) for( x = 0; x < cols; x++ )
{ {
float vx, vy; float vx, vy;
int sx, sy, x0, y0, x1, y1, r, k; int sx, sy, x0, y0, x1, y1, r;
CvPoint pt; CvPoint pt;
vx = dx_row[x]; vx = dx_row[x];
@ -869,7 +868,7 @@ icvHoughCirclesGradient( CvMat* img, float dp, float min_dist,
x0 = cvRound((x*idp)*ONE); x0 = cvRound((x*idp)*ONE);
y0 = cvRound((y*idp)*ONE); y0 = cvRound((y*idp)*ONE);
// Step from min_radius to max_radius in both directions of the gradient // Step from min_radius to max_radius in both directions of the gradient
for( k = 0; k < 2; k++ ) for(int k1 = 0; k1 < 2; k1++ )
{ {
x1 = x0 + min_radius * sx; x1 = x0 + min_radius * sx;
y1 = y0 + min_radius * sy; y1 = y0 + min_radius * sy;
@ -934,7 +933,7 @@ icvHoughCirclesGradient( CvMat* img, float dp, float min_dist,
//Calculate circle's center in pixels //Calculate circle's center in pixels
float cx = (float)((x + 0.5f)*dp), cy = (float)(( y + 0.5f )*dp); float cx = (float)((x + 0.5f)*dp), cy = (float)(( y + 0.5f )*dp);
float start_dist, dist_sum; float start_dist, dist_sum;
float r_best = 0, c[3]; float r_best = 0;
int max_count = 0; int max_count = 0;
// Check distance with previously detected circles // Check distance with previously detected circles
for( j = 0; j < circles->total; j++ ) for( j = 0; j < circles->total; j++ )
@ -996,6 +995,7 @@ icvHoughCirclesGradient( CvMat* img, float dp, float min_dist,
// Check if the circle has enough support // Check if the circle has enough support
if( max_count > acc_threshold ) if( max_count > acc_threshold )
{ {
float c[3];
c[0] = cx; c[0] = cx;
c[1] = cy; c[1] = cy;
c[2] = (float)r_best; c[2] = (float)r_best;

39
modules/imgproc/src/imgwarp.cpp
View File

@ -97,7 +97,6 @@ static inline void interpolateLanczos4( float x, float* coeffs )
static const double cs[][2]= static const double cs[][2]=
{{1, 0}, {-s45, -s45}, {0, 1}, {s45, -s45}, {-1, 0}, {s45, s45}, {0, -1}, {-s45, s45}}; {{1, 0}, {-s45, -s45}, {0, 1}, {s45, -s45}, {-1, 0}, {s45, s45}, {0, -1}, {-s45, s45}};
int i;
if( x < FLT_EPSILON ) if( x < FLT_EPSILON )
{ {
for( int i = 0; i < 8; i++ ) for( int i = 0; i < 8; i++ )
@ -108,7 +107,7 @@ static inline void interpolateLanczos4( float x, float* coeffs )
float sum = 0; float sum = 0;
double y0=-(x+3)*CV_PI*0.25, s0 = sin(y0), c0=cos(y0); double y0=-(x+3)*CV_PI*0.25, s0 = sin(y0), c0=cos(y0);
for( i = 0; i < 8; i++ ) for(int i = 0; i < 8; i++ )
{ {
double y = -(x+3-i)*CV_PI*0.25; double y = -(x+3-i)*CV_PI*0.25;
coeffs[i] = (float)((cs[i][0]*s0 + cs[i][1]*c0)/(y*y)); coeffs[i] = (float)((cs[i][0]*s0 + cs[i][1]*c0)/(y*y));
@ -116,7 +115,7 @@ static inline void interpolateLanczos4( float x, float* coeffs )
} }
sum = 1.f/sum; sum = 1.f/sum;
for( i = 0; i < 8; i++ ) for(int i = 0; i < 8; i++ )
coeffs[i] *= sum; coeffs[i] *= sum;
} }
@ -1091,14 +1090,14 @@ static void resizeGeneric_( const Mat& src, Mat& dst,
const T* srows[MAX_ESIZE]={0}; const T* srows[MAX_ESIZE]={0};
WT* rows[MAX_ESIZE]={0}; WT* rows[MAX_ESIZE]={0};
int prev_sy[MAX_ESIZE]; int prev_sy[MAX_ESIZE];
int k, dy; int dy;
xmin *= cn; xmin *= cn;
xmax *= cn; xmax *= cn;
HResize hresize; HResize hresize;
VResize vresize; VResize vresize;
for( k = 0; k < ksize; k++ ) for(int k = 0; k < ksize; k++ )
{ {
prev_sy[k] = -1; prev_sy[k] = -1;
rows[k] = (WT*)_buffer + bufstep*k; rows[k] = (WT*)_buffer + bufstep*k;
@ -1107,9 +1106,9 @@ static void resizeGeneric_( const Mat& src, Mat& dst,
// image resize is a separable operation. In case of not too strong // image resize is a separable operation. In case of not too strong
for( dy = 0; dy < dsize.height; dy++, beta += ksize ) for( dy = 0; dy < dsize.height; dy++, beta += ksize )
{ {
int sy0 = yofs[dy], k, k0=ksize, k1=0, ksize2 = ksize/2; int sy0 = yofs[dy], k0=ksize, k1=0, ksize2 = ksize/2;
for( k = 0; k < ksize; k++ ) for(int k = 0; k < ksize; k++ )
{ {
int sy = clip(sy0 - ksize2 + 1 + k, 0, ssize.height); int sy = clip(sy0 - ksize2 + 1 + k, 0, ssize.height);
for( k1 = std::max(k1, k); k1 < ksize; k1++ ) for( k1 = std::max(k1, k); k1 < ksize; k1++ )
@ -2374,25 +2373,25 @@ static void remapLanczos4( const Mat& _src, Mat& _dst, const Mat& _xy,
for( i = 0; i < 8; i++, w += 8 ) for( i = 0; i < 8; i++, w += 8 )
{ {
int yi = y[i]; int yi = y[i];
const T* S = S0 + yi*sstep; const T* S1 = S0 + yi*sstep;
if( yi < 0 ) if( yi < 0 )
continue; continue;
if( x[0] >= 0 ) if( x[0] >= 0 )
sum += (S[x[0]] - cv)*w[0]; sum += (S1[x[0]] - cv)*w[0];
if( x[1] >= 0 ) if( x[1] >= 0 )
sum += (S[x[1]] - cv)*w[1]; sum += (S1[x[1]] - cv)*w[1];
if( x[2] >= 0 ) if( x[2] >= 0 )
sum += (S[x[2]] - cv)*w[2]; sum += (S1[x[2]] - cv)*w[2];
if( x[3] >= 0 ) if( x[3] >= 0 )
sum += (S[x[3]] - cv)*w[3]; sum += (S1[x[3]] - cv)*w[3];
if( x[4] >= 0 ) if( x[4] >= 0 )
sum += (S[x[4]] - cv)*w[4]; sum += (S1[x[4]] - cv)*w[4];
if( x[5] >= 0 ) if( x[5] >= 0 )
sum += (S[x[5]] - cv)*w[5]; sum += (S1[x[5]] - cv)*w[5];
if( x[6] >= 0 ) if( x[6] >= 0 )
sum += (S[x[6]] - cv)*w[6]; sum += (S1[x[6]] - cv)*w[6];
if( x[7] >= 0 ) if( x[7] >= 0 )
sum += (S[x[7]] - cv)*w[7]; sum += (S1[x[7]] - cv)*w[7];
} }
D[k] = castOp(sum); D[k] = castOp(sum);
} }
@ -2966,8 +2965,8 @@ void cv::warpAffine( InputArray _src, OutputArray _dst,
remap( src, dpart, _XY, Mat(), interpolation, borderType, borderValue ); remap( src, dpart, _XY, Mat(), interpolation, borderType, borderValue );
else else
{ {
Mat matA(bh, bw, CV_16U, A); Mat _matA(bh, bw, CV_16U, A);
remap( src, dpart, _XY, matA, interpolation, borderType, borderValue ); remap( src, dpart, _XY, _matA, interpolation, borderType, borderValue );
} }
} }
} }
@ -3064,8 +3063,8 @@ void cv::warpPerspective( InputArray _src, OutputArray _dst, InputArray _M0,
remap( src, dpart, _XY, Mat(), interpolation, borderType, borderValue ); remap( src, dpart, _XY, Mat(), interpolation, borderType, borderValue );
else else
{ {
Mat matA(bh, bw, CV_16U, A); Mat _matA(bh, bw, CV_16U, A);
remap( src, dpart, _XY, matA, interpolation, borderType, borderValue ); remap( src, dpart, _XY, _matA, interpolation, borderType, borderValue );
} }
} }
} }

4
modules/imgproc/src/moments.cpp
View File

@ -248,7 +248,7 @@ template<> void momentsInTile<uchar, int, int>( const cv::Mat& img, double* mome
typedef int WT; typedef int WT;
typedef int MT; typedef int MT;
cv::Size size = img.size(); cv::Size size = img.size();
int x, y; int y;
MT mom[10] = {0,0,0,0,0,0,0,0,0,0}; MT mom[10] = {0,0,0,0,0,0,0,0,0,0};
bool useSIMD = cv::checkHardwareSupport(CV_CPU_SSE2); bool useSIMD = cv::checkHardwareSupport(CV_CPU_SSE2);
@ -312,7 +312,7 @@ template<> void momentsInTile<uchar, int, int>( const cv::Mat& img, double* mome
mom[0] += x0; // m00 mom[0] += x0; // m00
} }
for( x = 0; x < 10; x++ ) for(int x = 0; x < 10; x++ )
moments[x] = (double)mom[x]; moments[x] = (double)mom[x];
} }

10
modules/imgproc/src/shapedescr.cpp
View File

@ -287,7 +287,7 @@ cvMinEnclosingCircle( const void* array, CvPoint2D32f * _center, float *_radius
*_radius = 0; *_radius = 0;
CvSeqReader reader; CvSeqReader reader;
int i, k, count; int k, count;
CvPoint2D32f pts[8]; CvPoint2D32f pts[8];
CvContour contour_header; CvContour contour_header;
CvSeqBlock block; CvSeqBlock block;
@ -324,7 +324,7 @@ cvMinEnclosingCircle( const void* array, CvPoint2D32f * _center, float *_radius
pt_left = pt_right = pt_top = pt_bottom = (CvPoint *)(reader.ptr); pt_left = pt_right = pt_top = pt_bottom = (CvPoint *)(reader.ptr);
CV_READ_SEQ_ELEM( pt, reader ); CV_READ_SEQ_ELEM( pt, reader );
for( i = 1; i < count; i++ ) for(int i = 1; i < count; i++ )
{ {
CvPoint* pt_ptr = (CvPoint*)reader.ptr; CvPoint* pt_ptr = (CvPoint*)reader.ptr;
CV_READ_SEQ_ELEM( pt, reader ); CV_READ_SEQ_ELEM( pt, reader );
@ -351,7 +351,7 @@ cvMinEnclosingCircle( const void* array, CvPoint2D32f * _center, float *_radius
pt_left = pt_right = pt_top = pt_bottom = (CvPoint2D32f *) (reader.ptr); pt_left = pt_right = pt_top = pt_bottom = (CvPoint2D32f *) (reader.ptr);
CV_READ_SEQ_ELEM( pt, reader ); CV_READ_SEQ_ELEM( pt, reader );
for( i = 1; i < count; i++ ) for(int i = 1; i < count; i++ )
{ {
CvPoint2D32f* pt_ptr = (CvPoint2D32f*)reader.ptr; CvPoint2D32f* pt_ptr = (CvPoint2D32f*)reader.ptr;
CV_READ_SEQ_ELEM( pt, reader ); CV_READ_SEQ_ELEM( pt, reader );
@ -382,7 +382,7 @@ cvMinEnclosingCircle( const void* array, CvPoint2D32f * _center, float *_radius
cvStartReadSeq( sequence, &reader, 0 ); cvStartReadSeq( sequence, &reader, 0 );
for( i = 0; i < count; i++ ) for(int i = 0; i < count; i++ )
{ {
if( !is_float ) if( !is_float )
{ {
@ -429,7 +429,7 @@ cvMinEnclosingCircle( const void* array, CvPoint2D32f * _center, float *_radius
cvStartReadSeq( sequence, &reader, 0 ); cvStartReadSeq( sequence, &reader, 0 );
radius = 0.f; radius = 0.f;
for( i = 0; i < count; i++ ) for(int i = 0; i < count; i++ )
{ {
CvPoint2D32f ptfl; CvPoint2D32f ptfl;
float t, dx, dy; float t, dx, dy;

10
modules/imgproc/src/undistort.cpp
View File

@ -500,8 +500,8 @@ float cv::initWideAngleProjMap( InputArray _cameraMatrix0, InputArray _distCoeff
Point2f dcenter((destImageWidth-1)*0.5f, 0.f); Point2f dcenter((destImageWidth-1)*0.5f, 0.f);
float xmin = FLT_MAX, xmax = -FLT_MAX, ymin = FLT_MAX, ymax = -FLT_MAX; float xmin = FLT_MAX, xmax = -FLT_MAX, ymin = FLT_MAX, ymax = -FLT_MAX;
int N = 9; int N = 9;
std::vector<Point2f> u(1), v(1); std::vector<Point2f> uvec(1), vvec(1);
Mat _u(u), I = Mat::eye(3,3,CV_64F); Mat I = Mat::eye(3,3,CV_64F);
float alpha = (float)_alpha; float alpha = (float)_alpha;
int ndcoeffs = distCoeffs0.cols*distCoeffs0.rows*distCoeffs0.channels(); int ndcoeffs = distCoeffs0.cols*distCoeffs0.rows*distCoeffs0.channels();
@ -517,9 +517,9 @@ float cv::initWideAngleProjMap( InputArray _cameraMatrix0, InputArray _distCoeff
for( int j = 0; j < N; j++ ) for( int j = 0; j < N; j++ )
{ {
Point2f p((float)j*imageSize.width/(N-1), (float)i*imageSize.height/(N-1)); Point2f p((float)j*imageSize.width/(N-1), (float)i*imageSize.height/(N-1));
u[0] = p; uvec[0] = p;
undistortPoints(_u, v, cameraMatrix, distCoeffs, I, I); undistortPoints(uvec, vvec, cameraMatrix, distCoeffs, I, I);
Point2f q = mapPointSpherical(v[0], alpha, 0, projType); Point2f q = mapPointSpherical(vvec[0], alpha, 0, projType);
if( xmin > q.x ) xmin = q.x; if( xmin > q.x ) xmin = q.x;
if( xmax < q.x ) xmax = q.x; if( xmax < q.x ) xmax = q.x;
if( ymin > q.y ) ymin = q.y; if( ymin > q.y ) ymin = q.y;

6
modules/imgproc/test/test_contours.cpp
View File

@ -266,7 +266,7 @@ void CV_FindContourTest::run_func()
// the whole testing is done here, run_func() is not utilized in this test // the whole testing is done here, run_func() is not utilized in this test
int CV_FindContourTest::validate_test_results( int /*test_case_idx*/ ) int CV_FindContourTest::validate_test_results( int /*test_case_idx*/ )
{ {
int i, code = cvtest::TS::OK; int code = cvtest::TS::OK;
cvCmpS( img[0], 0, img[0], CV_CMP_GT ); cvCmpS( img[0], 0, img[0], CV_CMP_GT );
@ -303,7 +303,7 @@ int CV_FindContourTest::validate_test_results( int /*test_case_idx*/ )
CvTreeNodeIterator iterator2; CvTreeNodeIterator iterator2;
int count3; int count3;
for( i = 0; i < 2; i++ ) for(int i = 0; i < 2; i++ )
{ {
CvTreeNodeIterator iterator; CvTreeNodeIterator iterator;
cvInitTreeNodeIterator( &iterator, i == 0 ? contours : contours2, INT_MAX ); cvInitTreeNodeIterator( &iterator, i == 0 ? contours : contours2, INT_MAX );
@ -353,7 +353,7 @@ int CV_FindContourTest::validate_test_results( int /*test_case_idx*/ )
goto _exit_; goto _exit_;
} }
for( i = 0; i < seq1->total; i++ ) for(int i = 0; i < seq1->total; i++ )
{ {
CvPoint pt1; CvPoint pt1;
CvPoint pt2; CvPoint pt2;

40
modules/imgproc/test/test_convhull.cpp
View File

@ -254,7 +254,7 @@ int CV_BaseShapeDescrTest::read_params( CvFileStorage* fs )
} }
void CV_BaseShapeDescrTest::generate_point_set( void* points ) void CV_BaseShapeDescrTest::generate_point_set( void* pointsSet )
{ {
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
int i, k, n, total, point_type; int i, k, n, total, point_type;
@ -269,16 +269,16 @@ void CV_BaseShapeDescrTest::generate_point_set( void* points )
} }
memset( &reader, 0, sizeof(reader) ); memset( &reader, 0, sizeof(reader) );
if( CV_IS_SEQ(points) ) if( CV_IS_SEQ(pointsSet) )
{ {
CvSeq* ptseq = (CvSeq*)points; CvSeq* ptseq = (CvSeq*)pointsSet;
total = ptseq->total; total = ptseq->total;
point_type = CV_SEQ_ELTYPE(ptseq); point_type = CV_SEQ_ELTYPE(ptseq);
cvStartReadSeq( ptseq, &reader ); cvStartReadSeq( ptseq, &reader );
} }
else else
{ {
CvMat* ptm = (CvMat*)points; CvMat* ptm = (CvMat*)pointsSet;
assert( CV_IS_MAT(ptm) && CV_IS_MAT_CONT(ptm->type) ); assert( CV_IS_MAT(ptm) && CV_IS_MAT_CONT(ptm->type) );
total = ptm->rows + ptm->cols - 1; total = ptm->rows + ptm->cols - 1;
point_type = CV_MAT_TYPE(ptm->type); point_type = CV_MAT_TYPE(ptm->type);
@ -614,16 +614,16 @@ int CV_ConvHullTest::validate_test_results( int test_case_idx )
for( i = 0; i < point_count; i++ ) for( i = 0; i < point_count; i++ )
{ {
int idx = 0, on_edge = 0; int idx = 0, on_edge = 0;
double result = cvTsPointPolygonTest( p[i], h, hull_count, &idx, &on_edge ); double pptresult = cvTsPointPolygonTest( p[i], h, hull_count, &idx, &on_edge );
if( result < 0 ) if( pptresult < 0 )
{ {
ts->printf( cvtest::TS::LOG, "The point #%d is outside of the convex hull\n", i ); ts->printf( cvtest::TS::LOG, "The point #%d is outside of the convex hull\n", i );
code = cvtest::TS::FAIL_BAD_ACCURACY; code = cvtest::TS::FAIL_BAD_ACCURACY;
goto _exit_; goto _exit_;
} }
if( result < FLT_EPSILON && !on_edge ) if( pptresult < FLT_EPSILON && !on_edge )
mask->data.ptr[idx] = (uchar)1; mask->data.ptr[idx] = (uchar)1;
} }
@ -735,15 +735,15 @@ int CV_MinAreaRectTest::validate_test_results( int test_case_idx )
for( i = 0; i < point_count; i++ ) for( i = 0; i < point_count; i++ )
{ {
int idx = 0, on_edge = 0; int idx = 0, on_edge = 0;
double result = cvTsPointPolygonTest( p[i], box_pt, 4, &idx, &on_edge ); double pptresult = cvTsPointPolygonTest( p[i], box_pt, 4, &idx, &on_edge );
if( result < -eps ) if( pptresult < -eps )
{ {
ts->printf( cvtest::TS::LOG, "The point #%d is outside of the box\n", i ); ts->printf( cvtest::TS::LOG, "The point #%d is outside of the box\n", i );
code = cvtest::TS::FAIL_BAD_ACCURACY; code = cvtest::TS::FAIL_BAD_ACCURACY;
goto _exit_; goto _exit_;
} }
if( result < eps ) if( pptresult < eps )
{ {
for( j = 0; j < 4; j++ ) for( j = 0; j < 4; j++ )
{ {
@ -997,7 +997,7 @@ CV_FitEllipseTest::CV_FitEllipseTest()
} }
void CV_FitEllipseTest::generate_point_set( void* points ) void CV_FitEllipseTest::generate_point_set( void* pointsSet )
{ {
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
int i, total, point_type; int i, total, point_type;
@ -1020,16 +1020,16 @@ void CV_FitEllipseTest::generate_point_set( void* points )
} }
memset( &reader, 0, sizeof(reader) ); memset( &reader, 0, sizeof(reader) );
if( CV_IS_SEQ(points) ) if( CV_IS_SEQ(pointsSet) )
{ {
CvSeq* ptseq = (CvSeq*)points; CvSeq* ptseq = (CvSeq*)pointsSet;
total = ptseq->total; total = ptseq->total;
point_type = CV_SEQ_ELTYPE(ptseq); point_type = CV_SEQ_ELTYPE(ptseq);
cvStartReadSeq( ptseq, &reader ); cvStartReadSeq( ptseq, &reader );
} }
else else
{ {
CvMat* ptm = (CvMat*)points; CvMat* ptm = (CvMat*)pointsSet;
assert( CV_IS_MAT(ptm) && CV_IS_MAT_CONT(ptm->type) ); assert( CV_IS_MAT(ptm) && CV_IS_MAT_CONT(ptm->type) );
total = ptm->rows + ptm->cols - 1; total = ptm->rows + ptm->cols - 1;
point_type = CV_MAT_TYPE(ptm->type); point_type = CV_MAT_TYPE(ptm->type);
@ -1226,7 +1226,7 @@ CV_FitLineTest::CV_FitLineTest()
} }
void CV_FitLineTest::generate_point_set( void* points ) void CV_FitLineTest::generate_point_set( void* pointsSet )
{ {
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
int i, k, n, total, point_type; int i, k, n, total, point_type;
@ -1250,16 +1250,16 @@ void CV_FitLineTest::generate_point_set( void* points )
memset( &reader, 0, sizeof(reader) ); memset( &reader, 0, sizeof(reader) );
if( CV_IS_SEQ(points) ) if( CV_IS_SEQ(pointsSet) )
{ {
CvSeq* ptseq = (CvSeq*)points; CvSeq* ptseq = (CvSeq*)pointsSet;
total = ptseq->total; total = ptseq->total;
point_type = CV_MAT_DEPTH(CV_SEQ_ELTYPE(ptseq)); point_type = CV_MAT_DEPTH(CV_SEQ_ELTYPE(ptseq));
cvStartReadSeq( ptseq, &reader ); cvStartReadSeq( ptseq, &reader );
} }
else else
{ {
CvMat* ptm = (CvMat*)points; CvMat* ptm = (CvMat*)pointsSet;
assert( CV_IS_MAT(ptm) && CV_IS_MAT_CONT(ptm->type) ); assert( CV_IS_MAT(ptm) && CV_IS_MAT_CONT(ptm->type) );
total = ptm->rows + ptm->cols - 1; total = ptm->rows + ptm->cols - 1;
point_type = CV_MAT_DEPTH(CV_MAT_TYPE(ptm->type)); point_type = CV_MAT_DEPTH(CV_MAT_TYPE(ptm->type));
@ -1498,7 +1498,7 @@ CV_ContourMomentsTest::CV_ContourMomentsTest()
} }
void CV_ContourMomentsTest::generate_point_set( void* points ) void CV_ContourMomentsTest::generate_point_set( void* pointsSet )
{ {
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
float max_sz; float max_sz;
@ -1518,7 +1518,7 @@ void CV_ContourMomentsTest::generate_point_set( void* points )
max_r_scale = cvtest::randReal(rng)*max_max_r_scale*0.01; max_r_scale = cvtest::randReal(rng)*max_max_r_scale*0.01;
angle = cvtest::randReal(rng)*360; angle = cvtest::randReal(rng)*360;
cvTsGenerateTousledBlob( center, axes, max_r_scale, angle, points, rng ); cvTsGenerateTousledBlob( center, axes, max_r_scale, angle, pointsSet, rng );
if( points1 ) if( points1 )
points1->flags = CV_SEQ_MAGIC_VAL + CV_SEQ_POLYGON; points1->flags = CV_SEQ_MAGIC_VAL + CV_SEQ_POLYGON;

28
modules/imgproc/test/test_filter.cpp
View File

@ -253,46 +253,46 @@ void CV_MorphologyBaseTest::prepare_to_validation( int /*test_case_idx*/ )
Mat _ielement(element->nRows, element->nCols, CV_32S, element->values); Mat _ielement(element->nRows, element->nCols, CV_32S, element->values);
Mat _element; Mat _element;
_ielement.convertTo(_element, CV_8U); _ielement.convertTo(_element, CV_8U);
Point anchor(element->anchorX, element->anchorY); Point _anchor(element->anchorX, element->anchorY);
int border = BORDER_REPLICATE; int _border = BORDER_REPLICATE;
if( optype == CV_MOP_ERODE ) if( optype == CV_MOP_ERODE )
{ {
cvtest::erode( src, dst, _element, anchor, border ); cvtest::erode( src, dst, _element, _anchor, _border );
} }
else if( optype == CV_MOP_DILATE ) else if( optype == CV_MOP_DILATE )
{ {
cvtest::dilate( src, dst, _element, anchor, border ); cvtest::dilate( src, dst, _element, _anchor, _border );
} }
else else
{ {
Mat temp; Mat temp;
if( optype == CV_MOP_OPEN ) if( optype == CV_MOP_OPEN )
{ {
cvtest::erode( src, temp, _element, anchor, border ); cvtest::erode( src, temp, _element, _anchor, _border );
cvtest::dilate( temp, dst, _element, anchor, border ); cvtest::dilate( temp, dst, _element, _anchor, _border );
} }
else if( optype == CV_MOP_CLOSE ) else if( optype == CV_MOP_CLOSE )
{ {
cvtest::dilate( src, temp, _element, anchor, border ); cvtest::dilate( src, temp, _element, _anchor, _border );
cvtest::erode( temp, dst, _element, anchor, border ); cvtest::erode( temp, dst, _element, _anchor, _border );
} }
else if( optype == CV_MOP_GRADIENT ) else if( optype == CV_MOP_GRADIENT )
{ {
cvtest::erode( src, temp, _element, anchor, border ); cvtest::erode( src, temp, _element, _anchor, _border );
cvtest::dilate( src, dst, _element, anchor, border ); cvtest::dilate( src, dst, _element, _anchor, _border );
cvtest::add( dst, 1, temp, -1, Scalar::all(0), dst, dst.type() ); cvtest::add( dst, 1, temp, -1, Scalar::all(0), dst, dst.type() );
} }
else if( optype == CV_MOP_TOPHAT ) else if( optype == CV_MOP_TOPHAT )
{ {
cvtest::erode( src, temp, _element, anchor, border ); cvtest::erode( src, temp, _element, _anchor, _border );
cvtest::dilate( temp, dst, _element, anchor, border ); cvtest::dilate( temp, dst, _element, _anchor, _border );
cvtest::add( src, 1, dst, -1, Scalar::all(0), dst, dst.type() ); cvtest::add( src, 1, dst, -1, Scalar::all(0), dst, dst.type() );
} }
else if( optype == CV_MOP_BLACKHAT ) else if( optype == CV_MOP_BLACKHAT )
{ {
cvtest::dilate( src, temp, _element, anchor, border ); cvtest::dilate( src, temp, _element, _anchor, _border );
cvtest::erode( temp, dst, _element, anchor, border ); cvtest::erode( temp, dst, _element, _anchor, _border );
cvtest::add( dst, 1, src, -1, Scalar::all(0), dst, dst.type() ); cvtest::add( dst, 1, src, -1, Scalar::all(0), dst, dst.type() );
} }
else else

4
modules/imgproc/test/test_floodfill.cpp
View File

@ -94,7 +94,7 @@ void CV_FloodFillTest::get_test_array_types_and_sizes( int test_case_idx,
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
int depth, cn; int depth, cn;
int i; int i;
double buf[8]; double buff[8];
cvtest::ArrayTest::get_test_array_types_and_sizes( test_case_idx, sizes, types ); cvtest::ArrayTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
depth = cvtest::randInt(rng) % 3; depth = cvtest::randInt(rng) % 3;
@ -127,7 +127,7 @@ void CV_FloodFillTest::get_test_array_types_and_sizes( int test_case_idx,
l_diff = u_diff = Scalar::all(0.); l_diff = u_diff = Scalar::all(0.);
else else
{ {
Mat m( 1, 8, CV_16S, buf ); Mat m( 1, 8, CV_16S, buff );
rng.fill( m, RNG::NORMAL, Scalar::all(0), Scalar::all(32) ); rng.fill( m, RNG::NORMAL, Scalar::all(0), Scalar::all(32) );
for( i = 0; i < 4; i++ ) for( i = 0; i < 4; i++ )
{ {

8
modules/imgproc/test/test_histograms.cpp
View File

@ -255,13 +255,13 @@ void CV_BaseHistTest::init_hist( int /*test_case_idx*/, int hist_i )
else else
{ {
CvArr* arr = hist[hist_i]->bins; CvArr* arr = hist[hist_i]->bins;
int i, j, total_size = 1, nz_count; int i, j, totalSize = 1, nz_count;
int idx[CV_MAX_DIM]; int idx[CV_MAX_DIM];
for( i = 0; i < cdims; i++ ) for( i = 0; i < cdims; i++ )
total_size *= dims[i]; totalSize *= dims[i];
nz_count = cvtest::randInt(rng) % MAX( total_size/4, 100 ); nz_count = cvtest::randInt(rng) % MAX( totalSize/4, 100 );
nz_count = MIN( nz_count, total_size ); nz_count = MIN( nz_count, totalSize );
// a zero number of non-zero elements should be allowed // a zero number of non-zero elements should be allowed
for( i = 0; i < nz_count; i++ ) for( i = 0; i < nz_count; i++ )

16
modules/imgproc/test/test_imgwarp.cpp
View File

@ -516,8 +516,8 @@ int CV_WarpAffineTest::prepare_test_case( int test_case_idx )
if( code <= 0 ) if( code <= 0 )
return code; return code;
double buf[6]; double buffer[6];
Mat tmp( 2, 3, mat.type(), buf ); Mat tmp( 2, 3, mat.type(), buffer );
center.x = (float)((cvtest::randReal(rng)*1.2 - 0.1)*src.cols); center.x = (float)((cvtest::randReal(rng)*1.2 - 0.1)*src.cols);
center.y = (float)((cvtest::randReal(rng)*1.2 - 0.1)*src.rows); center.y = (float)((cvtest::randReal(rng)*1.2 - 0.1)*src.rows);
@ -636,17 +636,17 @@ int CV_WarpPerspectiveTest::prepare_test_case( int test_case_idx )
s[3] = Point2f(0,src.rows-1.f); s[3] = Point2f(0,src.rows-1.f);
d[3] = Point2f(0,dst.rows-1.f); d[3] = Point2f(0,dst.rows-1.f);
float buf[16]; float bufer[16];
Mat tmp( 1, 16, CV_32FC1, buf ); Mat tmp( 1, 16, CV_32FC1, bufer );
rng.fill( tmp, CV_RAND_NORMAL, Scalar::all(0.), Scalar::all(0.1) ); rng.fill( tmp, CV_RAND_NORMAL, Scalar::all(0.), Scalar::all(0.1) );
for( i = 0; i < 4; i++ ) for( i = 0; i < 4; i++ )
{ {
s[i].x += buf[i*4]*src.cols/2; s[i].x += bufer[i*4]*src.cols/2;
s[i].y += buf[i*4+1]*src.rows/2; s[i].y += bufer[i*4+1]*src.rows/2;
d[i].x += buf[i*4+2]*dst.cols/2; d[i].x += bufer[i*4+2]*dst.cols/2;
d[i].y += buf[i*4+3]*dst.rows/2; d[i].y += bufer[i*4+3]*dst.rows/2;
} }
cv::getPerspectiveTransform( s, d ).convertTo( mat, mat.depth() ); cv::getPerspectiveTransform( s, d ).convertTo( mat, mat.depth() );

3
modules/imgproc/test/test_thresh.cpp
View File

@ -91,7 +91,8 @@ void CV_ThreshTest::get_test_array_types_and_sizes( int test_case_idx,
} }
else if( depth == CV_16S ) else if( depth == CV_16S )
{ {
float min_val = SHRT_MIN-100.f, max_val = SHRT_MAX+100.f; float min_val = SHRT_MIN-100.f;
max_val = SHRT_MAX+100.f;
thresh_val = (float)(cvtest::randReal(rng)*(max_val - min_val) + min_val); thresh_val = (float)(cvtest::randReal(rng)*(max_val - min_val) + min_val);
max_val = (float)(cvtest::randReal(rng)*(max_val - min_val) + min_val); max_val = (float)(cvtest::randReal(rng)*(max_val - min_val) + min_val);
if( cvtest::randInt(rng)%4 == 0 ) if( cvtest::randInt(rng)%4 == 0 )

48
modules/legacy/include/opencv2/legacy/legacy.hpp
View File

@ -1347,9 +1347,9 @@ class CV_EXPORTS CvImage
{ {
public: public:
CvImage() : image(0), refcount(0) {} CvImage() : image(0), refcount(0) {}
CvImage( CvSize size, int depth, int channels ) CvImage( CvSize _size, int _depth, int _channels )
{ {
image = cvCreateImage( size, depth, channels ); image = cvCreateImage( _size, _depth, _channels );
refcount = image ? new int(1) : 0; refcount = image ? new int(1) : 0;
} }
@ -1383,12 +1383,12 @@ public:
CvImage clone() { return CvImage(image ? cvCloneImage(image) : 0); } CvImage clone() { return CvImage(image ? cvCloneImage(image) : 0); }
void create( CvSize size, int depth, int channels ) void create( CvSize _size, int _depth, int _channels )
{ {
if( !image || !refcount || if( !image || !refcount ||
image->width != size.width || image->height != size.height || image->width != _size.width || image->height != _size.height ||
image->depth != depth || image->nChannels != channels ) image->depth != _depth || image->nChannels != _channels )
attach( cvCreateImage( size, depth, channels )); attach( cvCreateImage( _size, _depth, _channels ));
} }
void release() { detach(); } void release() { detach(); }
@ -1447,9 +1447,9 @@ public:
int coi() const { return !image || !image->roi ? 0 : image->roi->coi; } int coi() const { return !image || !image->roi ? 0 : image->roi->coi; }
void set_roi(CvRect roi) { cvSetImageROI(image,roi); } void set_roi(CvRect _roi) { cvSetImageROI(image,_roi); }
void reset_roi() { cvResetImageROI(image); } void reset_roi() { cvResetImageROI(image); }
void set_coi(int coi) { cvSetImageCOI(image,coi); } void set_coi(int _coi) { cvSetImageCOI(image,_coi); }
int depth() const { return image ? image->depth : 0; } int depth() const { return image ? image->depth : 0; }
int channels() const { return image ? image->nChannels : 0; } int channels() const { return image ? image->nChannels : 0; }
int pix_size() const { return image ? ((image->depth & 255)>>3)*image->nChannels : 0; } int pix_size() const { return image ? ((image->depth & 255)>>3)*image->nChannels : 0; }
@ -1511,18 +1511,18 @@ class CV_EXPORTS CvMatrix
{ {
public: public:
CvMatrix() : matrix(0) {} CvMatrix() : matrix(0) {}
CvMatrix( int rows, int cols, int type ) CvMatrix( int _rows, int _cols, int _type )
{ matrix = cvCreateMat( rows, cols, type ); } { matrix = cvCreateMat( _rows, _cols, _type ); }
CvMatrix( int rows, int cols, int type, CvMat* hdr, CvMatrix( int _rows, int _cols, int _type, CvMat* hdr,
void* data=0, int step=CV_AUTOSTEP ) void* _data=0, int _step=CV_AUTOSTEP )
{ matrix = cvInitMatHeader( hdr, rows, cols, type, data, step ); } { matrix = cvInitMatHeader( hdr, _rows, _cols, _type, _data, _step ); }
CvMatrix( int rows, int cols, int type, CvMemStorage* storage, bool alloc_data=true ); CvMatrix( int rows, int cols, int type, CvMemStorage* storage, bool alloc_data=true );
CvMatrix( int rows, int cols, int type, void* data, int step=CV_AUTOSTEP ) CvMatrix( int _rows, int _cols, int _type, void* _data, int _step=CV_AUTOSTEP )
{ matrix = cvCreateMatHeader( rows, cols, type ); { matrix = cvCreateMatHeader( _rows, _cols, _type );
cvSetData( matrix, data, step ); } cvSetData( matrix, _data, _step ); }
CvMatrix( CvMat* m ) CvMatrix( CvMat* m )
{ matrix = m; } { matrix = m; }
@ -1557,12 +1557,12 @@ public:
addref(); addref();
} }
void create( int rows, int cols, int type ) void create( int _rows, int _cols, int _type )
{ {
if( !matrix || !matrix->refcount || if( !matrix || !matrix->refcount ||
matrix->rows != rows || matrix->cols != cols || matrix->rows != _rows || matrix->cols != _cols ||
CV_MAT_TYPE(matrix->type) != type ) CV_MAT_TYPE(matrix->type) != _type )
set( cvCreateMat( rows, cols, type ), false ); set( cvCreateMat( _rows, _cols, _type ), false );
} }
void addref() const void addref() const
@ -1626,8 +1626,8 @@ public:
const uchar* data() const { return matrix ? matrix->data.ptr : 0; } const uchar* data() const { return matrix ? matrix->data.ptr : 0; }
int step() const { return matrix ? matrix->step : 0; } int step() const { return matrix ? matrix->step : 0; }
void set_data( void* data, int step=CV_AUTOSTEP ) void set_data( void* _data, int _step=CV_AUTOSTEP )
{ cvSetData( matrix, data, step ); } { cvSetData( matrix, _data, _step ); }
uchar* row(int i) { return !matrix ? 0 : matrix->data.ptr + i*matrix->step; } uchar* row(int i) { return !matrix ? 0 : matrix->data.ptr + i*matrix->step; }
const uchar* row(int i) const const uchar* row(int i) const
@ -2014,8 +2014,8 @@ struct CV_EXPORTS BaseKeypoint
: x(0), y(0), image(NULL) : x(0), y(0), image(NULL)
{} {}
BaseKeypoint(int x, int y, IplImage* image) BaseKeypoint(int _x, int _y, IplImage* _image)
: x(x), y(y), image(image) : x(_x), y(_y), image(_image)
{} {}
}; };

8
modules/legacy/src/blobtrackanalysistrackdist.cpp
View File

@ -350,11 +350,10 @@ public:
virtual void Process(IplImage* pImg, IplImage* /*pFG*/) virtual void Process(IplImage* pImg, IplImage* /*pFG*/)
{ {
int i;
double MinTv = pImg->width/1440.0; /* minimal threshold for speed difference */ double MinTv = pImg->width/1440.0; /* minimal threshold for speed difference */
double MinTv2 = MinTv*MinTv; double MinTv2 = MinTv*MinTv;
for(i=m_Tracks.GetBlobNum(); i>0; --i) for(int i=m_Tracks.GetBlobNum(); i>0; --i)
{ {
DefTrackForDist* pF = (DefTrackForDist*)m_Tracks.GetBlob(i-1); DefTrackForDist* pF = (DefTrackForDist*)m_Tracks.GetBlob(i-1);
pF->state = 0; pF->state = 0;
@ -466,14 +465,13 @@ public:
if(m_Wnd) if(m_Wnd)
{ /* Debug output: */ { /* Debug output: */
int i;
if(m_pDebugImg==NULL) if(m_pDebugImg==NULL)
m_pDebugImg = cvCloneImage(pImg); m_pDebugImg = cvCloneImage(pImg);
else else
cvCopy(pImg, m_pDebugImg); cvCopy(pImg, m_pDebugImg);
for(i=m_TrackDataBase.GetBlobNum(); i>0; --i) for(int i=m_TrackDataBase.GetBlobNum(); i>0; --i)
{ /* Draw all elements in track data base: */ { /* Draw all elements in track data base: */
int j; int j;
DefTrackForDist* pF = (DefTrackForDist*)m_TrackDataBase.GetBlob(i-1); DefTrackForDist* pF = (DefTrackForDist*)m_TrackDataBase.GetBlob(i-1);
@ -497,7 +495,7 @@ public:
pF->close = 0; pF->close = 0;
} /* Draw all elements in track data base. */ } /* Draw all elements in track data base. */
for(i=m_Tracks.GetBlobNum(); i>0; --i) for(int i=m_Tracks.GetBlobNum(); i>0; --i)
{ /* Draw all elements for all trajectories: */ { /* Draw all elements for all trajectories: */
DefTrackForDist* pF = (DefTrackForDist*)m_Tracks.GetBlob(i-1); DefTrackForDist* pF = (DefTrackForDist*)m_Tracks.GetBlob(i-1);
int j; int j;

4
modules/legacy/src/blobtrackingcc.cpp
View File

@ -301,8 +301,8 @@ public:
{ /* Find a neighbour on current frame { /* Find a neighbour on current frame
* for each blob from previous frame: * for each blob from previous frame:
*/ */
CvBlob* pB = m_BlobList.GetBlob(i-1); CvBlob* pBl = m_BlobList.GetBlob(i-1);
DefBlobTracker* pBT = (DefBlobTracker*)pB; DefBlobTracker* pBT = (DefBlobTracker*)pBl;
//int BlobID = CV_BLOB_ID(pB); //int BlobID = CV_BLOB_ID(pB);
//CvBlob* pBBest = NULL; //CvBlob* pBBest = NULL;
//double DistBest = -1; //double DistBest = -1;

13
modules/legacy/src/kdtree.cpp
View File

@ -93,18 +93,19 @@ class CvKDTreeWrap : public CvFeatureTree {
assert(results->cols == k); assert(results->cols == k);
assert(dist->cols == k); assert(dist->cols == k);
for (int j = 0; j < d->rows; ++j) { for (int j = 0; j < d->rows; ++j)
const typename __treetype::scalar_type* dj = {
(const typename __treetype::scalar_type*) dptr; const typename __treetype::scalar_type* dj = (const typename __treetype::scalar_type*) dptr;
int* resultsj = (int*) resultsptr; int* resultsj = (int*) resultsptr;
double* distj = (double*) distptr; double* distj = (double*) distptr;
tr->find_nn_bbf(dj, k, emax, nn); tr->find_nn_bbf(dj, k, emax, nn);
assert((int)nn.size() <= k); assert((int)nn.size() <= k);
for (unsigned int j = 0; j < nn.size(); ++j) { for (unsigned int i = 0; i < nn.size(); ++i)
*resultsj++ = *nn[j].p; {
*distj++ = nn[j].dist; *resultsj++ = *nn[i].p;
*distj++ = nn[i].dist;
} }
std::fill(resultsj, resultsj + k - nn.size(), -1); std::fill(resultsj, resultsj + k - nn.size(), -1);
std::fill(distj, distj + k - nn.size(), 0); std::fill(distj, distj + k - nn.size(), 0);

14
modules/ml/include/opencv2/ml/ml.hpp
View File

@ -170,12 +170,7 @@ struct CV_EXPORTS_W_MAP CvParamGrid
min_val = max_val = step = 0; min_val = max_val = step = 0;
} }
CvParamGrid( double min_val, double max_val, double log_step ) CvParamGrid( double min_val, double max_val, double log_step );
{
this->min_val = min_val;
this->max_val = max_val;
step = log_step;
}
//CvParamGrid( int param_id ); //CvParamGrid( int param_id );
bool check() const; bool check() const;
@ -184,6 +179,13 @@ struct CV_EXPORTS_W_MAP CvParamGrid
CV_PROP_RW double step; CV_PROP_RW double step;
}; };
inline CvParamGrid::CvParamGrid( double _min_val, double _max_val, double _log_step )
{
min_val = _min_val;
max_val = _max_val;
step = _log_step;
}
class CV_EXPORTS_W CvNormalBayesClassifier : public CvStatModel class CV_EXPORTS_W CvNormalBayesClassifier : public CvStatModel
{ {
public: public:

18
modules/ml/src/ann_mlp.cpp
View File

@ -1087,7 +1087,7 @@ struct rprop_loop {
for(int si = range.begin(); si < range.end(); si++ ) for(int si = range.begin(); si < range.end(); si++ )
{ {
if (si % dcount0 != 0) continue; if (si % dcount0 != 0) continue;
int n1, n2, j, k; int n1, n2, k;
double* w; double* w;
CvMat _w, _dEdw, hdr1, hdr2, ghdr1, ghdr2, _df; CvMat _w, _dEdw, hdr1, hdr2, ghdr1, ghdr2, _df;
CvMat *x1, *x2, *grad1, *grad2, *temp; CvMat *x1, *x2, *grad1, *grad2, *temp;
@ -1105,7 +1105,7 @@ struct rprop_loop {
{ {
const float* x0data = x0->data.fl[si+i]; const float* x0data = x0->data.fl[si+i];
double* xdata = x[0]+i*ivcount; double* xdata = x[0]+i*ivcount;
for( j = 0; j < ivcount; j++ ) for(int j = 0; j < ivcount; j++ )
xdata[j] = x0data[j]*w[j*2] + w[j*2+1]; xdata[j] = x0data[j]*w[j*2] + w[j*2+1];
} }
} }
@ -1114,7 +1114,7 @@ struct rprop_loop {
{ {
const double* x0data = x0->data.db[si+i]; const double* x0data = x0->data.db[si+i];
double* xdata = x[0]+i*ivcount; double* xdata = x[0]+i*ivcount;
for( j = 0; j < ivcount; j++ ) for(int j = 0; j < ivcount; j++ )
xdata[j] = x0data[j]*w[j*2] + w[j*2+1]; xdata[j] = x0data[j]*w[j*2] + w[j*2+1];
} }
cvInitMatHeader( x1, dcount, ivcount, CV_64F, x[0] ); cvInitMatHeader( x1, dcount, ivcount, CV_64F, x[0] );
@ -1144,7 +1144,7 @@ struct rprop_loop {
double* gdata = grad1->data.db + i*ovcount; double* gdata = grad1->data.db + i*ovcount;
double sweight = sw ? sw[si+i] : inv_count, E1 = 0; double sweight = sw ? sw[si+i] : inv_count, E1 = 0;
for( j = 0; j < ovcount; j++ ) for(int j = 0; j < ovcount; j++ )
{ {
double t = udata[j]*w[j*2] + w[j*2+1] - xdata[j]; double t = udata[j]*w[j*2] + w[j*2+1] - xdata[j];
gdata[j] = t*sweight; gdata[j] = t*sweight;
@ -1191,7 +1191,7 @@ struct rprop_loop {
{ {
double* dst = _dEdw.data.db + n1*n2; double* dst = _dEdw.data.db + n1*n2;
const double* src = grad1->data.db + k*n2; const double* src = grad1->data.db + k*n2;
for( j = 0; j < n2; j++ ) for(int j = 0; j < n2; j++ )
dst[j] += src[j]; dst[j] += src[j];
} }
@ -1215,7 +1215,7 @@ struct rprop_loop {
int CvANN_MLP::train_rprop( CvVectors x0, CvVectors u, const double* sw ) int CvANN_MLP::train_rprop( CvVectors x0, CvVectors u, const double* sw )
{ {
const int max_buf_sz = 1 << 16; const int max_buf_size = 1 << 16;
CvMat* dw = 0; CvMat* dw = 0;
CvMat* dEdw = 0; CvMat* dEdw = 0;
CvMat* prev_dEdw_sign = 0; CvMat* prev_dEdw_sign = 0;
@ -1256,7 +1256,7 @@ int CvANN_MLP::train_rprop( CvVectors x0, CvVectors u, const double* sw )
cvZero( prev_dEdw_sign ); cvZero( prev_dEdw_sign );
inv_count = 1./count; inv_count = 1./count;
dcount0 = max_buf_sz/(2*total); dcount0 = max_buf_size/(2*total);
dcount0 = MAX( dcount0, 1 ); dcount0 = MAX( dcount0, 1 );
dcount0 = MIN( dcount0, count ); dcount0 = MIN( dcount0, count );
buf_sz = dcount0*(total + max_count)*2; buf_sz = dcount0*(total + max_count)*2;
@ -1600,8 +1600,8 @@ CvANN_MLP::CvANN_MLP( const Mat& _layer_sizes, int _activ_func,
void CvANN_MLP::create( const Mat& _layer_sizes, int _activ_func, void CvANN_MLP::create( const Mat& _layer_sizes, int _activ_func,
double _f_param1, double _f_param2 ) double _f_param1, double _f_param2 )
{ {
CvMat layer_sizes = _layer_sizes; CvMat cvlayer_sizes = _layer_sizes;
create( &layer_sizes, _activ_func, _f_param1, _f_param2 ); create( &cvlayer_sizes, _activ_func, _f_param1, _f_param2 );
} }
int CvANN_MLP::train( const Mat& _inputs, const Mat& _outputs, int CvANN_MLP::train( const Mat& _inputs, const Mat& _outputs,

8
modules/ml/src/boost.cpp
View File

@ -129,7 +129,7 @@ CvBoostTree::train( CvDTreeTrainData*, const CvMat* )
void void
CvBoostTree::scale( double scale ) CvBoostTree::scale( double _scale )
{ {
CvDTreeNode* node = root; CvDTreeNode* node = root;
@ -139,7 +139,7 @@ CvBoostTree::scale( double scale )
CvDTreeNode* parent; CvDTreeNode* parent;
for(;;) for(;;)
{ {
node->value *= scale; node->value *= _scale;
if( !node->left ) if( !node->left )
break; break;
node = node->left; node = node->left;
@ -1088,7 +1088,7 @@ CvBoost::train( const CvMat* _train_data, int _tflag,
} }
bool CvBoost::train( CvMLData* _data, bool CvBoost::train( CvMLData* _data,
CvBoostParams params, CvBoostParams _params,
bool update ) bool update )
{ {
bool result = false; bool result = false;
@ -1105,7 +1105,7 @@ bool CvBoost::train( CvMLData* _data,
const CvMat* var_idx = _data->get_var_idx(); const CvMat* var_idx = _data->get_var_idx();
CV_CALL( result = train( values, CV_ROW_SAMPLE, response, var_idx, CV_CALL( result = train( values, CV_ROW_SAMPLE, response, var_idx,
train_sidx, var_types, missing, params, update ) ); train_sidx, var_types, missing, _params, update ) );
__END__; __END__;

46
modules/ml/src/ertrees.cpp
View File

@ -442,15 +442,15 @@ void CvERTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
if( cv_n ) if( cv_n )
{ {
unsigned short* udst = 0; unsigned short* usdst = 0;
int* idst = 0; int* idst2 = 0;
if (is_buf_16u) if (is_buf_16u)
{ {
udst = (unsigned short*)(buf->data.s + (get_work_var_count()-1)*sample_count); usdst = (unsigned short*)(buf->data.s + (get_work_var_count()-1)*sample_count);
for( i = vi = 0; i < sample_count; i++ ) for( i = vi = 0; i < sample_count; i++ )
{ {
udst[i] = (unsigned short)vi++; usdst[i] = (unsigned short)vi++;
vi &= vi < cv_n ? -1 : 0; vi &= vi < cv_n ? -1 : 0;
} }
@ -459,15 +459,15 @@ void CvERTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
int a = (*rng)(sample_count); int a = (*rng)(sample_count);
int b = (*rng)(sample_count); int b = (*rng)(sample_count);
unsigned short unsh = (unsigned short)vi; unsigned short unsh = (unsigned short)vi;
CV_SWAP( udst[a], udst[b], unsh ); CV_SWAP( usdst[a], usdst[b], unsh );
} }
} }
else else
{ {
idst = buf->data.i + (get_work_var_count()-1)*sample_count; idst2 = buf->data.i + (get_work_var_count()-1)*sample_count;
for( i = vi = 0; i < sample_count; i++ ) for( i = vi = 0; i < sample_count; i++ )
{ {
idst[i] = vi++; idst2[i] = vi++;
vi &= vi < cv_n ? -1 : 0; vi &= vi < cv_n ? -1 : 0;
} }
@ -475,7 +475,7 @@ void CvERTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
{ {
int a = (*rng)(sample_count); int a = (*rng)(sample_count);
int b = (*rng)(sample_count); int b = (*rng)(sample_count);
CV_SWAP( idst[a], idst[b], vi ); CV_SWAP( idst2[a], idst2[b], vi );
} }
} }
} }
@ -591,7 +591,7 @@ const int* CvERTreeTrainData::get_cat_var_data( CvDTreeNode* n, int vi, int* cat
void CvERTreeTrainData::get_vectors( const CvMat* _subsample_idx, void CvERTreeTrainData::get_vectors( const CvMat* _subsample_idx,
float* values, uchar* missing, float* values, uchar* missing,
float* responses, bool get_class_idx ) float* _responses, bool get_class_idx )
{ {
CvMat* subsample_idx = 0; CvMat* subsample_idx = 0;
CvMat* subsample_co = 0; CvMat* subsample_co = 0;
@ -664,7 +664,7 @@ void CvERTreeTrainData::get_vectors( const CvMat* _subsample_idx,
} }
// copy responses // copy responses
if( responses ) if( _responses )
{ {
if( is_classifier ) if( is_classifier )
{ {
@ -675,7 +675,7 @@ void CvERTreeTrainData::get_vectors( const CvMat* _subsample_idx,
int idx = sidx ? sidx[i] : i; int idx = sidx ? sidx[i] : i;
int val = get_class_idx ? src[idx] : int val = get_class_idx ? src[idx] :
cat_map->data.i[cat_ofs->data.i[cat_var_count]+src[idx]]; cat_map->data.i[cat_ofs->data.i[cat_var_count]+src[idx]];
responses[i] = (float)val; _responses[i] = (float)val;
} }
} }
else else
@ -686,7 +686,7 @@ void CvERTreeTrainData::get_vectors( const CvMat* _subsample_idx,
for( i = 0; i < count; i++ ) for( i = 0; i < count; i++ )
{ {
int idx = sidx ? sidx[i] : i; int idx = sidx ? sidx[i] : i;
responses[i] = _values[idx]; _responses[i] = _values[idx];
} }
} }
} }
@ -853,7 +853,7 @@ CvDTreeSplit* CvForestERTree::find_split_ord_class( CvDTreeNode* node, int vi, f
const float epsilon = FLT_EPSILON*2; const float epsilon = FLT_EPSILON*2;
const float split_delta = (1 + FLT_EPSILON) * FLT_EPSILON; const float split_delta = (1 + FLT_EPSILON) * FLT_EPSILON;
int n = node->sample_count, i; int n = node->sample_count;
int m = data->get_num_classes(); int m = data->get_num_classes();
cv::AutoBuffer<uchar> inn_buf; cv::AutoBuffer<uchar> inn_buf;
@ -882,8 +882,8 @@ CvDTreeSplit* CvForestERTree::find_split_ord_class( CvDTreeNode* node, int vi, f
for (; smpi < n; smpi++) for (; smpi < n; smpi++)
{ {
float ptemp = values[smpi]; float ptemp = values[smpi];
int m = missing[smpi]; int ms = missing[smpi];
if (m) continue; if (ms) continue;
if ( ptemp < pmin) if ( ptemp < pmin)
pmin = ptemp; pmin = ptemp;
if ( ptemp > pmax) if ( ptemp > pmax)
@ -908,7 +908,7 @@ CvDTreeSplit* CvForestERTree::find_split_ord_class( CvDTreeNode* node, int vi, f
int L = 0, R = 0; int L = 0, R = 0;
// init arrays of class instance counters on both sides of the split // init arrays of class instance counters on both sides of the split
for( i = 0; i < m; i++ ) for(int i = 0; i < m; i++ )
{ {
lc[i] = 0; lc[i] = 0;
rc[i] = 0; rc[i] = 0;
@ -917,8 +917,8 @@ CvDTreeSplit* CvForestERTree::find_split_ord_class( CvDTreeNode* node, int vi, f
{ {
int r = responses[si]; int r = responses[si];
float val = values[si]; float val = values[si];
int m = missing[si]; int ms = missing[si];
if (m) continue; if (ms) continue;
if ( val < split_val ) if ( val < split_val )
{ {
lc[r]++; lc[r]++;
@ -944,7 +944,7 @@ CvDTreeSplit* CvForestERTree::find_split_ord_class( CvDTreeNode* node, int vi, f
double L = 0, R = 0; double L = 0, R = 0;
// init arrays of class instance counters on both sides of the split // init arrays of class instance counters on both sides of the split
for( i = 0; i < m; i++ ) for(int i = 0; i < m; i++ )
{ {
lc[i] = 0; lc[i] = 0;
rc[i] = 0; rc[i] = 0;
@ -953,9 +953,9 @@ CvDTreeSplit* CvForestERTree::find_split_ord_class( CvDTreeNode* node, int vi, f
{ {
int r = responses[si]; int r = responses[si];
float val = values[si]; float val = values[si];
int m = missing[si]; int ms = missing[si];
double p = priors[r]; double p = priors[r];
if (m) continue; if (ms) continue;
if ( val < split_val ) if ( val < split_val )
{ {
lc[r] += p; lc[r] += p;
@ -1579,7 +1579,7 @@ bool CvERTrees::train( const CvMat* _train_data, int _tflag,
} }
bool CvERTrees::train( CvMLData* data, CvRTParams params) bool CvERTrees::train( CvMLData* _data, CvRTParams params)
{ {
bool result = false; bool result = false;
@ -1587,7 +1587,7 @@ bool CvERTrees::train( CvMLData* data, CvRTParams params)
__BEGIN__; __BEGIN__;
CV_CALL( result = CvRTrees::train( data, params) ); CV_CALL( result = CvRTrees::train( _data, params) );
__END__; __END__;

32
modules/ml/src/gbt.cpp
View File

@ -166,13 +166,13 @@ bool CvGBTrees::problem_type() const
//=========================================================================== //===========================================================================
bool bool
CvGBTrees::train( CvMLData* data, CvGBTreesParams params, bool update ) CvGBTrees::train( CvMLData* _data, CvGBTreesParams _params, bool update )
{ {
bool result; bool result;
result = train ( data->get_values(), CV_ROW_SAMPLE, result = train ( _data->get_values(), CV_ROW_SAMPLE,
data->get_responses(), data->get_var_idx(), _data->get_responses(), _data->get_var_idx(),
data->get_train_sample_idx(), data->get_var_types(), _data->get_train_sample_idx(), _data->get_var_types(),
data->get_missing(), params, update); _data->get_missing(), _params, update);
//update is not supported //update is not supported
return result; return result;
} }
@ -1294,12 +1294,12 @@ CvGBTrees::calc_error( CvMLData* _data, int type, std::vector<float> *resp )
{ {
float err = 0.0f; float err = 0.0f;
const CvMat* sample_idx = (type == CV_TRAIN_ERROR) ? const CvMat* _sample_idx = (type == CV_TRAIN_ERROR) ?
_data->get_train_sample_idx() : _data->get_train_sample_idx() :
_data->get_test_sample_idx(); _data->get_test_sample_idx();
const CvMat* response = _data->get_responses(); const CvMat* response = _data->get_responses();
int n = sample_idx ? get_len(sample_idx) : 0; int n = _sample_idx ? get_len(_sample_idx) : 0;
n = (type == CV_TRAIN_ERROR && n == 0) ? _data->get_values()->rows : n; n = (type == CV_TRAIN_ERROR && n == 0) ? _data->get_values()->rows : n;
if (!n) if (!n)
@ -1315,7 +1315,7 @@ CvGBTrees::calc_error( CvMLData* _data, int type, std::vector<float> *resp )
pred_resp = new float[n]; pred_resp = new float[n];
Sample_predictor predictor = Sample_predictor(this, pred_resp, _data->get_values(), Sample_predictor predictor = Sample_predictor(this, pred_resp, _data->get_values(),
_data->get_missing(), sample_idx); _data->get_missing(), _sample_idx);
//#ifdef HAVE_TBB //#ifdef HAVE_TBB
// tbb::parallel_for(cv::BlockedRange(0,n), predictor, tbb::auto_partitioner()); // tbb::parallel_for(cv::BlockedRange(0,n), predictor, tbb::auto_partitioner());
@ -1323,7 +1323,7 @@ CvGBTrees::calc_error( CvMLData* _data, int type, std::vector<float> *resp )
cv::parallel_for(cv::BlockedRange(0,n), predictor); cv::parallel_for(cv::BlockedRange(0,n), predictor);
//#endif //#endif
int* sidx = sample_idx ? sample_idx->data.i : 0; int* sidx = _sample_idx ? _sample_idx->data.i : 0;
int r_step = CV_IS_MAT_CONT(response->type) ? int r_step = CV_IS_MAT_CONT(response->type) ?
1 : response->step / CV_ELEM_SIZE(response->type); 1 : response->step / CV_ELEM_SIZE(response->type);
@ -1357,7 +1357,7 @@ CvGBTrees::CvGBTrees( const cv::Mat& trainData, int tflag,
const cv::Mat& responses, const cv::Mat& varIdx, const cv::Mat& responses, const cv::Mat& varIdx,
const cv::Mat& sampleIdx, const cv::Mat& varType, const cv::Mat& sampleIdx, const cv::Mat& varType,
const cv::Mat& missingDataMask, const cv::Mat& missingDataMask,
CvGBTreesParams params ) CvGBTreesParams _params )
{ {
data = 0; data = 0;
weak = 0; weak = 0;
@ -1371,14 +1371,14 @@ CvGBTrees::CvGBTrees( const cv::Mat& trainData, int tflag,
clear(); clear();
train(trainData, tflag, responses, varIdx, sampleIdx, varType, missingDataMask, params, false); train(trainData, tflag, responses, varIdx, sampleIdx, varType, missingDataMask, _params, false);
} }
bool CvGBTrees::train( const cv::Mat& trainData, int tflag, bool CvGBTrees::train( const cv::Mat& trainData, int tflag,
const cv::Mat& responses, const cv::Mat& varIdx, const cv::Mat& responses, const cv::Mat& varIdx,
const cv::Mat& sampleIdx, const cv::Mat& varType, const cv::Mat& sampleIdx, const cv::Mat& varType,
const cv::Mat& missingDataMask, const cv::Mat& missingDataMask,
CvGBTreesParams params, CvGBTreesParams _params,
bool update ) bool update )
{ {
CvMat _trainData = trainData, _responses = responses; CvMat _trainData = trainData, _responses = responses;
@ -1387,13 +1387,13 @@ bool CvGBTrees::train( const cv::Mat& trainData, int tflag,
return train( &_trainData, tflag, &_responses, varIdx.empty() ? 0 : &_varIdx, return train( &_trainData, tflag, &_responses, varIdx.empty() ? 0 : &_varIdx,
sampleIdx.empty() ? 0 : &_sampleIdx, varType.empty() ? 0 : &_varType, sampleIdx.empty() ? 0 : &_sampleIdx, varType.empty() ? 0 : &_varType,
missingDataMask.empty() ? 0 : &_missingDataMask, params, update); missingDataMask.empty() ? 0 : &_missingDataMask, _params, update);
} }
float CvGBTrees::predict( const cv::Mat& sample, const cv::Mat& missing, float CvGBTrees::predict( const cv::Mat& sample, const cv::Mat& _missing,
const cv::Range& slice, int k ) const const cv::Range& slice, int k ) const
{ {
CvMat _sample = sample, _missing = missing; CvMat _sample = sample, miss = _missing;
return predict(&_sample, missing.empty() ? 0 : &_missing, 0, return predict(&_sample, _missing.empty() ? 0 : &miss, 0,
slice==cv::Range::all() ? CV_WHOLE_SEQ : cvSlice(slice.start, slice.end), k); slice==cv::Range::all() ? CV_WHOLE_SEQ : cvSlice(slice.start, slice.end), k);
} }

4
modules/ml/src/knearest.cpp
View File

@ -470,10 +470,10 @@ float CvKNearest::find_nearest( const Mat& _samples, int k, Mat* _results,
} }
float CvKNearest::find_nearest( const cv::Mat& samples, int k, CV_OUT cv::Mat& results, float CvKNearest::find_nearest( const cv::Mat& _samples, int k, CV_OUT cv::Mat& results,
CV_OUT cv::Mat& neighborResponses, CV_OUT cv::Mat& dists) const CV_OUT cv::Mat& neighborResponses, CV_OUT cv::Mat& dists) const
{ {
return find_nearest(samples, k, &results, 0, &neighborResponses, &dists); return find_nearest(_samples, k, &results, 0, &neighborResponses, &dists);
} }
/* End of file */ /* End of file */

6
modules/ml/src/nbayes.cpp
View File

@ -241,13 +241,13 @@ bool CvNormalBayesClassifier::train( const CvMat* _train_data, const CvMat* _res
double* cov_data = cov->data.db + i*_var_count; double* cov_data = cov->data.db + i*_var_count;
double s1val = sum1[i]; double s1val = sum1[i];
double avg1 = avg_data[i]; double avg1 = avg_data[i];
int count = count_data[i]; int _count = count_data[i];
for( j = 0; j <= i; j++ ) for( j = 0; j <= i; j++ )
{ {
double avg2 = avg2_data[j]; double avg2 = avg2_data[j];
double cov_val = prod_data[j] - avg1 * sum2[j] - avg2 * s1val + avg1 * avg2 * count; double cov_val = prod_data[j] - avg1 * sum2[j] - avg2 * s1val + avg1 * avg2 * _count;
cov_val = (count > 1) ? cov_val / (count - 1) : cov_val; cov_val = (_count > 1) ? cov_val / (_count - 1) : cov_val;
cov_data[j] = cov_val; cov_data[j] = cov_val;
} }
} }

14
modules/ml/src/rtrees.cpp
View File

@ -307,14 +307,14 @@ bool CvRTrees::train( const CvMat* _train_data, int _tflag,
return grow_forest( params.term_crit ); return grow_forest( params.term_crit );
} }
bool CvRTrees::train( CvMLData* data, CvRTParams params ) bool CvRTrees::train( CvMLData* _data, CvRTParams params )
{ {
const CvMat* values = data->get_values(); const CvMat* values = _data->get_values();
const CvMat* response = data->get_responses(); const CvMat* response = _data->get_responses();
const CvMat* missing = data->get_missing(); const CvMat* missing = _data->get_missing();
const CvMat* var_types = data->get_var_types(); const CvMat* var_types = _data->get_var_types();
const CvMat* train_sidx = data->get_train_sample_idx(); const CvMat* train_sidx = _data->get_train_sample_idx();
const CvMat* var_idx = data->get_var_idx(); const CvMat* var_idx = _data->get_var_idx();
return train( values, CV_ROW_SAMPLE, response, var_idx, return train( values, CV_ROW_SAMPLE, response, var_idx,
train_sidx, var_types, missing, params ); train_sidx, var_types, missing, params );

31
modules/ml/src/svm.cpp
View File

@ -1065,10 +1065,10 @@ bool CvSVMSolver::solve_eps_svr( int _sample_count, int _var_count, const float*
CvSVMKernel* _kernel, double* _alpha, CvSVMSolutionInfo& _si ) CvSVMKernel* _kernel, double* _alpha, CvSVMSolutionInfo& _si )
{ {
int i; int i;
double p = _kernel->params->p, C = _kernel->params->C; double p = _kernel->params->p, _C = _kernel->params->C;
if( !create( _sample_count, _var_count, _samples, 0, if( !create( _sample_count, _var_count, _samples, 0,
_sample_count*2, 0, C, C, _storage, _kernel, &CvSVMSolver::get_row_svr, _sample_count*2, 0, _C, _C, _storage, _kernel, &CvSVMSolver::get_row_svr,
&CvSVMSolver::select_working_set, &CvSVMSolver::calc_rho )) &CvSVMSolver::select_working_set, &CvSVMSolver::calc_rho ))
return false; return false;
@ -1101,7 +1101,7 @@ bool CvSVMSolver::solve_nu_svr( int _sample_count, int _var_count, const float**
CvSVMKernel* _kernel, double* _alpha, CvSVMSolutionInfo& _si ) CvSVMKernel* _kernel, double* _alpha, CvSVMSolutionInfo& _si )
{ {
int i; int i;
double C = _kernel->params->C, sum; double _C = _kernel->params->C, sum;
if( !create( _sample_count, _var_count, _samples, 0, if( !create( _sample_count, _var_count, _samples, 0,
_sample_count*2, 0, 1., 1., _storage, _kernel, &CvSVMSolver::get_row_svr, _sample_count*2, 0, 1., 1., _storage, _kernel, &CvSVMSolver::get_row_svr,
@ -1110,11 +1110,11 @@ bool CvSVMSolver::solve_nu_svr( int _sample_count, int _var_count, const float**
y = (schar*)cvMemStorageAlloc( storage, sample_count*2*sizeof(y[0]) ); y = (schar*)cvMemStorageAlloc( storage, sample_count*2*sizeof(y[0]) );
alpha = (double*)cvMemStorageAlloc( storage, alpha_count*sizeof(alpha[0]) ); alpha = (double*)cvMemStorageAlloc( storage, alpha_count*sizeof(alpha[0]) );
sum = C * _kernel->params->nu * sample_count * 0.5; sum = _C * _kernel->params->nu * sample_count * 0.5;
for( i = 0; i < sample_count; i++ ) for( i = 0; i < sample_count; i++ )
{ {
alpha[i] = alpha[i + sample_count] = MIN(sum, C); alpha[i] = alpha[i + sample_count] = MIN(sum, _C);
sum -= alpha[i]; sum -= alpha[i];
b[i] = -_y[i]; b[i] = -_y[i];
@ -1628,12 +1628,11 @@ bool CvSVM::train_auto( const CvMat* _train_data, const CvMat* _responses,
int svm_type, sample_count, var_count, sample_size; int svm_type, sample_count, var_count, sample_size;
int block_size = 1 << 16; int block_size = 1 << 16;
double* alpha; double* alpha;
int i, k;
RNG* rng = &theRNG(); RNG* rng = &theRNG();
// all steps are logarithmic and must be > 1 // all steps are logarithmic and must be > 1
double degree_step = 10, g_step = 10, coef_step = 10, C_step = 10, nu_step = 10, p_step = 10; double degree_step = 10, g_step = 10, coef_step = 10, C_step = 10, nu_step = 10, p_step = 10;
double gamma = 0, C = 0, degree = 0, coef = 0, p = 0, nu = 0; double gamma = 0, _C = 0, degree = 0, coef = 0, p = 0, nu = 0;
double best_degree = 0, best_gamma = 0, best_coef = 0, best_C = 0, best_nu = 0, best_p = 0; double best_degree = 0, best_gamma = 0, best_coef = 0, best_C = 0, best_nu = 0, best_p = 0;
float min_error = FLT_MAX, error; float min_error = FLT_MAX, error;
@ -1760,7 +1759,7 @@ bool CvSVM::train_auto( const CvMat* _train_data, const CvMat* _responses,
cvZero( responses_local ); cvZero( responses_local );
// randomly permute samples and responses // randomly permute samples and responses
for( i = 0; i < sample_count; i++ ) for(int i = 0; i < sample_count; i++ )
{ {
int i1 = (*rng)(sample_count); int i1 = (*rng)(sample_count);
int i2 = (*rng)(sample_count); int i2 = (*rng)(sample_count);
@ -1779,7 +1778,7 @@ bool CvSVM::train_auto( const CvMat* _train_data, const CvMat* _responses,
{ {
// count class samples // count class samples
int num_0=0,num_1=0; int num_0=0,num_1=0;
for (i=0; i<sample_count; ++i) for (int i=0; i<sample_count; ++i)
{ {
if (responses->data.i[i]==class_labels->data.i[0]) if (responses->data.i[i]==class_labels->data.i[0])
++num_0; ++num_0;
@ -1875,10 +1874,10 @@ bool CvSVM::train_auto( const CvMat* _train_data, const CvMat* _responses,
} }
int* cls_lbls = class_labels ? class_labels->data.i : 0; int* cls_lbls = class_labels ? class_labels->data.i : 0;
C = C_grid.min_val; _C = C_grid.min_val;
do do
{ {
params.C = C; params.C = _C;
gamma = gamma_grid.min_val; gamma = gamma_grid.min_val;
do do
{ {
@ -1906,7 +1905,7 @@ bool CvSVM::train_auto( const CvMat* _train_data, const CvMat* _responses,
int train_size = trainset_size; int train_size = trainset_size;
error = 0; error = 0;
for( k = 0; k < k_fold; k++ ) for(int k = 0; k < k_fold; k++ )
{ {
memcpy( samples_local, samples, sizeof(samples[0])*test_size*k ); memcpy( samples_local, samples, sizeof(samples[0])*test_size*k );
memcpy( samples_local + test_size*k, test_samples_ptr + test_size, memcpy( samples_local + test_size*k, test_samples_ptr + test_size,
@ -1930,7 +1929,7 @@ bool CvSVM::train_auto( const CvMat* _train_data, const CvMat* _responses,
EXIT; EXIT;
// Compute test set error on <test_size> samples // Compute test set error on <test_size> samples
for( i = 0; i < test_size; i++, true_resp += resp_elem_size, test_samples_ptr++ ) for(int i = 0; i < test_size; i++, true_resp += resp_elem_size, test_samples_ptr++ )
{ {
float resp = predict( *test_samples_ptr, var_count ); float resp = predict( *test_samples_ptr, var_count );
error += is_regression ? powf( resp - *(float*)true_resp, 2 ) error += is_regression ? powf( resp - *(float*)true_resp, 2 )
@ -1943,7 +1942,7 @@ bool CvSVM::train_auto( const CvMat* _train_data, const CvMat* _responses,
best_degree = degree; best_degree = degree;
best_gamma = gamma; best_gamma = gamma;
best_coef = coef; best_coef = coef;
best_C = C; best_C = _C;
best_nu = nu; best_nu = nu;
best_p = p; best_p = p;
} }
@ -1962,9 +1961,9 @@ bool CvSVM::train_auto( const CvMat* _train_data, const CvMat* _responses,
gamma *= gamma_grid.step; gamma *= gamma_grid.step;
} }
while( gamma < gamma_grid.max_val ); while( gamma < gamma_grid.max_val );
C *= C_grid.step; _C *= C_grid.step;
} }
while( C < C_grid.max_val ); while( _C < C_grid.max_val );
} }
min_error /= (float) sample_count; min_error /= (float) sample_count;

32
modules/ml/src/tree.cpp
View File

@ -564,15 +564,15 @@ void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
if( cv_n ) if( cv_n )
{ {
unsigned short* udst = 0; unsigned short* usdst = 0;
int* idst = 0; int* idst2 = 0;
if (is_buf_16u) if (is_buf_16u)
{ {
udst = (unsigned short*)(buf->data.s + (get_work_var_count()-1)*sample_count); usdst = (unsigned short*)(buf->data.s + (get_work_var_count()-1)*sample_count);
for( i = vi = 0; i < sample_count; i++ ) for( i = vi = 0; i < sample_count; i++ )
{ {
udst[i] = (unsigned short)vi++; usdst[i] = (unsigned short)vi++;
vi &= vi < cv_n ? -1 : 0; vi &= vi < cv_n ? -1 : 0;
} }
@ -581,15 +581,15 @@ void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
int a = (*rng)(sample_count); int a = (*rng)(sample_count);
int b = (*rng)(sample_count); int b = (*rng)(sample_count);
unsigned short unsh = (unsigned short)vi; unsigned short unsh = (unsigned short)vi;
CV_SWAP( udst[a], udst[b], unsh ); CV_SWAP( usdst[a], usdst[b], unsh );
} }
} }
else else
{ {
idst = buf->data.i + (get_work_var_count()-1)*sample_count; idst2 = buf->data.i + (get_work_var_count()-1)*sample_count;
for( i = vi = 0; i < sample_count; i++ ) for( i = vi = 0; i < sample_count; i++ )
{ {
idst[i] = vi++; idst2[i] = vi++;
vi &= vi < cv_n ? -1 : 0; vi &= vi < cv_n ? -1 : 0;
} }
@ -597,7 +597,7 @@ void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
{ {
int a = (*rng)(sample_count); int a = (*rng)(sample_count);
int b = (*rng)(sample_count); int b = (*rng)(sample_count);
CV_SWAP( idst[a], idst[b], vi ); CV_SWAP( idst2[a], idst2[b], vi );
} }
} }
} }
@ -865,7 +865,7 @@ CvDTreeNode* CvDTreeTrainData::subsample_data( const CvMat* _subsample_idx )
void CvDTreeTrainData::get_vectors( const CvMat* _subsample_idx, void CvDTreeTrainData::get_vectors( const CvMat* _subsample_idx,
float* values, uchar* missing, float* values, uchar* missing,
float* responses, bool get_class_idx ) float* _responses, bool get_class_idx )
{ {
CvMat* subsample_idx = 0; CvMat* subsample_idx = 0;
CvMat* subsample_co = 0; CvMat* subsample_co = 0;
@ -962,7 +962,7 @@ void CvDTreeTrainData::get_vectors( const CvMat* _subsample_idx,
} }
// copy responses // copy responses
if( responses ) if( _responses )
{ {
if( is_classifier ) if( is_classifier )
{ {
@ -972,7 +972,7 @@ void CvDTreeTrainData::get_vectors( const CvMat* _subsample_idx,
int idx = sidx ? sidx[i] : i; int idx = sidx ? sidx[i] : i;
int val = get_class_idx ? src[idx] : int val = get_class_idx ? src[idx] :
cat_map->data.i[cat_ofs->data.i[cat_var_count]+src[idx]]; cat_map->data.i[cat_ofs->data.i[cat_var_count]+src[idx]];
responses[i] = (float)val; _responses[i] = (float)val;
} }
} }
else else
@ -983,7 +983,7 @@ void CvDTreeTrainData::get_vectors( const CvMat* _subsample_idx,
for( i = 0; i < count; i++ ) for( i = 0; i < count; i++ )
{ {
int idx = sidx ? sidx[i] : i; int idx = sidx ? sidx[i] : i;
responses[i] = _values[idx]; _responses[i] = _values[idx];
} }
} }
} }
@ -1205,11 +1205,11 @@ const int* CvDTreeTrainData::get_sample_indices( CvDTreeNode* n, int* indices_bu
const float* CvDTreeTrainData::get_ord_responses( CvDTreeNode* n, float* values_buf, int*sample_indices_buf ) const float* CvDTreeTrainData::get_ord_responses( CvDTreeNode* n, float* values_buf, int*sample_indices_buf )
{ {
int sample_count = n->sample_count; int _sample_count = n->sample_count;
int r_step = CV_IS_MAT_CONT(responses->type) ? 1 : responses->step/CV_ELEM_SIZE(responses->type); int r_step = CV_IS_MAT_CONT(responses->type) ? 1 : responses->step/CV_ELEM_SIZE(responses->type);
const int* indices = get_sample_indices(n, sample_indices_buf); const int* indices = get_sample_indices(n, sample_indices_buf);
for( int i = 0; i < sample_count && for( int i = 0; i < _sample_count &&
(((indices[i] >= 0) && !is_buf_16u) || ((indices[i] != 65535) && is_buf_16u)); i++ ) (((indices[i] >= 0) && !is_buf_16u) || ((indices[i] != 65535) && is_buf_16u)); i++ )
{ {
int idx = indices[i]; int idx = indices[i];
@ -3527,7 +3527,7 @@ int CvDTree::cut_tree( int T, int fold, double min_alpha )
} }
void CvDTree::free_prune_data(bool cut_tree) void CvDTree::free_prune_data(bool _cut_tree)
{ {
CvDTreeNode* node = root; CvDTreeNode* node = root;
@ -3548,7 +3548,7 @@ void CvDTree::free_prune_data(bool cut_tree)
for( parent = node->parent; parent && parent->right == node; for( parent = node->parent; parent && parent->right == node;
node = parent, parent = parent->parent ) node = parent, parent = parent->parent )
{ {
if( cut_tree && parent->Tn <= pruned_tree_idx ) if( _cut_tree && parent->Tn <= pruned_tree_idx )
{ {
data->free_node( parent->left ); data->free_node( parent->left );
data->free_node( parent->right ); data->free_node( parent->right );

12
modules/ml/test/test_emknearestkmeans.cpp
View File

@ -327,12 +327,12 @@ void CV_KNearestTest::run( int /*start_from*/ )
class EM_Params class EM_Params
{ {
public: public:
EM_Params(int nclusters=10, int covMatType=EM::COV_MAT_DIAGONAL, int startStep=EM::START_AUTO_STEP, EM_Params(int _nclusters=10, int _covMatType=EM::COV_MAT_DIAGONAL, int _startStep=EM::START_AUTO_STEP,
const cv::TermCriteria& termCrit=cv::TermCriteria(cv::TermCriteria::COUNT+cv::TermCriteria::EPS, 100, FLT_EPSILON), const cv::TermCriteria& _termCrit=cv::TermCriteria(cv::TermCriteria::COUNT+cv::TermCriteria::EPS, 100, FLT_EPSILON),
const cv::Mat* probs=0, const cv::Mat* weights=0, const cv::Mat* _probs=0, const cv::Mat* _weights=0,
const cv::Mat* means=0, const std::vector<cv::Mat>* covs=0) const cv::Mat* _means=0, const std::vector<cv::Mat>* _covs=0)
: nclusters(nclusters), covMatType(covMatType), startStep(startStep), : nclusters(_nclusters), covMatType(_covMatType), startStep(_startStep),
probs(probs), weights(weights), means(means), covs(covs), termCrit(termCrit) probs(_probs), weights(_weights), means(_means), covs(_covs), termCrit(_termCrit)
{} {}
int nclusters; int nclusters;

Some files were not shown because too many files have changed in this diff Show More