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})

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

@ -230,7 +230,7 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
int found = 0; int found = 0;
CvCBQuad *quads = 0, **quad_group = 0; CvCBQuad *quads = 0, **quad_group = 0;
CvCBCorner *corners = 0, **corner_group = 0; CvCBCorner *corners = 0, **corner_group = 0;
try try
{ {
int k = 0; int k = 0;
@ -252,11 +252,11 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
if( out_corner_count ) if( out_corner_count )
*out_corner_count = 0; *out_corner_count = 0;
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;
@ -316,8 +316,8 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
for( dilations = min_dilations; dilations <= max_dilations; dilations++ ) for( dilations = min_dilations; dilations <= max_dilations; dilations++ )
{ {
if (found) if (found)
break; // already found it break; // already found it
cvFree(&quads); cvFree(&quads);
cvFree(&corners); cvFree(&corners);
@ -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++)
@ -455,7 +455,7 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
#endif #endif
if (count == 0) if (count == 0)
continue; // haven't found inner quads continue; // haven't found inner quads
// If count is more than it should be, this will remove those quads // If count is more than it should be, this will remove those quads
@ -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 )
@ -505,19 +505,19 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
if( found ) if( found )
found = icvCheckBoardMonotony( out_corners, pattern_size ); found = icvCheckBoardMonotony( out_corners, pattern_size );
// check that none of the found corners is too close to the image boundary // check that none of the found corners is too close to the image boundary
if( found ) if( found )
{ {
const int BORDER = 8; const int BORDER = 8;
for( k = 0; k < pattern_size.width*pattern_size.height; k++ ) for( k = 0; k < pattern_size.width*pattern_size.height; k++ )
{ {
if( out_corners[k].x <= BORDER || out_corners[k].x > img->cols - BORDER || if( out_corners[k].x <= BORDER || out_corners[k].x > img->cols - BORDER ||
out_corners[k].y <= BORDER || out_corners[k].y > img->rows - BORDER ) out_corners[k].y <= BORDER || out_corners[k].y > img->rows - BORDER )
break; break;
} }
found = k == pattern_size.width*pattern_size.height; found = k == pattern_size.width*pattern_size.height;
} }
if( found && pattern_size.height % 2 == 0 && pattern_size.width % 2 == 0 ) if( found && pattern_size.height % 2 == 0 && pattern_size.width % 2 == 0 )
{ {
@ -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);
@ -559,7 +559,7 @@ int cvFindChessboardCorners( const void* arr, CvSize pattern_size,
cvFree(&corner_group); cvFree(&corner_group);
throw; throw;
} }
cvFree(&quads); cvFree(&quads);
cvFree(&corners); cvFree(&corners);
cvFree(&quad_group); cvFree(&quad_group);
@ -582,7 +582,7 @@ static int
icvCheckBoardMonotony( CvPoint2D32f* corners, CvSize pattern_size ) icvCheckBoardMonotony( CvPoint2D32f* corners, CvSize pattern_size )
{ {
int i, j, k; int i, j, k;
for( k = 0; k < 2; k++ ) for( k = 0; k < 2; k++ )
{ {
for( i = 0; i < (k == 0 ? pattern_size.height : pattern_size.width); i++ ) for( i = 0; i < (k == 0 ? pattern_size.height : pattern_size.width); i++ )
@ -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)
{ {
@ -682,7 +681,7 @@ icvOrderFoundConnectedQuads( int quad_count, CvCBQuad **quads,
case 1: case 1:
col += 2; break; col += 2; break;
case 2: case 2:
row += 2; break; row += 2; break;
case 3: case 3:
col -= 2; break; col -= 2; break;
} }
@ -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
@ -778,7 +777,7 @@ icvOrderFoundConnectedQuads( int quad_count, CvCBQuad **quads,
case 1: case 1:
col += 2; break; col += 2; break;
case 2: case 2:
row += 2; break; row += 2; break;
case 3: case 3:
col -= 2; break; col -= 2; break;
} }
@ -817,7 +816,7 @@ icvOrderFoundConnectedQuads( int quad_count, CvCBQuad **quads,
// final trimming of outer quads // final trimming of outer quads
if (dcol == w && drow == h) // found correct inner quads if (dcol == w && drow == h) // found correct inner quads
{ {
PRINTF("Inner bounds ok, check outer quads\n"); PRINTF("Inner bounds ok, check outer quads\n");
int rcount = quad_count; int rcount = quad_count;
@ -832,7 +831,7 @@ icvOrderFoundConnectedQuads( int quad_count, CvCBQuad **quads,
if (quads[i]->neighbors[j] && quads[i]->neighbors[j]->ordered) if (quads[i]->neighbors[j] && quads[i]->neighbors[j]->ordered)
outer = true; outer = true;
} }
if (!outer) // not an outer quad, eliminate if (!outer) // not an outer quad, eliminate
{ {
PRINTF("Removing quad %d\n", i); PRINTF("Removing quad %d\n", i);
icvRemoveQuadFromGroup(quads,rcount,quads[i]); icvRemoveQuadFromGroup(quads,rcount,quads[i]);
@ -876,7 +875,7 @@ icvAddOuterQuad( CvCBQuad *quad, CvCBQuad **quads, int quad_count,
quad->count += 1; quad->count += 1;
q->neighbors[j] = quad; q->neighbors[j] = quad;
q->group_idx = quad->group_idx; q->group_idx = quad->group_idx;
q->count = 1; // number of neighbors q->count = 1; // number of neighbors
q->ordered = false; q->ordered = false;
q->edge_len = quad->edge_len; q->edge_len = quad->edge_len;
@ -1262,7 +1261,7 @@ icvCheckQuadGroup( CvCBQuad **quad_group, int quad_count,
int width = 0, height = 0; int width = 0, height = 0;
int hist[5] = {0,0,0,0,0}; int hist[5] = {0,0,0,0,0};
CvCBCorner* first = 0, *first2 = 0, *right, *cur, *below, *c; CvCBCorner* first = 0, *first2 = 0, *right, *cur, *below, *c;
// build dual graph, which vertices are internal quad corners // build dual graph, which vertices are internal quad corners
// and two vertices are connected iff they lie on the same quad edge // and two vertices are connected iff they lie on the same quad edge
for( i = 0; i < quad_count; i++ ) for( i = 0; i < quad_count; i++ )
@ -1485,7 +1484,7 @@ icvCheckQuadGroup( CvCBQuad **quad_group, int quad_count,
result = corner_count; result = corner_count;
finalize: finalize:
if( result <= 0 ) if( result <= 0 )
{ {
corner_count = MIN( corner_count, pattern_size.width*pattern_size.height ); corner_count = MIN( corner_count, pattern_size.width*pattern_size.height );
@ -1697,7 +1696,7 @@ icvGenerateQuads( CvCBQuad **out_quads, CvCBCorner **out_corners,
CV_POLY_APPROX_DP, (float)approx_level ); CV_POLY_APPROX_DP, (float)approx_level );
if( dst_contour->total == 4 ) if( dst_contour->total == 4 )
break; break;
// we call this again on its own output, because sometimes // we call this again on its own output, because sometimes
// cvApproxPoly() does not simplify as much as it should. // cvApproxPoly() does not simplify as much as it should.
dst_contour = cvApproxPoly( dst_contour, sizeof(CvContour), temp_storage, dst_contour = cvApproxPoly( dst_contour, sizeof(CvContour), temp_storage,
@ -2006,17 +2005,17 @@ bool cv::findCirclesGrid( InputArray _image, Size patternSize,
#endif #endif
if (isFound) if (isFound)
{ {
switch(parameters.gridType) switch(parameters.gridType)
{ {
case CirclesGridFinderParameters::SYMMETRIC_GRID: case CirclesGridFinderParameters::SYMMETRIC_GRID:
boxFinder.getHoles(centers); boxFinder.getHoles(centers);
break; break;
case CirclesGridFinderParameters::ASYMMETRIC_GRID: case CirclesGridFinderParameters::ASYMMETRIC_GRID:
boxFinder.getAsymmetricHoles(centers); boxFinder.getAsymmetricHoles(centers);
break; break;
default: default:
CV_Error(CV_StsBadArg, "Unkown pattern type"); CV_Error(CV_StsBadArg, "Unkown pattern type");
} }
if (i != 0) if (i != 0)
{ {
@ -2027,7 +2026,7 @@ bool cv::findCirclesGrid( InputArray _image, Size patternSize,
Mat(centers).copyTo(_centers); Mat(centers).copyTo(_centers);
return true; return true;
} }
boxFinder.getHoles(centers); boxFinder.getHoles(centers);
if (i != attempts - 1) if (i != attempts - 1)
{ {

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];

16
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;
} }
@ -505,11 +505,11 @@ void Graph::floydWarshall(cv::Mat &distanceMatrix, int infinity) const
{ {
for (Vertices::const_iterator it3 = vertices.begin(); it3 != vertices.end(); it3++) for (Vertices::const_iterator it3 = vertices.begin(); it3 != vertices.end(); it3++)
{ {
int i1 = (int)it1->first, i2 = (int)it2->first, i3 = (int)it3->first; int i1 = (int)it1->first, i2 = (int)it2->first, i3 = (int)it3->first;
int val1 = distanceMatrix.at<int> (i2, i3); int val1 = distanceMatrix.at<int> (i2, i3);
int val2; int val2;
if (distanceMatrix.at<int> (i2, i1) == infinity || if (distanceMatrix.at<int> (i2, i1) == infinity ||
distanceMatrix.at<int> (i1, i3) == infinity) distanceMatrix.at<int> (i1, i3) == infinity)
val2 = val1; val2 = val1;
else else
{ {

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

@ -8,26 +8,26 @@ epnp::epnp(const cv::Mat& cameraMatrix, const cv::Mat& opoints, const cv::Mat& i
if (cameraMatrix.depth() == CV_32F) if (cameraMatrix.depth() == CV_32F)
init_camera_parameters<float>(cameraMatrix); init_camera_parameters<float>(cameraMatrix);
else else
init_camera_parameters<double>(cameraMatrix); init_camera_parameters<double>(cameraMatrix);
number_of_correspondences = std::max(opoints.checkVector(3, CV_32F), opoints.checkVector(3, CV_64F)); number_of_correspondences = std::max(opoints.checkVector(3, CV_32F), opoints.checkVector(3, CV_64F));
pws.resize(3 * number_of_correspondences); pws.resize(3 * number_of_correspondences);
us.resize(2 * number_of_correspondences); us.resize(2 * number_of_correspondences);
if (opoints.depth() == ipoints.depth()) if (opoints.depth() == ipoints.depth())
{ {
if (opoints.depth() == CV_32F) if (opoints.depth() == CV_32F)
init_points<cv::Point3f,cv::Point2f>(opoints, ipoints); init_points<cv::Point3f,cv::Point2f>(opoints, ipoints);
else else
init_points<cv::Point3d,cv::Point2d>(opoints, ipoints); init_points<cv::Point3d,cv::Point2d>(opoints, ipoints);
} }
else if (opoints.depth() == CV_32F) else if (opoints.depth() == CV_32F)
init_points<cv::Point3f,cv::Point2d>(opoints, ipoints); init_points<cv::Point3f,cv::Point2d>(opoints, ipoints);
else else
init_points<cv::Point3d,cv::Point2f>(opoints, ipoints); init_points<cv::Point3d,cv::Point2f>(opoints, ipoints);
alphas.resize(4 * number_of_correspondences); alphas.resize(4 * number_of_correspondences);
pcs.resize(3 * number_of_correspondences); pcs.resize(3 * number_of_correspondences);
max_nr = 0; max_nr = 0;
@ -97,15 +97,15 @@ void epnp::compute_barycentric_coordinates(void)
for(int j = 0; j < 3; j++) for(int j = 0; j < 3; j++)
a[1 + j] = a[1 + j] =
ci[3 * j ] * (pi[0] - cws[0][0]) + ci[3 * j ] * (pi[0] - cws[0][0]) +
ci[3 * j + 1] * (pi[1] - cws[0][1]) + ci[3 * j + 1] * (pi[1] - cws[0][1]) +
ci[3 * j + 2] * (pi[2] - cws[0][2]); ci[3 * j + 2] * (pi[2] - cws[0][2]);
a[0] = 1.0f - a[1] - a[2] - a[3]; a[0] = 1.0f - a[1] - a[2] - a[3];
} }
} }
void epnp::fill_M(CvMat * M, void epnp::fill_M(CvMat * M,
const int row, const double * as, const double u, const double v) const int row, const double * as, const double u, const double v)
{ {
double * M1 = M->data.db + row * 12; double * M1 = M->data.db + row * 12;
double * M2 = M1 + 12; double * M2 = M1 + 12;
@ -130,7 +130,7 @@ void epnp::compute_ccs(const double * betas, const double * ut)
const double * v = ut + 12 * (11 - i); const double * v = ut + 12 * (11 - i);
for(int j = 0; j < 4; j++) for(int j = 0; j < 4; j++)
for(int k = 0; k < 3; k++) for(int k = 0; k < 3; k++)
ccs[j][k] += betas[i] * v[3 * j + k]; ccs[j][k] += betas[i] * v[3 * j + k];
} }
} }
@ -195,7 +195,7 @@ void epnp::compute_pose(cv::Mat& R, cv::Mat& t)
} }
void epnp::copy_R_and_t(const double R_src[3][3], const double t_src[3], void epnp::copy_R_and_t(const double R_src[3][3], const double t_src[3],
double R_dst[3][3], double t_dst[3]) double R_dst[3][3], double t_dst[3])
{ {
for(int i = 0; i < 3; i++) { for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) for(int j = 0; j < 3; j++)
@ -282,7 +282,7 @@ void epnp::solve_for_sign(void)
if (pcs[2] < 0.0) { if (pcs[2] < 0.0) {
for(int i = 0; i < 4; i++) for(int i = 0; i < 4; i++)
for(int j = 0; j < 3; j++) for(int j = 0; j < 3; j++)
ccs[i][j] = -ccs[i][j]; ccs[i][j] = -ccs[i][j];
for(int i = 0; i < number_of_correspondences; i++) { for(int i = 0; i < number_of_correspondences; i++) {
pcs[3 * i ] = -pcs[3 * i]; pcs[3 * i ] = -pcs[3 * i];
@ -293,7 +293,7 @@ void epnp::solve_for_sign(void)
} }
double epnp::compute_R_and_t(const double * ut, const double * betas, double epnp::compute_R_and_t(const double * ut, const double * betas,
double R[3][3], double t[3]) double R[3][3], double t[3])
{ {
compute_ccs(betas, ut); compute_ccs(betas, ut);
compute_pcs(); compute_pcs();
@ -322,13 +322,13 @@ double epnp::reprojection_error(const double R[3][3], const double t[3])
} }
return sum2 / number_of_correspondences; return sum2 / number_of_correspondences;
} }
// betas10 = [B11 B12 B22 B13 B23 B33 B14 B24 B34 B44] // betas10 = [B11 B12 B22 B13 B23 B33 B14 B24 B34 B44]
// betas_approx_1 = [B11 B12 B13 B14] // betas_approx_1 = [B11 B12 B13 B14]
void epnp::find_betas_approx_1(const CvMat * L_6x10, const CvMat * Rho, void epnp::find_betas_approx_1(const CvMat * L_6x10, const CvMat * Rho,
double * betas) double * betas)
{ {
double l_6x4[6 * 4], b4[4]; double l_6x4[6 * 4], b4[4];
CvMat L_6x4 = cvMat(6, 4, CV_64F, l_6x4); CvMat L_6x4 = cvMat(6, 4, CV_64F, l_6x4);
@ -360,7 +360,7 @@ void epnp::find_betas_approx_1(const CvMat * L_6x10, const CvMat * Rho,
// betas_approx_2 = [B11 B12 B22 ] // betas_approx_2 = [B11 B12 B22 ]
void epnp::find_betas_approx_2(const CvMat * L_6x10, const CvMat * Rho, void epnp::find_betas_approx_2(const CvMat * L_6x10, const CvMat * Rho,
double * betas) double * betas)
{ {
double l_6x3[6 * 3], b3[3]; double l_6x3[6 * 3], b3[3];
CvMat L_6x3 = cvMat(6, 3, CV_64F, l_6x3); CvMat L_6x3 = cvMat(6, 3, CV_64F, l_6x3);
@ -392,7 +392,7 @@ void epnp::find_betas_approx_2(const CvMat * L_6x10, const CvMat * Rho,
// betas_approx_3 = [B11 B12 B22 B13 B23 ] // betas_approx_3 = [B11 B12 B22 B13 B23 ]
void epnp::find_betas_approx_3(const CvMat * L_6x10, const CvMat * Rho, void epnp::find_betas_approx_3(const CvMat * L_6x10, const CvMat * Rho,
double * betas) double * betas)
{ {
double l_6x5[6 * 5], b5[5]; double l_6x5[6 * 5], b5[5];
CvMat L_6x5 = cvMat(6, 5, CV_64F, l_6x5); CvMat L_6x5 = cvMat(6, 5, CV_64F, l_6x5);
@ -440,8 +440,8 @@ void epnp::compute_L_6x10(const double * ut, double * l_6x10)
b++; b++;
if (b > 3) { if (b > 3) {
a++; a++;
b = a + 1; b = a + 1;
} }
} }
} }
@ -473,7 +473,7 @@ void epnp::compute_rho(double * rho)
} }
void epnp::compute_A_and_b_gauss_newton(const double * l_6x10, const double * rho, void epnp::compute_A_and_b_gauss_newton(const double * l_6x10, const double * rho,
const double betas[4], CvMat * A, CvMat * b) const double betas[4], CvMat * A, CvMat * b)
{ {
for(int i = 0; i < 6; i++) { for(int i = 0; i < 6; i++) {
const double * rowL = l_6x10 + i * 10; const double * rowL = l_6x10 + i * 10;
@ -485,23 +485,22 @@ void epnp::compute_A_and_b_gauss_newton(const double * l_6x10, const double * rh
rowA[3] = rowL[6] * betas[0] + rowL[7] * betas[1] + rowL[8] * betas[2] + 2 * rowL[9] * betas[3]; rowA[3] = rowL[6] * betas[0] + rowL[7] * betas[1] + rowL[8] * betas[2] + 2 * rowL[9] * betas[3];
cvmSet(b, i, 0, rho[i] - cvmSet(b, i, 0, rho[i] -
( (
rowL[0] * betas[0] * betas[0] + rowL[0] * betas[0] * betas[0] +
rowL[1] * betas[0] * betas[1] + rowL[1] * betas[0] * betas[1] +
rowL[2] * betas[1] * betas[1] + rowL[2] * betas[1] * betas[1] +
rowL[3] * betas[0] * betas[2] + rowL[3] * betas[0] * betas[2] +
rowL[4] * betas[1] * betas[2] + rowL[4] * betas[1] * betas[2] +
rowL[5] * betas[2] * betas[2] + rowL[5] * betas[2] * betas[2] +
rowL[6] * betas[0] * betas[3] + rowL[6] * betas[0] * betas[3] +
rowL[7] * betas[1] * betas[3] + rowL[7] * betas[1] * betas[3] +
rowL[8] * betas[2] * betas[3] + rowL[8] * betas[2] * betas[3] +
rowL[9] * betas[3] * betas[3] rowL[9] * betas[3] * betas[3]
)); ));
} }
} }
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,12 +509,13 @@ 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);
for(int i = 0; i < 4; i++) for(int i = 0; i < 4; i++)
betas[i] += x[i]; betas[i] += x[i];
} }
} }
@ -524,53 +524,64 @@ 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; else
for(int i = k; i < nr; i++) { {
*ppAik *= inv_eta; double * ppAik2 = ppAkk, sum2 = 0.0, inv_eta = 1. / eta;
sum += *ppAik * *ppAik; for(int i = k; i < nr; i++)
ppAik += nc; {
*ppAik2 *= inv_eta;
sum2 += *ppAik2 * *ppAik2;
ppAik2 += nc;
} }
double sigma = sqrt(sum); 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; {
for(int i = k; i < nr; i++) { double * ppAik = ppAkk, sum = 0;
sum += *ppAik * ppAik[j - k]; for(int i = k; i < nr; i++)
ppAik += nc; {
} sum += *ppAik * ppAik[j - k];
double tau = sum / A1[k]; ppAik += nc;
ppAik = ppAkk; }
for(int i = k; i < nr; i++) { double tau = sum / A1[k];
ppAik[j - k] -= tau * *ppAik; ppAik = ppAkk;
ppAik += nc; for(int i = k; i < nr; i++)
} {
ppAik[j - k] -= tau * *ppAik;
ppAik += nc;
}
} }
} }
ppAkk += nc + 1; ppAkk += nc + 1;
@ -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++;
} }

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

@ -9,151 +9,151 @@ using namespace std;
void p3p::init_inverse_parameters() void p3p::init_inverse_parameters()
{ {
inv_fx = 1. / fx; inv_fx = 1. / fx;
inv_fy = 1. / fy; inv_fy = 1. / fy;
cx_fx = cx / fx; cx_fx = cx / fx;
cy_fy = cy / fy; cy_fy = cy / fy;
} }
p3p::p3p(cv::Mat cameraMatrix) p3p::p3p(cv::Mat cameraMatrix)
{ {
if (cameraMatrix.depth() == CV_32F) if (cameraMatrix.depth() == CV_32F)
init_camera_parameters<float>(cameraMatrix); init_camera_parameters<float>(cameraMatrix);
else else
init_camera_parameters<double>(cameraMatrix); init_camera_parameters<double>(cameraMatrix);
init_inverse_parameters(); init_inverse_parameters();
} }
p3p::p3p(double _fx, double _fy, double _cx, double _cy) p3p::p3p(double _fx, double _fy, double _cx, double _cy)
{ {
fx = _fx; fx = _fx;
fy = _fy; fy = _fy;
cx = _cx; cx = _cx;
cy = _cy; cy = _cy;
init_inverse_parameters(); init_inverse_parameters();
} }
bool p3p::solve(cv::Mat& R, cv::Mat& tvec, const cv::Mat& opoints, const cv::Mat& ipoints) bool p3p::solve(cv::Mat& R, cv::Mat& tvec, const cv::Mat& opoints, const cv::Mat& ipoints)
{ {
double rotation_matrix[3][3], translation[3]; double rotation_matrix[3][3], translation[3];
std::vector<double> points; std::vector<double> points;
if (opoints.depth() == ipoints.depth()) if (opoints.depth() == ipoints.depth())
{ {
if (opoints.depth() == CV_32F) if (opoints.depth() == CV_32F)
extract_points<cv::Point3f,cv::Point2f>(opoints, ipoints, points); extract_points<cv::Point3f,cv::Point2f>(opoints, ipoints, points);
else else
extract_points<cv::Point3d,cv::Point2d>(opoints, ipoints, points); extract_points<cv::Point3d,cv::Point2d>(opoints, ipoints, points);
} }
else if (opoints.depth() == CV_32F) else if (opoints.depth() == CV_32F)
extract_points<cv::Point3f,cv::Point2d>(opoints, ipoints, points); extract_points<cv::Point3f,cv::Point2d>(opoints, ipoints, points);
else else
extract_points<cv::Point3d,cv::Point2f>(opoints, ipoints, points); extract_points<cv::Point3d,cv::Point2f>(opoints, ipoints, points);
bool result = solve(rotation_matrix, translation, points[0], points[1], points[2], points[3], points[4], points[5], bool result = solve(rotation_matrix, translation, points[0], points[1], points[2], points[3], points[4], points[5],
points[6], points[7], points[8], points[9], points[10], points[11], points[12], points[13], points[14], points[6], points[7], points[8], points[9], points[10], points[11], points[12], points[13], points[14],
points[15], points[16], points[17], points[18], points[19]); points[15], points[16], points[17], points[18], points[19]);
cv::Mat(3, 1, CV_64F, translation).copyTo(tvec); cv::Mat(3, 1, CV_64F, translation).copyTo(tvec);
cv::Mat(3, 3, CV_64F, rotation_matrix).copyTo(R); cv::Mat(3, 3, CV_64F, rotation_matrix).copyTo(R);
return result; return result;
} }
bool p3p::solve(double R[3][3], double t[3], bool p3p::solve(double R[3][3], double t[3],
double mu0, double mv0, double X0, double Y0, double Z0, double mu0, double mv0, double X0, double Y0, double Z0,
double mu1, double mv1, double X1, double Y1, double Z1, double mu1, double mv1, double X1, double Y1, double Z1,
double mu2, double mv2, double X2, double Y2, double Z2, double mu2, double mv2, double X2, double Y2, double Z2,
double mu3, double mv3, double X3, double Y3, double Z3) double mu3, double mv3, double X3, double Y3, double Z3)
{ {
double Rs[4][3][3], ts[4][3]; double Rs[4][3][3], ts[4][3];
int n = solve(Rs, ts, mu0, mv0, X0, Y0, Z0, mu1, mv1, X1, Y1, Z1, mu2, mv2, X2, Y2, Z2); int n = solve(Rs, ts, mu0, mv0, X0, Y0, Z0, mu1, mv1, X1, Y1, Z1, mu2, mv2, X2, Y2, Z2);
if (n == 0) if (n == 0)
return false; return false;
int ns = 0; int ns = 0;
double min_reproj = 0; double min_reproj = 0;
for(int i = 0; i < n; i++) { for(int i = 0; i < n; i++) {
double X3p = Rs[i][0][0] * X3 + Rs[i][0][1] * Y3 + Rs[i][0][2] * Z3 + ts[i][0]; double X3p = Rs[i][0][0] * X3 + Rs[i][0][1] * Y3 + Rs[i][0][2] * Z3 + ts[i][0];
double Y3p = Rs[i][1][0] * X3 + Rs[i][1][1] * Y3 + Rs[i][1][2] * Z3 + ts[i][1]; double Y3p = Rs[i][1][0] * X3 + Rs[i][1][1] * Y3 + Rs[i][1][2] * Z3 + ts[i][1];
double Z3p = Rs[i][2][0] * X3 + Rs[i][2][1] * Y3 + Rs[i][2][2] * Z3 + ts[i][2]; double Z3p = Rs[i][2][0] * X3 + Rs[i][2][1] * Y3 + Rs[i][2][2] * Z3 + ts[i][2];
double mu3p = cx + fx * X3p / Z3p; double mu3p = cx + fx * X3p / Z3p;
double mv3p = cy + fy * Y3p / Z3p; double mv3p = cy + fy * Y3p / Z3p;
double reproj = (mu3p - mu3) * (mu3p - mu3) + (mv3p - mv3) * (mv3p - mv3); double reproj = (mu3p - mu3) * (mu3p - mu3) + (mv3p - mv3) * (mv3p - mv3);
if (i == 0 || min_reproj > reproj) { if (i == 0 || min_reproj > reproj) {
ns = i; ns = i;
min_reproj = reproj; min_reproj = reproj;
} }
} }
for(int i = 0; i < 3; i++) { for(int i = 0; i < 3; i++) {
for(int j = 0; j < 3; j++) for(int j = 0; j < 3; j++)
R[i][j] = Rs[ns][i][j]; R[i][j] = Rs[ns][i][j];
t[i] = ts[ns][i]; t[i] = ts[ns][i];
} }
return true; return true;
} }
int p3p::solve(double R[4][3][3], double t[4][3], int p3p::solve(double R[4][3][3], double t[4][3],
double mu0, double mv0, double X0, double Y0, double Z0, double mu0, double mv0, double X0, double Y0, double Z0,
double mu1, double mv1, double X1, double Y1, double Z1, double mu1, double mv1, double X1, double Y1, double Z1,
double mu2, double mv2, double X2, double Y2, double Z2) double mu2, double mv2, double X2, double Y2, double Z2)
{ {
double mk0, mk1, mk2; double mk0, mk1, mk2;
double norm; double norm;
mu0 = inv_fx * mu0 - cx_fx; mu0 = inv_fx * mu0 - cx_fx;
mv0 = inv_fy * mv0 - cy_fy; mv0 = inv_fy * mv0 - cy_fy;
norm = sqrt(mu0 * mu0 + mv0 * mv0 + 1); norm = sqrt(mu0 * mu0 + mv0 * mv0 + 1);
mk0 = 1. / norm; mu0 *= mk0; mv0 *= mk0; mk0 = 1. / norm; mu0 *= mk0; mv0 *= mk0;
mu1 = inv_fx * mu1 - cx_fx; mu1 = inv_fx * mu1 - cx_fx;
mv1 = inv_fy * mv1 - cy_fy; mv1 = inv_fy * mv1 - cy_fy;
norm = sqrt(mu1 * mu1 + mv1 * mv1 + 1); norm = sqrt(mu1 * mu1 + mv1 * mv1 + 1);
mk1 = 1. / norm; mu1 *= mk1; mv1 *= mk1; mk1 = 1. / norm; mu1 *= mk1; mv1 *= mk1;
mu2 = inv_fx * mu2 - cx_fx; mu2 = inv_fx * mu2 - cx_fx;
mv2 = inv_fy * mv2 - cy_fy; mv2 = inv_fy * mv2 - cy_fy;
norm = sqrt(mu2 * mu2 + mv2 * mv2 + 1); norm = sqrt(mu2 * mu2 + mv2 * mv2 + 1);
mk2 = 1. / norm; mu2 *= mk2; mv2 *= mk2; mk2 = 1. / norm; mu2 *= mk2; mv2 *= mk2;
double distances[3]; double distances[3];
distances[0] = sqrt( (X1 - X2) * (X1 - X2) + (Y1 - Y2) * (Y1 - Y2) + (Z1 - Z2) * (Z1 - Z2) ); distances[0] = sqrt( (X1 - X2) * (X1 - X2) + (Y1 - Y2) * (Y1 - Y2) + (Z1 - Z2) * (Z1 - Z2) );
distances[1] = sqrt( (X0 - X2) * (X0 - X2) + (Y0 - Y2) * (Y0 - Y2) + (Z0 - Z2) * (Z0 - Z2) ); distances[1] = sqrt( (X0 - X2) * (X0 - X2) + (Y0 - Y2) * (Y0 - Y2) + (Z0 - Z2) * (Z0 - Z2) );
distances[2] = sqrt( (X0 - X1) * (X0 - X1) + (Y0 - Y1) * (Y0 - Y1) + (Z0 - Z1) * (Z0 - Z1) ); distances[2] = sqrt( (X0 - X1) * (X0 - X1) + (Y0 - Y1) * (Y0 - Y1) + (Z0 - Z1) * (Z0 - Z1) );
// Calculate angles // Calculate angles
double cosines[3]; double cosines[3];
cosines[0] = mu1 * mu2 + mv1 * mv2 + mk1 * mk2; cosines[0] = mu1 * mu2 + mv1 * mv2 + mk1 * mk2;
cosines[1] = mu0 * mu2 + mv0 * mv2 + mk0 * mk2; cosines[1] = mu0 * mu2 + mv0 * mv2 + mk0 * mk2;
cosines[2] = mu0 * mu1 + mv0 * mv1 + mk0 * mk1; cosines[2] = mu0 * mu1 + mv0 * mv1 + mk0 * mk1;
double lengths[4][3]; double lengths[4][3];
int n = solve_for_lengths(lengths, distances, cosines); int n = solve_for_lengths(lengths, distances, cosines);
int nb_solutions = 0; int nb_solutions = 0;
for(int i = 0; i < n; i++) { for(int i = 0; i < n; i++) {
double M_orig[3][3]; double M_orig[3][3];
M_orig[0][0] = lengths[i][0] * mu0; M_orig[0][0] = lengths[i][0] * mu0;
M_orig[0][1] = lengths[i][0] * mv0; M_orig[0][1] = lengths[i][0] * mv0;
M_orig[0][2] = lengths[i][0] * mk0; M_orig[0][2] = lengths[i][0] * mk0;
M_orig[1][0] = lengths[i][1] * mu1; M_orig[1][0] = lengths[i][1] * mu1;
M_orig[1][1] = lengths[i][1] * mv1; M_orig[1][1] = lengths[i][1] * mv1;
M_orig[1][2] = lengths[i][1] * mk1; M_orig[1][2] = lengths[i][1] * mk1;
M_orig[2][0] = lengths[i][2] * mu2; M_orig[2][0] = lengths[i][2] * mu2;
M_orig[2][1] = lengths[i][2] * mv2; M_orig[2][1] = lengths[i][2] * mv2;
M_orig[2][2] = lengths[i][2] * mk2; M_orig[2][2] = lengths[i][2] * mk2;
if (!align(M_orig, X0, Y0, Z0, X1, Y1, Z1, X2, Y2, Z2, R[nb_solutions], t[nb_solutions])) if (!align(M_orig, X0, Y0, Z0, X1, Y1, Z1, X2, Y2, Z2, R[nb_solutions], t[nb_solutions]))
continue; continue;
nb_solutions++; nb_solutions++;
} }
return nb_solutions; return nb_solutions;
} }
/// Given 3D distances between three points and cosines of 3 angles at the apex, calculates /// Given 3D distances between three points and cosines of 3 angles at the apex, calculates
@ -170,247 +170,247 @@ int p3p::solve(double R[4][3][3], double t[4][3],
int p3p::solve_for_lengths(double lengths[4][3], double distances[3], double cosines[3]) int p3p::solve_for_lengths(double lengths[4][3], double distances[3], double cosines[3])
{ {
double p = cosines[0] * 2; double p = cosines[0] * 2;
double q = cosines[1] * 2; double q = cosines[1] * 2;
double r = cosines[2] * 2; double r = cosines[2] * 2;
double inv_d22 = 1. / (distances[2] * distances[2]); double inv_d22 = 1. / (distances[2] * distances[2]);
double a = inv_d22 * (distances[0] * distances[0]); double a = inv_d22 * (distances[0] * distances[0]);
double b = inv_d22 * (distances[1] * distances[1]); double b = inv_d22 * (distances[1] * distances[1]);
double a2 = a * a, b2 = b * b, p2 = p * p, q2 = q * q, r2 = r * r; double a2 = a * a, b2 = b * b, p2 = p * p, q2 = q * q, r2 = r * r;
double pr = p * r, pqr = q * pr; double pr = p * r, pqr = q * pr;
// Check reality condition (the four points should not be coplanar) // Check reality condition (the four points should not be coplanar)
if (p2 + q2 + r2 - pqr - 1 == 0) if (p2 + q2 + r2 - pqr - 1 == 0)
return 0; return 0;
double ab = a * b, a_2 = 2*a; double ab = a * b, a_2 = 2*a;
double A = -2 * b + b2 + a2 + 1 + ab*(2 - r2) - a_2; double A = -2 * b + b2 + a2 + 1 + ab*(2 - r2) - a_2;
// Check reality condition // Check reality condition
if (A == 0) return 0; if (A == 0) return 0;
double a_4 = 4*a; double a_4 = 4*a;
double B = q*(-2*(ab + a2 + 1 - b) + r2*ab + a_4) + pr*(b - b2 + ab); double B = q*(-2*(ab + a2 + 1 - b) + r2*ab + a_4) + pr*(b - b2 + ab);
double C = q2 + b2*(r2 + p2 - 2) - b*(p2 + pqr) - ab*(r2 + pqr) + (a2 - a_2)*(2 + q2) + 2; double C = q2 + b2*(r2 + p2 - 2) - b*(p2 + pqr) - ab*(r2 + pqr) + (a2 - a_2)*(2 + q2) + 2;
double D = pr*(ab-b2+b) + q*((p2-2)*b + 2 * (ab - a2) + a_4 - 2); double D = pr*(ab-b2+b) + q*((p2-2)*b + 2 * (ab - a2) + a_4 - 2);
double E = 1 + 2*(b - a - ab) + b2 - b*p2 + a2; double E = 1 + 2*(b - a - ab) + b2 - b*p2 + a2;
double temp = (p2*(a-1+b) + r2*(a-1-b) + pqr - a*pqr); double temp = (p2*(a-1+b) + r2*(a-1-b) + pqr - a*pqr);
double b0 = b * temp * temp; double b0 = b * temp * temp;
// Check reality condition // Check reality condition
if (b0 == 0) if (b0 == 0)
return 0; return 0;
double real_roots[4]; double real_roots[4];
int n = solve_deg4(A, B, C, D, E, real_roots[0], real_roots[1], real_roots[2], real_roots[3]); int n = solve_deg4(A, B, C, D, E, real_roots[0], real_roots[1], real_roots[2], real_roots[3]);
if (n == 0) if (n == 0)
return 0; return 0;
int nb_solutions = 0; int nb_solutions = 0;
double r3 = r2*r, pr2 = p*r2, r3q = r3 * q; double r3 = r2*r, pr2 = p*r2, r3q = r3 * q;
double inv_b0 = 1. / b0; double inv_b0 = 1. / b0;
// For each solution of x // For each solution of x
for(int i = 0; i < n; i++) { for(int i = 0; i < n; i++) {
double x = real_roots[i]; double x = real_roots[i];
// Check reality condition // Check reality condition
if (x <= 0) if (x <= 0)
continue; continue;
double x2 = x*x; double x2 = x*x;
double b1 = double b1 =
((1-a-b)*x2 + (q*a-q)*x + 1 - a + b) * ((1-a-b)*x2 + (q*a-q)*x + 1 - a + b) *
(((r3*(a2 + ab*(2 - r2) - a_2 + b2 - 2*b + 1)) * x + (((r3*(a2 + ab*(2 - r2) - a_2 + b2 - 2*b + 1)) * x +
(r3q*(2*(b-a2) + a_4 + ab*(r2 - 2) - 2) + pr2*(1 + a2 + 2*(ab-a-b) + r2*(b - b2) + b2))) * x2 + (r3q*(2*(b-a2) + a_4 + ab*(r2 - 2) - 2) + pr2*(1 + a2 + 2*(ab-a-b) + r2*(b - b2) + b2))) * x2 +
(r3*(q2*(1-2*a+a2) + r2*(b2-ab) - a_4 + 2*(a2 - b2) + 2) + r*p2*(b2 + 2*(ab - b - a) + 1 + a2) + pr2*q*(a_4 + 2*(b - ab - a2) - 2 - r2*b)) * x + (r3*(q2*(1-2*a+a2) + r2*(b2-ab) - a_4 + 2*(a2 - b2) + 2) + r*p2*(b2 + 2*(ab - b - a) + 1 + a2) + pr2*q*(a_4 + 2*(b - ab - a2) - 2 - r2*b)) * x +
2*r3q*(a_2 - b - a2 + ab - 1) + pr2*(q2 - a_4 + 2*(a2 - b2) + r2*b + q2*(a2 - a_2) + 2) + 2*r3q*(a_2 - b - a2 + ab - 1) + pr2*(q2 - a_4 + 2*(a2 - b2) + r2*b + q2*(a2 - a_2) + 2) +
p2*(p*(2*(ab - a - b) + a2 + b2 + 1) + 2*q*r*(b + a_2 - a2 - ab - 1))); p2*(p*(2*(ab - a - b) + a2 + b2 + 1) + 2*q*r*(b + a_2 - a2 - ab - 1)));
// Check reality condition // Check reality condition
if (b1 <= 0) if (b1 <= 0)
continue; continue;
double y = inv_b0 * b1; double y = inv_b0 * b1;
double v = x2 + y*y - x*y*r; double v = x2 + y*y - x*y*r;
if (v <= 0) if (v <= 0)
continue; continue;
double Z = distances[2] / sqrt(v); double Z = distances[2] / sqrt(v);
double X = x * Z; double X = x * Z;
double Y = y * Z; double Y = y * Z;
lengths[nb_solutions][0] = X; lengths[nb_solutions][0] = X;
lengths[nb_solutions][1] = Y; lengths[nb_solutions][1] = Y;
lengths[nb_solutions][2] = Z; lengths[nb_solutions][2] = Z;
nb_solutions++; nb_solutions++;
} }
return nb_solutions; return nb_solutions;
} }
bool p3p::align(double M_end[3][3], bool p3p::align(double M_end[3][3],
double X0, double Y0, double Z0, double X0, double Y0, double Z0,
double X1, double Y1, double Z1, double X1, double Y1, double Z1,
double X2, double Y2, double Z2, double X2, double Y2, double Z2,
double R[3][3], double T[3]) double R[3][3], double T[3])
{ {
// Centroids: // Centroids:
double C_start[3], C_end[3]; double C_start[3], C_end[3];
for(int i = 0; i < 3; i++) C_end[i] = (M_end[0][i] + M_end[1][i] + M_end[2][i]) / 3; for(int i = 0; i < 3; i++) C_end[i] = (M_end[0][i] + M_end[1][i] + M_end[2][i]) / 3;
C_start[0] = (X0 + X1 + X2) / 3; C_start[0] = (X0 + X1 + X2) / 3;
C_start[1] = (Y0 + Y1 + Y2) / 3; C_start[1] = (Y0 + Y1 + Y2) / 3;
C_start[2] = (Z0 + Z1 + Z2) / 3; C_start[2] = (Z0 + Z1 + Z2) / 3;
// Covariance matrix s: // Covariance matrix s:
double s[3 * 3]; double s[3 * 3];
for(int j = 0; j < 3; j++) { for(int j = 0; j < 3; j++) {
s[0 * 3 + j] = (X0 * M_end[0][j] + X1 * M_end[1][j] + X2 * M_end[2][j]) / 3 - C_end[j] * C_start[0]; s[0 * 3 + j] = (X0 * M_end[0][j] + X1 * M_end[1][j] + X2 * M_end[2][j]) / 3 - C_end[j] * C_start[0];
s[1 * 3 + j] = (Y0 * M_end[0][j] + Y1 * M_end[1][j] + Y2 * M_end[2][j]) / 3 - C_end[j] * C_start[1]; s[1 * 3 + j] = (Y0 * M_end[0][j] + Y1 * M_end[1][j] + Y2 * M_end[2][j]) / 3 - C_end[j] * C_start[1];
s[2 * 3 + j] = (Z0 * M_end[0][j] + Z1 * M_end[1][j] + Z2 * M_end[2][j]) / 3 - C_end[j] * C_start[2]; s[2 * 3 + j] = (Z0 * M_end[0][j] + Z1 * M_end[1][j] + Z2 * M_end[2][j]) / 3 - C_end[j] * C_start[2];
} }
double Qs[16], evs[4], U[16]; double Qs[16], evs[4], U[16];
Qs[0 * 4 + 0] = s[0 * 3 + 0] + s[1 * 3 + 1] + s[2 * 3 + 2]; Qs[0 * 4 + 0] = s[0 * 3 + 0] + s[1 * 3 + 1] + s[2 * 3 + 2];
Qs[1 * 4 + 1] = s[0 * 3 + 0] - s[1 * 3 + 1] - s[2 * 3 + 2]; Qs[1 * 4 + 1] = s[0 * 3 + 0] - s[1 * 3 + 1] - s[2 * 3 + 2];
Qs[2 * 4 + 2] = s[1 * 3 + 1] - s[2 * 3 + 2] - s[0 * 3 + 0]; Qs[2 * 4 + 2] = s[1 * 3 + 1] - s[2 * 3 + 2] - s[0 * 3 + 0];
Qs[3 * 4 + 3] = s[2 * 3 + 2] - s[0 * 3 + 0] - s[1 * 3 + 1]; Qs[3 * 4 + 3] = s[2 * 3 + 2] - s[0 * 3 + 0] - s[1 * 3 + 1];
Qs[1 * 4 + 0] = Qs[0 * 4 + 1] = s[1 * 3 + 2] - s[2 * 3 + 1]; Qs[1 * 4 + 0] = Qs[0 * 4 + 1] = s[1 * 3 + 2] - s[2 * 3 + 1];
Qs[2 * 4 + 0] = Qs[0 * 4 + 2] = s[2 * 3 + 0] - s[0 * 3 + 2]; Qs[2 * 4 + 0] = Qs[0 * 4 + 2] = s[2 * 3 + 0] - s[0 * 3 + 2];
Qs[3 * 4 + 0] = Qs[0 * 4 + 3] = s[0 * 3 + 1] - s[1 * 3 + 0]; Qs[3 * 4 + 0] = Qs[0 * 4 + 3] = s[0 * 3 + 1] - s[1 * 3 + 0];
Qs[2 * 4 + 1] = Qs[1 * 4 + 2] = s[1 * 3 + 0] + s[0 * 3 + 1]; Qs[2 * 4 + 1] = Qs[1 * 4 + 2] = s[1 * 3 + 0] + s[0 * 3 + 1];
Qs[3 * 4 + 1] = Qs[1 * 4 + 3] = s[2 * 3 + 0] + s[0 * 3 + 2]; Qs[3 * 4 + 1] = Qs[1 * 4 + 3] = s[2 * 3 + 0] + s[0 * 3 + 2];
Qs[3 * 4 + 2] = Qs[2 * 4 + 3] = s[2 * 3 + 1] + s[1 * 3 + 2]; Qs[3 * 4 + 2] = Qs[2 * 4 + 3] = s[2 * 3 + 1] + s[1 * 3 + 2];
jacobi_4x4(Qs, evs, U); jacobi_4x4(Qs, evs, U);
// Looking for the largest eigen value: // Looking for the largest eigen value:
int i_ev = 0; int i_ev = 0;
double ev_max = evs[i_ev]; double ev_max = evs[i_ev];
for(int i = 1; i < 4; i++) for(int i = 1; i < 4; i++)
if (evs[i] > ev_max) if (evs[i] > ev_max)
ev_max = evs[i_ev = i]; ev_max = evs[i_ev = i];
// Quaternion: // Quaternion:
double q[4]; double q[4];
for(int i = 0; i < 4; i++) for(int i = 0; i < 4; i++)
q[i] = U[i * 4 + i_ev]; q[i] = U[i * 4 + i_ev];
double q02 = q[0] * q[0], q12 = q[1] * q[1], q22 = q[2] * q[2], q32 = q[3] * q[3]; double q02 = q[0] * q[0], q12 = q[1] * q[1], q22 = q[2] * q[2], q32 = q[3] * q[3];
double q0_1 = q[0] * q[1], q0_2 = q[0] * q[2], q0_3 = q[0] * q[3]; double q0_1 = q[0] * q[1], q0_2 = q[0] * q[2], q0_3 = q[0] * q[3];
double q1_2 = q[1] * q[2], q1_3 = q[1] * q[3]; double q1_2 = q[1] * q[2], q1_3 = q[1] * q[3];
double q2_3 = q[2] * q[3]; double q2_3 = q[2] * q[3];
R[0][0] = q02 + q12 - q22 - q32; R[0][0] = q02 + q12 - q22 - q32;
R[0][1] = 2. * (q1_2 - q0_3); R[0][1] = 2. * (q1_2 - q0_3);
R[0][2] = 2. * (q1_3 + q0_2); R[0][2] = 2. * (q1_3 + q0_2);
R[1][0] = 2. * (q1_2 + q0_3); R[1][0] = 2. * (q1_2 + q0_3);
R[1][1] = q02 + q22 - q12 - q32; R[1][1] = q02 + q22 - q12 - q32;
R[1][2] = 2. * (q2_3 - q0_1); R[1][2] = 2. * (q2_3 - q0_1);
R[2][0] = 2. * (q1_3 - q0_2); R[2][0] = 2. * (q1_3 - q0_2);
R[2][1] = 2. * (q2_3 + q0_1); R[2][1] = 2. * (q2_3 + q0_1);
R[2][2] = q02 + q32 - q12 - q22; R[2][2] = q02 + q32 - q12 - q22;
for(int i = 0; i < 3; i++) for(int i = 0; i < 3; i++)
T[i] = C_end[i] - (R[i][0] * C_start[0] + R[i][1] * C_start[1] + R[i][2] * C_start[2]); T[i] = C_end[i] - (R[i][0] * C_start[0] + R[i][1] * C_start[1] + R[i][2] * C_start[2]);
return true; return true;
} }
bool p3p::jacobi_4x4(double * A, double * D, double * U) bool p3p::jacobi_4x4(double * A, double * D, double * U)
{ {
double B[4], Z[4]; double B[4], Z[4];
double Id[16] = {1., 0., 0., 0., double Id[16] = {1., 0., 0., 0.,
0., 1., 0., 0., 0., 1., 0., 0.,
0., 0., 1., 0., 0., 0., 1., 0.,
0., 0., 0., 1.}; 0., 0., 0., 1.};
memcpy(U, Id, 16 * sizeof(double)); memcpy(U, Id, 16 * sizeof(double));
B[0] = A[0]; B[1] = A[5]; B[2] = A[10]; B[3] = A[15]; B[0] = A[0]; B[1] = A[5]; B[2] = A[10]; B[3] = A[15];
memcpy(D, B, 4 * sizeof(double)); memcpy(D, B, 4 * sizeof(double));
memset(Z, 0, 4 * sizeof(double)); memset(Z, 0, 4 * sizeof(double));
for(int iter = 0; iter < 50; iter++) { for(int iter = 0; iter < 50; iter++) {
double sum = fabs(A[1]) + fabs(A[2]) + fabs(A[3]) + fabs(A[6]) + fabs(A[7]) + fabs(A[11]); double sum = fabs(A[1]) + fabs(A[2]) + fabs(A[3]) + fabs(A[6]) + fabs(A[7]) + fabs(A[11]);
if (sum == 0.0) if (sum == 0.0)
return true; return true;
double tresh = (iter < 3) ? 0.2 * sum / 16. : 0.0; double tresh = (iter < 3) ? 0.2 * sum / 16. : 0.0;
for(int i = 0; i < 3; i++) { for(int i = 0; i < 3; i++) {
double * pAij = A + 5 * i + 1; double * pAij = A + 5 * i + 1;
for(int j = i + 1 ; j < 4; j++) { for(int j = i + 1 ; j < 4; j++) {
double Aij = *pAij; double Aij = *pAij;
double eps_machine = 100.0 * fabs(Aij); double eps_machine = 100.0 * fabs(Aij);
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);
double s = t * c; double s = t * c;
double tau = s / (1.0 + c); double tau = s / (1.0 + c);
for(int k = 0; k <= i - 1; k++) { for(int k = 0; k <= i - 1; k++) {
double g = A[k * 4 + i], h = A[k * 4 + j]; double g = A[k * 4 + i], h = A[k * 4 + j];
A[k * 4 + i] = g - s * (h + g * tau); A[k * 4 + i] = g - s * (h + g * tau);
A[k * 4 + j] = h + s * (g - h * tau); A[k * 4 + j] = h + s * (g - h * tau);
} }
for(int k = i + 1; k <= j - 1; k++) { for(int k = i + 1; k <= j - 1; k++) {
double g = A[i * 4 + k], h = A[k * 4 + j]; double g = A[i * 4 + k], h = A[k * 4 + j];
A[i * 4 + k] = g - s * (h + g * tau); A[i * 4 + k] = g - s * (h + g * tau);
A[k * 4 + j] = h + s * (g - h * tau); A[k * 4 + j] = h + s * (g - h * tau);
} }
for(int k = j + 1; k < 4; k++) { for(int k = j + 1; k < 4; k++) {
double g = A[i * 4 + k], h = A[j * 4 + k]; double g = A[i * 4 + k], h = A[j * 4 + k];
A[i * 4 + k] = g - s * (h + g * tau); A[i * 4 + k] = g - s * (h + g * tau);
A[j * 4 + k] = h + s * (g - h * tau); A[j * 4 + k] = h + s * (g - h * tau);
} }
for(int k = 0; k < 4; k++) { for(int k = 0; k < 4; k++) {
double g = U[k * 4 + i], h = U[k * 4 + j]; double g = U[k * 4 + i], h = U[k * 4 + j];
U[k * 4 + i] = g - s * (h + g * tau); U[k * 4 + i] = g - s * (h + g * tau);
U[k * 4 + j] = h + s * (g - h * tau); U[k * 4 + j] = h + s * (g - h * tau);
} }
} }
pAij++; pAij++;
} }
} }
for(int i = 0; i < 4; i++) B[i] += Z[i]; for(int i = 0; i < 4; i++) B[i] += Z[i];
memcpy(D, B, 4 * sizeof(double)); memcpy(D, B, 4 * sizeof(double));
memset(Z, 0, 4 * sizeof(double)); memset(Z, 0, 4 * sizeof(double));
} }
return false; return false;
} }

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);

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

@ -155,7 +155,7 @@ static void prefilterNorm( const Mat& src, Mat& dst, int winsize, int ftzero, uc
val = ((curr[x]*4 + curr[x-1] + curr[x+1] + prev[x] + next[x])*scale_g - sum*scale_s) >> 10; val = ((curr[x]*4 + curr[x-1] + curr[x+1] + prev[x] + next[x])*scale_g - sum*scale_s) >> 10;
dptr[x] = tab[val + OFS]; dptr[x] = tab[val + OFS];
} }
sum += vsum[x+wsz2] - vsum[x-wsz2-1]; sum += vsum[x+wsz2] - vsum[x-wsz2-1];
val = ((curr[x]*5 + curr[x-1] + prev[x] + next[x])*scale_g - sum*scale_s) >> 10; val = ((curr[x]*5 + curr[x-1] + prev[x] + next[x])*scale_g - sum*scale_s) >> 10;
dptr[x] = tab[val + OFS]; dptr[x] = tab[val + OFS];
@ -170,15 +170,15 @@ prefilterXSobel( const Mat& src, Mat& dst, int ftzero )
const int OFS = 256*4, TABSZ = OFS*2 + 256; const int OFS = 256*4, TABSZ = OFS*2 + 256;
uchar tab[TABSZ]; uchar tab[TABSZ];
Size size = src.size(); Size size = src.size();
for( x = 0; x < TABSZ; x++ ) for( x = 0; x < TABSZ; x++ )
tab[x] = (uchar)(x - OFS < -ftzero ? 0 : x - OFS > ftzero ? ftzero*2 : x - OFS + ftzero); tab[x] = (uchar)(x - OFS < -ftzero ? 0 : x - OFS > ftzero ? ftzero*2 : x - OFS + ftzero);
uchar val0 = tab[0 + OFS]; uchar val0 = tab[0 + OFS];
#if CV_SSE2 #if CV_SSE2
volatile bool useSIMD = checkHardwareSupport(CV_CPU_SSE2); volatile bool useSIMD = checkHardwareSupport(CV_CPU_SSE2);
#endif #endif
for( y = 0; y < size.height-1; y += 2 ) for( y = 0; y < size.height-1; y += 2 )
{ {
const uchar* srow1 = src.ptr<uchar>(y); const uchar* srow1 = src.ptr<uchar>(y);
@ -187,10 +187,10 @@ prefilterXSobel( const Mat& src, Mat& dst, int ftzero )
const uchar* srow3 = y < size.height-2 ? srow1 + src.step*2 : srow1; const uchar* srow3 = y < size.height-2 ? srow1 + src.step*2 : srow1;
uchar* dptr0 = dst.ptr<uchar>(y); uchar* dptr0 = dst.ptr<uchar>(y);
uchar* dptr1 = dptr0 + dst.step; uchar* dptr1 = dptr0 + dst.step;
dptr0[0] = dptr0[size.width-1] = dptr1[0] = dptr1[size.width-1] = val0; dptr0[0] = dptr0[size.width-1] = dptr1[0] = dptr1[size.width-1] = val0;
x = 1; x = 1;
#if CV_SSE2 #if CV_SSE2
if( useSIMD ) if( useSIMD )
{ {
@ -205,26 +205,26 @@ prefilterXSobel( const Mat& src, Mat& dst, int ftzero )
d0 = _mm_sub_epi16(d0, c0); d0 = _mm_sub_epi16(d0, c0);
d1 = _mm_sub_epi16(d1, c1); d1 = _mm_sub_epi16(d1, c1);
__m128i c2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i*)(srow2 + x - 1)), z); __m128i c2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i*)(srow2 + x - 1)), z);
__m128i c3 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i*)(srow2 + x - 1)), z); __m128i c3 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i*)(srow2 + x - 1)), z);
__m128i d2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i*)(srow2 + x + 1)), z); __m128i d2 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i*)(srow2 + x + 1)), z);
__m128i d3 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i*)(srow2 + x + 1)), z); __m128i d3 = _mm_unpacklo_epi8(_mm_loadl_epi64((__m128i*)(srow2 + x + 1)), z);
d2 = _mm_sub_epi16(d2, c2); d2 = _mm_sub_epi16(d2, c2);
d3 = _mm_sub_epi16(d3, c3); d3 = _mm_sub_epi16(d3, c3);
__m128i v0 = _mm_add_epi16(d0, _mm_add_epi16(d2, _mm_add_epi16(d1, d1))); __m128i v0 = _mm_add_epi16(d0, _mm_add_epi16(d2, _mm_add_epi16(d1, d1)));
__m128i v1 = _mm_add_epi16(d1, _mm_add_epi16(d3, _mm_add_epi16(d2, d2))); __m128i v1 = _mm_add_epi16(d1, _mm_add_epi16(d3, _mm_add_epi16(d2, d2)));
v0 = _mm_packus_epi16(_mm_add_epi16(v0, ftz), _mm_add_epi16(v1, ftz)); v0 = _mm_packus_epi16(_mm_add_epi16(v0, ftz), _mm_add_epi16(v1, ftz));
v0 = _mm_min_epu8(v0, ftz2); v0 = _mm_min_epu8(v0, ftz2);
_mm_storel_epi64((__m128i*)(dptr0 + x), v0); _mm_storel_epi64((__m128i*)(dptr0 + x), v0);
_mm_storel_epi64((__m128i*)(dptr1 + x), _mm_unpackhi_epi64(v0, v0)); _mm_storel_epi64((__m128i*)(dptr1 + x), _mm_unpackhi_epi64(v0, v0));
} }
} }
#endif #endif
for( ; x < size.width-1; x++ ) for( ; x < size.width-1; x++ )
{ {
int d0 = srow0[x+1] - srow0[x-1], d1 = srow1[x+1] - srow1[x-1], int d0 = srow0[x+1] - srow0[x-1], d1 = srow1[x+1] - srow1[x-1],
@ -235,7 +235,7 @@ prefilterXSobel( const Mat& src, Mat& dst, int ftzero )
dptr1[x] = (uchar)v1; dptr1[x] = (uchar)v1;
} }
} }
for( ; y < size.height; y++ ) for( ; y < size.height; y++ )
{ {
uchar* dptr = dst.ptr<uchar>(y); uchar* dptr = dst.ptr<uchar>(y);
@ -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;
@ -374,7 +374,7 @@ static void findStereoCorrespondenceBM_SSE2( const Mat& left, const Mat& right,
// initialize sums // initialize sums
for( d = 0; d < ndisp; d++ ) for( d = 0; d < ndisp; d++ )
sad[d] = (ushort)(hsad0[d-ndisp*dy0]*(wsz2 + 2 - dy0)); sad[d] = (ushort)(hsad0[d-ndisp*dy0]*(wsz2 + 2 - dy0));
hsad = hsad0 + (1 - dy0)*ndisp; hsad = hsad0 + (1 - dy0)*ndisp;
for( y = 1 - dy0; y < wsz2; y++, hsad += ndisp ) for( y = 1 - dy0; y < wsz2; y++, hsad += ndisp )
for( d = 0; d < ndisp; d += 16 ) for( d = 0; d < ndisp; d += 16 )
@ -405,28 +405,28 @@ static void findStereoCorrespondenceBM_SSE2( const Mat& left, const Mat& right,
{ {
__m128i u0 = _mm_load_si128((__m128i*)(hsad_sub + d)); __m128i u0 = _mm_load_si128((__m128i*)(hsad_sub + d));
__m128i u1 = _mm_load_si128((__m128i*)(hsad + d)); __m128i u1 = _mm_load_si128((__m128i*)(hsad + d));
__m128i v0 = _mm_load_si128((__m128i*)(hsad_sub + d + 8)); __m128i v0 = _mm_load_si128((__m128i*)(hsad_sub + d + 8));
__m128i v1 = _mm_load_si128((__m128i*)(hsad + d + 8)); __m128i v1 = _mm_load_si128((__m128i*)(hsad + d + 8));
__m128i usad8 = _mm_load_si128((__m128i*)(sad + d)); __m128i usad8 = _mm_load_si128((__m128i*)(sad + d));
__m128i vsad8 = _mm_load_si128((__m128i*)(sad + d + 8)); __m128i vsad8 = _mm_load_si128((__m128i*)(sad + d + 8));
u1 = _mm_sub_epi16(u1, u0); u1 = _mm_sub_epi16(u1, u0);
v1 = _mm_sub_epi16(v1, v0); v1 = _mm_sub_epi16(v1, v0);
usad8 = _mm_add_epi16(usad8, u1); usad8 = _mm_add_epi16(usad8, u1);
vsad8 = _mm_add_epi16(vsad8, v1); vsad8 = _mm_add_epi16(vsad8, v1);
mask = _mm_cmpgt_epi16(minsad8, usad8); mask = _mm_cmpgt_epi16(minsad8, usad8);
minsad8 = _mm_min_epi16(minsad8, usad8); minsad8 = _mm_min_epi16(minsad8, usad8);
mind8 = _mm_max_epi16(mind8, _mm_and_si128(mask, d8)); mind8 = _mm_max_epi16(mind8, _mm_and_si128(mask, d8));
_mm_store_si128((__m128i*)(sad + d), usad8); _mm_store_si128((__m128i*)(sad + d), usad8);
_mm_store_si128((__m128i*)(sad + d + 8), vsad8); _mm_store_si128((__m128i*)(sad + d + 8), vsad8);
mask = _mm_cmpgt_epi16(minsad8, vsad8); mask = _mm_cmpgt_epi16(minsad8, vsad8);
minsad8 = _mm_min_epi16(minsad8, vsad8); minsad8 = _mm_min_epi16(minsad8, vsad8);
d8 = _mm_add_epi16(d8, dd_8); d8 = _mm_add_epi16(d8, dd_8);
mind8 = _mm_max_epi16(mind8, _mm_and_si128(mask, d8)); mind8 = _mm_max_epi16(mind8, _mm_and_si128(mask, d8));
d8 = _mm_add_epi16(d8, dd_8); d8 = _mm_add_epi16(d8, dd_8);
@ -438,32 +438,33 @@ static void findStereoCorrespondenceBM_SSE2( const Mat& left, const Mat& right,
dptr[y*dstep] = FILTERED; dptr[y*dstep] = FILTERED;
continue; continue;
} }
__m128i minsad82 = _mm_unpackhi_epi64(minsad8, minsad8); __m128i minsad82 = _mm_unpackhi_epi64(minsad8, minsad8);
__m128i mind82 = _mm_unpackhi_epi64(mind8, mind8); __m128i mind82 = _mm_unpackhi_epi64(mind8, mind8);
mask = _mm_cmpgt_epi16(minsad8, minsad82); mask = _mm_cmpgt_epi16(minsad8, minsad82);
mind8 = _mm_xor_si128(mind8,_mm_and_si128(_mm_xor_si128(mind82,mind8),mask)); mind8 = _mm_xor_si128(mind8,_mm_and_si128(_mm_xor_si128(mind82,mind8),mask));
minsad8 = _mm_min_epi16(minsad8, minsad82); minsad8 = _mm_min_epi16(minsad8, minsad82);
minsad82 = _mm_shufflelo_epi16(minsad8, _MM_SHUFFLE(3,2,3,2)); minsad82 = _mm_shufflelo_epi16(minsad8, _MM_SHUFFLE(3,2,3,2));
mind82 = _mm_shufflelo_epi16(mind8, _MM_SHUFFLE(3,2,3,2)); mind82 = _mm_shufflelo_epi16(mind8, _MM_SHUFFLE(3,2,3,2));
mask = _mm_cmpgt_epi16(minsad8, minsad82); mask = _mm_cmpgt_epi16(minsad8, minsad82);
mind8 = _mm_xor_si128(mind8,_mm_and_si128(_mm_xor_si128(mind82,mind8),mask)); mind8 = _mm_xor_si128(mind8,_mm_and_si128(_mm_xor_si128(mind82,mind8),mask));
minsad8 = _mm_min_epi16(minsad8, minsad82); minsad8 = _mm_min_epi16(minsad8, minsad82);
minsad82 = _mm_shufflelo_epi16(minsad8, 1); minsad82 = _mm_shufflelo_epi16(minsad8, 1);
mind82 = _mm_shufflelo_epi16(mind8, 1); mind82 = _mm_shufflelo_epi16(mind8, 1);
mask = _mm_cmpgt_epi16(minsad8, minsad82); mask = _mm_cmpgt_epi16(minsad8, minsad82);
mind8 = _mm_xor_si128(mind8,_mm_and_si128(_mm_xor_si128(mind82,mind8),mask)); mind8 = _mm_xor_si128(mind8,_mm_and_si128(_mm_xor_si128(mind82,mind8),mask));
mind = (short)_mm_cvtsi128_si32(mind8); mind = (short)_mm_cvtsi128_si32(mind8);
minsad = sad[mind]; minsad = sad[mind];
if( uniquenessRatio > 0 ) if( uniquenessRatio > 0 )
{ {
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
@ -567,7 +569,7 @@ findStereoCorrespondenceBM( const Mat& left, const Mat& right,
htext[y] += tab[lval]; htext[y] += tab[lval];
} }
} }
// initialize the left and right borders of the disparity map // initialize the left and right borders of the disparity map
for( y = 0; y < height; y++ ) for( y = 0; y < height; y++ )
{ {
@ -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;
@ -611,7 +613,7 @@ findStereoCorrespondenceBM( const Mat& left, const Mat& right,
// initialize sums // initialize sums
for( d = 0; d < ndisp; d++ ) for( d = 0; d < ndisp; d++ )
sad[d] = (int)(hsad0[d-ndisp*dy0]*(wsz2 + 2 - dy0)); sad[d] = (int)(hsad0[d-ndisp*dy0]*(wsz2 + 2 - dy0));
hsad = hsad0 + (1 - dy0)*ndisp; hsad = hsad0 + (1 - dy0)*ndisp;
for( y = 1 - dy0; y < wsz2; y++, hsad += ndisp ) for( y = 1 - dy0; y < wsz2; y++, hsad += ndisp )
for( d = 0; d < ndisp; d++ ) for( d = 0; d < ndisp; d++ )
@ -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];
} }
@ -681,16 +684,16 @@ struct PrefilterInvoker
state = _state; state = _state;
} }
void operator()( int ind ) const void operator()( int ind ) const
{ {
if( state->preFilterType == CV_STEREO_BM_NORMALIZED_RESPONSE ) if( state->preFilterType == CV_STEREO_BM_NORMALIZED_RESPONSE )
prefilterNorm( *imgs0[ind], *imgs[ind], state->preFilterSize, state->preFilterCap, buf[ind] ); prefilterNorm( *imgs0[ind], *imgs[ind], state->preFilterSize, state->preFilterCap, buf[ind] );
else else
prefilterXSobel( *imgs0[ind], *imgs[ind], state->preFilterCap ); prefilterXSobel( *imgs0[ind], *imgs[ind], state->preFilterCap );
} }
const Mat* imgs0[2]; const Mat* imgs0[2];
Mat* imgs[2]; Mat* imgs[2];
uchar* buf[2]; uchar* buf[2];
CvStereoBMState *state; CvStereoBMState *state;
}; };
@ -709,21 +712,21 @@ struct FindStereoCorrespInvoker
useShorts = _useShorts; useShorts = _useShorts;
validDisparityRect = _validDisparityRect; validDisparityRect = _validDisparityRect;
} }
void operator()( const BlockedRange& range ) const void operator()( const BlockedRange& range ) const
{ {
int cols = left->cols, rows = left->rows; int cols = left->cols, rows = left->rows;
int _row0 = min(cvRound(range.begin() * rows / nstripes), rows); int _row0 = min(cvRound(range.begin() * rows / nstripes), rows);
int _row1 = min(cvRound(range.end() * rows / nstripes), rows); int _row1 = min(cvRound(range.end() * rows / nstripes), rows);
uchar *ptr = state->slidingSumBuf->data.ptr + range.begin() * stripeBufSize; uchar *ptr = state->slidingSumBuf->data.ptr + range.begin() * stripeBufSize;
int FILTERED = (state->minDisparity - 1)*16; int FILTERED = (state->minDisparity - 1)*16;
Rect roi = validDisparityRect & Rect(0, _row0, cols, _row1 - _row0); Rect roi = validDisparityRect & Rect(0, _row0, cols, _row1 - _row0);
if( roi.height == 0 ) if( roi.height == 0 )
return; return;
int row0 = roi.y; int row0 = roi.y;
int row1 = roi.y + roi.height; int row1 = roi.y + roi.height;
Mat part; Mat part;
if( row0 > _row0 ) if( row0 > _row0 )
{ {
@ -735,22 +738,22 @@ struct FindStereoCorrespInvoker
part = disp->rowRange(row1, _row1); part = disp->rowRange(row1, _row1);
part = Scalar::all(FILTERED); part = Scalar::all(FILTERED);
} }
Mat left_i = left->rowRange(row0, row1); Mat left_i = left->rowRange(row0, row1);
Mat right_i = right->rowRange(row0, row1); Mat right_i = right->rowRange(row0, row1);
Mat disp_i = disp->rowRange(row0, row1); Mat disp_i = disp->rowRange(row0, row1);
Mat cost_i = state->disp12MaxDiff >= 0 ? Mat(state->cost).rowRange(row0, row1) : Mat(); Mat cost_i = state->disp12MaxDiff >= 0 ? Mat(state->cost).rowRange(row0, row1) : Mat();
#if CV_SSE2 #if CV_SSE2
if( useShorts ) if( useShorts )
findStereoCorrespondenceBM_SSE2( left_i, right_i, disp_i, cost_i, *state, ptr, row0, rows - row1 ); findStereoCorrespondenceBM_SSE2( left_i, right_i, disp_i, cost_i, *state, ptr, row0, rows - row1 );
else else
#endif #endif
findStereoCorrespondenceBM( left_i, right_i, disp_i, cost_i, *state, ptr, row0, rows - row1 ); findStereoCorrespondenceBM( left_i, right_i, disp_i, cost_i, *state, ptr, row0, rows - row1 );
if( state->disp12MaxDiff >= 0 ) if( state->disp12MaxDiff >= 0 )
validateDisparity( disp_i, cost_i, state->minDisparity, state->numberOfDisparities, state->disp12MaxDiff ); validateDisparity( disp_i, cost_i, state->minDisparity, state->numberOfDisparities, state->disp12MaxDiff );
if( roi.x > 0 ) if( roi.x > 0 )
{ {
part = disp_i.colRange(0, roi.x); part = disp_i.colRange(0, roi.x);
@ -767,7 +770,7 @@ protected:
const Mat *left, *right; const Mat *left, *right;
Mat* disp; Mat* disp;
CvStereoBMState *state; CvStereoBMState *state;
int nstripes; int nstripes;
int stripeBufSize; int stripeBufSize;
bool useShorts; bool useShorts;
@ -775,7 +778,7 @@ protected:
}; };
static void findStereoCorrespondenceBM( const Mat& left0, const Mat& right0, Mat& disp0, CvStereoBMState* state) static void findStereoCorrespondenceBM( const Mat& left0, const Mat& right0, Mat& disp0, CvStereoBMState* state)
{ {
if (left0.size() != right0.size() || disp0.size() != left0.size()) if (left0.size() != right0.size() || disp0.size() != left0.size())
CV_Error( CV_StsUnmatchedSizes, "All the images must have the same size" ); CV_Error( CV_StsUnmatchedSizes, "All the images must have the same size" );
@ -783,7 +786,7 @@ static void findStereoCorrespondenceBM( const Mat& left0, const Mat& right0, Mat
CV_Error( CV_StsUnsupportedFormat, "Both input images must have CV_8UC1" ); CV_Error( CV_StsUnsupportedFormat, "Both input images must have CV_8UC1" );
if (disp0.type() != CV_16SC1 && disp0.type() != CV_32FC1) if (disp0.type() != CV_16SC1 && disp0.type() != CV_32FC1)
CV_Error( CV_StsUnsupportedFormat, "Disparity image must have CV_16SC1 or CV_32FC1 format" ); CV_Error( CV_StsUnsupportedFormat, "Disparity image must have CV_16SC1 or CV_32FC1 format" );
if( !state ) if( !state )
CV_Error( CV_StsNullPtr, "Stereo BM state is NULL." ); CV_Error( CV_StsNullPtr, "Stereo BM state is NULL." );
@ -809,7 +812,7 @@ static void findStereoCorrespondenceBM( const Mat& left0, const Mat& right0, Mat
if( state->uniquenessRatio < 0 ) if( state->uniquenessRatio < 0 )
CV_Error( CV_StsOutOfRange, "uniqueness ratio must be non-negative" ); CV_Error( CV_StsOutOfRange, "uniqueness ratio must be non-negative" );
if( !state->preFilteredImg0 || state->preFilteredImg0->cols * state->preFilteredImg0->rows < left0.cols * left0.rows ) if( !state->preFilteredImg0 || state->preFilteredImg0->cols * state->preFilteredImg0->rows < left0.cols * left0.rows )
{ {
cvReleaseMat( &state->preFilteredImg0 ); cvReleaseMat( &state->preFilteredImg0 );
@ -822,7 +825,7 @@ static void findStereoCorrespondenceBM( const Mat& left0, const Mat& right0, Mat
} }
Mat left(left0.size(), CV_8U, state->preFilteredImg0->data.ptr); Mat left(left0.size(), CV_8U, state->preFilteredImg0->data.ptr);
Mat right(right0.size(), CV_8U, state->preFilteredImg1->data.ptr); Mat right(right0.size(), CV_8U, state->preFilteredImg1->data.ptr);
int mindisp = state->minDisparity; int mindisp = state->minDisparity;
int ndisp = state->numberOfDisparities; int ndisp = state->numberOfDisparities;
@ -832,15 +835,15 @@ static void findStereoCorrespondenceBM( const Mat& left0, const Mat& right0, Mat
int rofs = -min(ndisp - 1 + mindisp, 0); int rofs = -min(ndisp - 1 + mindisp, 0);
int width1 = width - rofs - ndisp + 1; int width1 = width - rofs - ndisp + 1;
int FILTERED = (state->minDisparity - 1) << DISPARITY_SHIFT; int FILTERED = (state->minDisparity - 1) << DISPARITY_SHIFT;
if( lofs >= width || rofs >= width || width1 < 1 ) if( lofs >= width || rofs >= width || width1 < 1 )
{ {
disp0 = Scalar::all( FILTERED * ( disp0.type() < CV_32F ? 1 : 1./(1 << DISPARITY_SHIFT) ) ); disp0 = Scalar::all( FILTERED * ( disp0.type() < CV_32F ? 1 : 1./(1 << DISPARITY_SHIFT) ) );
return; return;
} }
Mat disp = disp0; Mat disp = disp0;
if( disp0.type() == CV_32F) if( disp0.type() == CV_32F)
{ {
if( !state->disp || state->disp->rows != disp0.rows || state->disp->cols != disp0.cols ) if( !state->disp || state->disp->rows != disp0.rows || state->disp->cols != disp0.cols )
@ -850,8 +853,8 @@ static void findStereoCorrespondenceBM( const Mat& left0, const Mat& right0, Mat
} }
disp = cv::cvarrToMat(state->disp); disp = cv::cvarrToMat(state->disp);
} }
int wsz = state->SADWindowSize; int wsz = state->SADWindowSize;
int bufSize0 = (int)((ndisp + 2)*sizeof(int)); int bufSize0 = (int)((ndisp + 2)*sizeof(int));
bufSize0 += (int)((height+wsz+2)*ndisp*sizeof(int)); bufSize0 += (int)((height+wsz+2)*ndisp*sizeof(int));
bufSize0 += (int)((height + wsz + 2)*sizeof(int)); bufSize0 += (int)((height + wsz + 2)*sizeof(int));
@ -861,16 +864,16 @@ static void findStereoCorrespondenceBM( const Mat& left0, const Mat& right0, Mat
int bufSize2 = 0; int bufSize2 = 0;
if( state->speckleRange >= 0 && state->speckleWindowSize > 0 ) if( state->speckleRange >= 0 && state->speckleWindowSize > 0 )
bufSize2 = width*height*(sizeof(cv::Point_<short>) + sizeof(int) + sizeof(uchar)); bufSize2 = width*height*(sizeof(cv::Point_<short>) + sizeof(int) + sizeof(uchar));
#if CV_SSE2 #if CV_SSE2
bool useShorts = state->preFilterCap <= 31 && state->SADWindowSize <= 21 && checkHardwareSupport(CV_CPU_SSE2); bool useShorts = state->preFilterCap <= 31 && state->SADWindowSize <= 21 && checkHardwareSupport(CV_CPU_SSE2);
#else #else
const bool useShorts = false; const bool useShorts = false;
#endif #endif
#ifdef HAVE_TBB #ifdef HAVE_TBB
const double SAD_overhead_coeff = 10.0; const double SAD_overhead_coeff = 10.0;
double N0 = 8000000 / (useShorts ? 1 : 4); // approx tbb's min number instructions reasonable for one thread double N0 = 8000000 / (useShorts ? 1 : 4); // approx tbb's min number instructions reasonable for one thread
double maxStripeSize = min(max(N0 / (width * ndisp), (wsz-1) * SAD_overhead_coeff), (double)height); double maxStripeSize = min(max(N0 / (width * ndisp), (wsz-1) * SAD_overhead_coeff), (double)height);
int nstripes = cvCeil(height / maxStripeSize); int nstripes = cvCeil(height / maxStripeSize);
#else #else
@ -878,27 +881,27 @@ static void findStereoCorrespondenceBM( const Mat& left0, const Mat& right0, Mat
#endif #endif
int bufSize = max(bufSize0 * nstripes, max(bufSize1 * 2, bufSize2)); int bufSize = max(bufSize0 * nstripes, max(bufSize1 * 2, bufSize2));
if( !state->slidingSumBuf || state->slidingSumBuf->cols < bufSize ) if( !state->slidingSumBuf || state->slidingSumBuf->cols < bufSize )
{ {
cvReleaseMat( &state->slidingSumBuf ); cvReleaseMat( &state->slidingSumBuf );
state->slidingSumBuf = cvCreateMat( 1, bufSize, CV_8U ); state->slidingSumBuf = cvCreateMat( 1, bufSize, CV_8U );
} }
uchar *_buf = state->slidingSumBuf->data.ptr; uchar *_buf = state->slidingSumBuf->data.ptr;
int idx[] = {0,1}; int idx[] = {0,1};
parallel_do(idx, idx+2, PrefilterInvoker(left0, right0, left, right, _buf, _buf + bufSize1, state)); parallel_do(idx, idx+2, PrefilterInvoker(left0, right0, left, right, _buf, _buf + bufSize1, state));
Rect validDisparityRect(0, 0, width, height), R1 = state->roi1, R2 = state->roi2; Rect validDisparityRect(0, 0, width, height), R1 = state->roi1, R2 = state->roi2;
validDisparityRect = getValidDisparityROI(R1.area() > 0 ? Rect(0, 0, width, height) : validDisparityRect, validDisparityRect = getValidDisparityROI(R1.area() > 0 ? Rect(0, 0, width, height) : validDisparityRect,
R2.area() > 0 ? Rect(0, 0, width, height) : validDisparityRect, R2.area() > 0 ? Rect(0, 0, width, height) : validDisparityRect,
state->minDisparity, state->numberOfDisparities, state->minDisparity, state->numberOfDisparities,
state->SADWindowSize); state->SADWindowSize);
parallel_for(BlockedRange(0, nstripes), parallel_for(BlockedRange(0, nstripes),
FindStereoCorrespInvoker(left, right, disp, state, nstripes, FindStereoCorrespInvoker(left, right, disp, state, nstripes,
bufSize0, useShorts, validDisparityRect)); bufSize0, useShorts, validDisparityRect));
if( state->speckleRange >= 0 && state->speckleWindowSize > 0 ) if( state->speckleRange >= 0 && state->speckleWindowSize > 0 )
{ {
Mat buf(state->slidingSumBuf); Mat buf(state->slidingSumBuf);
@ -906,7 +909,7 @@ static void findStereoCorrespondenceBM( const Mat& left0, const Mat& right0, Mat
} }
if (disp0.data != disp.data) if (disp0.data != disp.data)
disp.convertTo(disp0, disp0.type(), 1./(1 << DISPARITY_SHIFT), 0); disp.convertTo(disp0, disp0.type(), 1./(1 << DISPARITY_SHIFT), 0);
} }
StereoBM::StereoBM() StereoBM::StereoBM()
@ -928,13 +931,13 @@ void StereoBM::operator()( InputArray _left, InputArray _right,
CV_Assert( disptype == CV_16S || disptype == CV_32F ); CV_Assert( disptype == CV_16S || disptype == CV_32F );
_disparity.create(left.size(), disptype); _disparity.create(left.size(), disptype);
Mat disparity = _disparity.getMat(); Mat disparity = _disparity.getMat();
findStereoCorrespondenceBM(left, right, disparity, state); findStereoCorrespondenceBM(left, right, disparity, state);
} }
template<> void Ptr<CvStereoBMState>::delete_obj() template<> void Ptr<CvStereoBMState>::delete_obj()
{ cvReleaseStereoBMState(&obj); } { cvReleaseStereoBMState(&obj); }
} }
CV_IMPL void cvFindStereoCorrespondenceBM( const CvArr* leftarr, const CvArr* rightarr, CV_IMPL void cvFindStereoCorrespondenceBM( const CvArr* leftarr, const CvArr* rightarr,
@ -942,7 +945,7 @@ CV_IMPL void cvFindStereoCorrespondenceBM( const CvArr* leftarr, const CvArr* ri
{ {
cv::Mat left = cv::cvarrToMat(leftarr), cv::Mat left = cv::cvarrToMat(leftarr),
right = cv::cvarrToMat(rightarr), right = cv::cvarrToMat(rightarr),
disp = cv::cvarrToMat(disparr); disp = cv::cvarrToMat(disparr);
cv::findStereoCorrespondenceBM(left, right, disp, state); cv::findStereoCorrespondenceBM(left, right, disp, state);
} }

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

@ -44,17 +44,17 @@
This is a variation of This is a variation of
"Stereo Processing by Semiglobal Matching and Mutual Information" "Stereo Processing by Semiglobal Matching and Mutual Information"
by Heiko Hirschmuller. by Heiko Hirschmuller.
We match blocks rather than individual pixels, thus the algorithm is called We match blocks rather than individual pixels, thus the algorithm is called
SGBM (Semi-global block matching) SGBM (Semi-global block matching)
*/ */
#include "precomp.hpp" #include "precomp.hpp"
#include <limits.h> #include <limits.h>
namespace cv namespace cv
{ {
typedef uchar PixType; typedef uchar PixType;
typedef short CostType; typedef short CostType;
typedef short DispType; typedef short DispType;
@ -105,7 +105,7 @@ StereoSGBM::~StereoSGBM()
row1[x] and row2[x-d]. The subpixel algorithm from row1[x] and row2[x-d]. The subpixel algorithm from
"Depth Discontinuities by Pixel-to-Pixel Stereo" by Stan Birchfield and C. Tomasi "Depth Discontinuities by Pixel-to-Pixel Stereo" by Stan Birchfield and C. Tomasi
is used, hence the suffix BT. is used, hence the suffix BT.
the temporary buffer should contain width2*2 elements the temporary buffer should contain width2*2 elements
*/ */
static void calcPixelCostBT( const Mat& img1, const Mat& img2, int y, static void calcPixelCostBT( const Mat& img1, const Mat& img2, int y,
@ -119,25 +119,25 @@ static void calcPixelCostBT( const Mat& img1, const Mat& img2, int y,
int D = maxD - minD, width1 = maxX1 - minX1, width2 = maxX2 - minX2; int D = maxD - minD, width1 = maxX1 - minX1, width2 = maxX2 - minX2;
const PixType *row1 = img1.ptr<PixType>(y), *row2 = img2.ptr<PixType>(y); const PixType *row1 = img1.ptr<PixType>(y), *row2 = img2.ptr<PixType>(y);
PixType *prow1 = buffer + width2*2, *prow2 = prow1 + width*cn*2; PixType *prow1 = buffer + width2*2, *prow2 = prow1 + width*cn*2;
tab += tabOfs; tab += tabOfs;
for( c = 0; c < cn*2; c++ ) for( c = 0; c < cn*2; c++ )
{ {
prow1[width*c] = prow1[width*c + width-1] = prow1[width*c] = prow1[width*c + width-1] =
prow2[width*c] = prow2[width*c + width-1] = tab[0]; prow2[width*c] = prow2[width*c + width-1] = tab[0];
} }
int n1 = y > 0 ? -(int)img1.step : 0, s1 = y < img1.rows-1 ? (int)img1.step : 0; int n1 = y > 0 ? -(int)img1.step : 0, s1 = y < img1.rows-1 ? (int)img1.step : 0;
int n2 = y > 0 ? -(int)img2.step : 0, s2 = y < img2.rows-1 ? (int)img2.step : 0; int n2 = y > 0 ? -(int)img2.step : 0, s2 = y < img2.rows-1 ? (int)img2.step : 0;
if( cn == 1 ) if( cn == 1 )
{ {
for( x = 1; x < width-1; x++ ) for( x = 1; x < width-1; x++ )
{ {
prow1[x] = tab[(row1[x+1] - row1[x-1])*2 + row1[x+n1+1] - row1[x+n1-1] + row1[x+s1+1] - row1[x+s1-1]]; prow1[x] = tab[(row1[x+1] - row1[x-1])*2 + row1[x+n1+1] - row1[x+n1-1] + row1[x+s1+1] - row1[x+s1-1]];
prow2[width-1-x] = tab[(row2[x+1] - row2[x-1])*2 + row2[x+n2+1] - row2[x+n2-1] + row2[x+s2+1] - row2[x+s2-1]]; prow2[width-1-x] = tab[(row2[x+1] - row2[x-1])*2 + row2[x+n2+1] - row2[x+n2-1] + row2[x+s2+1] - row2[x+s2-1]];
prow1[x+width] = row1[x]; prow1[x+width] = row1[x];
prow2[width-1-x+width] = row2[x]; prow2[width-1-x+width] = row2[x];
} }
@ -149,35 +149,35 @@ static void calcPixelCostBT( const Mat& img1, const Mat& img2, int y,
prow1[x] = tab[(row1[x*3+3] - row1[x*3-3])*2 + row1[x*3+n1+3] - row1[x*3+n1-3] + row1[x*3+s1+3] - row1[x*3+s1-3]]; prow1[x] = tab[(row1[x*3+3] - row1[x*3-3])*2 + row1[x*3+n1+3] - row1[x*3+n1-3] + row1[x*3+s1+3] - row1[x*3+s1-3]];
prow1[x+width] = tab[(row1[x*3+4] - row1[x*3-2])*2 + row1[x*3+n1+4] - row1[x*3+n1-2] + row1[x*3+s1+4] - row1[x*3+s1-2]]; prow1[x+width] = tab[(row1[x*3+4] - row1[x*3-2])*2 + row1[x*3+n1+4] - row1[x*3+n1-2] + row1[x*3+s1+4] - row1[x*3+s1-2]];
prow1[x+width*2] = tab[(row1[x*3+5] - row1[x*3-1])*2 + row1[x*3+n1+5] - row1[x*3+n1-1] + row1[x*3+s1+5] - row1[x*3+s1-1]]; prow1[x+width*2] = tab[(row1[x*3+5] - row1[x*3-1])*2 + row1[x*3+n1+5] - row1[x*3+n1-1] + row1[x*3+s1+5] - row1[x*3+s1-1]];
prow2[width-1-x] = tab[(row2[x*3+3] - row2[x*3-3])*2 + row2[x*3+n2+3] - row2[x*3+n2-3] + row2[x*3+s2+3] - row2[x*3+s2-3]]; prow2[width-1-x] = tab[(row2[x*3+3] - row2[x*3-3])*2 + row2[x*3+n2+3] - row2[x*3+n2-3] + row2[x*3+s2+3] - row2[x*3+s2-3]];
prow2[width-1-x+width] = tab[(row2[x*3+4] - row2[x*3-2])*2 + row2[x*3+n2+4] - row2[x*3+n2-2] + row2[x*3+s2+4] - row2[x*3+s2-2]]; prow2[width-1-x+width] = tab[(row2[x*3+4] - row2[x*3-2])*2 + row2[x*3+n2+4] - row2[x*3+n2-2] + row2[x*3+s2+4] - row2[x*3+s2-2]];
prow2[width-1-x+width*2] = tab[(row2[x*3+5] - row2[x*3-1])*2 + row2[x*3+n2+5] - row2[x*3+n2-1] + row2[x*3+s2+5] - row2[x*3+s2-1]]; prow2[width-1-x+width*2] = tab[(row2[x*3+5] - row2[x*3-1])*2 + row2[x*3+n2+5] - row2[x*3+n2-1] + row2[x*3+s2+5] - row2[x*3+s2-1]];
prow1[x+width*3] = row1[x*3]; prow1[x+width*3] = row1[x*3];
prow1[x+width*4] = row1[x*3+1]; prow1[x+width*4] = row1[x*3+1];
prow1[x+width*5] = row1[x*3+2]; prow1[x+width*5] = row1[x*3+2];
prow2[width-1-x+width*3] = row2[x*3]; prow2[width-1-x+width*3] = row2[x*3];
prow2[width-1-x+width*4] = row2[x*3+1]; prow2[width-1-x+width*4] = row2[x*3+1];
prow2[width-1-x+width*5] = row2[x*3+2]; prow2[width-1-x+width*5] = row2[x*3+2];
} }
} }
memset( cost, 0, width1*D*sizeof(cost[0]) ); memset( cost, 0, width1*D*sizeof(cost[0]) );
buffer -= minX2; buffer -= minX2;
cost -= minX1*D + minD; // simplify the cost indices inside the loop cost -= minX1*D + minD; // simplify the cost indices inside the loop
#if CV_SSE2 #if CV_SSE2
volatile bool useSIMD = checkHardwareSupport(CV_CPU_SSE2); volatile bool useSIMD = checkHardwareSupport(CV_CPU_SSE2);
#endif #endif
#if 1 #if 1
for( c = 0; c < cn*2; c++, prow1 += width, prow2 += width ) for( c = 0; c < cn*2; c++, prow1 += width, prow2 += width )
{ {
int diff_scale = c < cn ? 0 : 2; int diff_scale = c < cn ? 0 : 2;
// precompute // precompute
// v0 = min(row2[x-1/2], row2[x], row2[x+1/2]) and // v0 = min(row2[x-1/2], row2[x], row2[x+1/2]) and
// v1 = max(row2[x-1/2], row2[x], row2[x+1/2]) and // v1 = max(row2[x-1/2], row2[x], row2[x+1/2]) and
@ -191,7 +191,7 @@ static void calcPixelCostBT( const Mat& img1, const Mat& img2, int y,
buffer[x] = (PixType)v0; buffer[x] = (PixType)v0;
buffer[x + width2] = (PixType)v1; buffer[x + width2] = (PixType)v1;
} }
for( x = minX1; x < maxX1; x++ ) for( x = minX1; x < maxX1; x++ )
{ {
int u = prow1[x]; int u = prow1[x];
@ -199,14 +199,14 @@ static void calcPixelCostBT( const Mat& img1, const Mat& img2, int y,
int ur = x < width-1 ? (u + prow1[x+1])/2 : u; int ur = x < width-1 ? (u + prow1[x+1])/2 : u;
int u0 = min(ul, ur); u0 = min(u0, u); int u0 = min(ul, ur); u0 = min(u0, u);
int u1 = max(ul, ur); u1 = max(u1, u); int u1 = max(ul, ur); u1 = max(u1, u);
#if CV_SSE2 #if CV_SSE2
if( useSIMD ) if( useSIMD )
{ {
__m128i _u = _mm_set1_epi8((char)u), _u0 = _mm_set1_epi8((char)u0); __m128i _u = _mm_set1_epi8((char)u), _u0 = _mm_set1_epi8((char)u0);
__m128i _u1 = _mm_set1_epi8((char)u1), z = _mm_setzero_si128(); __m128i _u1 = _mm_set1_epi8((char)u1), z = _mm_setzero_si128();
__m128i ds = _mm_cvtsi32_si128(diff_scale); __m128i ds = _mm_cvtsi32_si128(diff_scale);
for( int d = minD; d < maxD; d += 16 ) for( int d = minD; d < maxD; d += 16 )
{ {
__m128i _v = _mm_loadu_si128((const __m128i*)(prow2 + width-x-1 + d)); __m128i _v = _mm_loadu_si128((const __m128i*)(prow2 + width-x-1 + d));
@ -215,10 +215,10 @@ static void calcPixelCostBT( const Mat& img1, const Mat& img2, int y,
__m128i c0 = _mm_max_epu8(_mm_subs_epu8(_u, _v1), _mm_subs_epu8(_v0, _u)); __m128i c0 = _mm_max_epu8(_mm_subs_epu8(_u, _v1), _mm_subs_epu8(_v0, _u));
__m128i c1 = _mm_max_epu8(_mm_subs_epu8(_v, _u1), _mm_subs_epu8(_u0, _v)); __m128i c1 = _mm_max_epu8(_mm_subs_epu8(_v, _u1), _mm_subs_epu8(_u0, _v));
__m128i diff = _mm_min_epu8(c0, c1); __m128i diff = _mm_min_epu8(c0, c1);
c0 = _mm_load_si128((__m128i*)(cost + x*D + d)); c0 = _mm_load_si128((__m128i*)(cost + x*D + d));
c1 = _mm_load_si128((__m128i*)(cost + x*D + d + 8)); c1 = _mm_load_si128((__m128i*)(cost + x*D + d + 8));
_mm_store_si128((__m128i*)(cost + x*D + d), _mm_adds_epi16(c0, _mm_srl_epi16(_mm_unpacklo_epi8(diff,z), ds))); _mm_store_si128((__m128i*)(cost + x*D + d), _mm_adds_epi16(c0, _mm_srl_epi16(_mm_unpacklo_epi8(diff,z), ds)));
_mm_store_si128((__m128i*)(cost + x*D + d + 8), _mm_adds_epi16(c1, _mm_srl_epi16(_mm_unpackhi_epi8(diff,z), ds))); _mm_store_si128((__m128i*)(cost + x*D + d + 8), _mm_adds_epi16(c1, _mm_srl_epi16(_mm_unpackhi_epi8(diff,z), ds)));
} }
@ -233,7 +233,7 @@ static void calcPixelCostBT( const Mat& img1, const Mat& img2, int y,
int v1 = buffer[width-x-1 + d + width2]; int v1 = buffer[width-x-1 + d + width2];
int c0 = max(0, u - v1); c0 = max(c0, v0 - u); int c0 = max(0, u - v1); c0 = max(c0, v0 - u);
int c1 = max(0, v - u1); c1 = max(c1, u0 - v); int c1 = max(0, v - u1); c1 = max(c1, u0 - v);
cost[x*D + d] = (CostType)(cost[x*D+d] + (min(c0, c1) >> diff_scale)); cost[x*D + d] = (CostType)(cost[x*D+d] + (min(c0, c1) >> diff_scale));
} }
} }
@ -249,14 +249,14 @@ static void calcPixelCostBT( const Mat& img1, const Mat& img2, int y,
if( useSIMD ) if( useSIMD )
{ {
__m128i _u = _mm_set1_epi8(u), z = _mm_setzero_si128(); __m128i _u = _mm_set1_epi8(u), z = _mm_setzero_si128();
for( int d = minD; d < maxD; d += 16 ) for( int d = minD; d < maxD; d += 16 )
{ {
__m128i _v = _mm_loadu_si128((const __m128i*)(prow2 + width-1-x + d)); __m128i _v = _mm_loadu_si128((const __m128i*)(prow2 + width-1-x + d));
__m128i diff = _mm_adds_epu8(_mm_subs_epu8(_u,_v), _mm_subs_epu8(_v,_u)); __m128i diff = _mm_adds_epu8(_mm_subs_epu8(_u,_v), _mm_subs_epu8(_v,_u));
__m128i c0 = _mm_load_si128((__m128i*)(cost + x*D + d)); __m128i c0 = _mm_load_si128((__m128i*)(cost + x*D + d));
__m128i c1 = _mm_load_si128((__m128i*)(cost + x*D + d + 8)); __m128i c1 = _mm_load_si128((__m128i*)(cost + x*D + d + 8));
_mm_store_si128((__m128i*)(cost + x*D + d), _mm_adds_epi16(c0, _mm_unpacklo_epi8(diff,z))); _mm_store_si128((__m128i*)(cost + x*D + d), _mm_adds_epi16(c0, _mm_unpacklo_epi8(diff,z)));
_mm_store_si128((__m128i*)(cost + x*D + d + 8), _mm_adds_epi16(c1, _mm_unpackhi_epi8(diff,z))); _mm_store_si128((__m128i*)(cost + x*D + d + 8), _mm_adds_epi16(c1, _mm_unpackhi_epi8(diff,z)));
} }
@ -282,22 +282,22 @@ static void calcPixelCostBT( const Mat& img1, const Mat& img2, int y,
minD <= d < maxD. minD <= d < maxD.
disp2full is the reverse disparity map, that is: disp2full is the reverse disparity map, that is:
disp2full(x+roi.x,y+roi.y)=d means that img2(x+roi.x, y+roi.y) ~ img1(x+roi.x+d, y+roi.y) disp2full(x+roi.x,y+roi.y)=d means that img2(x+roi.x, y+roi.y) ~ img1(x+roi.x+d, y+roi.y)
note that disp1buf will have the same size as the roi and note that disp1buf will have the same size as the roi and
disp2full will have the same size as img1 (or img2). disp2full will have the same size as img1 (or img2).
On exit disp2buf is not the final disparity, it is an intermediate result that becomes On exit disp2buf is not the final disparity, it is an intermediate result that becomes
final after all the tiles are processed. final after all the tiles are processed.
the disparity in disp1buf is written with sub-pixel accuracy the disparity in disp1buf is written with sub-pixel accuracy
(4 fractional bits, see CvStereoSGBM::DISP_SCALE), (4 fractional bits, see CvStereoSGBM::DISP_SCALE),
using quadratic interpolation, while the disparity in disp2buf using quadratic interpolation, while the disparity in disp2buf
is written as is, without interpolation. is written as is, without interpolation.
disp2cost also has the same size as img1 (or img2). disp2cost also has the same size as img1 (or img2).
It contains the minimum current cost, used to find the best disparity, corresponding to the minimal cost. It contains the minimum current cost, used to find the best disparity, corresponding to the minimal cost.
*/ */
static void computeDisparitySGBM( const Mat& img1, const Mat& img2, static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
Mat& disp1, const StereoSGBM& params, Mat& disp1, const StereoSGBM& params,
Mat& buffer ) Mat& buffer )
{ {
#if CV_SSE2 #if CV_SSE2
@ -312,15 +312,15 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0 5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0, 4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
}; };
volatile bool useSIMD = checkHardwareSupport(CV_CPU_SSE2); volatile bool useSIMD = checkHardwareSupport(CV_CPU_SSE2);
#endif #endif
const int ALIGN = 16; const int ALIGN = 16;
const int DISP_SHIFT = StereoSGBM::DISP_SHIFT; const int DISP_SHIFT = StereoSGBM::DISP_SHIFT;
const int DISP_SCALE = StereoSGBM::DISP_SCALE; const int DISP_SCALE = StereoSGBM::DISP_SCALE;
const CostType MAX_COST = SHRT_MAX; const CostType MAX_COST = SHRT_MAX;
int minD = params.minDisparity, maxD = minD + params.numberOfDisparities; int minD = params.minDisparity, maxD = minD + params.numberOfDisparities;
Size SADWindowSize; Size SADWindowSize;
SADWindowSize.width = SADWindowSize.height = params.SADWindowSize > 0 ? params.SADWindowSize : 5; SADWindowSize.width = SADWindowSize.height = params.SADWindowSize > 0 ? params.SADWindowSize : 5;
@ -336,28 +336,28 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
int npasses = params.fullDP ? 2 : 1; int npasses = params.fullDP ? 2 : 1;
const int TAB_OFS = 256*4, TAB_SIZE = 256 + TAB_OFS*2; const int TAB_OFS = 256*4, TAB_SIZE = 256 + TAB_OFS*2;
PixType clipTab[TAB_SIZE]; PixType clipTab[TAB_SIZE];
for( k = 0; k < TAB_SIZE; k++ ) for( k = 0; k < TAB_SIZE; k++ )
clipTab[k] = (PixType)(min(max(k - TAB_OFS, -ftzero), ftzero) + ftzero); clipTab[k] = (PixType)(min(max(k - TAB_OFS, -ftzero), ftzero) + ftzero);
if( minX1 >= maxX1 ) if( minX1 >= maxX1 )
{ {
disp1 = Scalar::all(INVALID_DISP_SCALED); disp1 = Scalar::all(INVALID_DISP_SCALED);
return; return;
} }
CV_Assert( D % 16 == 0 ); CV_Assert( D % 16 == 0 );
// NR - the number of directions. the loop on x below that computes Lr assumes that NR == 8. // NR - the number of directions. the loop on x below that computes Lr assumes that NR == 8.
// if you change NR, please, modify the loop as well. // if you change NR, please, modify the loop as well.
int D2 = D+16, NRD2 = NR2*D2; int D2 = D+16, NRD2 = NR2*D2;
// the number of L_r(.,.) and min_k L_r(.,.) lines in the buffer: // the number of L_r(.,.) and min_k L_r(.,.) lines in the buffer:
// for 8-way dynamic programming we need the current row and // for 8-way dynamic programming we need the current row and
// the previous row, i.e. 2 rows in total // the previous row, i.e. 2 rows in total
const int NLR = 2; const int NLR = 2;
const int LrBorder = NLR - 1; const int LrBorder = NLR - 1;
// for each possible stereo match (img1(x,y) <=> img2(x-d,y)) // for each possible stereo match (img1(x,y) <=> img2(x-d,y))
// we keep pixel difference cost (C) and the summary cost over NR directions (S). // we keep pixel difference cost (C) and the summary cost over NR directions (S).
// we also keep all the partial costs for the previous line L_r(x,d) and also min_k L_r(x, k) // we also keep all the partial costs for the previous line L_r(x,d) and also min_k L_r(x, k)
@ -370,29 +370,29 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
CSBufSize*2*sizeof(CostType) + // C, S CSBufSize*2*sizeof(CostType) + // C, S
width*16*img1.channels()*sizeof(PixType) + // temp buffer for computing per-pixel cost width*16*img1.channels()*sizeof(PixType) + // temp buffer for computing per-pixel cost
width*(sizeof(CostType) + sizeof(DispType)) + 1024; // disp2cost + disp2 width*(sizeof(CostType) + sizeof(DispType)) + 1024; // disp2cost + disp2
if( !buffer.data || !buffer.isContinuous() || if( !buffer.data || !buffer.isContinuous() ||
buffer.cols*buffer.rows*buffer.elemSize() < totalBufSize ) buffer.cols*buffer.rows*buffer.elemSize() < totalBufSize )
buffer.create(1, (int)totalBufSize, CV_8U); buffer.create(1, (int)totalBufSize, CV_8U);
// summary cost over different (nDirs) directions // summary cost over different (nDirs) directions
CostType* Cbuf = (CostType*)alignPtr(buffer.data, ALIGN); CostType* Cbuf = (CostType*)alignPtr(buffer.data, ALIGN);
CostType* Sbuf = Cbuf + CSBufSize; CostType* Sbuf = Cbuf + CSBufSize;
CostType* hsumBuf = Sbuf + CSBufSize; CostType* hsumBuf = Sbuf + CSBufSize;
CostType* pixDiff = hsumBuf + costBufSize*hsumBufNRows; CostType* pixDiff = hsumBuf + costBufSize*hsumBufNRows;
CostType* disp2cost = pixDiff + costBufSize + (LrSize + minLrSize)*NLR; CostType* disp2cost = pixDiff + costBufSize + (LrSize + minLrSize)*NLR;
DispType* disp2ptr = (DispType*)(disp2cost + width); DispType* disp2ptr = (DispType*)(disp2cost + width);
PixType* tempBuf = (PixType*)(disp2ptr + width); PixType* tempBuf = (PixType*)(disp2ptr + width);
// add P2 to every C(x,y). it saves a few operations in the inner loops // add P2 to every C(x,y). it saves a few operations in the inner loops
for( k = 0; k < width1*D; k++ ) for( k = 0; k < width1*D; k++ )
Cbuf[k] = (CostType)P2; Cbuf[k] = (CostType)P2;
for( int pass = 1; pass <= npasses; pass++ ) for( int pass = 1; pass <= npasses; pass++ )
{ {
int x1, y1, x2, y2, dx, dy; int x1, y1, x2, y2, dx, dy;
if( pass == 1 ) if( pass == 1 )
{ {
y1 = 0; y2 = height; dy = 1; y1 = 0; y2 = height; dy = 1;
@ -403,9 +403,9 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
y1 = height-1; y2 = -1; dy = -1; y1 = height-1; y2 = -1; dy = -1;
x1 = width1-1; x2 = -1; dx = -1; x1 = width1-1; x2 = -1; dx = -1;
} }
CostType *Lr[NLR]={0}, *minLr[NLR]={0}; CostType *Lr[NLR]={0}, *minLr[NLR]={0};
for( k = 0; k < NLR; k++ ) for( k = 0; k < NLR; k++ )
{ {
// shift Lr[k] and minLr[k] pointers, because we allocated them with the borders, // shift Lr[k] and minLr[k] pointers, because we allocated them with the borders,
@ -418,26 +418,26 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
minLr[k] = pixDiff + costBufSize + LrSize*NLR + minLrSize*k + NR2*2; minLr[k] = pixDiff + costBufSize + LrSize*NLR + minLrSize*k + NR2*2;
memset( minLr[k] - LrBorder*NR2, 0, minLrSize*sizeof(CostType) ); memset( minLr[k] - LrBorder*NR2, 0, minLrSize*sizeof(CostType) );
} }
for( int y = y1; y != y2; y += dy ) for( int y = y1; y != y2; y += dy )
{ {
int x, d; int x, d;
DispType* disp1ptr = disp1.ptr<DispType>(y); DispType* disp1ptr = disp1.ptr<DispType>(y);
CostType* C = Cbuf + (!params.fullDP ? 0 : y*costBufSize); CostType* C = Cbuf + (!params.fullDP ? 0 : y*costBufSize);
CostType* S = Sbuf + (!params.fullDP ? 0 : y*costBufSize); CostType* S = Sbuf + (!params.fullDP ? 0 : y*costBufSize);
if( pass == 1 ) // compute C on the first pass, and reuse it on the second pass, if any. if( pass == 1 ) // compute C on the first pass, and reuse it on the second pass, if any.
{ {
int dy1 = y == 0 ? 0 : y + SH2, dy2 = y == 0 ? SH2 : dy1; int dy1 = y == 0 ? 0 : y + SH2, dy2 = y == 0 ? SH2 : dy1;
for( k = dy1; k <= dy2; k++ ) for( k = dy1; k <= dy2; k++ )
{ {
CostType* hsumAdd = hsumBuf + (min(k, height-1) % hsumBufNRows)*costBufSize; CostType* hsumAdd = hsumBuf + (min(k, height-1) % hsumBufNRows)*costBufSize;
if( k < height ) if( k < height )
{ {
calcPixelCostBT( img1, img2, k, minD, maxD, pixDiff, tempBuf, clipTab, TAB_OFS, ftzero ); calcPixelCostBT( img1, img2, k, minD, maxD, pixDiff, tempBuf, clipTab, TAB_OFS, ftzero );
memset(hsumAdd, 0, D*sizeof(CostType)); memset(hsumAdd, 0, D*sizeof(CostType));
for( x = 0; x <= SW2*D; x += D ) for( x = 0; x <= SW2*D; x += D )
{ {
@ -445,17 +445,17 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
for( d = 0; d < D; d++ ) for( d = 0; d < D; d++ )
hsumAdd[d] = (CostType)(hsumAdd[d] + pixDiff[x + d]*scale); hsumAdd[d] = (CostType)(hsumAdd[d] + pixDiff[x + d]*scale);
} }
if( y > 0 ) if( y > 0 )
{ {
const CostType* hsumSub = hsumBuf + (max(y - SH2 - 1, 0) % hsumBufNRows)*costBufSize; const CostType* hsumSub = hsumBuf + (max(y - SH2 - 1, 0) % hsumBufNRows)*costBufSize;
const CostType* Cprev = !params.fullDP || y == 0 ? C : C - costBufSize; const CostType* Cprev = !params.fullDP || y == 0 ? C : C - costBufSize;
for( x = D; x < width1*D; x += D ) for( x = D; x < width1*D; x += D )
{ {
const CostType* pixAdd = pixDiff + min(x + SW2*D, (width1-1)*D); const CostType* pixAdd = pixDiff + min(x + SW2*D, (width1-1)*D);
const CostType* pixSub = pixDiff + max(x - (SW2+1)*D, 0); const CostType* pixSub = pixDiff + max(x - (SW2+1)*D, 0);
#if CV_SSE2 #if CV_SSE2
if( useSIMD ) if( useSIMD )
{ {
@ -490,13 +490,13 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
{ {
const CostType* pixAdd = pixDiff + min(x + SW2*D, (width1-1)*D); const CostType* pixAdd = pixDiff + min(x + SW2*D, (width1-1)*D);
const CostType* pixSub = pixDiff + max(x - (SW2+1)*D, 0); const CostType* pixSub = pixDiff + max(x - (SW2+1)*D, 0);
for( d = 0; d < D; d++ ) for( d = 0; d < D; d++ )
hsumAdd[x + d] = (CostType)(hsumAdd[x - D + d] + pixAdd[d] - pixSub[d]); hsumAdd[x + d] = (CostType)(hsumAdd[x - D + d] + pixAdd[d] - pixSub[d]);
} }
} }
} }
if( y == 0 ) if( y == 0 )
{ {
int scale = k == 0 ? SH2 + 1 : 1; int scale = k == 0 ? SH2 + 1 : 1;
@ -504,18 +504,18 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
C[x] = (CostType)(C[x] + hsumAdd[x]*scale); C[x] = (CostType)(C[x] + hsumAdd[x]*scale);
} }
} }
// also, clear the S buffer // also, clear the S buffer
for( k = 0; k < width1*D; k++ ) for( k = 0; k < width1*D; k++ )
S[k] = 0; S[k] = 0;
} }
// clear the left and the right borders // clear the left and the right borders
memset( Lr[0] - NRD2*LrBorder - 8, 0, NRD2*LrBorder*sizeof(CostType) ); memset( Lr[0] - NRD2*LrBorder - 8, 0, NRD2*LrBorder*sizeof(CostType) );
memset( Lr[0] + width1*NRD2 - 8, 0, NRD2*LrBorder*sizeof(CostType) ); memset( Lr[0] + width1*NRD2 - 8, 0, NRD2*LrBorder*sizeof(CostType) );
memset( minLr[0] - NR2*LrBorder, 0, NR2*LrBorder*sizeof(CostType) ); memset( minLr[0] - NR2*LrBorder, 0, NR2*LrBorder*sizeof(CostType) );
memset( minLr[0] + width1*NR2, 0, NR2*LrBorder*sizeof(CostType) ); memset( minLr[0] + width1*NR2, 0, NR2*LrBorder*sizeof(CostType) );
/* /*
[formula 13 in the paper] [formula 13 in the paper]
compute L_r(p, d) = C(p, d) + compute L_r(p, d) = C(p, d) +
@ -537,87 +537,87 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
for( x = x1; x != x2; x += dx ) for( x = x1; x != x2; x += dx )
{ {
int xm = x*NR2, xd = xm*D2; int xm = x*NR2, xd = xm*D2;
int delta0 = minLr[0][xm - dx*NR2] + P2, delta1 = minLr[1][xm - NR2 + 1] + P2; int delta0 = minLr[0][xm - dx*NR2] + P2, delta1 = minLr[1][xm - NR2 + 1] + P2;
int delta2 = minLr[1][xm + 2] + P2, delta3 = minLr[1][xm + NR2 + 3] + P2; int delta2 = minLr[1][xm + 2] + P2, delta3 = minLr[1][xm + NR2 + 3] + P2;
CostType* Lr_p0 = Lr[0] + xd - dx*NRD2; CostType* Lr_p0 = Lr[0] + xd - dx*NRD2;
CostType* Lr_p1 = Lr[1] + xd - NRD2 + D2; CostType* Lr_p1 = Lr[1] + xd - NRD2 + D2;
CostType* Lr_p2 = Lr[1] + xd + D2*2; CostType* Lr_p2 = Lr[1] + xd + D2*2;
CostType* Lr_p3 = Lr[1] + xd + NRD2 + D2*3; CostType* Lr_p3 = Lr[1] + xd + NRD2 + D2*3;
Lr_p0[-1] = Lr_p0[D] = Lr_p1[-1] = Lr_p1[D] = Lr_p0[-1] = Lr_p0[D] = Lr_p1[-1] = Lr_p1[D] =
Lr_p2[-1] = Lr_p2[D] = Lr_p3[-1] = Lr_p3[D] = MAX_COST; Lr_p2[-1] = Lr_p2[D] = Lr_p3[-1] = Lr_p3[D] = MAX_COST;
CostType* Lr_p = Lr[0] + xd; CostType* Lr_p = Lr[0] + xd;
const CostType* Cp = C + x*D; const CostType* Cp = C + x*D;
CostType* Sp = S + x*D; CostType* Sp = S + x*D;
#if CV_SSE2 #if CV_SSE2
if( useSIMD ) if( useSIMD )
{ {
__m128i _P1 = _mm_set1_epi16((short)P1); __m128i _P1 = _mm_set1_epi16((short)P1);
__m128i _delta0 = _mm_set1_epi16((short)delta0); __m128i _delta0 = _mm_set1_epi16((short)delta0);
__m128i _delta1 = _mm_set1_epi16((short)delta1); __m128i _delta1 = _mm_set1_epi16((short)delta1);
__m128i _delta2 = _mm_set1_epi16((short)delta2); __m128i _delta2 = _mm_set1_epi16((short)delta2);
__m128i _delta3 = _mm_set1_epi16((short)delta3); __m128i _delta3 = _mm_set1_epi16((short)delta3);
__m128i _minL0 = _mm_set1_epi16((short)MAX_COST); __m128i _minL0 = _mm_set1_epi16((short)MAX_COST);
for( d = 0; d < D; d += 8 ) for( d = 0; d < D; d += 8 )
{ {
__m128i Cpd = _mm_load_si128((const __m128i*)(Cp + d)); __m128i Cpd = _mm_load_si128((const __m128i*)(Cp + d));
__m128i L0, L1, L2, L3; __m128i L0, L1, L2, L3;
L0 = _mm_load_si128((const __m128i*)(Lr_p0 + d)); L0 = _mm_load_si128((const __m128i*)(Lr_p0 + d));
L1 = _mm_load_si128((const __m128i*)(Lr_p1 + d)); L1 = _mm_load_si128((const __m128i*)(Lr_p1 + d));
L2 = _mm_load_si128((const __m128i*)(Lr_p2 + d)); L2 = _mm_load_si128((const __m128i*)(Lr_p2 + d));
L3 = _mm_load_si128((const __m128i*)(Lr_p3 + d)); L3 = _mm_load_si128((const __m128i*)(Lr_p3 + d));
L0 = _mm_min_epi16(L0, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p0 + d - 1)), _P1)); L0 = _mm_min_epi16(L0, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p0 + d - 1)), _P1));
L0 = _mm_min_epi16(L0, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p0 + d + 1)), _P1)); L0 = _mm_min_epi16(L0, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p0 + d + 1)), _P1));
L1 = _mm_min_epi16(L1, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p1 + d - 1)), _P1)); L1 = _mm_min_epi16(L1, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p1 + d - 1)), _P1));
L1 = _mm_min_epi16(L1, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p1 + d + 1)), _P1)); L1 = _mm_min_epi16(L1, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p1 + d + 1)), _P1));
L2 = _mm_min_epi16(L2, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p2 + d - 1)), _P1)); L2 = _mm_min_epi16(L2, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p2 + d - 1)), _P1));
L2 = _mm_min_epi16(L2, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p2 + d + 1)), _P1)); L2 = _mm_min_epi16(L2, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p2 + d + 1)), _P1));
L3 = _mm_min_epi16(L3, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p3 + d - 1)), _P1)); L3 = _mm_min_epi16(L3, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p3 + d - 1)), _P1));
L3 = _mm_min_epi16(L3, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p3 + d + 1)), _P1)); L3 = _mm_min_epi16(L3, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p3 + d + 1)), _P1));
L0 = _mm_min_epi16(L0, _delta0); L0 = _mm_min_epi16(L0, _delta0);
L0 = _mm_adds_epi16(_mm_subs_epi16(L0, _delta0), Cpd); L0 = _mm_adds_epi16(_mm_subs_epi16(L0, _delta0), Cpd);
L1 = _mm_min_epi16(L1, _delta1); L1 = _mm_min_epi16(L1, _delta1);
L1 = _mm_adds_epi16(_mm_subs_epi16(L1, _delta1), Cpd); L1 = _mm_adds_epi16(_mm_subs_epi16(L1, _delta1), Cpd);
L2 = _mm_min_epi16(L2, _delta2); L2 = _mm_min_epi16(L2, _delta2);
L2 = _mm_adds_epi16(_mm_subs_epi16(L2, _delta2), Cpd); L2 = _mm_adds_epi16(_mm_subs_epi16(L2, _delta2), Cpd);
L3 = _mm_min_epi16(L3, _delta3); L3 = _mm_min_epi16(L3, _delta3);
L3 = _mm_adds_epi16(_mm_subs_epi16(L3, _delta3), Cpd); L3 = _mm_adds_epi16(_mm_subs_epi16(L3, _delta3), Cpd);
_mm_store_si128( (__m128i*)(Lr_p + d), L0); _mm_store_si128( (__m128i*)(Lr_p + d), L0);
_mm_store_si128( (__m128i*)(Lr_p + d + D2), L1); _mm_store_si128( (__m128i*)(Lr_p + d + D2), L1);
_mm_store_si128( (__m128i*)(Lr_p + d + D2*2), L2); _mm_store_si128( (__m128i*)(Lr_p + d + D2*2), L2);
_mm_store_si128( (__m128i*)(Lr_p + d + D2*3), L3); _mm_store_si128( (__m128i*)(Lr_p + d + D2*3), L3);
__m128i t0 = _mm_min_epi16(_mm_unpacklo_epi16(L0, L2), _mm_unpackhi_epi16(L0, L2)); __m128i t0 = _mm_min_epi16(_mm_unpacklo_epi16(L0, L2), _mm_unpackhi_epi16(L0, L2));
__m128i t1 = _mm_min_epi16(_mm_unpacklo_epi16(L1, L3), _mm_unpackhi_epi16(L1, L3)); __m128i t1 = _mm_min_epi16(_mm_unpacklo_epi16(L1, L3), _mm_unpackhi_epi16(L1, L3));
t0 = _mm_min_epi16(_mm_unpacklo_epi16(t0, t1), _mm_unpackhi_epi16(t0, t1)); t0 = _mm_min_epi16(_mm_unpacklo_epi16(t0, t1), _mm_unpackhi_epi16(t0, t1));
_minL0 = _mm_min_epi16(_minL0, t0); _minL0 = _mm_min_epi16(_minL0, t0);
__m128i Sval = _mm_load_si128((const __m128i*)(Sp + d)); __m128i Sval = _mm_load_si128((const __m128i*)(Sp + d));
L0 = _mm_adds_epi16(L0, L1); L0 = _mm_adds_epi16(L0, L1);
L2 = _mm_adds_epi16(L2, L3); L2 = _mm_adds_epi16(L2, L3);
Sval = _mm_adds_epi16(Sval, L0); Sval = _mm_adds_epi16(Sval, L0);
Sval = _mm_adds_epi16(Sval, L2); Sval = _mm_adds_epi16(Sval, L2);
_mm_store_si128((__m128i*)(Sp + d), Sval); _mm_store_si128((__m128i*)(Sp + d), Sval);
} }
_minL0 = _mm_min_epi16(_minL0, _mm_srli_si128(_minL0, 8)); _minL0 = _mm_min_epi16(_minL0, _mm_srli_si128(_minL0, 8));
_mm_storel_epi64((__m128i*)&minLr[0][xm], _minL0); _mm_storel_epi64((__m128i*)&minLr[0][xm], _minL0);
} }
@ -625,28 +625,28 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
#endif #endif
{ {
int minL0 = MAX_COST, minL1 = MAX_COST, minL2 = MAX_COST, minL3 = MAX_COST; int minL0 = MAX_COST, minL1 = MAX_COST, minL2 = MAX_COST, minL3 = MAX_COST;
for( d = 0; d < D; d++ ) for( d = 0; d < D; d++ )
{ {
int Cpd = Cp[d], L0, L1, L2, L3; int Cpd = Cp[d], L0, L1, L2, L3;
L0 = Cpd + min((int)Lr_p0[d], min(Lr_p0[d-1] + P1, min(Lr_p0[d+1] + P1, delta0))) - delta0; L0 = Cpd + min((int)Lr_p0[d], min(Lr_p0[d-1] + P1, min(Lr_p0[d+1] + P1, delta0))) - delta0;
L1 = Cpd + min((int)Lr_p1[d], min(Lr_p1[d-1] + P1, min(Lr_p1[d+1] + P1, delta1))) - delta1; L1 = Cpd + min((int)Lr_p1[d], min(Lr_p1[d-1] + P1, min(Lr_p1[d+1] + P1, delta1))) - delta1;
L2 = Cpd + min((int)Lr_p2[d], min(Lr_p2[d-1] + P1, min(Lr_p2[d+1] + P1, delta2))) - delta2; L2 = Cpd + min((int)Lr_p2[d], min(Lr_p2[d-1] + P1, min(Lr_p2[d+1] + P1, delta2))) - delta2;
L3 = Cpd + min((int)Lr_p3[d], min(Lr_p3[d-1] + P1, min(Lr_p3[d+1] + P1, delta3))) - delta3; L3 = Cpd + min((int)Lr_p3[d], min(Lr_p3[d-1] + P1, min(Lr_p3[d+1] + P1, delta3))) - delta3;
Lr_p[d] = (CostType)L0; Lr_p[d] = (CostType)L0;
minL0 = min(minL0, L0); minL0 = min(minL0, L0);
Lr_p[d + D2] = (CostType)L1; Lr_p[d + D2] = (CostType)L1;
minL1 = min(minL1, L1); minL1 = min(minL1, L1);
Lr_p[d + D2*2] = (CostType)L2; Lr_p[d + D2*2] = (CostType)L2;
minL2 = min(minL2, L2); minL2 = min(minL2, L2);
Lr_p[d + D2*3] = (CostType)L3; Lr_p[d + D2*3] = (CostType)L3;
minL3 = min(minL3, L3); minL3 = min(minL3, L3);
Sp[d] = saturate_cast<CostType>(Sp[d] + L0 + L1 + L2 + L3); Sp[d] = saturate_cast<CostType>(Sp[d] + L0 + L1 + L2 + L3);
} }
minLr[0][xm] = (CostType)minL0; minLr[0][xm] = (CostType)minL0;
@ -655,7 +655,7 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
minLr[0][xm+3] = (CostType)minL3; minLr[0][xm+3] = (CostType)minL3;
} }
} }
if( pass == npasses ) if( pass == npasses )
{ {
for( x = 0; x < width; x++ ) for( x = 0; x < width; x++ )
@ -663,73 +663,73 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
disp1ptr[x] = disp2ptr[x] = (DispType)INVALID_DISP_SCALED; disp1ptr[x] = disp2ptr[x] = (DispType)INVALID_DISP_SCALED;
disp2cost[x] = MAX_COST; disp2cost[x] = MAX_COST;
} }
for( x = width1 - 1; x >= 0; x-- ) for( x = width1 - 1; x >= 0; x-- )
{ {
CostType* Sp = S + x*D; CostType* Sp = S + x*D;
int minS = MAX_COST, bestDisp = -1; int minS = MAX_COST, bestDisp = -1;
if( npasses == 1 ) if( npasses == 1 )
{ {
int xm = x*NR2, xd = xm*D2; int xm = x*NR2, xd = xm*D2;
int minL0 = MAX_COST; int minL0 = MAX_COST;
int delta0 = minLr[0][xm + NR2] + P2; int delta0 = minLr[0][xm + NR2] + P2;
CostType* Lr_p0 = Lr[0] + xd + NRD2; CostType* Lr_p0 = Lr[0] + xd + NRD2;
Lr_p0[-1] = Lr_p0[D] = MAX_COST; Lr_p0[-1] = Lr_p0[D] = MAX_COST;
CostType* Lr_p = Lr[0] + xd; CostType* Lr_p = Lr[0] + xd;
const CostType* Cp = C + x*D; const CostType* Cp = C + x*D;
#if CV_SSE2 #if CV_SSE2
if( useSIMD ) if( useSIMD )
{ {
__m128i _P1 = _mm_set1_epi16((short)P1); __m128i _P1 = _mm_set1_epi16((short)P1);
__m128i _delta0 = _mm_set1_epi16((short)delta0); __m128i _delta0 = _mm_set1_epi16((short)delta0);
__m128i _minL0 = _mm_set1_epi16((short)minL0); __m128i _minL0 = _mm_set1_epi16((short)minL0);
__m128i _minS = _mm_set1_epi16(MAX_COST), _bestDisp = _mm_set1_epi16(-1); __m128i _minS = _mm_set1_epi16(MAX_COST), _bestDisp = _mm_set1_epi16(-1);
__m128i _d8 = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7), _8 = _mm_set1_epi16(8); __m128i _d8 = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7), _8 = _mm_set1_epi16(8);
for( d = 0; d < D; d += 8 ) for( d = 0; d < D; d += 8 )
{ {
__m128i Cpd = _mm_load_si128((const __m128i*)(Cp + d)), L0; __m128i Cpd = _mm_load_si128((const __m128i*)(Cp + d)), L0;
L0 = _mm_load_si128((const __m128i*)(Lr_p0 + d)); L0 = _mm_load_si128((const __m128i*)(Lr_p0 + d));
L0 = _mm_min_epi16(L0, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p0 + d - 1)), _P1)); L0 = _mm_min_epi16(L0, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p0 + d - 1)), _P1));
L0 = _mm_min_epi16(L0, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p0 + d + 1)), _P1)); L0 = _mm_min_epi16(L0, _mm_adds_epi16(_mm_loadu_si128((const __m128i*)(Lr_p0 + d + 1)), _P1));
L0 = _mm_min_epi16(L0, _delta0); L0 = _mm_min_epi16(L0, _delta0);
L0 = _mm_adds_epi16(_mm_subs_epi16(L0, _delta0), Cpd); L0 = _mm_adds_epi16(_mm_subs_epi16(L0, _delta0), Cpd);
_mm_store_si128((__m128i*)(Lr_p + d), L0); _mm_store_si128((__m128i*)(Lr_p + d), L0);
_minL0 = _mm_min_epi16(_minL0, L0); _minL0 = _mm_min_epi16(_minL0, L0);
L0 = _mm_adds_epi16(L0, *(__m128i*)(Sp + d)); L0 = _mm_adds_epi16(L0, *(__m128i*)(Sp + d));
_mm_store_si128((__m128i*)(Sp + d), L0); _mm_store_si128((__m128i*)(Sp + d), L0);
__m128i mask = _mm_cmpgt_epi16(_minS, L0); __m128i mask = _mm_cmpgt_epi16(_minS, L0);
_minS = _mm_min_epi16(_minS, L0); _minS = _mm_min_epi16(_minS, L0);
_bestDisp = _mm_xor_si128(_bestDisp, _mm_and_si128(_mm_xor_si128(_bestDisp,_d8), mask)); _bestDisp = _mm_xor_si128(_bestDisp, _mm_and_si128(_mm_xor_si128(_bestDisp,_d8), mask));
_d8 = _mm_adds_epi16(_d8, _8); _d8 = _mm_adds_epi16(_d8, _8);
} }
short CV_DECL_ALIGNED(16) bestDispBuf[8]; short CV_DECL_ALIGNED(16) bestDispBuf[8];
_mm_store_si128((__m128i*)bestDispBuf, _bestDisp); _mm_store_si128((__m128i*)bestDispBuf, _bestDisp);
_minL0 = _mm_min_epi16(_minL0, _mm_srli_si128(_minL0, 8)); _minL0 = _mm_min_epi16(_minL0, _mm_srli_si128(_minL0, 8));
_minL0 = _mm_min_epi16(_minL0, _mm_srli_si128(_minL0, 4)); _minL0 = _mm_min_epi16(_minL0, _mm_srli_si128(_minL0, 4));
_minL0 = _mm_min_epi16(_minL0, _mm_srli_si128(_minL0, 2)); _minL0 = _mm_min_epi16(_minL0, _mm_srli_si128(_minL0, 2));
__m128i qS = _mm_min_epi16(_minS, _mm_srli_si128(_minS, 8)); __m128i qS = _mm_min_epi16(_minS, _mm_srli_si128(_minS, 8));
qS = _mm_min_epi16(qS, _mm_srli_si128(qS, 4)); qS = _mm_min_epi16(qS, _mm_srli_si128(qS, 4));
qS = _mm_min_epi16(qS, _mm_srli_si128(qS, 2)); qS = _mm_min_epi16(qS, _mm_srli_si128(qS, 2));
minLr[0][xm] = (CostType)_mm_cvtsi128_si32(_minL0); minLr[0][xm] = (CostType)_mm_cvtsi128_si32(_minL0);
minS = (CostType)_mm_cvtsi128_si32(qS); minS = (CostType)_mm_cvtsi128_si32(qS);
qS = _mm_shuffle_epi32(_mm_unpacklo_epi16(qS, qS), 0); qS = _mm_shuffle_epi32(_mm_unpacklo_epi16(qS, qS), 0);
qS = _mm_cmpeq_epi16(_minS, qS); qS = _mm_cmpeq_epi16(_minS, qS);
int idx = _mm_movemask_epi8(_mm_packs_epi16(qS, qS)) & 255; int idx = _mm_movemask_epi8(_mm_packs_epi16(qS, qS)) & 255;
bestDisp = bestDispBuf[LSBTab[idx]]; bestDisp = bestDispBuf[LSBTab[idx]];
} }
else else
@ -738,10 +738,10 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
for( d = 0; d < D; d++ ) for( d = 0; d < D; d++ )
{ {
int L0 = Cp[d] + min((int)Lr_p0[d], min(Lr_p0[d-1] + P1, min(Lr_p0[d+1] + P1, delta0))) - delta0; int L0 = Cp[d] + min((int)Lr_p0[d], min(Lr_p0[d-1] + P1, min(Lr_p0[d+1] + P1, delta0))) - delta0;
Lr_p[d] = (CostType)L0; Lr_p[d] = (CostType)L0;
minL0 = min(minL0, L0); minL0 = min(minL0, L0);
int Sval = Sp[d] = saturate_cast<CostType>(Sp[d] + L0); int Sval = Sp[d] = saturate_cast<CostType>(Sp[d] + L0);
if( Sval < minS ) if( Sval < minS )
{ {
@ -764,7 +764,7 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
} }
} }
} }
for( d = 0; d < D; d++ ) for( d = 0; d < D; d++ )
{ {
if( Sp[d]*(100 - uniquenessRatio) < minS*100 && std::abs(bestDisp - d) > 1 ) if( Sp[d]*(100 - uniquenessRatio) < minS*100 && std::abs(bestDisp - d) > 1 )
@ -773,13 +773,13 @@ 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 )
{ {
// do subpixel quadratic interpolation: // do subpixel quadratic interpolation:
@ -792,24 +792,24 @@ static void computeDisparitySGBM( const Mat& img1, const Mat& img2,
d *= DISP_SCALE; d *= DISP_SCALE;
disp1ptr[x + minX1] = (DispType)(d + minD*DISP_SCALE); disp1ptr[x + minX1] = (DispType)(d + minD*DISP_SCALE);
} }
for( x = minX1; x < maxX1; x++ ) for( x = minX1; x < maxX1; x++ )
{ {
// 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 )
disp1ptr[x] = (DispType)INVALID_DISP_SCALED; disp1ptr[x] = (DispType)INVALID_DISP_SCALED;
} }
} }
// now shift the cyclic buffers // now shift the cyclic buffers
std::swap( Lr[0], Lr[1] ); std::swap( Lr[0], Lr[1] );
std::swap( minLr[0], minLr[1] ); std::swap( minLr[0], minLr[1] );
@ -825,13 +825,13 @@ void StereoSGBM::operator ()( InputArray _left, InputArray _right,
Mat left = _left.getMat(), right = _right.getMat(); Mat left = _left.getMat(), right = _right.getMat();
CV_Assert( left.size() == right.size() && left.type() == right.type() && CV_Assert( left.size() == right.size() && left.type() == right.type() &&
left.depth() == DataType<PixType>::depth ); left.depth() == DataType<PixType>::depth );
_disp.create( left.size(), CV_16S ); _disp.create( left.size(), CV_16S );
Mat disp = _disp.getMat(); Mat disp = _disp.getMat();
computeDisparitySGBM( left, right, disp, *this, buffer ); computeDisparitySGBM( left, right, disp, *this, buffer );
medianBlur(disp, disp, 3); medianBlur(disp, disp, 3);
if( speckleWindowSize > 0 ) if( speckleWindowSize > 0 )
filterSpeckles(disp, (minDisparity - 1)*DISP_SCALE, speckleWindowSize, DISP_SCALE*speckleRange, buffer); filterSpeckles(disp, (minDisparity - 1)*DISP_SCALE, speckleWindowSize, DISP_SCALE*speckleRange, buffer);
} }
@ -844,33 +844,33 @@ Rect getValidDisparityROI( Rect roi1, Rect roi2,
{ {
int SW2 = SADWindowSize/2; int SW2 = SADWindowSize/2;
int minD = minDisparity, maxD = minDisparity + numberOfDisparities - 1; int minD = minDisparity, maxD = minDisparity + numberOfDisparities - 1;
int xmin = max(roi1.x, roi2.x + maxD) + SW2; int xmin = max(roi1.x, roi2.x + maxD) + SW2;
int xmax = min(roi1.x + roi1.width, roi2.x + roi2.width - minD) - SW2; int xmax = min(roi1.x + roi1.width, roi2.x + roi2.width - minD) - SW2;
int ymin = max(roi1.y, roi2.y) + SW2; int ymin = max(roi1.y, roi2.y) + SW2;
int ymax = min(roi1.y + roi1.height, roi2.y + roi2.height) - SW2; int ymax = min(roi1.y + roi1.height, roi2.y + roi2.height) - SW2;
Rect r(xmin, ymin, xmax - xmin, ymax - ymin); Rect r(xmin, ymin, xmax - xmin, ymax - ymin);
return r.width > 0 && r.height > 0 ? r : Rect(); return r.width > 0 && r.height > 0 ? r : Rect();
}
} }
}
void cv::filterSpeckles( InputOutputArray _img, double _newval, int maxSpeckleSize, void cv::filterSpeckles( InputOutputArray _img, double _newval, int maxSpeckleSize,
double _maxDiff, InputOutputArray __buf ) double _maxDiff, InputOutputArray __buf )
{ {
Mat img = _img.getMat(); Mat img = _img.getMat();
Mat temp, &_buf = __buf.needed() ? __buf.getMatRef() : temp; Mat temp, &_buf = __buf.needed() ? __buf.getMatRef() : temp;
CV_Assert( img.type() == CV_16SC1 ); CV_Assert( img.type() == CV_16SC1 );
int newVal = cvRound(_newval); int newVal = cvRound(_newval);
int maxDiff = cvRound(_maxDiff); int maxDiff = cvRound(_maxDiff);
int width = img.cols, height = img.rows, npixels = width*height; int width = img.cols, height = img.rows, npixels = width*height;
size_t bufSize = npixels*(int)(sizeof(Point2s) + sizeof(int) + sizeof(uchar)); size_t bufSize = npixels*(int)(sizeof(Point2s) + sizeof(int) + sizeof(uchar));
if( !_buf.isContinuous() || !_buf.data || _buf.cols*_buf.rows*_buf.elemSize() < bufSize ) if( !_buf.isContinuous() || !_buf.data || _buf.cols*_buf.rows*_buf.elemSize() < bufSize )
_buf.create(1, (int)bufSize, CV_8U); _buf.create(1, (int)bufSize, CV_8U);
uchar* buf = _buf.data; uchar* buf = _buf.data;
int i, j, dstep = (int)(img.step/sizeof(short)); int i, j, dstep = (int)(img.step/sizeof(short));
int* labels = (int*)buf; int* labels = (int*)buf;
@ -879,33 +879,33 @@ void cv::filterSpeckles( InputOutputArray _img, double _newval, int maxSpeckleSi
buf += npixels*sizeof(wbuf[0]); buf += npixels*sizeof(wbuf[0]);
uchar* rtype = (uchar*)buf; uchar* rtype = (uchar*)buf;
int curlabel = 0; int curlabel = 0;
// clear out label assignments // clear out label assignments
memset(labels, 0, npixels*sizeof(labels[0])); memset(labels, 0, npixels*sizeof(labels[0]));
for( i = 0; i < height; i++ ) for( i = 0; i < height; i++ )
{ {
short* ds = img.ptr<short>(i); short* ds = img.ptr<short>(i);
int* ls = labels + width*i; int* ls = labels + width*i;
for( j = 0; j < width; j++ ) for( j = 0; j < width; j++ )
{ {
if( ds[j] != newVal ) // not a bad disparity if( ds[j] != newVal ) // not a bad disparity
{ {
if( ls[j] ) // has a label, check for bad label if( ls[j] ) // has a label, check for bad label
{ {
if( rtype[ls[j]] ) // small region, zero out disparity if( rtype[ls[j]] ) // small region, zero out disparity
ds[j] = (short)newVal; ds[j] = (short)newVal;
} }
// no label, assign and propagate // no label, assign and propagate
else else
{ {
Point2s* ws = wbuf; // initialize wavefront Point2s* ws = wbuf; // initialize wavefront
Point2s p((short)j, (short)i); // current pixel Point2s p((short)j, (short)i); // current pixel
curlabel++; // next label curlabel++; // next label
int count = 0; // current region size int count = 0; // current region size
ls[j] = curlabel; ls[j] = curlabel;
// wavefront propagation // wavefront propagation
while( ws >= wbuf ) // wavefront not empty while( ws >= wbuf ) // wavefront not empty
{ {
@ -914,50 +914,50 @@ void cv::filterSpeckles( InputOutputArray _img, double _newval, int maxSpeckleSi
short* dpp = &img.at<short>(p.y, p.x); short* dpp = &img.at<short>(p.y, p.x);
short dp = *dpp; short dp = *dpp;
int* lpp = labels + width*p.y + p.x; int* lpp = labels + width*p.y + p.x;
if( p.x < width-1 && !lpp[+1] && dpp[+1] != newVal && std::abs(dp - dpp[+1]) <= maxDiff ) if( p.x < width-1 && !lpp[+1] && dpp[+1] != newVal && std::abs(dp - dpp[+1]) <= maxDiff )
{ {
lpp[+1] = curlabel; lpp[+1] = curlabel;
*ws++ = Point2s(p.x+1, p.y); *ws++ = Point2s(p.x+1, p.y);
} }
if( p.x > 0 && !lpp[-1] && dpp[-1] != newVal && std::abs(dp - dpp[-1]) <= maxDiff ) if( p.x > 0 && !lpp[-1] && dpp[-1] != newVal && std::abs(dp - dpp[-1]) <= maxDiff )
{ {
lpp[-1] = curlabel; lpp[-1] = curlabel;
*ws++ = Point2s(p.x-1, p.y); *ws++ = Point2s(p.x-1, p.y);
} }
if( p.y < height-1 && !lpp[+width] && dpp[+dstep] != newVal && std::abs(dp - dpp[+dstep]) <= maxDiff ) if( p.y < height-1 && !lpp[+width] && dpp[+dstep] != newVal && std::abs(dp - dpp[+dstep]) <= maxDiff )
{ {
lpp[+width] = curlabel; lpp[+width] = curlabel;
*ws++ = Point2s(p.x, p.y+1); *ws++ = Point2s(p.x, p.y+1);
} }
if( p.y > 0 && !lpp[-width] && dpp[-dstep] != newVal && std::abs(dp - dpp[-dstep]) <= maxDiff ) if( p.y > 0 && !lpp[-width] && dpp[-dstep] != newVal && std::abs(dp - dpp[-dstep]) <= maxDiff )
{ {
lpp[-width] = curlabel; lpp[-width] = curlabel;
*ws++ = Point2s(p.x, p.y-1); *ws++ = Point2s(p.x, p.y-1);
} }
// pop most recent and propagate // pop most recent and propagate
// NB: could try least recent, maybe better convergence // NB: could try least recent, maybe better convergence
p = *--ws; p = *--ws;
} }
// assign label type // assign label type
if( count <= maxSpeckleSize ) // speckle region if( count <= maxSpeckleSize ) // speckle region
{ {
rtype[ls[j]] = 1; // small region label rtype[ls[j]] = 1; // small region label
ds[j] = (short)newVal; ds[j] = (short)newVal;
} }
else else
rtype[ls[j]] = 0; // large region label rtype[ls[j]] = 0; // large region label
} }
} }
} }
} }
} }
void cv::validateDisparity( InputOutputArray _disp, InputArray _cost, int minDisparity, void cv::validateDisparity( InputOutputArray _disp, InputArray _cost, int minDisparity,
int numberOfDisparities, int disp12MaxDiff ) int numberOfDisparities, int disp12MaxDiff )
{ {
@ -971,32 +971,32 @@ void cv::validateDisparity( InputOutputArray _disp, InputArray _cost, int minDis
const int DISP_SHIFT = 4, DISP_SCALE = 1 << DISP_SHIFT; const int DISP_SHIFT = 4, DISP_SCALE = 1 << DISP_SHIFT;
int INVALID_DISP = minD - 1, INVALID_DISP_SCALED = INVALID_DISP*DISP_SCALE; int INVALID_DISP = minD - 1, INVALID_DISP_SCALED = INVALID_DISP*DISP_SCALE;
int costType = cost.type(); int costType = cost.type();
disp12MaxDiff *= DISP_SCALE; disp12MaxDiff *= DISP_SCALE;
CV_Assert( numberOfDisparities > 0 && disp.type() == CV_16S && CV_Assert( numberOfDisparities > 0 && disp.type() == CV_16S &&
(costType == CV_16S || costType == CV_32S) && (costType == CV_16S || costType == CV_32S) &&
disp.size() == cost.size() ); disp.size() == cost.size() );
for( int y = 0; y < rows; y++ ) for( int y = 0; y < rows; y++ )
{ {
short* dptr = disp.ptr<short>(y); short* dptr = disp.ptr<short>(y);
for( x = 0; x < cols; x++ ) for( x = 0; x < cols; x++ )
{ {
disp2buf[x] = INVALID_DISP_SCALED; disp2buf[x] = INVALID_DISP_SCALED;
disp2cost[x] = INT_MAX; disp2cost[x] = INT_MAX;
} }
if( costType == CV_16S ) if( costType == CV_16S )
{ {
const short* cptr = cost.ptr<short>(y); const short* cptr = cost.ptr<short>(y);
for( x = minX1; x < maxX1; x++ ) for( x = minX1; x < maxX1; x++ )
{ {
int d = dptr[x], c = cptr[x]; int d = dptr[x], c = cptr[x];
int x2 = x - ((d + DISP_SCALE/2) >> DISP_SHIFT); int x2 = x - ((d + DISP_SCALE/2) >> DISP_SHIFT);
if( disp2cost[x2] > c ) if( disp2cost[x2] > c )
{ {
disp2cost[x2] = c; disp2cost[x2] = c;
@ -1007,12 +1007,12 @@ void cv::validateDisparity( InputOutputArray _disp, InputArray _cost, int minDis
else else
{ {
const int* cptr = cost.ptr<int>(y); const int* cptr = cost.ptr<int>(y);
for( x = minX1; x < maxX1; x++ ) for( x = minX1; x < maxX1; x++ )
{ {
int d = dptr[x], c = cptr[x]; int d = dptr[x], c = cptr[x];
int x2 = x - ((d + DISP_SCALE/2) >> DISP_SHIFT); int x2 = x - ((d + DISP_SCALE/2) >> DISP_SHIFT);
if( disp2cost[x2] < c ) if( disp2cost[x2] < c )
{ {
disp2cost[x2] = c; disp2cost[x2] = c;
@ -1020,7 +1020,7 @@ void cv::validateDisparity( InputOutputArray _disp, InputArray _cost, int minDis
} }
} }
} }
for( x = minX1; x < maxX1; x++ ) for( x = minX1; x < maxX1; x++ )
{ {
// we round the computed disparity both towards -inf and +inf and check // we round the computed disparity both towards -inf and +inf and check

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

File diff suppressed because it is too large Load Diff

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

@ -55,22 +55,22 @@ using namespace cv;
using namespace std; using namespace std;
//template<class T> ostream& operator<<(ostream& out, const Mat_<T>& mat) //template<class T> ostream& operator<<(ostream& out, const Mat_<T>& mat)
//{ //{
// for(Mat_<T>::const_iterator pos = mat.begin(), end = mat.end(); pos != end; ++pos) // for(Mat_<T>::const_iterator pos = mat.begin(), end = mat.end(); pos != end; ++pos)
// out << *pos << " "; // out << *pos << " ";
// return out; // return out;
//} //}
//ostream& operator<<(ostream& out, const Mat& mat) { return out << Mat_<double>(mat); } //ostream& operator<<(ostream& out, const Mat& mat) { return out << Mat_<double>(mat); }
Mat calcRvec(const vector<Point3f>& points, const Size& cornerSize) Mat calcRvec(const vector<Point3f>& points, const Size& cornerSize)
{ {
Point3f p00 = points[0]; Point3f p00 = points[0];
Point3f p10 = points[1]; Point3f p10 = points[1];
Point3f p01 = points[cornerSize.width]; Point3f p01 = points[cornerSize.width];
Vec3d ex(p10.x - p00.x, p10.y - p00.y, p10.z - p00.z); Vec3d ex(p10.x - p00.x, p10.y - p00.y, p10.z - p00.z);
Vec3d ey(p01.x - p00.x, p01.y - p00.y, p01.z - p00.z); Vec3d ey(p01.x - p00.x, p01.y - p00.y, p01.z - p00.z);
Vec3d ez = ex.cross(ey); Vec3d ez = ex.cross(ey);
Mat rot(3, 3, CV_64F); Mat rot(3, 3, CV_64F);
*rot.ptr<Vec3d>(0) = ex; *rot.ptr<Vec3d>(0) = ex;
@ -89,7 +89,7 @@ public:
{ {
} }
~CV_CalibrateCameraArtificialTest() {} ~CV_CalibrateCameraArtificialTest() {}
protected: protected:
int r; int r;
const static int JUST_FIND_CORNERS = 0; const static int JUST_FIND_CORNERS = 0;
@ -111,7 +111,7 @@ protected:
{ {
ts->printf( cvtest::TS::LOG, "Bad shape of camera matrix returned \n"); ts->printf( cvtest::TS::LOG, "Bad shape of camera matrix returned \n");
ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH); ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH);
} }
double fx_e = camMat_est.at<double>(0, 0), fy_e = camMat_est.at<double>(1, 1); double fx_e = camMat_est.at<double>(0, 0), fy_e = camMat_est.at<double>(1, 1);
double cx_e = camMat_est.at<double>(0, 2), cy_e = camMat_est.at<double>(1, 2); double cx_e = camMat_est.at<double>(0, 2), cy_e = camMat_est.at<double>(1, 2);
@ -121,19 +121,19 @@ protected:
const double eps = 1e-2; const double eps = 1e-2;
const double dlt = 1e-5; const double dlt = 1e-5;
bool fail = checkErr(fx_e, fx, eps, dlt) || checkErr(fy_e, fy, eps, dlt) || bool fail = checkErr(fx_e, fx, eps, dlt) || checkErr(fy_e, fy, eps, dlt) ||
checkErr(cx_e, cx, eps, dlt) || checkErr(cy_e, cy, eps, dlt); checkErr(cx_e, cx, eps, dlt) || checkErr(cy_e, cy, eps, dlt);
if (fail) if (fail)
{ {
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
} }
ts->printf( cvtest::TS::LOG, "%d) Expected [Fx Fy Cx Cy] = [%.3f %.3f %.3f %.3f]\n", r, fx, fy, cx, cy); ts->printf( cvtest::TS::LOG, "%d) Expected [Fx Fy Cx Cy] = [%.3f %.3f %.3f %.3f]\n", r, fx, fy, cx, cy);
ts->printf( cvtest::TS::LOG, "%d) Estimated [Fx Fy Cx Cy] = [%.3f %.3f %.3f %.3f]\n", r, fx_e, fy_e, cx_e, cy_e); ts->printf( cvtest::TS::LOG, "%d) Estimated [Fx Fy Cx Cy] = [%.3f %.3f %.3f %.3f]\n", r, fx_e, fy_e, cx_e, cy_e);
} }
void compareDistCoeffs(const Mat_<double>& distCoeffs, const Mat& distCoeffs_est) void compareDistCoeffs(const Mat_<double>& distCoeffs, const Mat& distCoeffs_est)
{ {
const double *dt_e = distCoeffs_est.ptr<double>(); const double *dt_e = distCoeffs_est.ptr<double>();
double k1_e = dt_e[0], k2_e = dt_e[1], k3_e = dt_e[4]; double k1_e = dt_e[0], k2_e = dt_e[1], k3_e = dt_e[4];
@ -143,21 +143,21 @@ protected:
double p1 = distCoeffs(0, 2), p2 = distCoeffs(0, 3); double p1 = distCoeffs(0, 2), p2 = distCoeffs(0, 3);
const double eps = 5e-2; const double eps = 5e-2;
const double dlt = 1e-3; const double dlt = 1e-3;
const double eps_k3 = 5; const double eps_k3 = 5;
const double dlt_k3 = 1e-3; const double dlt_k3 = 1e-3;
bool fail = checkErr(k1_e, k1, eps, dlt) || checkErr(k2_e, k2, eps, dlt) || checkErr(k3_e, k3, eps_k3, dlt_k3) || bool fail = checkErr(k1_e, k1, eps, dlt) || checkErr(k2_e, k2, eps, dlt) || checkErr(k3_e, k3, eps_k3, dlt_k3) ||
checkErr(p1_e, p1, eps, dlt) || checkErr(p2_e, p2, eps, dlt); checkErr(p1_e, p1, eps, dlt) || checkErr(p2_e, p2, eps, dlt);
if (fail) if (fail)
{ {
// commented according to vp123's recomendation. TODO - improve accuaracy // commented according to vp123's recomendation. TODO - improve accuaracy
//ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); ss //ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); ss
} }
ts->printf( cvtest::TS::LOG, "%d) DistCoeff exp=(%.2f, %.2f, %.4f, %.4f %.2f)\n", r, k1, k2, p1, p2, k3); ts->printf( cvtest::TS::LOG, "%d) DistCoeff exp=(%.2f, %.2f, %.4f, %.4f %.2f)\n", r, k1, k2, p1, p2, k3);
ts->printf( cvtest::TS::LOG, "%d) DistCoeff est=(%.2f, %.2f, %.4f, %.4f %.2f)\n", r, k1_e, k2_e, p1_e, p2_e, k3_e); ts->printf( cvtest::TS::LOG, "%d) DistCoeff est=(%.2f, %.2f, %.4f, %.4f %.2f)\n", r, k1_e, k2_e, p1_e, p2_e, k3_e);
ts->printf( cvtest::TS::LOG, "%d) AbsError = [%.5f %.5f %.5f %.5f %.5f]\n", r, fabs(k1-k1_e), fabs(k2-k2_e), fabs(p1-p1_e), fabs(p2-p2_e), fabs(k3-k3_e)); ts->printf( cvtest::TS::LOG, "%d) AbsError = [%.5f %.5f %.5f %.5f %.5f]\n", r, fabs(k1-k1_e), fabs(k2-k2_e), fabs(p1-p1_e), fabs(p2-p2_e), fabs(k3-k3_e));
} }
@ -173,20 +173,20 @@ protected:
const Point3d& tvec = *tvecs[i].ptr<Point3d>(); const Point3d& tvec = *tvecs[i].ptr<Point3d>();
const Point3d& tvec_est = *tvecs_est[i].ptr<Point3d>(); const Point3d& tvec_est = *tvecs_est[i].ptr<Point3d>();
if (norm(tvec_est - tvec) > eps* (norm(tvec) + dlt)) if (norm(tvec_est - tvec) > eps* (norm(tvec) + dlt))
{ {
if (err_count++ < errMsgNum) if (err_count++ < errMsgNum)
{ {
if (err_count == errMsgNum) if (err_count == errMsgNum)
ts->printf( cvtest::TS::LOG, "%d) ...\n", r); ts->printf( cvtest::TS::LOG, "%d) ...\n", r);
else else
{ {
ts->printf( cvtest::TS::LOG, "%d) Bad accuracy in returned tvecs. Index = %d\n", r, i); ts->printf( cvtest::TS::LOG, "%d) Bad accuracy in returned tvecs. Index = %d\n", r, i);
ts->printf( cvtest::TS::LOG, "%d) norm(tvec_est - tvec) = %f, norm(tvec_exp) = %f \n", r, norm(tvec_est - tvec), norm(tvec)); ts->printf( cvtest::TS::LOG, "%d) norm(tvec_est - tvec) = %f, norm(tvec_exp) = %f \n", r, norm(tvec_est - tvec), norm(tvec));
} }
} }
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
} }
} }
} }
@ -199,20 +199,20 @@ protected:
int err_count = 0; int err_count = 0;
const int errMsgNum = 4; const int errMsgNum = 4;
for(size_t i = 0; i < rvecs.size(); ++i) for(size_t i = 0; i < rvecs.size(); ++i)
{ {
Rodrigues(rvecs[i], rmat); Rodrigues(rvecs[i], rmat);
Rodrigues(rvecs_est[i], rmat_est); Rodrigues(rvecs_est[i], rmat_est);
if (norm(rmat_est, rmat) > eps* (norm(rmat) + dlt)) if (norm(rmat_est, rmat) > eps* (norm(rmat) + dlt))
{ {
if (err_count++ < errMsgNum) if (err_count++ < errMsgNum)
{ {
if (err_count == errMsgNum) if (err_count == errMsgNum)
ts->printf( cvtest::TS::LOG, "%d) ...\n", r); ts->printf( cvtest::TS::LOG, "%d) ...\n", r);
else else
{ {
ts->printf( cvtest::TS::LOG, "%d) Bad accuracy in returned rvecs (rotation matrs). Index = %d\n", r, i); ts->printf( cvtest::TS::LOG, "%d) Bad accuracy in returned rvecs (rotation matrs). Index = %d\n", r, i);
ts->printf( cvtest::TS::LOG, "%d) norm(rot_mat_est - rot_mat_exp) = %f, norm(rot_mat_exp) = %f \n", r, norm(rmat_est, rmat), norm(rmat)); ts->printf( cvtest::TS::LOG, "%d) norm(rot_mat_est - rot_mat_exp) = %f, norm(rot_mat_exp) = %f \n", r, norm(rmat_est, rmat), norm(rmat));
} }
} }
@ -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]);
} }
@ -243,7 +243,7 @@ protected:
Size2f sqSile; Size2f sqSile;
vector<Point3f> chessboard3D; vector<Point3f> chessboard3D;
vector<Mat> boards, rvecs_exp, tvecs_exp, rvecs_spnp, tvecs_spnp; vector<Mat> boards, rvecs_exp, tvecs_exp, rvecs_spnp, tvecs_spnp;
vector< vector<Point3f> > objectPoints; vector< vector<Point3f> > objectPoints;
vector< vector<Point2f> > imagePoints_art; vector< vector<Point2f> > imagePoints_art;
vector< vector<Point2f> > imagePoints_findCb; vector< vector<Point2f> > imagePoints_findCb;
@ -268,29 +268,29 @@ protected:
imagePoints_findCb.clear(); imagePoints_findCb.clear();
vector<Point2f> corners_art, corners_fcb; vector<Point2f> corners_art, corners_fcb;
for(size_t i = 0; i < brdsNum; ++i) for(size_t i = 0; i < brdsNum; ++i)
{ {
for(;;) for(;;)
{ {
boards[i] = cbg(bg, camMat, distCoeffs, sqSile, corners_art); boards[i] = cbg(bg, camMat, distCoeffs, sqSile, corners_art);
if(findChessboardCorners(boards[i], cornersSize, corners_fcb)) if(findChessboardCorners(boards[i], cornersSize, corners_fcb))
break; break;
} }
//cv::namedWindow("CB"); imshow("CB", boards[i]); cv::waitKey(); //cv::namedWindow("CB"); imshow("CB", boards[i]); cv::waitKey();
imagePoints_art.push_back(corners_art); imagePoints_art.push_back(corners_art);
imagePoints_findCb.push_back(corners_fcb); imagePoints_findCb.push_back(corners_fcb);
tvecs_exp[i].create(1, 3, CV_64F); tvecs_exp[i].create(1, 3, CV_64F);
*tvecs_exp[i].ptr<Point3d>() = cbg.corners3d[0]; *tvecs_exp[i].ptr<Point3d>() = cbg.corners3d[0];
rvecs_exp[i] = calcRvec(cbg.corners3d, cbg.cornersSize()); rvecs_exp[i] = calcRvec(cbg.corners3d, cbg.cornersSize());
} }
} }
void runTest(const Size& imgSize, const Mat_<double>& camMat, const Mat_<double>& distCoeffs, size_t brdsNum, const Size& cornersSize, int flag = 0) void runTest(const Size& imgSize, const Mat_<double>& camMat, const Mat_<double>& distCoeffs, size_t brdsNum, const Size& cornersSize, int flag = 0)
{ {
const TermCriteria tc(TermCriteria::EPS|TermCriteria::MAX_ITER, 30, 0.1); const TermCriteria tc(TermCriteria::EPS|TermCriteria::MAX_ITER, 30, 0.1);
vector< vector<Point2f> > imagePoints; vector< vector<Point2f> > imagePoints;
@ -300,9 +300,9 @@ protected:
case JUST_FIND_CORNERS: imagePoints = imagePoints_findCb; break; case JUST_FIND_CORNERS: imagePoints = imagePoints_findCb; break;
case ARTIFICIAL_CORNERS: imagePoints = imagePoints_art; break; case ARTIFICIAL_CORNERS: imagePoints = imagePoints_art; break;
case USE_CORNERS_SUBPIX: case USE_CORNERS_SUBPIX:
for(size_t i = 0; i < brdsNum; ++i) for(size_t i = 0; i < brdsNum; ++i)
{ {
Mat gray; Mat gray;
cvtColor(boards[i], gray, CV_BGR2GRAY); cvtColor(boards[i], gray, CV_BGR2GRAY);
vector<Point2f> tmp = imagePoints_findCb[i]; vector<Point2f> tmp = imagePoints_findCb[i];
@ -312,9 +312,9 @@ protected:
break; break;
case USE_4QUAD_CORNERS: case USE_4QUAD_CORNERS:
for(size_t i = 0; i < brdsNum; ++i) for(size_t i = 0; i < brdsNum; ++i)
{ {
Mat gray; Mat gray;
cvtColor(boards[i], gray, CV_BGR2GRAY); cvtColor(boards[i], gray, CV_BGR2GRAY);
vector<Point2f> tmp = imagePoints_findCb[i]; vector<Point2f> tmp = imagePoints_findCb[i];
find4QuadCornerSubpix(gray, tmp, Size(5, 5)); find4QuadCornerSubpix(gray, tmp, Size(5, 5));
imagePoints.push_back(tmp); imagePoints.push_back(tmp);
@ -323,7 +323,7 @@ protected:
default: default:
throw std::exception(); throw std::exception();
} }
Mat camMat_est = Mat::eye(3, 3, CV_64F), distCoeffs_est = Mat::zeros(1, 5, CV_64F); Mat camMat_est = Mat::eye(3, 3, CV_64F), distCoeffs_est = Mat::zeros(1, 5, CV_64F);
vector<Mat> rvecs_est, tvecs_est; vector<Mat> rvecs_est, tvecs_est;
@ -342,9 +342,9 @@ protected:
compareCameraMatrs(camMat, camMat_est); compareCameraMatrs(camMat, camMat_est);
compareDistCoeffs(distCoeffs, distCoeffs_est); compareDistCoeffs(distCoeffs, distCoeffs_est);
compareShiftVecs(tvecs_exp, tvecs_est); compareShiftVecs(tvecs_exp, tvecs_est);
compareRotationVecs(rvecs_exp, rvecs_est); compareRotationVecs(rvecs_exp, rvecs_est);
double rep_errorWOI = reprojectErrorWithoutIntrinsics(chessboard3D, rvecs_exp, tvecs_exp, rvecs_est, tvecs_est); double rep_errorWOI = reprojectErrorWithoutIntrinsics(chessboard3D, rvecs_exp, tvecs_exp, rvecs_est, tvecs_est);
rep_errorWOI /= brdsNum * cornersSize.area(); rep_errorWOI /= brdsNum * cornersSize.area();
const double thres2 = 0.01; const double thres2 = 0.01;
@ -352,8 +352,8 @@ protected:
{ {
ts->printf( cvtest::TS::LOG, "%d) Too big reproject error without intrinsics = %f\n", r, rep_errorWOI); ts->printf( cvtest::TS::LOG, "%d) Too big reproject error without intrinsics = %f\n", r, rep_errorWOI);
ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY);
} }
ts->printf( cvtest::TS::LOG, "%d) Testing solvePnP...\n", r); ts->printf( cvtest::TS::LOG, "%d) Testing solvePnP...\n", r);
rvecs_spnp.resize(brdsNum); rvecs_spnp.resize(brdsNum);
tvecs_spnp.resize(brdsNum); tvecs_spnp.resize(brdsNum);
@ -361,11 +361,11 @@ protected:
solvePnP(Mat(objectPoints[i]), Mat(imagePoints[i]), camMat, distCoeffs, rvecs_spnp[i], tvecs_spnp[i]); solvePnP(Mat(objectPoints[i]), Mat(imagePoints[i]), camMat, distCoeffs, rvecs_spnp[i], tvecs_spnp[i]);
compareShiftVecs(tvecs_exp, tvecs_spnp); compareShiftVecs(tvecs_exp, tvecs_spnp);
compareRotationVecs(rvecs_exp, rvecs_spnp); compareRotationVecs(rvecs_exp, rvecs_spnp);
} }
void run(int) void run(int)
{ {
ts->set_failed_test_info(cvtest::TS::OK); ts->set_failed_test_info(cvtest::TS::OK);
RNG& rng = theRNG(); RNG& rng = theRNG();
@ -373,11 +373,11 @@ protected:
int progress = 0; int progress = 0;
int repeat_num = 3; int repeat_num = 3;
for(r = 0; r < repeat_num; ++r) for(r = 0; r < repeat_num; ++r)
{ {
const int brds_num = 20; const int brds_num = 20;
Mat bg(Size(640, 480), CV_8UC3); Mat bg(Size(640, 480), CV_8UC3);
randu(bg, Scalar::all(32), Scalar::all(255)); randu(bg, Scalar::all(32), Scalar::all(255));
GaussianBlur(bg, bg, Size(5, 5), 2); GaussianBlur(bg, bg, Size(5, 5), 2);
double fx = 300 + (20 * (double)rng - 10); double fx = 300 + (20 * (double)rng - 10);
@ -399,20 +399,20 @@ protected:
Mat_<double> distCoeffs(1, 5, 0.0); Mat_<double> distCoeffs(1, 5, 0.0);
distCoeffs << k1, k2, p1, p2, k3; distCoeffs << k1, k2, p1, p2, k3;
ChessBoardGenerator cbg(Size(9, 8)); ChessBoardGenerator cbg(Size(9, 8));
cbg.min_cos = 0.9; cbg.min_cos = 0.9;
cbg.cov = 0.8; cbg.cov = 0.8;
progress = update_progress(progress, r, repeat_num, 0); progress = update_progress(progress, r, repeat_num, 0);
ts->printf( cvtest::TS::LOG, "\n"); ts->printf( cvtest::TS::LOG, "\n");
prepareForTest(bg, camMat, distCoeffs, brds_num, cbg); prepareForTest(bg, camMat, distCoeffs, brds_num, cbg);
ts->printf( cvtest::TS::LOG, "artificial corners\n"); ts->printf( cvtest::TS::LOG, "artificial corners\n");
runTest(bg.size(), camMat, distCoeffs, brds_num, cbg.cornersSize(), ARTIFICIAL_CORNERS); runTest(bg.size(), camMat, distCoeffs, brds_num, cbg.cornersSize(), ARTIFICIAL_CORNERS);
progress = update_progress(progress, r, repeat_num, 0); progress = update_progress(progress, r, repeat_num, 0);
ts->printf( cvtest::TS::LOG, "findChessboard corners\n"); ts->printf( cvtest::TS::LOG, "findChessboard corners\n");
runTest(bg.size(), camMat, distCoeffs, brds_num, cbg.cornersSize(), JUST_FIND_CORNERS); runTest(bg.size(), camMat, distCoeffs, brds_num, cbg.cornersSize(), JUST_FIND_CORNERS);
progress = update_progress(progress, r, repeat_num, 0); progress = update_progress(progress, r, repeat_num, 0);
ts->printf( cvtest::TS::LOG, "cornersSubPix corners\n"); ts->printf( cvtest::TS::LOG, "cornersSubPix corners\n");
@ -424,6 +424,6 @@ protected:
progress = update_progress(progress, r, repeat_num, 0); progress = update_progress(progress, r, repeat_num, 0);
} }
} }
}; };
TEST(Calib3d_CalibrateCamera_CPP, accuracy_on_artificial_data) { CV_CalibrateCameraArtificialTest test; test.safe_run(); } TEST(Calib3d_CalibrateCamera_CPP, accuracy_on_artificial_data) { CV_CalibrateCameraArtificialTest test; test.safe_run(); }

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

@ -54,9 +54,9 @@ void show_points( const Mat& gray, const Mat& u, const vector<Point2f>& v, Size
{ {
Mat rgb( gray.size(), CV_8U); Mat rgb( gray.size(), CV_8U);
merge(vector<Mat>(3, gray), rgb); merge(vector<Mat>(3, gray), rgb);
for(size_t i = 0; i < v.size(); i++ ) for(size_t i = 0; i < v.size(); i++ )
circle( rgb, v[i], 3, CV_RGB(255, 0, 0), CV_FILLED); circle( rgb, v[i], 3, CV_RGB(255, 0, 0), CV_FILLED);
if( !u.empty() ) if( !u.empty() )
{ {
@ -67,7 +67,7 @@ void show_points( const Mat& gray, const Mat& u, const vector<Point2f>& v, Size
} }
if (!v.empty()) if (!v.empty())
{ {
Mat corners((int)v.size(), 1, CV_32FC2, (void*)&v[0]); Mat corners((int)v.size(), 1, CV_32FC2, (void*)&v[0]);
drawChessboardCorners( rgb, pattern_size, corners, was_found ); drawChessboardCorners( rgb, pattern_size, corners, was_found );
} }
//namedWindow( "test", 0 ); imshow( "test", rgb ); waitKey(0); //namedWindow( "test", 0 ); imshow( "test", rgb ); waitKey(0);
@ -122,11 +122,11 @@ double calcError(const vector<Point2f>& v, const Mat& u)
//printf("\n"); //printf("\n");
err = min(err, err1); err = min(err, err1);
} }
#if defined(_L2_ERR) #if defined(_L2_ERR)
err = sqrt(err/count_exp); err = sqrt(err/count_exp);
#endif //_L2_ERR #endif //_L2_ERR
return err; return err;
} }
@ -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,23 +145,23 @@ 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;
} }
run_batch("chessboard_list_subpixel.dat"); run_batch("chessboard_list_subpixel.dat");
break; break;
case CIRCLES_GRID: case CIRCLES_GRID:
@ -176,36 +175,34 @@ 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;
#endif #endif
string folder; string folder;
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;
} }
FileStorage fs( folder + filename, FileStorage::READ ); FileStorage fs( folder + filename, FileStorage::READ );
FileNode board_list = fs["boards"]; FileNode board_list = fs["boards"];
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,29 +213,29 @@ 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];
Mat gray = imread( folder + img_file, 0); Mat gray = imread( folder + img_file, 0);
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();
vector<Point2f> v; vector<Point2f> v;
@ -256,11 +253,11 @@ void CV_ChessboardDetectorTest::run_batch( const string& filename )
break; break;
} }
show_points( gray, Mat(), v, pattern_size, result ); show_points( gray, Mat(), v, pattern_size, result );
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,45 +288,45 @@ 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();
#endif #endif
progress = update_progress( progress, idx, max_idx, 0 ); progress = update_progress( progress, idx, max_idx, 0 );
} }
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)
{ {
Mat m1(cornSz, CV_32FC2, (Point2f*)&corners_generated[0]); Mat m1(cornSz, CV_32FC2, (Point2f*)&corners_generated[0]);
Mat m2; flip(m1, m2, 0); Mat m2; flip(m1, m2, 0);
Mat m3; flip(m1, m3, 1); m3 = m3.t(); flip(m3, m3, 1); Mat m3; flip(m1, m3, 1); m3 = m3.t(); flip(m3, m3, 1);
Mat m4 = m1.t(); flip(m4, m4, 1); Mat m4 = m1.t(); flip(m4, m4, 1);
double min1 = min(calcError(corners_found, m1), calcError(corners_found, m2)); double min1 = min(calcError(corners_found, m1), calcError(corners_found, m2));
double min2 = min(calcError(corners_found, m3), calcError(corners_found, m4)); double min2 = min(calcError(corners_found, m3), calcError(corners_found, m4));
return min(min1, min2); return min(min1, min2);
} }
bool validateData(const ChessBoardGenerator& cbg, const Size& imgSz, bool validateData(const ChessBoardGenerator& cbg, const Size& imgSz,
const vector<Point2f>& corners_generated) const vector<Point2f>& corners_generated)
{ {
Size cornersSize = cbg.cornersSize(); Size cornersSize = cbg.cornersSize();
@ -341,7 +338,7 @@ bool validateData(const ChessBoardGenerator& cbg, const Size& imgSz,
for(int j = 1; j < mat.cols - 2; ++j) for(int j = 1; j < mat.cols - 2; ++j)
{ {
const Point2f& cur = mat(i, j); const Point2f& cur = mat(i, j);
tmp = norm( cur - mat(i + 1, j + 1) ); tmp = norm( cur - mat(i + 1, j + 1) );
if (tmp < minNeibDist) if (tmp < minNeibDist)
tmp = minNeibDist; tmp = minNeibDist;
@ -361,33 +358,33 @@ bool validateData(const ChessBoardGenerator& cbg, const Size& imgSz,
const double threshold = 0.25; const double threshold = 0.25;
double cbsize = (max(cornersSize.width, cornersSize.height) + 1) * minNeibDist; double cbsize = (max(cornersSize.width, cornersSize.height) + 1) * minNeibDist;
int imgsize = min(imgSz.height, imgSz.width); int imgsize = min(imgSz.height, imgSz.width);
return imgsize * threshold < cbsize; return imgsize * threshold < cbsize;
} }
bool CV_ChessboardDetectorTest::checkByGenerator() bool CV_ChessboardDetectorTest::checkByGenerator()
{ {
bool res = true; bool res = true;
//theRNG() = 0x58e6e895b9913160; //theRNG() = 0x58e6e895b9913160;
//cv::DefaultRngAuto dra; //cv::DefaultRngAuto dra;
//theRNG() = *ts->get_rng(); //theRNG() = *ts->get_rng();
Mat bg(Size(800, 600), CV_8UC3, Scalar::all(255)); Mat bg(Size(800, 600), CV_8UC3, Scalar::all(255));
randu(bg, Scalar::all(0), Scalar::all(255)); randu(bg, Scalar::all(0), Scalar::all(255));
GaussianBlur(bg, bg, Size(7,7), 3.0); GaussianBlur(bg, bg, Size(7,7), 3.0);
Mat_<float> camMat(3, 3); Mat_<float> camMat(3, 3);
camMat << 300.f, 0.f, bg.cols/2.f, 0, 300.f, bg.rows/2.f, 0.f, 0.f, 1.f; camMat << 300.f, 0.f, bg.cols/2.f, 0, 300.f, bg.rows/2.f, 0.f, 0.f, 1.f;
Mat_<float> distCoeffs(1, 5); Mat_<float> distCoeffs(1, 5);
distCoeffs << 1.2f, 0.2f, 0.f, 0.f, 0.f; distCoeffs << 1.2f, 0.2f, 0.f, 0.f, 0.f;
const Size sizes[] = { Size(6, 6), Size(8, 6), Size(11, 12), Size(5, 4) }; const Size sizes[] = { Size(6, 6), Size(8, 6), Size(11, 12), Size(5, 4) };
const size_t sizes_num = sizeof(sizes)/sizeof(sizes[0]); const size_t sizes_num = sizeof(sizes)/sizeof(sizes[0]);
const int test_num = 16; const int test_num = 16;
int progress = 0; int progress = 0;
for(int i = 0; i < test_num; ++i) for(int i = 0; i < test_num; ++i)
{ {
progress = update_progress( progress, i, test_num, 0 ); progress = update_progress( progress, i, test_num, 0 );
ChessBoardGenerator cbg(sizes[i % sizes_num]); ChessBoardGenerator cbg(sizes[i % sizes_num]);
@ -398,37 +395,37 @@ bool CV_ChessboardDetectorTest::checkByGenerator()
if(!validateData(cbg, cb.size(), corners_generated)) if(!validateData(cbg, cb.size(), corners_generated))
{ {
ts->printf( cvtest::TS::LOG, "Chess board skipped - too small" ); ts->printf( cvtest::TS::LOG, "Chess board skipped - too small" );
continue; continue;
} }
/*cb = cb * 0.8 + Scalar::all(30); /*cb = cb * 0.8 + Scalar::all(30);
GaussianBlur(cb, cb, Size(3, 3), 0.8); */ GaussianBlur(cb, cb, Size(3, 3), 0.8); */
//cv::addWeighted(cb, 0.8, bg, 0.2, 20, cb); //cv::addWeighted(cb, 0.8, bg, 0.2, 20, cb);
//cv::namedWindow("CB"); cv::imshow("CB", cb); cv::waitKey(); //cv::namedWindow("CB"); cv::imshow("CB", cb); cv::waitKey();
vector<Point2f> corners_found; vector<Point2f> corners_found;
int flags = i % 8; // need to check branches for all flags int flags = i % 8; // need to check branches for all flags
bool found = findChessboardCorners(cb, cbg.cornersSize(), corners_found, flags); bool found = findChessboardCorners(cb, cbg.cornersSize(), corners_found, flags);
if (!found) if (!found)
{ {
ts->printf( cvtest::TS::LOG, "Chess board corners not found\n" ); ts->printf( cvtest::TS::LOG, "Chess board corners not found\n" );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY ); ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
res = false; res = false;
return res; return res;
} }
double err = calcErrorMinError(cbg.cornersSize(), corners_found, corners_generated); double err = calcErrorMinError(cbg.cornersSize(), corners_found, corners_generated);
if( err > rough_success_error_level ) if( err > rough_success_error_level )
{ {
ts->printf( cvtest::TS::LOG, "bad accuracy of corner guesses" ); ts->printf( cvtest::TS::LOG, "bad accuracy of corner guesses" );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY ); ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
res = false; res = false;
return res; return res;
} }
} }
/* ***** negative ***** */ /* ***** negative ***** */
{ {
vector<Point2f> corners_found; vector<Point2f> corners_found;
bool found = findChessboardCorners(bg, Size(8, 7), corners_found); bool found = findChessboardCorners(bg, Size(8, 7), corners_found);
if (found) if (found)
@ -437,27 +434,27 @@ bool CV_ChessboardDetectorTest::checkByGenerator()
ChessBoardGenerator cbg(Size(8, 7)); ChessBoardGenerator cbg(Size(8, 7));
vector<Point2f> cg; vector<Point2f> cg;
Mat cb = cbg(bg, camMat, distCoeffs, cg); Mat cb = cbg(bg, camMat, distCoeffs, cg);
found = findChessboardCorners(cb, Size(3, 4), corners_found); found = findChessboardCorners(cb, Size(3, 4), corners_found);
if (found) if (found)
res = false; res = false;
Point2f c = std::accumulate(cg.begin(), cg.end(), Point2f(), plus<Point2f>()) * (1.f/cg.size()); Point2f c = std::accumulate(cg.begin(), cg.end(), Point2f(), plus<Point2f>()) * (1.f/cg.size());
Mat_<double> aff(2, 3); Mat_<double> aff(2, 3);
aff << 1.0, 0.0, -(double)c.x, 0.0, 1.0, 0.0; aff << 1.0, 0.0, -(double)c.x, 0.0, 1.0, 0.0;
Mat sh; Mat sh;
warpAffine(cb, sh, aff, cb.size()); warpAffine(cb, sh, aff, cb.size());
found = findChessboardCorners(sh, cbg.cornersSize(), corners_found); found = findChessboardCorners(sh, cbg.cornersSize(), corners_found);
if (found) if (found)
res = false; res = false;
vector< vector<Point> > cnts(1); vector< vector<Point> > cnts(1);
vector<Point>& cnt = cnts[0]; vector<Point>& cnt = cnts[0];
cnt.push_back(cg[ 0]); cnt.push_back(cg[0+2]); cnt.push_back(cg[ 0]); cnt.push_back(cg[0+2]);
cnt.push_back(cg[7+0]); cnt.push_back(cg[7+2]); cnt.push_back(cg[7+0]); cnt.push_back(cg[7+2]);
cv::drawContours(cb, cnts, -1, Scalar::all(128), CV_FILLED); cv::drawContours(cb, cnts, -1, Scalar::all(128), CV_FILLED);
found = findChessboardCorners(cb, cbg.cornersSize(), corners_found); found = findChessboardCorners(cb, cbg.cornersSize(), corners_found);
@ -466,7 +463,7 @@ bool CV_ChessboardDetectorTest::checkByGenerator()
cv::drawChessboardCorners(cb, cbg.cornersSize(), Mat(corners_found), found); cv::drawChessboardCorners(cb, cbg.cornersSize(), Mat(corners_found), found);
} }
return res; return res;
} }

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

@ -47,87 +47,87 @@ using namespace std;
class Differential class Differential
{ {
public: public:
typedef Mat_<double> mat_t; typedef Mat_<double> mat_t;
Differential(double eps_, const mat_t& rv1_, const mat_t& tv1_, const mat_t& rv2_, const mat_t& tv2_) Differential(double eps_, const mat_t& rv1_, const mat_t& tv1_, const mat_t& rv2_, const mat_t& tv2_)
: rv1(rv1_), tv1(tv1_), rv2(rv2_), tv2(tv2_), eps(eps_), ev(3, 1) {} : rv1(rv1_), tv1(tv1_), rv2(rv2_), tv2(tv2_), eps(eps_), ev(3, 1) {}
void dRv1(mat_t& dr3_dr1, mat_t& dt3_dr1) void dRv1(mat_t& dr3_dr1, mat_t& dt3_dr1)
{ {
dr3_dr1.create(3, 3); dt3_dr1.create(3, 3); dr3_dr1.create(3, 3); dt3_dr1.create(3, 3);
for(int i = 0; i < 3; ++i) for(int i = 0; i < 3; ++i)
{ {
ev.setTo(Scalar(0)); ev(i, 0) = eps; ev.setTo(Scalar(0)); ev(i, 0) = eps;
composeRT( rv1 + ev, tv1, rv2, tv2, rv3_p, tv3_p); composeRT( rv1 + ev, tv1, rv2, tv2, rv3_p, tv3_p);
composeRT( rv1 - ev, tv1, rv2, tv2, rv3_m, tv3_m); composeRT( rv1 - ev, tv1, rv2, tv2, rv3_m, tv3_m);
dr3_dr1.col(i) = rv3_p - rv3_m; dr3_dr1.col(i) = rv3_p - rv3_m;
dt3_dr1.col(i) = tv3_p - tv3_m; dt3_dr1.col(i) = tv3_p - tv3_m;
} }
dr3_dr1 /= 2 * eps; dt3_dr1 /= 2 * eps; dr3_dr1 /= 2 * eps; dt3_dr1 /= 2 * eps;
} }
void dRv2(mat_t& dr3_dr2, mat_t& dt3_dr2) void dRv2(mat_t& dr3_dr2, mat_t& dt3_dr2)
{ {
dr3_dr2.create(3, 3); dt3_dr2.create(3, 3); dr3_dr2.create(3, 3); dt3_dr2.create(3, 3);
for(int i = 0; i < 3; ++i) for(int i = 0; i < 3; ++i)
{ {
ev.setTo(Scalar(0)); ev(i, 0) = eps; ev.setTo(Scalar(0)); ev(i, 0) = eps;
composeRT( rv1, tv1, rv2 + ev, tv2, rv3_p, tv3_p); composeRT( rv1, tv1, rv2 + ev, tv2, rv3_p, tv3_p);
composeRT( rv1, tv1, rv2 - ev, tv2, rv3_m, tv3_m); composeRT( rv1, tv1, rv2 - ev, tv2, rv3_m, tv3_m);
dr3_dr2.col(i) = rv3_p - rv3_m; dr3_dr2.col(i) = rv3_p - rv3_m;
dt3_dr2.col(i) = tv3_p - tv3_m; dt3_dr2.col(i) = tv3_p - tv3_m;
} }
dr3_dr2 /= 2 * eps; dt3_dr2 /= 2 * eps; dr3_dr2 /= 2 * eps; dt3_dr2 /= 2 * eps;
} }
void dTv1(mat_t& drt3_dt1, mat_t& dt3_dt1) void dTv1(mat_t& drt3_dt1, mat_t& dt3_dt1)
{ {
drt3_dt1.create(3, 3); dt3_dt1.create(3, 3); drt3_dt1.create(3, 3); dt3_dt1.create(3, 3);
for(int i = 0; i < 3; ++i) for(int i = 0; i < 3; ++i)
{ {
ev.setTo(Scalar(0)); ev(i, 0) = eps; ev.setTo(Scalar(0)); ev(i, 0) = eps;
composeRT( rv1, tv1 + ev, rv2, tv2, rv3_p, tv3_p); composeRT( rv1, tv1 + ev, rv2, tv2, rv3_p, tv3_p);
composeRT( rv1, tv1 - ev, rv2, tv2, rv3_m, tv3_m); composeRT( rv1, tv1 - ev, rv2, tv2, rv3_m, tv3_m);
drt3_dt1.col(i) = rv3_p - rv3_m; drt3_dt1.col(i) = rv3_p - rv3_m;
dt3_dt1.col(i) = tv3_p - tv3_m; dt3_dt1.col(i) = tv3_p - tv3_m;
} }
drt3_dt1 /= 2 * eps; dt3_dt1 /= 2 * eps; drt3_dt1 /= 2 * eps; dt3_dt1 /= 2 * eps;
} }
void dTv2(mat_t& dr3_dt2, mat_t& dt3_dt2) void dTv2(mat_t& dr3_dt2, mat_t& dt3_dt2)
{ {
dr3_dt2.create(3, 3); dt3_dt2.create(3, 3); dr3_dt2.create(3, 3); dt3_dt2.create(3, 3);
for(int i = 0; i < 3; ++i) for(int i = 0; i < 3; ++i)
{ {
ev.setTo(Scalar(0)); ev(i, 0) = eps; ev.setTo(Scalar(0)); ev(i, 0) = eps;
composeRT( rv1, tv1, rv2, tv2 + ev, rv3_p, tv3_p); composeRT( rv1, tv1, rv2, tv2 + ev, rv3_p, tv3_p);
composeRT( rv1, tv1, rv2, tv2 - ev, rv3_m, tv3_m); composeRT( rv1, tv1, rv2, tv2 - ev, rv3_m, tv3_m);
dr3_dt2.col(i) = rv3_p - rv3_m; dr3_dt2.col(i) = rv3_p - rv3_m;
dt3_dt2.col(i) = tv3_p - tv3_m; dt3_dt2.col(i) = tv3_p - tv3_m;
} }
dr3_dt2 /= 2 * eps; dt3_dt2 /= 2 * eps; dr3_dt2 /= 2 * eps; dt3_dt2 /= 2 * eps;
} }
private: private:
const mat_t& rv1, tv1, rv2, tv2; const mat_t& rv1, tv1, rv2, tv2;
double eps; double eps;
Mat_<double> ev; Mat_<double> ev;
Differential& operator=(const Differential&); Differential& operator=(const Differential&);
Mat rv3_m, tv3_m, rv3_p, tv3_p; Mat rv3_m, tv3_m, rv3_p, tv3_p;
}; };
class CV_composeRT_Test : public cvtest::BaseTest class CV_composeRT_Test : public cvtest::BaseTest
@ -135,24 +135,23 @@ class CV_composeRT_Test : public cvtest::BaseTest
public: public:
CV_composeRT_Test() {} CV_composeRT_Test() {}
~CV_composeRT_Test() {} ~CV_composeRT_Test() {}
protected: 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);
randu(rvec1, Scalar(0), Scalar(6.29)); randu(rvec1, Scalar(0), Scalar(6.29));
randu(rvec2, Scalar(0), Scalar(6.29)); randu(rvec2, Scalar(0), Scalar(6.29));
randu(tvec1, Scalar(-2), Scalar(2)); randu(tvec1, Scalar(-2), Scalar(2));
randu(tvec2, Scalar(-2), Scalar(2)); randu(tvec2, Scalar(-2), Scalar(2));
Mat rvec3, tvec3; Mat rvec3, tvec3;
composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3); composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3);
Mat rvec3_exp, tvec3_exp; Mat rvec3_exp, tvec3_exp;
Mat rmat1, rmat2; Mat rmat1, rmat2;
@ -164,53 +163,53 @@ 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);
Mat dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1, dt3dt1, dt3dr2, dt3dt2; Mat dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1, dt3dt1, dt3dr2, dt3dt2;
composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3, composeRT(rvec1, tvec1, rvec2, tvec2, rvec3, tvec3,
dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1, dt3dt1, dt3dr2, dt3dt2); dr3dr1, dr3dt1, dr3dr2, dr3dt2, dt3dr1, dt3dt1, dt3dr2, dt3dt2);
Mat_<double> dr3_dr1, dt3_dr1; Mat_<double> dr3_dr1, dt3_dr1;
diff.dRv1(dr3_dr1, dt3_dr1); diff.dRv1(dr3_dr1, dt3_dr1);
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;
diff.dRv2(dr3_dr2, dt3_dr2); diff.dRv2(dr3_dr2, dt3_dr2);
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;
diff.dTv1(dr3_dt1, dt3_dt1); diff.dTv1(dr3_dt1, dt3_dt1);
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;
diff.dTv2(dr3_dt2, dt3_dt2); diff.dTv2(dr3_dt2, dt3_dt2);
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);
} }
} }
}; };
TEST(Calib3d_ComposeRT, accuracy) { CV_composeRT_Test test; test.safe_run(); } TEST(Calib3d_ComposeRT, accuracy) { CV_composeRT_Test test; test.safe_run(); }

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

@ -86,20 +86,20 @@ protected:
double sigma; double sigma;
private: private:
float max_diff, max_2diff; float max_diff, max_2diff;
bool check_matrix_size(const cv::Mat& H); bool check_matrix_size(const cv::Mat& H);
bool check_matrix_diff(const cv::Mat& original, const cv::Mat& found, const int norm_type, double &diff); bool check_matrix_diff(const cv::Mat& original, const cv::Mat& found, const int norm_type, double &diff);
int check_ransac_mask_1(const Mat& src, const Mat& mask); int check_ransac_mask_1(const Mat& src, const Mat& mask);
int check_ransac_mask_2(const Mat& original_mask, const Mat& found_mask); int check_ransac_mask_2(const Mat& original_mask, const Mat& found_mask);
void print_information_1(int j, int N, int method, const Mat& H); void print_information_1(int j, int N, int method, const Mat& H);
void print_information_2(int j, int N, int method, const Mat& H, const Mat& H_res, int k, double diff); void print_information_2(int j, int N, int method, const Mat& H, const Mat& H_res, int k, double diff);
void print_information_3(int j, int N, const Mat& mask); void print_information_3(int j, int N, const Mat& mask);
void print_information_4(int method, int j, int N, int k, int l, double diff); void print_information_4(int method, int j, int N, int k, int l, double diff);
void print_information_5(int method, int j, int N, int l, double diff); void print_information_5(int method, int j, int N, int l, double diff);
void print_information_6(int j, int N, int k, double diff, bool value); void print_information_6(int j, int N, int k, double diff, bool value);
void print_information_7(int j, int N, int k, double diff, bool original_value, bool found_value); void print_information_7(int j, int N, int k, double diff, bool original_value, bool found_value);
void print_information_8(int j, int N, int k, int l, double diff); void print_information_8(int j, int N, int k, int l, double diff);
}; };
CV_HomographyTest::CV_HomographyTest() : max_diff(1e-2f), max_2diff(2e-2f) CV_HomographyTest::CV_HomographyTest() : max_diff(1e-2f), max_2diff(2e-2f)
@ -112,7 +112,7 @@ CV_HomographyTest::CV_HomographyTest() : max_diff(1e-2f), max_2diff(2e-2f)
CV_HomographyTest::~CV_HomographyTest() {} CV_HomographyTest::~CV_HomographyTest() {}
bool CV_HomographyTest::check_matrix_size(const cv::Mat& H) bool CV_HomographyTest::check_matrix_size(const cv::Mat& H)
{ {
return (H.rows == 3) && (H.cols == 3); return (H.rows == 3) && (H.cols == 3);
} }
@ -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;
@ -371,7 +371,7 @@ void CV_HomographyTest::run(int)
if (code) if (code)
{ {
print_information_3(j, N, mask[j]); print_information_3(j, N, mask[j]);
switch (code) switch (code)
{ {
case 1: { CV_Error(CALIB3D_HOMOGRAPHY_ERROR_RANSAC_MASK, MESSAGE_RANSAC_MASK_1); break; } case 1: { CV_Error(CALIB3D_HOMOGRAPHY_ERROR_RANSAC_MASK, MESSAGE_RANSAC_MASK_1); break; }
@ -380,7 +380,7 @@ void CV_HomographyTest::run(int)
default: break; default: break;
} }
return; return;
} }
@ -412,7 +412,7 @@ void CV_HomographyTest::run(int)
{ {
case 0: case 0:
case CV_LMEDS: case CV_LMEDS:
{ {
Mat H_res_64 [4] = { cv::findHomography(src_mat_2f, dst_mat_2f), Mat H_res_64 [4] = { cv::findHomography(src_mat_2f, dst_mat_2f),
cv::findHomography(src_mat_2f, dst_vec), cv::findHomography(src_mat_2f, dst_vec),
cv::findHomography(src_vec, dst_mat_2f), cv::findHomography(src_vec, dst_mat_2f),
@ -465,7 +465,7 @@ void CV_HomographyTest::run(int)
} }
continue; continue;
} }
case CV_RANSAC: case CV_RANSAC:
{ {
cv::Mat mask_res [4]; cv::Mat mask_res [4];
@ -555,7 +555,7 @@ void CV_HomographyTest::run(int)
} }
} }
} }
continue; continue;
} }

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)

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

@ -421,7 +421,7 @@ void CV_StereoMatchingTest::run(int)
ts->set_failed_test_info( code ); ts->set_failed_test_info( code );
return; return;
} }
string fullResultFilename = dataPath + ALGORITHMS_DIR + algorithmName + RESULT_FILE; string fullResultFilename = dataPath + ALGORITHMS_DIR + algorithmName + RESULT_FILE;
FileStorage resFS( fullResultFilename, FileStorage::READ ); FileStorage resFS( fullResultFilename, FileStorage::READ );
bool isWrite = true; // write or compare results bool isWrite = true; // write or compare results
@ -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;
} }
@ -713,7 +713,7 @@ class CV_StereoSGBMTest : public CV_StereoMatchingTest
public: public:
CV_StereoSGBMTest() CV_StereoSGBMTest()
{ {
name = "stereosgbm"; name = "stereosgbm";
fill(rmsEps.begin(), rmsEps.end(), 0.25f); fill(rmsEps.begin(), rmsEps.end(), 0.25f);
fill(fracEps.begin(), fracEps.end(), 0.01f); fill(fracEps.begin(), fracEps.end(), 0.01f);
} }

306
modules/contrib/include/opencv2/contrib/contrib.hpp
View File

@ -63,48 +63,48 @@ private:
GSD_INTENSITY_LT = 15, GSD_INTENSITY_LT = 15,
GSD_INTENSITY_UT = 250 GSD_INTENSITY_UT = 250
}; };
class CV_EXPORTS Histogram class CV_EXPORTS Histogram
{ {
private: private:
enum { enum {
HistogramSize = (GSD_HUE_UT - GSD_HUE_LT + 1) HistogramSize = (GSD_HUE_UT - GSD_HUE_LT + 1)
}; };
protected: protected:
int findCoverageIndex(double surfaceToCover, int defaultValue = 0); int findCoverageIndex(double surfaceToCover, int defaultValue = 0);
public: public:
CvHistogram *fHistogram; CvHistogram *fHistogram;
Histogram(); Histogram();
virtual ~Histogram(); virtual ~Histogram();
void findCurveThresholds(int &x1, int &x2, double percent = 0.05); void findCurveThresholds(int &x1, int &x2, double percent = 0.05);
void mergeWith(Histogram *source, double weight); void mergeWith(Histogram *source, double weight);
}; };
int nStartCounter, nFrameCount, nSkinHueLowerBound, nSkinHueUpperBound, nMorphingMethod, nSamplingDivider; int nStartCounter, nFrameCount, nSkinHueLowerBound, nSkinHueUpperBound, nMorphingMethod, nSamplingDivider;
double fHistogramMergeFactor, fHuePercentCovered; double fHistogramMergeFactor, fHuePercentCovered;
Histogram histogramHueMotion, skinHueHistogram; Histogram histogramHueMotion, skinHueHistogram;
IplImage *imgHueFrame, *imgSaturationFrame, *imgLastGrayFrame, *imgMotionFrame, *imgFilteredFrame; IplImage *imgHueFrame, *imgSaturationFrame, *imgLastGrayFrame, *imgMotionFrame, *imgFilteredFrame;
IplImage *imgShrinked, *imgTemp, *imgGrayFrame, *imgHSVFrame; IplImage *imgShrinked, *imgTemp, *imgGrayFrame, *imgHSVFrame;
protected: protected:
void initData(IplImage *src, int widthDivider, int heightDivider); void initData(IplImage *src, int widthDivider, int heightDivider);
void adaptiveFilter(); void adaptiveFilter();
public: public:
enum { enum {
MORPHING_METHOD_NONE = 0, MORPHING_METHOD_NONE = 0,
MORPHING_METHOD_ERODE = 1, MORPHING_METHOD_ERODE = 1,
MORPHING_METHOD_ERODE_ERODE = 2, MORPHING_METHOD_ERODE_ERODE = 2,
MORPHING_METHOD_ERODE_DILATE = 3 MORPHING_METHOD_ERODE_DILATE = 3
}; };
CvAdaptiveSkinDetector(int samplingDivider = 1, int morphingMethod = MORPHING_METHOD_NONE); CvAdaptiveSkinDetector(int samplingDivider = 1, int morphingMethod = MORPHING_METHOD_NONE);
virtual ~CvAdaptiveSkinDetector(); virtual ~CvAdaptiveSkinDetector();
virtual void process(IplImage *inputBGRImage, IplImage *outputHueMask); virtual void process(IplImage *inputBGRImage, IplImage *outputHueMask);
}; };
@ -116,7 +116,7 @@ public:
class CV_EXPORTS CvFuzzyPoint { class CV_EXPORTS CvFuzzyPoint {
public: public:
double x, y, value; double x, y, value;
CvFuzzyPoint(double _x, double _y); CvFuzzyPoint(double _x, double _y);
}; };
@ -124,13 +124,13 @@ class CV_EXPORTS CvFuzzyCurve {
private: private:
std::vector<CvFuzzyPoint> points; std::vector<CvFuzzyPoint> points;
double value, centre; double value, centre;
bool between(double x, double x1, double x2); bool between(double x, double x1, double x2);
public: public:
CvFuzzyCurve(); CvFuzzyCurve();
~CvFuzzyCurve(); ~CvFuzzyCurve();
void setCentre(double _centre); void setCentre(double _centre);
double getCentre(); double getCentre();
void clear(); void clear();
@ -143,7 +143,7 @@ public:
class CV_EXPORTS CvFuzzyFunction { class CV_EXPORTS CvFuzzyFunction {
public: public:
std::vector<CvFuzzyCurve> curves; std::vector<CvFuzzyCurve> curves;
CvFuzzyFunction(); CvFuzzyFunction();
~CvFuzzyFunction(); ~CvFuzzyFunction();
void addCurve(CvFuzzyCurve *curve, double value = 0); void addCurve(CvFuzzyCurve *curve, double value = 0);
@ -186,7 +186,7 @@ private:
FuzzyResizer(); FuzzyResizer();
int calcOutput(double edgeDensity, double density); int calcOutput(double edgeDensity, double density);
}; };
class SearchWindow class SearchWindow
{ {
public: public:
@ -200,7 +200,7 @@ private:
double density; double density;
unsigned int depthLow, depthHigh; unsigned int depthLow, depthHigh;
int verticalEdgeLeft, verticalEdgeRight, horizontalEdgeTop, horizontalEdgeBottom; int verticalEdgeLeft, verticalEdgeRight, horizontalEdgeTop, horizontalEdgeBottom;
SearchWindow(); SearchWindow();
~SearchWindow(); ~SearchWindow();
void setSize(int _x, int _y, int _width, int _height); void setSize(int _x, int _y, int _width, int _height);
@ -212,7 +212,7 @@ private:
void getResizeAttribsEdgeDensityFuzzy(int &resizeDx, int &resizeDy, int &resizeDw, int &resizeDh); void getResizeAttribsEdgeDensityFuzzy(int &resizeDx, int &resizeDy, int &resizeDw, int &resizeDh);
bool meanShift(IplImage *maskImage, IplImage *depthMap, int maxIteration, bool initDepth); bool meanShift(IplImage *maskImage, IplImage *depthMap, int maxIteration, bool initDepth);
}; };
public: public:
enum TrackingState enum TrackingState
{ {
@ -222,40 +222,40 @@ public:
tsSetWindow = 3, tsSetWindow = 3,
tsDisabled = 10 tsDisabled = 10
}; };
enum ResizeMethod { enum ResizeMethod {
rmEdgeDensityLinear = 0, rmEdgeDensityLinear = 0,
rmEdgeDensityFuzzy = 1, rmEdgeDensityFuzzy = 1,
rmInnerDensity = 2 rmInnerDensity = 2
}; };
enum { enum {
MinKernelMass = 1000 MinKernelMass = 1000
}; };
SearchWindow kernel; SearchWindow kernel;
int searchMode; int searchMode;
private: private:
enum enum
{ {
MaxMeanShiftIteration = 5, MaxMeanShiftIteration = 5,
MaxSetSizeIteration = 5 MaxSetSizeIteration = 5
}; };
void findOptimumSearchWindow(SearchWindow &searchWindow, IplImage *maskImage, IplImage *depthMap, int maxIteration, int resizeMethod, bool initDepth); void findOptimumSearchWindow(SearchWindow &searchWindow, IplImage *maskImage, IplImage *depthMap, int maxIteration, int resizeMethod, bool initDepth);
public: public:
CvFuzzyMeanShiftTracker(); CvFuzzyMeanShiftTracker();
~CvFuzzyMeanShiftTracker(); ~CvFuzzyMeanShiftTracker();
void track(IplImage *maskImage, IplImage *depthMap, int resizeMethod, bool resetSearch, int minKernelMass = MinKernelMass); void track(IplImage *maskImage, IplImage *depthMap, int resizeMethod, bool resetSearch, int minKernelMass = MinKernelMass);
}; };
namespace cv namespace cv
{ {
class CV_EXPORTS Octree class CV_EXPORTS Octree
{ {
public: public:
@ -268,11 +268,11 @@ namespace cv
bool isLeaf; bool isLeaf;
int children[8]; int children[8];
}; };
Octree(); Octree();
Octree( const vector<Point3f>& points, int maxLevels = 10, int minPoints = 20 ); Octree( const vector<Point3f>& points, int maxLevels = 10, int minPoints = 20 );
virtual ~Octree(); virtual ~Octree();
virtual void buildTree( const vector<Point3f>& points, int maxLevels = 10, int minPoints = 20 ); virtual void buildTree( const vector<Point3f>& points, int maxLevels = 10, int minPoints = 20 );
virtual void getPointsWithinSphere( const Point3f& center, float radius, virtual void getPointsWithinSphere( const Point3f& center, float radius,
vector<Point3f>& points ) const; vector<Point3f>& points ) const;
@ -281,85 +281,85 @@ namespace cv
int minPoints; int minPoints;
vector<Point3f> points; vector<Point3f> points;
vector<Node> nodes; vector<Node> nodes;
virtual void buildNext(size_t node_ind); virtual void buildNext(size_t node_ind);
}; };
class CV_EXPORTS Mesh3D class CV_EXPORTS Mesh3D
{ {
public: public:
struct EmptyMeshException {}; struct EmptyMeshException {};
Mesh3D(); Mesh3D();
Mesh3D(const vector<Point3f>& vtx); Mesh3D(const vector<Point3f>& vtx);
~Mesh3D(); ~Mesh3D();
void buildOctree(); void buildOctree();
void clearOctree(); void clearOctree();
float estimateResolution(float tryRatio = 0.1f); float estimateResolution(float tryRatio = 0.1f);
void computeNormals(float normalRadius, int minNeighbors = 20); void computeNormals(float normalRadius, int minNeighbors = 20);
void computeNormals(const vector<int>& subset, float normalRadius, int minNeighbors = 20); void computeNormals(const vector<int>& subset, float normalRadius, int minNeighbors = 20);
void writeAsVrml(const String& file, const vector<Scalar>& colors = vector<Scalar>()) const; void writeAsVrml(const String& file, const vector<Scalar>& colors = vector<Scalar>()) const;
vector<Point3f> vtx; vector<Point3f> vtx;
vector<Point3f> normals; vector<Point3f> normals;
float resolution; float resolution;
Octree octree; Octree octree;
const static Point3f allzero; const static Point3f allzero;
}; };
class CV_EXPORTS SpinImageModel class CV_EXPORTS SpinImageModel
{ {
public: public:
/* model parameters, leave unset for default or auto estimate */ /* model parameters, leave unset for default or auto estimate */
float normalRadius; float normalRadius;
int minNeighbors; int minNeighbors;
float binSize; float binSize;
int imageWidth; int imageWidth;
float lambda; float lambda;
float gamma; float gamma;
float T_GeometriccConsistency; float T_GeometriccConsistency;
float T_GroupingCorespondances; float T_GroupingCorespondances;
/* public interface */ /* public interface */
SpinImageModel(); SpinImageModel();
explicit SpinImageModel(const Mesh3D& mesh); explicit SpinImageModel(const Mesh3D& mesh);
~SpinImageModel(); ~SpinImageModel();
void setLogger(std::ostream* log); void setLogger(std::ostream* log);
void selectRandomSubset(float ratio); void selectRandomSubset(float ratio);
void setSubset(const vector<int>& subset); void setSubset(const vector<int>& subset);
void compute(); void compute();
void match(const SpinImageModel& scene, vector< vector<Vec2i> >& result); void match(const SpinImageModel& scene, vector< vector<Vec2i> >& result);
Mat packRandomScaledSpins(bool separateScale = false, size_t xCount = 10, size_t yCount = 10) const; Mat packRandomScaledSpins(bool separateScale = false, size_t xCount = 10, size_t yCount = 10) const;
size_t getSpinCount() const { return spinImages.rows; } size_t getSpinCount() const { return spinImages.rows; }
Mat getSpinImage(size_t index) const { return spinImages.row((int)index); } Mat getSpinImage(size_t index) const { return spinImages.row((int)index); }
const Point3f& getSpinVertex(size_t index) const { return mesh.vtx[subset[index]]; } const Point3f& getSpinVertex(size_t index) const { return mesh.vtx[subset[index]]; }
const Point3f& getSpinNormal(size_t index) const { return mesh.normals[subset[index]]; } const Point3f& getSpinNormal(size_t index) const { return mesh.normals[subset[index]]; }
const Mesh3D& getMesh() const { return mesh; } const Mesh3D& getMesh() const { return mesh; }
Mesh3D& getMesh() { return mesh; } Mesh3D& getMesh() { return mesh; }
/* static utility functions */ /* static utility functions */
static bool spinCorrelation(const Mat& spin1, const Mat& spin2, float lambda, float& result); static bool spinCorrelation(const Mat& spin1, const Mat& spin2, float lambda, float& result);
static Point2f calcSpinMapCoo(const Point3f& point, const Point3f& vertex, const Point3f& normal); static Point2f calcSpinMapCoo(const Point3f& point, const Point3f& vertex, const Point3f& normal);
static float geometricConsistency(const Point3f& pointScene1, const Point3f& normalScene1, static float geometricConsistency(const Point3f& pointScene1, const Point3f& normalScene1,
const Point3f& pointModel1, const Point3f& normalModel1, const Point3f& pointModel1, const Point3f& normalModel1,
const Point3f& pointScene2, const Point3f& normalScene2, const Point3f& pointScene2, const Point3f& normalScene2,
const Point3f& pointModel2, const Point3f& normalModel2); const Point3f& pointModel2, const Point3f& normalModel2);
static float groupingCreteria(const Point3f& pointScene1, const Point3f& normalScene1, static float groupingCreteria(const Point3f& pointScene1, const Point3f& normalScene1,
const Point3f& pointModel1, const Point3f& normalModel1, const Point3f& pointModel1, const Point3f& normalModel1,
const Point3f& pointScene2, const Point3f& normalScene2, const Point3f& pointScene2, const Point3f& normalScene2,
@ -367,40 +367,40 @@ namespace cv
float gamma); float gamma);
protected: protected:
void defaultParams(); void defaultParams();
void matchSpinToModel(const Mat& spin, vector<int>& indeces, void matchSpinToModel(const Mat& spin, vector<int>& indeces,
vector<float>& corrCoeffs, bool useExtremeOutliers = true) const; vector<float>& corrCoeffs, bool useExtremeOutliers = true) const;
void repackSpinImages(const vector<uchar>& mask, Mat& spinImages, bool reAlloc = true) const; void repackSpinImages(const vector<uchar>& mask, Mat& spinImages, bool reAlloc = true) const;
vector<int> subset; vector<int> subset;
Mesh3D mesh; Mesh3D mesh;
Mat spinImages; Mat spinImages;
std::ostream* out; std::ostream* out;
}; };
class CV_EXPORTS TickMeter class CV_EXPORTS TickMeter
{ {
public: public:
TickMeter(); TickMeter();
void start(); void start();
void stop(); void stop();
int64 getTimeTicks() const; int64 getTimeTicks() const;
double getTimeMicro() const; double getTimeMicro() const;
double getTimeMilli() const; double getTimeMilli() const;
double getTimeSec() const; double getTimeSec() const;
int64 getCounter() const; int64 getCounter() const;
void reset(); void reset();
private: private:
int64 counter; int64 counter;
int64 sumTime; int64 sumTime;
int64 startTime; int64 startTime;
}; };
CV_EXPORTS std::ostream& operator<<(std::ostream& out, const TickMeter& tm); CV_EXPORTS std::ostream& operator<<(std::ostream& out, const TickMeter& tm);
class CV_EXPORTS SelfSimDescriptor class CV_EXPORTS SelfSimDescriptor
{ {
public: public:
@ -412,29 +412,29 @@ namespace cv
SelfSimDescriptor(const SelfSimDescriptor& ss); SelfSimDescriptor(const SelfSimDescriptor& ss);
virtual ~SelfSimDescriptor(); virtual ~SelfSimDescriptor();
SelfSimDescriptor& operator = (const SelfSimDescriptor& ss); SelfSimDescriptor& operator = (const SelfSimDescriptor& ss);
size_t getDescriptorSize() const; size_t getDescriptorSize() const;
Size getGridSize( Size imgsize, Size winStride ) const; Size getGridSize( Size imgsize, Size winStride ) const;
virtual void compute(const Mat& img, vector<float>& descriptors, Size winStride=Size(), virtual void compute(const Mat& img, vector<float>& descriptors, Size winStride=Size(),
const vector<Point>& locations=vector<Point>()) const; const vector<Point>& locations=vector<Point>()) const;
virtual void computeLogPolarMapping(Mat& mappingMask) const; virtual void computeLogPolarMapping(Mat& mappingMask) const;
virtual void SSD(const Mat& img, Point pt, Mat& ssd) const; virtual void SSD(const Mat& img, Point pt, Mat& ssd) const;
int smallSize; int smallSize;
int largeSize; int largeSize;
int startDistanceBucket; int startDistanceBucket;
int numberOfDistanceBuckets; int numberOfDistanceBuckets;
int numberOfAngles; int numberOfAngles;
enum { DEFAULT_SMALL_SIZE = 5, DEFAULT_LARGE_SIZE = 41, enum { DEFAULT_SMALL_SIZE = 5, DEFAULT_LARGE_SIZE = 41,
DEFAULT_NUM_ANGLES = 20, DEFAULT_START_DISTANCE_BUCKET = 3, DEFAULT_NUM_ANGLES = 20, DEFAULT_START_DISTANCE_BUCKET = 3,
DEFAULT_NUM_DISTANCE_BUCKETS = 7 }; DEFAULT_NUM_DISTANCE_BUCKETS = 7 };
}; };
typedef bool (*BundleAdjustCallback)(int iteration, double norm_error, void* user_data); typedef bool (*BundleAdjustCallback)(int iteration, double norm_error, void* user_data);
class LevMarqSparse { class LevMarqSparse {
public: public:
LevMarqSparse(); LevMarqSparse();
@ -447,9 +447,9 @@ namespace cv
Mat& visibility, // visibility matrix. rows correspond to points, columns correspond to cameras Mat& visibility, // visibility matrix. rows correspond to points, columns correspond to cameras
// 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),
@ -459,9 +459,9 @@ namespace cv
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
); );
virtual ~LevMarqSparse(); virtual ~LevMarqSparse();
virtual void run( int npoints, // number of points virtual void run( int npoints, // number of points
int ncameras, // number of cameras int ncameras, // number of cameras
int nPointParams, // number of params per one point (3 in case of 3D points) int nPointParams, // number of params per one point (3 in case of 3D points)
@ -471,9 +471,9 @@ namespace cv
Mat& visibility, // visibility matrix. rows correspond to points, columns correspond to cameras Mat& visibility, // visibility matrix. rows correspond to points, columns correspond to cameras
// 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),
@ -482,13 +482,13 @@ namespace cv
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
); );
virtual void clear(); virtual void clear();
// useful function to do simple bundle adjustment tasks // useful function to do simple bundle adjustment tasks
static void bundleAdjust(vector<Point3d>& points, // positions of points in global coordinate system (input and output) static void bundleAdjust(vector<Point3d>& points, // positions of points in global coordinate system (input and output)
const vector<vector<Point2d> >& imagePoints, // projections of 3d points for every camera const vector<vector<Point2d> >& imagePoints, // projections of 3d points for every camera
const vector<vector<int> >& visibility, // visibility of 3d points for every camera const vector<vector<int> >& visibility, // visibility of 3d points for every camera
vector<Mat>& cameraMatrix, // intrinsic matrices of all cameras (input and output) vector<Mat>& cameraMatrix, // intrinsic matrices of all cameras (input and output)
vector<Mat>& R, // rotation matrices of all cameras (input and output) vector<Mat>& R, // rotation matrices of all cameras (input and output)
vector<Mat>& T, // translation vector of all cameras (input and output) vector<Mat>& T, // translation vector of all cameras (input and output)
@ -496,123 +496,123 @@ namespace cv
const TermCriteria& criteria= const TermCriteria& criteria=
TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON), TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON),
BundleAdjustCallback cb = 0, void* user_data = 0); BundleAdjustCallback cb = 0, void* user_data = 0);
public: public:
virtual void optimize(CvMat &_vis); //main function that runs minimization virtual void optimize(CvMat &_vis); //main function that runs minimization
//iteratively asks for measurement for visible camera-point pairs //iteratively asks for measurement for visible camera-point pairs
void ask_for_proj(CvMat &_vis,bool once=false); void ask_for_proj(CvMat &_vis,bool once=false);
//iteratively asks for Jacobians for every camera_point pair //iteratively asks for Jacobians for every camera_point pair
void ask_for_projac(CvMat &_vis); void ask_for_projac(CvMat &_vis);
CvMat* err; //error X-hX CvMat* err; //error X-hX
double prevErrNorm, errNorm; double prevErrNorm, errNorm;
double lambda; double lambda;
CvTermCriteria criteria; CvTermCriteria criteria;
int iters; int iters;
CvMat** U; //size of array is equal to number of cameras CvMat** U; //size of array is equal to number of cameras
CvMat** V; //size of array is equal to number of points CvMat** V; //size of array is equal to number of points
CvMat** inv_V_star; //inverse of V* CvMat** inv_V_star; //inverse of V*
CvMat** A; CvMat** A;
CvMat** B; CvMat** B;
CvMat** W; CvMat** W;
CvMat* X; //measurement CvMat* X; //measurement
CvMat* hX; //current measurement extimation given new parameter vector CvMat* hX; //current measurement extimation given new parameter vector
CvMat* prevP; //current already accepted parameter. CvMat* prevP; //current already accepted parameter.
CvMat* P; // parameters used to evaluate function with new params CvMat* P; // parameters used to evaluate function with new params
// this parameters may be rejected // this parameters may be rejected
CvMat* deltaP; //computed increase of parameters (result of normal system solution ) CvMat* deltaP; //computed increase of parameters (result of normal system solution )
CvMat** ea; // sum_i AijT * e_ij , used as right part of normal equation CvMat** ea; // sum_i AijT * e_ij , used as right part of normal equation
// length of array is j = number of cameras // length of array is j = number of cameras
CvMat** eb; // sum_j BijT * e_ij , used as right part of normal equation CvMat** eb; // sum_j BijT * e_ij , used as right part of normal equation
// length of array is i = number of points // length of array is i = number of points
CvMat** Yj; //length of array is i = num_points CvMat** Yj; //length of array is i = num_points
CvMat* S; //big matrix of block Sjk , each block has size num_cam_params x num_cam_params CvMat* S; //big matrix of block Sjk , each block has size num_cam_params x num_cam_params
CvMat* JtJ_diag; //diagonal of JtJ, used to backup diagonal elements before augmentation CvMat* JtJ_diag; //diagonal of JtJ, used to backup diagonal elements before augmentation
CvMat* Vis_index; // matrix which element is index of measurement for point i and camera j CvMat* Vis_index; // matrix which element is index of measurement for point i and camera j
int num_cams; int num_cams;
int num_points; int num_points;
int num_err_param; int num_err_param;
int num_cam_param; int num_cam_param;
int num_point_param; int num_point_param;
//target function and jacobian pointers, which needs to be initialized //target function and jacobian pointers, which needs to be initialized
void (*fjac)(int i, int j, Mat& point_params, Mat& cam_params, Mat& A, Mat& B, void* data); void (*fjac)(int i, int j, Mat& point_params, Mat& cam_params, Mat& A, Mat& B, void* data);
void (*func)(int i, int j, Mat& point_params, Mat& cam_params, Mat& estim, void* data); void (*func)(int i, int j, Mat& point_params, Mat& cam_params, Mat& estim, void* data);
void* data; void* data;
BundleAdjustCallback cb; BundleAdjustCallback cb;
void* user_data; void* user_data;
}; };
CV_EXPORTS int chamerMatching( Mat& img, Mat& templ, CV_EXPORTS int chamerMatching( Mat& img, Mat& templ,
vector<vector<Point> >& results, vector<float>& cost, vector<vector<Point> >& results, vector<float>& cost,
double templScale=1, int maxMatches = 20, double templScale=1, int maxMatches = 20,
double minMatchDistance = 1.0, int padX = 3, double minMatchDistance = 1.0, int padX = 3,
int padY = 3, int scales = 5, double minScale = 0.6, double maxScale = 1.6, int padY = 3, int scales = 5, double minScale = 0.6, double maxScale = 1.6,
double orientationWeight = 0.5, double truncate = 20); double orientationWeight = 0.5, double truncate = 20);
class CV_EXPORTS StereoVar class CV_EXPORTS StereoVar
{ {
public: public:
// Flags // Flags
enum {USE_INITIAL_DISPARITY = 1, USE_EQUALIZE_HIST = 2, USE_SMART_ID = 4, USE_AUTO_PARAMS = 8, USE_MEDIAN_FILTERING = 16}; enum {USE_INITIAL_DISPARITY = 1, USE_EQUALIZE_HIST = 2, USE_SMART_ID = 4, USE_AUTO_PARAMS = 8, USE_MEDIAN_FILTERING = 16};
enum {CYCLE_O, CYCLE_V}; enum {CYCLE_O, CYCLE_V};
enum {PENALIZATION_TICHONOV, PENALIZATION_CHARBONNIER, PENALIZATION_PERONA_MALIK}; enum {PENALIZATION_TICHONOV, PENALIZATION_CHARBONNIER, PENALIZATION_PERONA_MALIK};
//! the default constructor //! the default constructor
CV_WRAP StereoVar(); CV_WRAP StereoVar();
//! the full constructor taking all the necessary algorithm parameters //! the full constructor taking all the necessary algorithm parameters
CV_WRAP StereoVar(int levels, double pyrScale, int nIt, int minDisp, int maxDisp, int poly_n, double poly_sigma, float fi, float lambda, int penalization, int cycle, int flags); CV_WRAP StereoVar(int levels, double pyrScale, int nIt, int minDisp, int maxDisp, int poly_n, double poly_sigma, float fi, float lambda, int penalization, int cycle, int flags);
//! the destructor //! the destructor
virtual ~StereoVar(); virtual ~StereoVar();
//! the stereo correspondence operator that computes disparity map for the specified rectified stereo pair //! the stereo correspondence operator that computes disparity map for the specified rectified stereo pair
CV_WRAP_AS(compute) virtual void operator()(const Mat& left, const Mat& right, Mat& disp); CV_WRAP_AS(compute) virtual void operator()(const Mat& left, const Mat& right, Mat& disp);
CV_PROP_RW int levels; CV_PROP_RW int levels;
CV_PROP_RW double pyrScale; CV_PROP_RW double pyrScale;
CV_PROP_RW int nIt; CV_PROP_RW int nIt;
CV_PROP_RW int minDisp; CV_PROP_RW int minDisp;
CV_PROP_RW int maxDisp; CV_PROP_RW int maxDisp;
CV_PROP_RW int poly_n; CV_PROP_RW int poly_n;
CV_PROP_RW double poly_sigma; CV_PROP_RW double poly_sigma;
CV_PROP_RW float fi; CV_PROP_RW float fi;
CV_PROP_RW float lambda; CV_PROP_RW float lambda;
CV_PROP_RW int penalization; CV_PROP_RW int penalization;
CV_PROP_RW int cycle; CV_PROP_RW int cycle;
CV_PROP_RW int flags; CV_PROP_RW int flags;
private: private:
void autoParams(); void autoParams();
void FMG(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level); void FMG(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level);
void VCycle_MyFAS(Mat &I1_h, Mat &I2_h, Mat &I2x_h, Mat &u_h, int level); void VCycle_MyFAS(Mat &I1_h, Mat &I2_h, Mat &I2x_h, Mat &u_h, int level);
void VariationalSolver(Mat &I1_h, Mat &I2_h, Mat &I2x_h, Mat &u_h, int level); void VariationalSolver(Mat &I1_h, Mat &I2_h, Mat &I2x_h, Mat &u_h, int level);
}; };
CV_EXPORTS void polyfit(const Mat& srcx, const Mat& srcy, Mat& dst, int order); CV_EXPORTS void polyfit(const Mat& srcx, const Mat& srcy, Mat& dst, int order);
class CV_EXPORTS Directory class CV_EXPORTS Directory
{ {
public: public:
static std::vector<std::string> GetListFiles ( const std::string& path, const std::string & exten = "*", bool addPath = true ); static std::vector<std::string> GetListFiles ( const std::string& path, const std::string & exten = "*", bool addPath = true );
static std::vector<std::string> GetListFilesR ( const std::string& path, const std::string & exten = "*", bool addPath = true ); static std::vector<std::string> GetListFilesR ( const std::string& path, const std::string & exten = "*", bool addPath = true );
static std::vector<std::string> GetListFolders( const std::string& path, const std::string & exten = "*", bool addPath = true ); static std::vector<std::string> GetListFolders( const std::string& path, const std::string & exten = "*", bool addPath = true );
}; };
/* /*
@ -654,7 +654,7 @@ namespace cv
class CV_EXPORTS LogPolar_Interp class CV_EXPORTS LogPolar_Interp
{ {
public: public:
LogPolar_Interp() {} LogPolar_Interp() {}
/** /**
@ -664,11 +664,11 @@ namespace cv
*\param center the transformation center: where the output precision is maximal *\param center the transformation center: where the output precision is maximal
*\param R the number of rings of the cortical image (default value 70 pixel) *\param R the number of rings of the cortical image (default value 70 pixel)
*\param ro0 the radius of the blind spot (default value 3 pixel) *\param ro0 the radius of the blind spot (default value 3 pixel)
*\param full \a 1 (default value) means that the retinal image (the inverse transform) is computed within the circumscribing circle. *\param full \a 1 (default value) means that the retinal image (the inverse transform) is computed within the circumscribing circle.
* \a 0 means that the retinal image is computed within the inscribed circle. * \a 0 means that the retinal image is computed within the inscribed circle.
*\param S the number of sectors of the cortical image (default value 70 pixel). *\param S the number of sectors of the cortical image (default value 70 pixel).
* Its value is usually internally computed to obtain a pixel aspect ratio equals to 1. * Its value is usually internally computed to obtain a pixel aspect ratio equals to 1.
*\param sp \a 1 (default value) means that the parameter \a S is internally computed. *\param sp \a 1 (default value) means that the parameter \a S is internally computed.
* \a 0 means that the parameter \a S is provided by the user. * \a 0 means that the parameter \a S is provided by the user.
*/ */
LogPolar_Interp(int w, int h, Point2i center, int R=70, double ro0=3.0, LogPolar_Interp(int w, int h, Point2i center, int R=70, double ro0=3.0,
@ -689,9 +689,9 @@ namespace cv
*Destructor *Destructor
*/ */
~LogPolar_Interp(); ~LogPolar_Interp();
protected: protected:
Mat Rsri; Mat Rsri;
Mat Csri; Mat Csri;
@ -716,10 +716,10 @@ namespace cv
*More details can be found in http://dx.doi.org/10.1007/978-3-642-23968-7_5 *More details can be found in http://dx.doi.org/10.1007/978-3-642-23968-7_5
*/ */
class CV_EXPORTS LogPolar_Overlapping class CV_EXPORTS LogPolar_Overlapping
{ {
public: public:
LogPolar_Overlapping() {} LogPolar_Overlapping() {}
/** /**
*Constructor *Constructor
*\param w the width of the input image *\param w the width of the input image
@ -727,11 +727,11 @@ namespace cv
*\param center the transformation center: where the output precision is maximal *\param center the transformation center: where the output precision is maximal
*\param R the number of rings of the cortical image (default value 70 pixel) *\param R the number of rings of the cortical image (default value 70 pixel)
*\param ro0 the radius of the blind spot (default value 3 pixel) *\param ro0 the radius of the blind spot (default value 3 pixel)
*\param full \a 1 (default value) means that the retinal image (the inverse transform) is computed within the circumscribing circle. *\param full \a 1 (default value) means that the retinal image (the inverse transform) is computed within the circumscribing circle.
* \a 0 means that the retinal image is computed within the inscribed circle. * \a 0 means that the retinal image is computed within the inscribed circle.
*\param S the number of sectors of the cortical image (default value 70 pixel). *\param S the number of sectors of the cortical image (default value 70 pixel).
* Its value is usually internally computed to obtain a pixel aspect ratio equals to 1. * Its value is usually internally computed to obtain a pixel aspect ratio equals to 1.
*\param sp \a 1 (default value) means that the parameter \a S is internally computed. *\param sp \a 1 (default value) means that the parameter \a S is internally computed.
* \a 0 means that the parameter \a S is provided by the user. * \a 0 means that the parameter \a S is provided by the user.
*/ */
LogPolar_Overlapping(int w, int h, Point2i center, int R=70, LogPolar_Overlapping(int w, int h, Point2i center, int R=70,
@ -752,9 +752,9 @@ namespace cv
*Destructor *Destructor
*/ */
~LogPolar_Overlapping(); ~LogPolar_Overlapping();
protected: protected:
Mat Rsri; Mat Rsri;
Mat Csri; Mat Csri;
vector<int> Rsr; vector<int> Rsr;
@ -793,7 +793,7 @@ namespace cv
{ {
public: public:
LogPolar_Adjacent() {} LogPolar_Adjacent() {}
/** /**
*Constructor *Constructor
*\param w the width of the input image *\param w the width of the input image
@ -802,13 +802,13 @@ namespace cv
*\param R the number of rings of the cortical image (default value 70 pixel) *\param R the number of rings of the cortical image (default value 70 pixel)
*\param ro0 the radius of the blind spot (default value 3 pixel) *\param ro0 the radius of the blind spot (default value 3 pixel)
*\param smin the size of the subpixel (default value 0.25 pixel) *\param smin the size of the subpixel (default value 0.25 pixel)
*\param full \a 1 (default value) means that the retinal image (the inverse transform) is computed within the circumscribing circle. *\param full \a 1 (default value) means that the retinal image (the inverse transform) is computed within the circumscribing circle.
* \a 0 means that the retinal image is computed within the inscribed circle. * \a 0 means that the retinal image is computed within the inscribed circle.
*\param S the number of sectors of the cortical image (default value 70 pixel). *\param S the number of sectors of the cortical image (default value 70 pixel).
* Its value is usually internally computed to obtain a pixel aspect ratio equals to 1. * Its value is usually internally computed to obtain a pixel aspect ratio equals to 1.
*\param sp \a 1 (default value) means that the parameter \a S is internally computed. *\param sp \a 1 (default value) means that the parameter \a S is internally computed.
* \a 0 means that the parameter \a S is provided by the user. * \a 0 means that the parameter \a S is provided by the user.
*/ */
LogPolar_Adjacent(int w, int h, Point2i center, int R=70, double ro0=3.0, double smin=0.25, int full=1, int S=117, int sp=1); LogPolar_Adjacent(int w, int h, Point2i center, int R=70, double ro0=3.0, double smin=0.25, int full=1, int S=117, int sp=1);
/** /**
*Transformation from Cartesian image to cortical (log-polar) image. *Transformation from Cartesian image to cortical (log-polar) image.
@ -845,10 +845,10 @@ namespace cv
bool get_uv(double x, double y, int&u, int&v); bool get_uv(double x, double y, int&u, int&v);
void create_map(int M, int N, int R, int S, double ro0, double smin); void create_map(int M, int N, int R, int S, double ro0, double smin);
}; };
CV_EXPORTS Mat subspaceProject(InputArray W, InputArray mean, InputArray src); CV_EXPORTS Mat subspaceProject(InputArray W, InputArray mean, InputArray src);
CV_EXPORTS Mat subspaceReconstruct(InputArray W, InputArray mean, InputArray src); CV_EXPORTS Mat subspaceReconstruct(InputArray W, InputArray mean, InputArray src);
class CV_EXPORTS LDA class CV_EXPORTS LDA
{ {
public: public:
@ -908,7 +908,7 @@ namespace cv
// Returns the eigenvalues of this LDA. // Returns the eigenvalues of this LDA.
Mat eigenvalues() const { return _eigenvalues; } Mat eigenvalues() const { return _eigenvalues; }
protected: protected:
bool _dataAsRow; bool _dataAsRow;
int _num_components; int _num_components;
@ -917,7 +917,7 @@ namespace cv
void lda(InputArray src, InputArray labels); void lda(InputArray src, InputArray labels);
}; };
class CV_EXPORTS FaceRecognizer : public Algorithm class CV_EXPORTS FaceRecognizer : public Algorithm
{ {
public: public:
@ -941,16 +941,16 @@ namespace cv
// Deserializes this object from a given cv::FileStorage. // Deserializes this object from a given cv::FileStorage.
virtual void load(const FileStorage& fs) = 0; virtual void load(const FileStorage& fs) = 0;
// Returns eigenvectors (if any) // Returns eigenvectors (if any)
virtual Mat eigenvectors() const { return Mat(); } virtual Mat eigenvectors() const { return Mat(); }
}; };
CV_EXPORTS Ptr<FaceRecognizer> createEigenFaceRecognizer(int num_components = 0); CV_EXPORTS Ptr<FaceRecognizer> createEigenFaceRecognizer(int num_components = 0);
CV_EXPORTS Ptr<FaceRecognizer> createFisherFaceRecognizer(int num_components = 0); CV_EXPORTS Ptr<FaceRecognizer> createFisherFaceRecognizer(int num_components = 0);
CV_EXPORTS Ptr<FaceRecognizer> createLBPHFaceRecognizer(int radius=1, int neighbors=8, CV_EXPORTS Ptr<FaceRecognizer> createLBPHFaceRecognizer(int radius=1, int neighbors=8,
int grid_x=8, int grid_y=8); int grid_x=8, int grid_y=8);
enum enum
{ {
COLORMAP_AUTUMN = 0, COLORMAP_AUTUMN = 0,
@ -968,9 +968,9 @@ namespace cv
COLORMAP_MKPJ1 = 12, COLORMAP_MKPJ1 = 12,
COLORMAP_MKPJ2 = 13 COLORMAP_MKPJ2 = 13
}; };
CV_EXPORTS void applyColorMap(InputArray src, OutputArray dst, int colormap); CV_EXPORTS void applyColorMap(InputArray src, OutputArray dst, int colormap);
CV_EXPORTS bool initModule_contrib(); CV_EXPORTS bool initModule_contrib();
} }

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

32
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; {
double e2 = prevErrNorm*prevErrNorm, e2n = e2 / nviz; int nviz = X->rows / num_err_param;
std::cerr<<"Iteration: "<<iters<<", normError: "<<e2<<" ("<<e2n<<")"<<std::endl; double e2 = prevErrNorm*prevErrNorm, e2n = e2 / nviz;
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; {
double e2 = errNorm*errNorm, e2_prev = prevErrNorm*prevErrNorm; int nviz = X->rows / num_err_param;
double e2n = e2/nviz, e2n_prev = e2_prev/nviz; double e2 = errNorm*errNorm, e2_prev = prevErrNorm*prevErrNorm;
std::cerr<<"move failed: lambda = "<<lambda<<", e2 = "<<e2<<" ("<<e2n<<") > "<<e2_prev<<" ("<<e2n_prev<<")"<<std::endl; double e2n = e2/nviz, e2n_prev = e2_prev/nviz;
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;

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

@ -22,7 +22,7 @@ namespace cv
{ {
using std::set; using std::set;
// Reads a sequence from a FileNode::SEQ with type _Tp into a result vector. // Reads a sequence from a FileNode::SEQ with type _Tp into a result vector.
template<typename _Tp> template<typename _Tp>
inline void readFileNodeList(const FileNode& fn, vector<_Tp>& result) { inline void readFileNodeList(const FileNode& fn, vector<_Tp>& result) {
@ -48,7 +48,7 @@ inline void writeFileNodeList(FileStorage& fs, const string& name,
} }
fs << "]"; fs << "]";
} }
static Mat asRowMatrix(InputArrayOfArrays src, int rtype, double alpha=1, double beta=0) static Mat asRowMatrix(InputArrayOfArrays src, int rtype, double alpha=1, double beta=0)
{ {
// number of samples // number of samples
@ -67,7 +67,7 @@ static Mat asRowMatrix(InputArrayOfArrays src, int rtype, double alpha=1, double
} }
return data; return data;
} }
// Removes duplicate elements in a given vector. // Removes duplicate elements in a given vector.
template<typename _Tp> template<typename _Tp>
inline vector<_Tp> remove_dups(const vector<_Tp>& src) { inline vector<_Tp> remove_dups(const vector<_Tp>& src) {
@ -82,7 +82,7 @@ inline vector<_Tp> remove_dups(const vector<_Tp>& src) {
return elems; return elems;
} }
// Turk, M., and Pentland, A. "Eigenfaces for recognition.". Journal of // Turk, M., and Pentland, A. "Eigenfaces for recognition.". Journal of
// Cognitive Neuroscience 3 (1991), 71–86. // Cognitive Neuroscience 3 (1991), 71–86.
class Eigenfaces : public FaceRecognizer class Eigenfaces : public FaceRecognizer
@ -124,10 +124,10 @@ public:
// See FaceRecognizer::save. // See FaceRecognizer::save.
void save(FileStorage& fs) const; void save(FileStorage& fs) const;
AlgorithmInfo* info() const; AlgorithmInfo* info() const;
}; };
// Belhumeur, P. N., Hespanha, J., and Kriegman, D. "Eigenfaces vs. Fisher- // Belhumeur, P. N., Hespanha, J., and Kriegman, D. "Eigenfaces vs. Fisher-
// faces: Recognition using class specific linear projection.". IEEE // faces: Recognition using class specific linear projection.". IEEE
// Transactions on Pattern Analysis and Machine Intelligence 19, 7 (1997), // Transactions on Pattern Analysis and Machine Intelligence 19, 7 (1997),
@ -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);
} }
@ -359,9 +359,9 @@ void Fisherfaces::train(InputArray src, InputArray _lbls) {
// get data // get data
Mat labels = _lbls.getMat(); Mat labels = _lbls.getMat();
Mat data = asRowMatrix(src, CV_64FC1); Mat data = asRowMatrix(src, CV_64FC1);
CV_Assert( labels.type() == CV_32S && (labels.cols == 1 || labels.rows == 1)); CV_Assert( labels.type() == CV_32S && (labels.cols == 1 || labels.rows == 1));
// dimensionality // dimensionality
int N = data.rows; // number of samples int N = data.rows; // number of samples
//int D = data.cols; // dimension of samples //int D = data.cols; // dimension of samples
@ -369,7 +369,7 @@ void Fisherfaces::train(InputArray src, InputArray _lbls) {
if(labels.total() != (size_t)N) if(labels.total() != (size_t)N)
CV_Error(CV_StsUnsupportedFormat, "Labels must be given as integer (CV_32SC1)."); CV_Error(CV_StsUnsupportedFormat, "Labels must be given as integer (CV_32SC1).");
// compute the Fisherfaces // compute the Fisherfaces
vector<int> ll; vector<int> ll;
labels.copyTo(ll); labels.copyTo(ll);
int C = (int)remove_dups(ll).size(); // number of unique classes int C = (int)remove_dups(ll).size(); // number of unique classes
@ -570,7 +570,7 @@ static Mat histc(InputArray _src, int minVal, int maxVal, bool normed)
return Mat(); return Mat();
} }
static Mat spatial_histogram(InputArray _src, int numPatterns, static Mat spatial_histogram(InputArray _src, int numPatterns,
int grid_x, int grid_y, bool normed) int grid_x, int grid_y, bool normed)
{ {
@ -610,7 +610,7 @@ static Mat elbp(InputArray src, int radius, int neighbors) {
elbp(src, dst, radius, neighbors); elbp(src, dst, radius, neighbors);
return dst; return dst;
} }
void LBPH::load(const FileStorage& fs) { void LBPH::load(const FileStorage& fs) {
fs["radius"] >> _radius; fs["radius"] >> _radius;
fs["neighbors"] >> _neighbors; fs["neighbors"] >> _neighbors;
@ -684,24 +684,24 @@ int LBPH::predict(InputArray _src) const {
} }
return minClass; return minClass;
} }
Ptr<FaceRecognizer> createEigenFaceRecognizer(int num_components) Ptr<FaceRecognizer> createEigenFaceRecognizer(int num_components)
{ {
return new Eigenfaces(num_components); return new Eigenfaces(num_components);
} }
Ptr<FaceRecognizer> createFisherFaceRecognizer(int num_components) Ptr<FaceRecognizer> createFisherFaceRecognizer(int num_components)
{ {
return new Fisherfaces(num_components); return new Fisherfaces(num_components);
} }
Ptr<FaceRecognizer> createLBPHFaceRecognizer(int radius, int neighbors, Ptr<FaceRecognizer> createLBPHFaceRecognizer(int radius, int neighbors,
int grid_x, int grid_y) int grid_x, int grid_y)
{ {
return new LBPH(radius, neighbors, grid_x, grid_y); return new LBPH(radius, neighbors, grid_x, grid_y);
} }
CV_INIT_ALGORITHM(Eigenfaces, "FaceRecognizer.Eigenfaces", CV_INIT_ALGORITHM(Eigenfaces, "FaceRecognizer.Eigenfaces",
obj.info()->addParam(obj, "ncomponents", obj._num_components); obj.info()->addParam(obj, "ncomponents", obj._num_components);
obj.info()->addParam(obj, "projections", obj._projections, true); obj.info()->addParam(obj, "projections", obj._projections, true);
@ -716,8 +716,8 @@ CV_INIT_ALGORITHM(Fisherfaces, "FaceRecognizer.Fisherfaces",
obj.info()->addParam(obj, "labels", obj._labels, true); obj.info()->addParam(obj, "labels", obj._labels, true);
obj.info()->addParam(obj, "eigenvectors", obj._eigenvectors, true); obj.info()->addParam(obj, "eigenvectors", obj._eigenvectors, true);
obj.info()->addParam(obj, "eigenvalues", obj._eigenvalues, true); obj.info()->addParam(obj, "eigenvalues", obj._eigenvalues, true);
obj.info()->addParam(obj, "mean", obj._mean, true)); obj.info()->addParam(obj, "mean", obj._mean, true));
CV_INIT_ALGORITHM(LBPH, "FaceRecognizer.LBPH", CV_INIT_ALGORITHM(LBPH, "FaceRecognizer.LBPH",
obj.info()->addParam(obj, "radius", obj._radius); obj.info()->addParam(obj, "radius", obj._radius);
obj.info()->addParam(obj, "neighbors", obj._neighbors); obj.info()->addParam(obj, "neighbors", obj._neighbors);
@ -725,7 +725,7 @@ CV_INIT_ALGORITHM(LBPH, "FaceRecognizer.LBPH",
obj.info()->addParam(obj, "grid_y", obj._grid_y); obj.info()->addParam(obj, "grid_y", obj._grid_y);
obj.info()->addParam(obj, "histograms", obj._histograms, true); obj.info()->addParam(obj, "histograms", obj._histograms, true);
obj.info()->addParam(obj, "labels", obj._labels, true)); obj.info()->addParam(obj, "labels", obj._labels, true));
bool initModule_contrib() bool initModule_contrib()
{ {
Ptr<Algorithm> efaces = createEigenfaces(), ffaces = createFisherfaces(), lbph = createLBPH(); Ptr<Algorithm> efaces = createEigenfaces(), ffaces = createFisherfaces(), lbph = createLBPH();

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;
} }
} }
} }

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

@ -60,9 +60,9 @@ ICVS 2011, Sophia Antipolis, France, September 20-22, 2011
namespace cv 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);
@ -130,7 +130,7 @@ void LogPolar_Interp::create_map(int M, int N, int R, int S, double ro0)
for(int u=0; u<R; u++) for(int u=0; u<R; u++)
{ {
Rsri.at<float>(v,u)=(float)(ro0*pow(a,u)*sin(v/q)+jc); Rsri.at<float>(v,u)=(float)(ro0*pow(a,u)*sin(v/q)+jc);
Csri.at<float>(v,u)=(float)(ro0*pow(a,u)*cos(v/q)+ic); Csri.at<float>(v,u)=(float)(ro0*pow(a,u)*cos(v/q)+ic);
} }
} }
@ -158,7 +158,7 @@ void LogPolar_Interp::create_map(int M, int N, int R, int S, double ro0)
const Mat LogPolar_Interp::to_cortical(const Mat &source) const Mat LogPolar_Interp::to_cortical(const Mat &source)
{ {
Mat out(S,R,CV_8UC1,Scalar(0)); Mat out(S,R,CV_8UC1,Scalar(0));
Mat source_border; Mat source_border;
copyMakeBorder(source,source_border,top,bottom,left,right,BORDER_CONSTANT,Scalar(0)); copyMakeBorder(source,source_border,top,bottom,left,right,BORDER_CONSTANT,Scalar(0));
@ -173,7 +173,7 @@ const Mat LogPolar_Interp::to_cartesian(const Mat &source)
Mat out(N,M,CV_8UC1,Scalar(0)); Mat out(N,M,CV_8UC1,Scalar(0));
Mat source_border; Mat source_border;
if (interp==INTER_NEAREST || interp==INTER_LINEAR){ if (interp==INTER_NEAREST || interp==INTER_LINEAR){
copyMakeBorder(source,source_border,0,1,0,0,BORDER_CONSTANT,Scalar(0)); copyMakeBorder(source,source_border,0,1,0,0,BORDER_CONSTANT,Scalar(0));
Mat rowS0 = source_border.row(S); Mat rowS0 = source_border.row(S);
@ -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);
@ -280,14 +280,14 @@ void LogPolar_Overlapping::create_map(int M, int N, int R, int S, double ro0)
for(int u=0; u<R; u++) for(int u=0; u<R; u++)
{ {
Rsri.at<float>(v,u)=(float)(ro0*pow(a,u)*sin(v/q)+jc); Rsri.at<float>(v,u)=(float)(ro0*pow(a,u)*sin(v/q)+jc);
Csri.at<float>(v,u)=(float)(ro0*pow(a,u)*cos(v/q)+ic); Csri.at<float>(v,u)=(float)(ro0*pow(a,u)*cos(v/q)+ic);
Rsr[v*R+u]=(int)floor(Rsri.at<float>(v,u)); Rsr[v*R+u]=(int)floor(Rsri.at<float>(v,u));
Csr[v*R+u]=(int)floor(Csri.at<float>(v,u)); Csr[v*R+u]=(int)floor(Csri.at<float>(v,u));
} }
} }
bool done=false; bool done=false;
for(int i=0; i<R; i++) for(int i=0; i<R; i++)
{ {
Wsr[i]=ro0*(a-1)*pow(a,i-1); Wsr[i]=ro0*(a-1)*pow(a,i-1);
@ -297,7 +297,7 @@ void LogPolar_Overlapping::create_map(int M, int N, int R, int S, double ro0)
done =true; done =true;
} }
} }
for(int j=0; j<N; j++) for(int j=0; j<N; j++)
{ {
for(int i=0; i<M; i++)//mdf for(int i=0; i<M; i++)//mdf
@ -312,7 +312,7 @@ void LogPolar_Overlapping::create_map(int M, int N, int R, int S, double ro0)
theta+=2*CV_PI; theta+=2*CV_PI;
ETAyx.at<float>(j,i)=(float)(q*theta); ETAyx.at<float>(j,i)=(float)(q*theta);
double ro2=(j-jc)*(j-jc)+(i-ic)*(i-ic); double ro2=(j-jc)*(j-jc)+(i-ic)*(i-ic);
CSIyx.at<float>(j,i)=(float)(0.5*log(ro2/(ro0*ro0))/log(a)); CSIyx.at<float>(j,i)=(float)(0.5*log(ro2/(ro0*ro0))/log(a));
} }
@ -387,7 +387,7 @@ const Mat LogPolar_Overlapping::to_cartesian(const Mat &source)
remap(source_border,out,CSIyx,ETAyx,INTER_LINEAR); remap(source_border,out,CSIyx,ETAyx,INTER_LINEAR);
int wm=w_ker_2D[R-1].w; int wm=w_ker_2D[R-1].w;
vector<double> IMG((N+2*wm+1)*(M+2*wm+1), 0.); vector<double> IMG((N+2*wm+1)*(M+2*wm+1), 0.);
vector<double> NOR((N+2*wm+1)*(M+2*wm+1), 0.); vector<double> NOR((N+2*wm+1)*(M+2*wm+1), 0.);
@ -426,14 +426,14 @@ const Mat LogPolar_Overlapping::to_cartesian(const Mat &source)
Mat out_cropped=out(Range(top,N-1-bottom),Range(left,M-1-right)); Mat out_cropped=out(Range(top,N-1-bottom),Range(left,M-1-right));
return out_cropped; return out_cropped;
} }
LogPolar_Overlapping::~LogPolar_Overlapping() 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);
@ -507,7 +507,7 @@ void LogPolar_Adjacent::create_map(int M, int N, int R, int S, double ro0, doubl
void LogPolar_Adjacent::subdivide_recursively(double x, double y, int i, int j, double length, double smin) void LogPolar_Adjacent::subdivide_recursively(double x, double y, int i, int j, double length, double smin)
{ {
if(length<=smin) if(length<=smin)
{ {
int u, v; int u, v;
@ -576,7 +576,7 @@ const Mat LogPolar_Adjacent::to_cortical(const Mat &source)
for(int j=0; j<N; j++) for(int j=0; j<N; j++)
for(int i=0; i<M; i++) for(int i=0; i<M; i++)
{ {
for(size_t z=0; z<(L[M*j+i]).size(); z++) for(size_t z=0; z<(L[M*j+i]).size(); z++)
{ {
map[R*((L[M*j+i])[z].v)+((L[M*j+i])[z].u)]+=((L[M*j+i])[z].a)*(source_border.at<uchar>(j,i)); map[R*((L[M*j+i])[z].v)+((L[M*j+i])[z].u)]+=((L[M*j+i])[z].a)*(source_border.at<uchar>(j,i));
@ -641,7 +641,7 @@ bool LogPolar_Adjacent::get_uv(double x, double y, int&u, int&v)
else else
v= (int) floor(q*(theta+2*CV_PI)); v= (int) floor(q*(theta+2*CV_PI));
return true; return true;
} }
} }
LogPolar_Adjacent::~LogPolar_Adjacent() LogPolar_Adjacent::~LogPolar_Adjacent()

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;
} }

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

@ -60,9 +60,9 @@ namespace cv
using std::min; using std::min;
using std::sqrt; using std::sqrt;
} }
namespace namespace
{ {
const static Scalar colors[] = const static Scalar colors[] =
{ {
CV_RGB(255, 0, 0), CV_RGB(255, 0, 0),
CV_RGB( 0, 255, 0), CV_RGB( 0, 255, 0),
@ -87,21 +87,21 @@ namespace
template<class FwIt, class T> void iota(FwIt first, FwIt last, T value) { while(first != last) *first++ = value++; } template<class FwIt, class T> void iota(FwIt first, FwIt last, T value) { while(first != last) *first++ = value++; }
void computeNormals( const Octree& Octree, const vector<Point3f>& centers, vector<Point3f>& normals, void computeNormals( const Octree& Octree, const vector<Point3f>& centers, vector<Point3f>& normals,
vector<uchar>& mask, float normalRadius, int minNeighbors = 20) vector<uchar>& mask, float normalRadius, int minNeighbors = 20)
{ {
size_t normals_size = centers.size(); size_t normals_size = centers.size();
normals.resize(normals_size); normals.resize(normals_size);
if (mask.size() != normals_size) if (mask.size() != normals_size)
{ {
size_t m = mask.size(); size_t m = mask.size();
mask.resize(normals_size); mask.resize(normals_size);
if (normals_size > m) if (normals_size > m)
for(; m < normals_size; ++m) for(; m < normals_size; ++m)
mask[m] = 1; mask[m] = 1;
} }
vector<Point3f> buffer; vector<Point3f> buffer;
buffer.reserve(128); buffer.reserve(128);
SVD svd; SVD svd;
@ -132,7 +132,7 @@ void computeNormals( const Octree& Octree, const vector<Point3f>& centers, vecto
mean.x /= buf_size; mean.x /= buf_size;
mean.y /= buf_size; mean.y /= buf_size;
mean.z /= buf_size; mean.z /= buf_size;
double pxpx = 0; double pxpx = 0;
double pypy = 0; double pypy = 0;
double pzpz = 0; double pzpz = 0;
@ -162,9 +162,9 @@ void computeNormals( const Octree& Octree, const vector<Point3f>& centers, vecto
/*normals[n] = Point3f( (float)((double*)svd.vt.data)[6], /*normals[n] = Point3f( (float)((double*)svd.vt.data)[6],
(float)((double*)svd.vt.data)[7], (float)((double*)svd.vt.data)[7],
(float)((double*)svd.vt.data)[8] );*/ (float)((double*)svd.vt.data)[8] );*/
normals[n] = reinterpret_cast<Point3d*>(svd.vt.data)[2]; normals[n] = reinterpret_cast<Point3d*>(svd.vt.data)[2];
mask[n] = 1; mask[n] = 1;
} }
} }
@ -213,22 +213,22 @@ inline __m128 transformSSE(const __m128* matrix, const __m128& in)
} }
inline __m128i _mm_mullo_epi32_emul(const __m128i& a, __m128i& b) inline __m128i _mm_mullo_epi32_emul(const __m128i& a, __m128i& b)
{ {
__m128i pack = _mm_packs_epi32(a, a); __m128i pack = _mm_packs_epi32(a, a);
return _mm_unpacklo_epi16(_mm_mullo_epi16(pack, b), _mm_mulhi_epi16(pack, b)); return _mm_unpacklo_epi16(_mm_mullo_epi16(pack, b), _mm_mulhi_epi16(pack, b));
} }
#endif #endif
void computeSpinImages( const Octree& Octree, const vector<Point3f>& points, const vector<Point3f>& normals, void computeSpinImages( const Octree& Octree, const vector<Point3f>& points, const vector<Point3f>& normals,
vector<uchar>& mask, Mat& spinImages, int imageWidth, float binSize) vector<uchar>& mask, Mat& spinImages, int imageWidth, float binSize)
{ {
float pixelsPerMeter = 1.f / binSize; float pixelsPerMeter = 1.f / binSize;
float support = imageWidth * binSize; float support = imageWidth * binSize;
assert(normals.size() == points.size()); assert(normals.size() == points.size());
assert(mask.size() == points.size()); assert(mask.size() == points.size());
size_t points_size = points.size(); size_t points_size = points.size();
mask.resize(points_size); mask.resize(points_size);
@ -257,7 +257,7 @@ void computeSpinImages( const Octree& Octree, const vector<Point3f>& points, con
int t = cvGetThreadNum(); int t = cvGetThreadNum();
vector<Point3f>& pointsInSphere = pointsInSpherePool[t]; vector<Point3f>& pointsInSphere = pointsInSpherePool[t];
const Point3f& center = points[i]; const Point3f& center = points[i];
Octree.getPointsWithinSphere(center, searchRad, pointsInSphere); Octree.getPointsWithinSphere(center, searchRad, pointsInSphere);
@ -269,7 +269,7 @@ void computeSpinImages( const Octree& Octree, const vector<Point3f>& points, con
} }
const Point3f& normal = normals[i]; const Point3f& normal = normals[i];
float rotmat[9]; float rotmat[9];
initRotationMat(normal, rotmat); initRotationMat(normal, rotmat);
Point3f new_center; Point3f new_center;
@ -287,7 +287,7 @@ void computeSpinImages( const Octree& Octree, const vector<Point3f>& points, con
{ {
__m128 rotmatSSE[3]; __m128 rotmatSSE[3];
convertTransformMatrix(rotmat, (float*)rotmatSSE); convertTransformMatrix(rotmat, (float*)rotmatSSE);
__m128 center_x4 = _mm_set1_ps(new_center.x); __m128 center_x4 = _mm_set1_ps(new_center.x);
__m128 center_y4 = _mm_set1_ps(new_center.y); __m128 center_y4 = _mm_set1_ps(new_center.y);
__m128 center_z4 = _mm_set1_ps(new_center.z + halfSuppport); __m128 center_z4 = _mm_set1_ps(new_center.z + halfSuppport);
@ -313,7 +313,7 @@ void computeSpinImages( const Octree& Octree, const vector<Point3f>& points, con
__m128 z0 = _mm_unpackhi_ps(pt0, pt1); // z0 z1 . . __m128 z0 = _mm_unpackhi_ps(pt0, pt1); // z0 z1 . .
__m128 z1 = _mm_unpackhi_ps(pt2, pt3); // z2 z3 . . __m128 z1 = _mm_unpackhi_ps(pt2, pt3); // z2 z3 . .
__m128 beta4 = _mm_sub_ps(center_z4, _mm_movelh_ps(z0, z1)); // b0 b1 b2 b3 __m128 beta4 = _mm_sub_ps(center_z4, _mm_movelh_ps(z0, z1)); // b0 b1 b2 b3
__m128 xy0 = _mm_unpacklo_ps(pt0, pt1); // x0 x1 y0 y1 __m128 xy0 = _mm_unpacklo_ps(pt0, pt1); // x0 x1 y0 y1
__m128 xy1 = _mm_unpacklo_ps(pt2, pt3); // x2 x3 y2 y3 __m128 xy1 = _mm_unpacklo_ps(pt2, pt3); // x2 x3 y2 y3
__m128 x4 = _mm_movelh_ps(xy0, xy1); // x0 x1 x2 x3 __m128 x4 = _mm_movelh_ps(xy0, xy1); // x0 x1 x2 x3
@ -322,7 +322,7 @@ void computeSpinImages( const Octree& Octree, const vector<Point3f>& points, con
x4 = _mm_sub_ps(x4, center_x4); x4 = _mm_sub_ps(x4, center_x4);
y4 = _mm_sub_ps(y4, center_y4); y4 = _mm_sub_ps(y4, center_y4);
__m128 alpha4 = _mm_sqrt_ps(_mm_add_ps(_mm_mul_ps(x4,x4),_mm_mul_ps(y4,y4))); __m128 alpha4 = _mm_sqrt_ps(_mm_add_ps(_mm_mul_ps(x4,x4),_mm_mul_ps(y4,y4)));
__m128 n1f4 = _mm_mul_ps( beta4, ppm4); /* beta4 float */ __m128 n1f4 = _mm_mul_ps( beta4, ppm4); /* beta4 float */
__m128 n2f4 = _mm_mul_ps(alpha4, ppm4); /* alpha4 float */ __m128 n2f4 = _mm_mul_ps(alpha4, ppm4); /* alpha4 float */
@ -333,21 +333,21 @@ void computeSpinImages( const Octree& Octree, const vector<Point3f>& points, con
__m128 f1 = _mm_sub_ps( n1f4, _mm_cvtepi32_ps(n1) ); /* { beta4 } */ __m128 f1 = _mm_sub_ps( n1f4, _mm_cvtepi32_ps(n1) ); /* { beta4 } */
__m128 f2 = _mm_sub_ps( n2f4, _mm_cvtepi32_ps(n2) ); /* { alpha4 } */ __m128 f2 = _mm_sub_ps( n2f4, _mm_cvtepi32_ps(n2) ); /* { alpha4 } */
__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
@ -395,9 +395,9 @@ void computeSpinImages( const Octree& Octree, const vector<Point3f>& points, con
if (beta >= support || beta < 0) if (beta >= support || beta < 0)
continue; continue;
alpha = sqrt( (new_center.x - pt.x) * (new_center.x - pt.x) + alpha = sqrt( (new_center.x - pt.x) * (new_center.x - pt.x) +
(new_center.y - pt.y) * (new_center.y - pt.y) ); (new_center.y - pt.y) * (new_center.y - pt.y) );
float n1f = beta * pixelsPerMeter; float n1f = beta * pixelsPerMeter;
float n2f = alpha * pixelsPerMeter; float n2f = alpha * pixelsPerMeter;
@ -407,7 +407,7 @@ void computeSpinImages( const Octree& Octree, const vector<Point3f>& points, con
float f1 = n1f - n1; float f1 = n1f - n1;
float f2 = n2f - n2; float f2 = n2f - n2;
if ((unsigned)n1 >= (unsigned)(spinImage.rows-1) || if ((unsigned)n1 >= (unsigned)(spinImage.rows-1) ||
(unsigned)n2 >= (unsigned)(spinImage.cols-1)) (unsigned)n2 >= (unsigned)(spinImage.cols-1))
continue; continue;
@ -454,27 +454,27 @@ float cv::Mesh3D::estimateResolution(float /*tryRatio*/)
vector<double> dist(tryNum * neighbors); vector<double> dist(tryNum * neighbors);
vector<int> inds(tryNum * neighbors); vector<int> inds(tryNum * neighbors);
vector<Point3f> query; vector<Point3f> query;
RNG& rng = theRNG(); RNG& rng = theRNG();
for(int i = 0; i < tryNum; ++i) for(int i = 0; i < tryNum; ++i)
query.push_back(vtx[rng.next() % vtx.size()]); query.push_back(vtx[rng.next() % vtx.size()]);
CvMat cvinds = cvMat( (int)tryNum, neighbors, CV_32S, &inds[0] ); CvMat cvinds = cvMat( (int)tryNum, neighbors, CV_32S, &inds[0] );
CvMat cvdist = cvMat( (int)tryNum, neighbors, CV_64F, &dist[0] ); CvMat cvdist = cvMat( (int)tryNum, neighbors, CV_64F, &dist[0] );
CvMat cvquery = cvMat( (int)tryNum, 3, CV_32F, &query[0] ); CvMat cvquery = cvMat( (int)tryNum, 3, CV_32F, &query[0] );
cvFindFeatures(tr, &cvquery, &cvinds, &cvdist, neighbors, 50); cvFindFeatures(tr, &cvquery, &cvinds, &cvdist, neighbors, 50);
cvReleaseFeatureTree(tr); cvReleaseFeatureTree(tr);
const int invalid_dist = -2; const int invalid_dist = -2;
for(int i = 0; i < tryNum; ++i) for(int i = 0; i < tryNum; ++i)
if (inds[i] == -1) if (inds[i] == -1)
dist[i] = invalid_dist; dist[i] = invalid_dist;
dist.resize(remove(dist.begin(), dist.end(), invalid_dist) - dist.begin()); dist.resize(remove(dist.begin(), dist.end(), invalid_dist) - dist.begin());
sort(dist, less<double>()); sort(dist, less<double>());
return resolution = (float)dist[ dist.size() / 2 ]; return resolution = (float)dist[ dist.size() / 2 ];
#else #else
CV_Error(CV_StsNotImplemented, ""); CV_Error(CV_StsNotImplemented, "");
@ -494,7 +494,7 @@ void cv::Mesh3D::computeNormals(const vector<int>& subset, float normalRadius, i
{ {
buildOctree(); buildOctree();
vector<uchar> mask(vtx.size(), 0); vector<uchar> mask(vtx.size(), 0);
for(size_t i = 0; i < subset.size(); ++i) for(size_t i = 0; i < subset.size(); ++i)
mask[subset[i]] = 1; mask[subset[i]] = 1;
::computeNormals(octree, vtx, normals, mask, normalRadius, minNeighbors); ::computeNormals(octree, vtx, normals, mask, normalRadius, minNeighbors);
} }
@ -504,31 +504,31 @@ void cv::Mesh3D::writeAsVrml(const String& file, const vector<Scalar>& _colors)
ofstream ofs(file.c_str()); ofstream ofs(file.c_str());
ofs << "#VRML V2.0 utf8" << endl; ofs << "#VRML V2.0 utf8" << endl;
ofs << "Shape" << std::endl << "{" << endl; ofs << "Shape" << std::endl << "{" << endl;
ofs << "geometry PointSet" << endl << "{" << endl; ofs << "geometry PointSet" << endl << "{" << endl;
ofs << "coord Coordinate" << endl << "{" << endl; ofs << "coord Coordinate" << endl << "{" << endl;
ofs << "point[" << endl; ofs << "point[" << endl;
for(size_t i = 0; i < vtx.size(); ++i) for(size_t i = 0; i < vtx.size(); ++i)
ofs << vtx[i].x << " " << vtx[i].y << " " << vtx[i].z << endl; ofs << vtx[i].x << " " << vtx[i].y << " " << vtx[i].z << endl;
ofs << "]" << endl; //point[ ofs << "]" << endl; //point[
ofs << "}" << endl; //Coordinate{ ofs << "}" << endl; //Coordinate{
if (vtx.size() == _colors.size()) if (vtx.size() == _colors.size())
{ {
ofs << "color Color" << endl << "{" << endl; ofs << "color Color" << endl << "{" << endl;
ofs << "color[" << endl; ofs << "color[" << endl;
for(size_t i = 0; i < _colors.size(); ++i) for(size_t i = 0; i < _colors.size(); ++i)
ofs << (float)_colors[i][2] << " " << (float)_colors[i][1] << " " << (float)_colors[i][0] << endl; ofs << (float)_colors[i][2] << " " << (float)_colors[i][1] << " " << (float)_colors[i][0] << endl;
ofs << "]" << endl; //color[ ofs << "]" << endl; //color[
ofs << "}" << endl; //color Color{ ofs << "}" << endl; //color Color{
} }
ofs << "}" << endl; //PointSet{ ofs << "}" << endl; //PointSet{
ofs << "}" << endl; //Shape{ ofs << "}" << endl; //Shape{
} }
@ -538,45 +538,45 @@ void cv::Mesh3D::writeAsVrml(const String& file, const vector<Scalar>& _colors)
bool cv::SpinImageModel::spinCorrelation(const Mat& spin1, const Mat& spin2, float lambda, float& result) bool cv::SpinImageModel::spinCorrelation(const Mat& spin1, const Mat& spin2, float lambda, float& result)
{ {
struct Math { static double atanh(double x) { return 0.5 * std::log( (1 + x) / (1 - x) ); } }; struct Math { static double atanh(double x) { return 0.5 * std::log( (1 + x) / (1 - x) ); } };
const float* s1 = spin1.ptr<float>(); const float* s1 = spin1.ptr<float>();
const float* s2 = spin2.ptr<float>(); const float* s2 = spin2.ptr<float>();
int spin_sz = spin1.cols * spin1.rows; int spin_sz = spin1.cols * spin1.rows;
double sum1 = 0.0, sum2 = 0.0, sum12 = 0.0, sum11 = 0.0, sum22 = 0.0; double sum1 = 0.0, sum2 = 0.0, sum12 = 0.0, sum11 = 0.0, sum22 = 0.0;
int N = 0; int N = 0;
int i = 0; int i = 0;
#if CV_SSE2//____________TEMPORARY_DISABLED_____________ #if CV_SSE2//____________TEMPORARY_DISABLED_____________
float CV_DECL_ALIGNED(16) su1[4], su2[4], su11[4], su22[4], su12[4], n[4]; float CV_DECL_ALIGNED(16) su1[4], su2[4], su11[4], su22[4], su12[4], n[4];
__m128 zerof4 = _mm_setzero_ps(); __m128 zerof4 = _mm_setzero_ps();
__m128 onef4 = _mm_set1_ps(1.f); __m128 onef4 = _mm_set1_ps(1.f);
__m128 Nf4 = zerof4; __m128 Nf4 = zerof4;
__m128 sum1f4 = zerof4; __m128 sum1f4 = zerof4;
__m128 sum2f4 = zerof4; __m128 sum2f4 = zerof4;
__m128 sum11f4 = zerof4; __m128 sum11f4 = zerof4;
__m128 sum22f4 = zerof4; __m128 sum22f4 = zerof4;
__m128 sum12f4 = zerof4; __m128 sum12f4 = zerof4;
for(; i < spin_sz - 5; i += 4) for(; i < spin_sz - 5; i += 4)
{ {
__m128 v1f4 = _mm_loadu_ps(s1 + i); __m128 v1f4 = _mm_loadu_ps(s1 + i);
__m128 v2f4 = _mm_loadu_ps(s2 + i); __m128 v2f4 = _mm_loadu_ps(s2 + i);
__m128 mskf4 = _mm_and_ps(_mm_cmpneq_ps(v1f4, zerof4), _mm_cmpneq_ps(v2f4, zerof4)); __m128 mskf4 = _mm_and_ps(_mm_cmpneq_ps(v1f4, zerof4), _mm_cmpneq_ps(v2f4, zerof4));
if( !_mm_movemask_ps(mskf4) ) if( !_mm_movemask_ps(mskf4) )
continue; continue;
Nf4 = _mm_add_ps(Nf4, _mm_and_ps(onef4, mskf4)); Nf4 = _mm_add_ps(Nf4, _mm_and_ps(onef4, mskf4));
v1f4 = _mm_and_ps(v1f4, mskf4); v1f4 = _mm_and_ps(v1f4, mskf4);
v2f4 = _mm_and_ps(v2f4, mskf4); v2f4 = _mm_and_ps(v2f4, mskf4);
sum1f4 = _mm_add_ps(sum1f4, v1f4); sum1f4 = _mm_add_ps(sum1f4, v1f4);
sum2f4 = _mm_add_ps(sum2f4, v2f4); sum2f4 = _mm_add_ps(sum2f4, v2f4);
sum11f4 = _mm_add_ps(sum11f4, _mm_mul_ps(v1f4, v1f4)); sum11f4 = _mm_add_ps(sum11f4, _mm_mul_ps(v1f4, v1f4));
sum22f4 = _mm_add_ps(sum22f4, _mm_mul_ps(v2f4, v2f4)); sum22f4 = _mm_add_ps(sum22f4, _mm_mul_ps(v2f4, v2f4));
sum12f4 = _mm_add_ps(sum12f4, _mm_mul_ps(v1f4, v2f4)); sum12f4 = _mm_add_ps(sum12f4, _mm_mul_ps(v1f4, v2f4));
} }
_mm_store_ps( su1, sum1f4 ); _mm_store_ps( su1, sum1f4 );
_mm_store_ps( su2, sum2f4 ); _mm_store_ps( su2, sum2f4 );
@ -601,11 +601,11 @@ bool cv::SpinImageModel::spinCorrelation(const Mat& spin1, const Mat& spin2, flo
if( !v1 || !v2 ) if( !v1 || !v2 )
continue; continue;
N++; N++;
sum1 += v1; sum1 += v1;
sum2 += v2; sum2 += v2;
sum11 += v1 * v1; sum11 += v1 * v1;
sum22 += v2 * v2; sum22 += v2 * v2;
sum12 += v1 * v2; sum12 += v1 * v2;
} }
if( N < 4 ) if( N < 4 )
@ -624,13 +624,13 @@ bool cv::SpinImageModel::spinCorrelation(const Mat& spin1, const Mat& spin2, flo
double corr = (Nsum12 - sum1 * sum2) / sqrt( (Nsum11 - sum1sum1) * (Nsum22 - sum2sum2) ); double corr = (Nsum12 - sum1 * sum2) / sqrt( (Nsum11 - sum1sum1) * (Nsum22 - sum2sum2) );
double atanh = Math::atanh(corr); double atanh = Math::atanh(corr);
result = (float)( atanh * atanh - lambda * ( 1.0 / (N - 3) ) ); result = (float)( atanh * atanh - lambda * ( 1.0 / (N - 3) ) );
return true; return true;
} }
inline Point2f cv::SpinImageModel::calcSpinMapCoo(const Point3f& p, const Point3f& v, const Point3f& n) inline Point2f cv::SpinImageModel::calcSpinMapCoo(const Point3f& p, const Point3f& v, const Point3f& n)
{ {
/*Point3f PmV(p.x - v.x, p.y - v.y, p.z - v.z); /*Point3f PmV(p.x - v.x, p.y - v.y, p.z - v.z);
float normalNorm = (float)norm(n); float normalNorm = (float)norm(n);
float beta = PmV.dot(n) / normalNorm; float beta = PmV.dot(n) / normalNorm;
float pmcNorm = (float)norm(PmV); float pmcNorm = (float)norm(PmV);
float alpha = sqrt( pmcNorm * pmcNorm - beta * beta); float alpha = sqrt( pmcNorm * pmcNorm - beta * beta);
@ -639,23 +639,23 @@ inline Point2f cv::SpinImageModel::calcSpinMapCoo(const Point3f& p, const Point3
float pmv_x = p.x - v.x, pmv_y = p.y - v.y, pmv_z = p.z - v.z; float pmv_x = p.x - v.x, pmv_y = p.y - v.y, pmv_z = p.z - v.z;
float beta = (pmv_x * n.x + pmv_y + n.y + pmv_z * n.z) / sqrt(n.x * n.x + n.y * n.y + n.z * n.z); float beta = (pmv_x * n.x + pmv_y + n.y + pmv_z * n.z) / sqrt(n.x * n.x + n.y * n.y + n.z * n.z);
float alpha = sqrt( pmv_x * pmv_x + pmv_y * pmv_y + pmv_z * pmv_z - beta * beta); float alpha = sqrt( pmv_x * pmv_x + pmv_y * pmv_y + pmv_z * pmv_z - beta * beta);
return Point2f(alpha, beta); return Point2f(alpha, beta);
} }
inline float cv::SpinImageModel::geometricConsistency(const Point3f& pointScene1, const Point3f& normalScene1, inline float cv::SpinImageModel::geometricConsistency(const Point3f& pointScene1, const Point3f& normalScene1,
const Point3f& pointModel1, const Point3f& normalModel1, const Point3f& pointModel1, const Point3f& normalModel1,
const Point3f& pointScene2, const Point3f& normalScene2, const Point3f& pointScene2, const Point3f& normalScene2,
const Point3f& pointModel2, const Point3f& normalModel2) const Point3f& pointModel2, const Point3f& normalModel2)
{ {
Point2f Sm2_to_m1, Ss2_to_s1; Point2f Sm2_to_m1, Ss2_to_s1;
Point2f Sm1_to_m2, Ss1_to_s2; Point2f Sm1_to_m2, Ss1_to_s2;
double n_Sm2_to_m1 = norm(Sm2_to_m1 = calcSpinMapCoo(pointModel2, pointModel1, normalModel1)); double n_Sm2_to_m1 = norm(Sm2_to_m1 = calcSpinMapCoo(pointModel2, pointModel1, normalModel1));
double n_Ss2_to_s1 = norm(Ss2_to_s1 = calcSpinMapCoo(pointScene2, pointScene1, normalScene1)); double n_Ss2_to_s1 = norm(Ss2_to_s1 = calcSpinMapCoo(pointScene2, pointScene1, normalScene1));
double gc21 = 2 * norm(Sm2_to_m1 - Ss2_to_s1) / (n_Sm2_to_m1 + n_Ss2_to_s1 ) ; double gc21 = 2 * norm(Sm2_to_m1 - Ss2_to_s1) / (n_Sm2_to_m1 + n_Ss2_to_s1 ) ;
double n_Sm1_to_m2 = norm(Sm1_to_m2 = calcSpinMapCoo(pointModel1, pointModel2, normalModel2)); double n_Sm1_to_m2 = norm(Sm1_to_m2 = calcSpinMapCoo(pointModel1, pointModel2, normalModel2));
double n_Ss1_to_s2 = norm(Ss1_to_s2 = calcSpinMapCoo(pointScene1, pointScene2, normalScene2)); double n_Ss1_to_s2 = norm(Ss1_to_s2 = calcSpinMapCoo(pointScene1, pointScene2, normalScene2));
@ -666,10 +666,10 @@ inline float cv::SpinImageModel::geometricConsistency(const Point3f& pointScene1
inline float cv::SpinImageModel::groupingCreteria(const Point3f& pointScene1, const Point3f& normalScene1, inline float cv::SpinImageModel::groupingCreteria(const Point3f& pointScene1, const Point3f& normalScene1,
const Point3f& pointModel1, const Point3f& normalModel1, const Point3f& pointModel1, const Point3f& normalModel1,
const Point3f& pointScene2, const Point3f& normalScene2, const Point3f& pointScene2, const Point3f& normalScene2,
const Point3f& pointModel2, const Point3f& normalModel2, const Point3f& pointModel2, const Point3f& normalModel2,
float gamma) float gamma)
{ {
Point2f Sm2_to_m1, Ss2_to_s1; Point2f Sm2_to_m1, Ss2_to_s1;
Point2f Sm1_to_m2, Ss1_to_s2; Point2f Sm1_to_m2, Ss1_to_s2;
@ -680,7 +680,7 @@ inline float cv::SpinImageModel::groupingCreteria(const Point3f& pointScene1, co
double gc21 = 2 * norm(Sm2_to_m1 - Ss2_to_s1) / (n_Sm2_to_m1 + n_Ss2_to_s1 ); double gc21 = 2 * norm(Sm2_to_m1 - Ss2_to_s1) / (n_Sm2_to_m1 + n_Ss2_to_s1 );
double wgc21 = gc21 / (1 - exp( -(n_Sm2_to_m1 + n_Ss2_to_s1) * gamma05_inv ) ); double wgc21 = gc21 / (1 - exp( -(n_Sm2_to_m1 + n_Ss2_to_s1) * gamma05_inv ) );
double n_Sm1_to_m2 = norm(Sm1_to_m2 = calcSpinMapCoo(pointModel1, pointModel2, normalModel2)); double n_Sm1_to_m2 = norm(Sm1_to_m2 = calcSpinMapCoo(pointModel1, pointModel2, normalModel2));
double n_Ss1_to_s2 = norm(Ss1_to_s2 = calcSpinMapCoo(pointScene1, pointScene2, normalScene2)); double n_Ss1_to_s2 = norm(Ss1_to_s2 = calcSpinMapCoo(pointScene1, pointScene2, normalScene2));
@ -692,10 +692,10 @@ inline float cv::SpinImageModel::groupingCreteria(const Point3f& pointScene1, co
cv::SpinImageModel::SpinImageModel(const Mesh3D& _mesh) : mesh(_mesh) , out(0) cv::SpinImageModel::SpinImageModel(const Mesh3D& _mesh) : mesh(_mesh) , out(0)
{ {
if (mesh.vtx.empty()) if (mesh.vtx.empty())
throw Mesh3D::EmptyMeshException(); throw Mesh3D::EmptyMeshException();
defaultParams(); defaultParams();
} }
cv::SpinImageModel::SpinImageModel() : out(0) { defaultParams(); } cv::SpinImageModel::SpinImageModel() : out(0) { defaultParams(); }
cv::SpinImageModel::~SpinImageModel() {} cv::SpinImageModel::~SpinImageModel() {}
@ -708,8 +708,8 @@ void cv::SpinImageModel::defaultParams()
minNeighbors = 20; minNeighbors = 20;
binSize = 0.f; /* autodetect according to mesh resolution */ binSize = 0.f; /* autodetect according to mesh resolution */
imageWidth = 32; imageWidth = 32;
lambda = 0.f; /* autodetect according to medan non zero images bin */ lambda = 0.f; /* autodetect according to medan non zero images bin */
gamma = 0.f; /* autodetect according to mesh resolution */ gamma = 0.f; /* autodetect according to mesh resolution */
@ -725,28 +725,28 @@ Mat cv::SpinImageModel::packRandomScaledSpins(bool separateScale, size_t xCount,
if (num == 0) if (num == 0)
return Mat(); return Mat();
RNG& rng = theRNG(); RNG& rng = theRNG();
vector<Mat> spins; vector<Mat> spins;
for(int i = 0; i < num; ++i) for(int i = 0; i < num; ++i)
spins.push_back(getSpinImage( rng.next() % spinNum ).reshape(1, imageWidth)); spins.push_back(getSpinImage( rng.next() % spinNum ).reshape(1, imageWidth));
if (separateScale) if (separateScale)
for(int i = 0; i < num; ++i) for(int i = 0; i < num; ++i)
{ {
double max; double max;
Mat spin8u; Mat spin8u;
minMaxLoc(spins[i], 0, &max); minMaxLoc(spins[i], 0, &max);
spins[i].convertTo(spin8u, CV_8U, -255.0/max, 255.0); spins[i].convertTo(spin8u, CV_8U, -255.0/max, 255.0);
spins[i] = spin8u; spins[i] = spin8u;
} }
else else
{ {
double totalMax = 0; double totalMax = 0;
for(int i = 0; i < num; ++i) for(int i = 0; i < num; ++i)
{ {
double m; double m;
minMaxLoc(spins[i], 0, &m); minMaxLoc(spins[i], 0, &m);
totalMax = max(m, totalMax); totalMax = max(m, totalMax);
} }
@ -760,12 +760,12 @@ Mat cv::SpinImageModel::packRandomScaledSpins(bool separateScale, size_t xCount,
int sz = spins.front().cols; int sz = spins.front().cols;
Mat result((int)(yCount * sz + (yCount - 1)), (int)(xCount * sz + (xCount - 1)), CV_8UC3); Mat result((int)(yCount * sz + (yCount - 1)), (int)(xCount * sz + (xCount - 1)), CV_8UC3);
result = colors[(static_cast<int64>(cvGetTickCount()/cvGetTickFrequency())/1000) % colors_mum]; result = colors[(static_cast<int64>(cvGetTickCount()/cvGetTickFrequency())/1000) % colors_mum];
int pos = 0; int pos = 0;
for(int y = 0; y < (int)yCount; ++y) for(int y = 0; y < (int)yCount; ++y)
for(int x = 0; x < (int)xCount; ++x) for(int x = 0; x < (int)xCount; ++x)
if (pos < num) if (pos < num)
{ {
int starty = (y + 0) * sz + y; int starty = (y + 0) * sz + y;
@ -778,7 +778,7 @@ Mat cv::SpinImageModel::packRandomScaledSpins(bool separateScale, size_t xCount,
cvtColor(spins[pos++], color, CV_GRAY2BGR); cvtColor(spins[pos++], color, CV_GRAY2BGR);
Mat roi = result(Range(starty, endy), Range(startx, endx)); Mat roi = result(Range(starty, endy), Range(startx, endx));
color.copyTo(roi); color.copyTo(roi);
} }
return result; return result;
} }
@ -811,8 +811,8 @@ void cv::SpinImageModel::selectRandomSubset(float ratio)
int pos = rnd.next() % left.size(); int pos = rnd.next() % left.size();
subset[i] = (int)left[pos]; subset[i] = (int)left[pos];
left[pos] = left.back(); left[pos] = left.back();
left.resize(left.size() - 1); left.resize(left.size() - 1);
} }
sort(subset, less<int>()); sort(subset, less<int>());
} }
@ -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
{ {
@ -849,13 +849,13 @@ void cv::SpinImageModel::repackSpinImages(const vector<uchar>& mask, Mat& spinIm
int first = dest + 1; int first = dest + 1;
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);
} }
} }
@ -865,13 +865,13 @@ void cv::SpinImageModel::compute()
if (binSize == 0.f) if (binSize == 0.f)
{ {
if (mesh.resolution == -1.f) if (mesh.resolution == -1.f)
mesh.estimateResolution(); mesh.estimateResolution();
binSize = mesh.resolution; binSize = mesh.resolution;
} }
/* estimate normalRadius */ /* estimate normalRadius */
normalRadius = normalRadius != 0.f ? normalRadius : binSize * imageWidth / 2; normalRadius = normalRadius != 0.f ? normalRadius : binSize * imageWidth / 2;
mesh.buildOctree(); mesh.buildOctree();
if (subset.empty()) if (subset.empty())
{ {
mesh.computeNormals(normalRadius, minNeighbors); mesh.computeNormals(normalRadius, minNeighbors);
@ -881,16 +881,16 @@ void cv::SpinImageModel::compute()
else else
mesh.computeNormals(subset, normalRadius, minNeighbors); mesh.computeNormals(subset, normalRadius, minNeighbors);
vector<uchar> mask(mesh.vtx.size(), 0); vector<uchar> mask(mesh.vtx.size(), 0);
for(size_t i = 0; i < subset.size(); ++i) for(size_t i = 0; i < subset.size(); ++i)
if (mesh.normals[subset[i]] == Mesh3D::allzero) if (mesh.normals[subset[i]] == Mesh3D::allzero)
subset[i] = -1; subset[i] = -1;
else else
mask[subset[i]] = 1; mask[subset[i]] = 1;
subset.resize( remove(subset.begin(), subset.end(), -1) - subset.begin() ); subset.resize( remove(subset.begin(), subset.end(), -1) - subset.begin() );
vector<Point3f> vtx; vector<Point3f> vtx;
vector<Point3f> normals; vector<Point3f> normals;
for(size_t i = 0; i < mask.size(); ++i) for(size_t i = 0; i < mask.size(); ++i)
if(mask[i]) if(mask[i])
{ {
@ -906,7 +906,7 @@ void cv::SpinImageModel::compute()
for(size_t i = 0; i < mask.size(); ++i) for(size_t i = 0; i < mask.size(); ++i)
if(mask[i]) if(mask[i])
if (spinMask[mask_pos++] == 0) if (spinMask[mask_pos++] == 0)
subset.resize( remove(subset.begin(), subset.end(), (int)i) - subset.begin() ); subset.resize( remove(subset.begin(), subset.end(), (int)i) - subset.begin() );
} }
void cv::SpinImageModel::matchSpinToModel(const Mat& spin, vector<int>& indeces, vector<float>& corrCoeffs, bool useExtremeOutliers) const void cv::SpinImageModel::matchSpinToModel(const Mat& spin, vector<int>& indeces, vector<float>& corrCoeffs, bool useExtremeOutliers) const
@ -920,46 +920,46 @@ void cv::SpinImageModel::matchSpinToModel(const Mat& spin, vector<int>& indeces,
vector<uchar> masks(model.spinImages.rows); vector<uchar> masks(model.spinImages.rows);
vector<float> cleanCorrs; vector<float> cleanCorrs;
cleanCorrs.reserve(model.spinImages.rows); cleanCorrs.reserve(model.spinImages.rows);
for(int i = 0; i < model.spinImages.rows; ++i) for(int i = 0; i < model.spinImages.rows; ++i)
{ {
masks[i] = spinCorrelation(spin, model.spinImages.row(i), model.lambda, corrs[i]); masks[i] = spinCorrelation(spin, model.spinImages.row(i), model.lambda, corrs[i]);
if (masks[i]) if (masks[i])
cleanCorrs.push_back(corrs[i]); cleanCorrs.push_back(corrs[i]);
} }
/* Filtering by measure histogram */ /* Filtering by measure histogram */
size_t total = cleanCorrs.size(); size_t total = cleanCorrs.size();
if(total < 5) if(total < 5)
return; return;
sort(cleanCorrs, less<float>()); sort(cleanCorrs, less<float>());
float lower_fourth = cleanCorrs[(1 * total) / 4 - 1]; float lower_fourth = cleanCorrs[(1 * total) / 4 - 1];
float upper_fourth = cleanCorrs[(3 * total) / 4 - 0]; float upper_fourth = cleanCorrs[(3 * total) / 4 - 0];
float fourth_spread = upper_fourth - lower_fourth; float fourth_spread = upper_fourth - lower_fourth;
//extreme or moderate? //extreme or moderate?
float coef = useExtremeOutliers ? 3.0f : 1.5f; float coef = useExtremeOutliers ? 3.0f : 1.5f;
float histThresHi = upper_fourth + coef * fourth_spread;
//float histThresLo = lower_fourth - coef * fourth_spread;
float histThresHi = upper_fourth + coef * fourth_spread;
//float histThresLo = lower_fourth - coef * fourth_spread;
for(size_t i = 0; i < corrs.size(); ++i) for(size_t i = 0; i < corrs.size(); ++i)
if (masks[i]) if (masks[i])
if (/* corrs[i] < histThresLo || */ corrs[i] > histThresHi) if (/* corrs[i] < histThresLo || */ corrs[i] > histThresHi)
{ {
indeces.push_back((int)i); indeces.push_back((int)i);
corrCoeffs.push_back(corrs[i]); corrCoeffs.push_back(corrs[i]);
} }
} }
namespace namespace
{ {
struct Match struct Match
{ {
int sceneInd; int sceneInd;
int modelInd; int modelInd;
float measure; float measure;
@ -984,7 +984,7 @@ struct WgcHelper
{ {
const float* wgcLine = mat.ptr<float>((int)corespInd); const float* wgcLine = mat.ptr<float>((int)corespInd);
float maximum = numeric_limits<float>::min(); float maximum = numeric_limits<float>::min();
for(citer pos = group.begin(); pos != group.end(); ++pos) for(citer pos = group.begin(); pos != group.end(); ++pos)
maximum = max(wgcLine[*pos], maximum); maximum = max(wgcLine[*pos], maximum);
@ -997,7 +997,7 @@ private:
} }
void cv::SpinImageModel::match(const SpinImageModel& scene, vector< vector<Vec2i> >& result) void cv::SpinImageModel::match(const SpinImageModel& scene, vector< vector<Vec2i> >& result)
{ {
if (mesh.vtx.empty()) if (mesh.vtx.empty())
throw Mesh3D::EmptyMeshException(); throw Mesh3D::EmptyMeshException();
@ -1006,25 +1006,25 @@ private:
SpinImageModel& model = *this; SpinImageModel& model = *this;
const float infinity = numeric_limits<float>::infinity(); const float infinity = numeric_limits<float>::infinity();
const float float_max = numeric_limits<float>::max(); const float float_max = numeric_limits<float>::max();
/* estimate gamma */ /* estimate gamma */
if (model.gamma == 0.f) if (model.gamma == 0.f)
{ {
if (model.mesh.resolution == -1.f) if (model.mesh.resolution == -1.f)
model.mesh.estimateResolution(); model.mesh.estimateResolution();
model.gamma = 4 * model.mesh.resolution; model.gamma = 4 * model.mesh.resolution;
} }
/* estimate lambda */ /* estimate lambda */
if (model.lambda == 0.f) if (model.lambda == 0.f)
{ {
vector<int> nonzero(model.spinImages.rows); vector<int> nonzero(model.spinImages.rows);
for(int i = 0; i < model.spinImages.rows; ++i) for(int i = 0; i < model.spinImages.rows; ++i)
nonzero[i] = countNonZero(model.spinImages.row(i)); nonzero[i] = countNonZero(model.spinImages.row(i));
sort(nonzero, less<int>()); sort(nonzero, less<int>());
model.lambda = static_cast<float>( nonzero[ nonzero.size()/2 ] ) / 2; model.lambda = static_cast<float>( nonzero[ nonzero.size()/2 ] ) / 2;
} }
TickMeter corr_timer; TickMeter corr_timer;
corr_timer.start(); corr_timer.start();
vector<Match> allMatches; vector<Match> allMatches;
@ -1032,37 +1032,37 @@ private:
{ {
vector<int> indeces; vector<int> indeces;
vector<float> coeffs; vector<float> coeffs;
matchSpinToModel(scene.spinImages.row(i), indeces, coeffs); matchSpinToModel(scene.spinImages.row(i), indeces, coeffs);
for(size_t t = 0; t < indeces.size(); ++t) for(size_t t = 0; t < indeces.size(); ++t)
allMatches.push_back(Match(i, indeces[t], coeffs[t])); allMatches.push_back(Match(i, indeces[t], coeffs[t]));
if (out) if (i % 100 == 0) *out << "Comparing scene spinimage " << i << " of " << scene.spinImages.rows << endl; if (out) if (i % 100 == 0) *out << "Comparing scene spinimage " << i << " of " << scene.spinImages.rows << endl;
} }
corr_timer.stop(); corr_timer.stop();
if (out) *out << "Spin correlation time = " << corr_timer << endl; if (out) *out << "Spin correlation time = " << corr_timer << endl;
if (out) *out << "Matches number = " << allMatches.size() << endl; if (out) *out << "Matches number = " << allMatches.size() << endl;
if(allMatches.empty()) if(allMatches.empty())
return; return;
/* filtering by similarity measure */ /* filtering by similarity measure */
const float fraction = 0.5f; const float fraction = 0.5f;
float maxMeasure = max_element(allMatches.begin(), allMatches.end(), less<float>())->measure; float maxMeasure = max_element(allMatches.begin(), allMatches.end(), less<float>())->measure;
allMatches.erase( allMatches.erase(
remove_if(allMatches.begin(), allMatches.end(), bind2nd(less<float>(), maxMeasure * fraction)), remove_if(allMatches.begin(), allMatches.end(), bind2nd(less<float>(), maxMeasure * fraction)),
allMatches.end()); allMatches.end());
if (out) *out << "Matches number [filtered by similarity measure] = " << allMatches.size() << endl; if (out) *out << "Matches number [filtered by similarity measure] = " << allMatches.size() << endl;
int matchesSize = (int)allMatches.size(); int matchesSize = (int)allMatches.size();
if(matchesSize == 0) if(matchesSize == 0)
return; return;
/* filtering by geometric consistency */ /* filtering by geometric consistency */
for(int i = 0; i < matchesSize; ++i) for(int i = 0; i < matchesSize; ++i)
{ {
int consistNum = 1; int consistNum = 1;
float gc = float_max; float gc = float_max;
for(int j = 0; j < matchesSize; ++j) for(int j = 0; j < matchesSize; ++j)
if (i != j) if (i != j)
{ {
@ -1075,31 +1075,31 @@ private:
{ {
const Point3f& pointSceneI = scene.getSpinVertex(mi.sceneInd); const Point3f& pointSceneI = scene.getSpinVertex(mi.sceneInd);
const Point3f& normalSceneI = scene.getSpinNormal(mi.sceneInd); const Point3f& normalSceneI = scene.getSpinNormal(mi.sceneInd);
const Point3f& pointModelI = model.getSpinVertex(mi.modelInd); const Point3f& pointModelI = model.getSpinVertex(mi.modelInd);
const Point3f& normalModelI = model.getSpinNormal(mi.modelInd); const Point3f& normalModelI = model.getSpinNormal(mi.modelInd);
const Point3f& pointSceneJ = scene.getSpinVertex(mj.sceneInd); const Point3f& pointSceneJ = scene.getSpinVertex(mj.sceneInd);
const Point3f& normalSceneJ = scene.getSpinNormal(mj.sceneInd); const Point3f& normalSceneJ = scene.getSpinNormal(mj.sceneInd);
const Point3f& pointModelJ = model.getSpinVertex(mj.modelInd); const Point3f& pointModelJ = model.getSpinVertex(mj.modelInd);
const Point3f& normalModelJ = model.getSpinNormal(mj.modelInd); const Point3f& normalModelJ = model.getSpinNormal(mj.modelInd);
gc = geometricConsistency(pointSceneI, normalSceneI, pointModelI, normalModelI, gc = geometricConsistency(pointSceneI, normalSceneI, pointModelI, normalModelI,
pointSceneJ, normalSceneJ, pointModelJ, normalModelJ); pointSceneJ, normalSceneJ, pointModelJ, normalModelJ);
} }
if (gc < model.T_GeometriccConsistency) if (gc < model.T_GeometriccConsistency)
++consistNum; ++consistNum;
} }
if (consistNum < matchesSize / 4) /* failed consistensy test */ if (consistNum < matchesSize / 4) /* failed consistensy test */
allMatches[i].measure = infinity; allMatches[i].measure = infinity;
} }
allMatches.erase( allMatches.erase(
remove_if(allMatches.begin(), allMatches.end(), bind2nd(equal_to<float>(), infinity)), remove_if(allMatches.begin(), allMatches.end(), bind2nd(equal_to<float>(), infinity)),
allMatches.end()); allMatches.end());
if (out) *out << "Matches number [filtered by geometric consistency] = " << allMatches.size() << endl; if (out) *out << "Matches number [filtered by geometric consistency] = " << allMatches.size() << endl;
@ -1110,11 +1110,11 @@ private:
if (out) *out << "grouping ..." << endl; if (out) *out << "grouping ..." << endl;
Mat groupingMat((int)matchesSize, (int)matchesSize, CV_32F); Mat groupingMat((int)matchesSize, (int)matchesSize, CV_32F);
groupingMat = Scalar(0); groupingMat = Scalar(0);
/* grouping */ /* grouping */
for(int j = 0; j < matchesSize; ++j) for(int j = 0; j < matchesSize; ++j)
for(int i = j + 1; i < matchesSize; ++i) for(int i = j + 1; i < matchesSize; ++i)
{ {
const Match& mi = allMatches[i]; const Match& mi = allMatches[i];
const Match& mj = allMatches[j]; const Match& mj = allMatches[j];
@ -1128,20 +1128,20 @@ private:
const Point3f& pointSceneI = scene.getSpinVertex(mi.sceneInd); const Point3f& pointSceneI = scene.getSpinVertex(mi.sceneInd);
const Point3f& normalSceneI = scene.getSpinNormal(mi.sceneInd); const Point3f& normalSceneI = scene.getSpinNormal(mi.sceneInd);
const Point3f& pointModelI = model.getSpinVertex(mi.modelInd); const Point3f& pointModelI = model.getSpinVertex(mi.modelInd);
const Point3f& normalModelI = model.getSpinNormal(mi.modelInd); const Point3f& normalModelI = model.getSpinNormal(mi.modelInd);
const Point3f& pointSceneJ = scene.getSpinVertex(mj.sceneInd); const Point3f& pointSceneJ = scene.getSpinVertex(mj.sceneInd);
const Point3f& normalSceneJ = scene.getSpinNormal(mj.sceneInd); const Point3f& normalSceneJ = scene.getSpinNormal(mj.sceneInd);
const Point3f& pointModelJ = model.getSpinVertex(mj.modelInd); const Point3f& pointModelJ = model.getSpinVertex(mj.modelInd);
const Point3f& normalModelJ = model.getSpinNormal(mj.modelInd); const Point3f& normalModelJ = model.getSpinNormal(mj.modelInd);
float wgc = groupingCreteria(pointSceneI, normalSceneI, pointModelI, normalModelI, float wgc = groupingCreteria(pointSceneI, normalSceneI, pointModelI, normalModelI,
pointSceneJ, normalSceneJ, pointModelJ, normalModelJ, pointSceneJ, normalSceneJ, pointModelJ, normalModelJ,
model.gamma); model.gamma);
groupingMat.ptr<float>(i)[j] = wgc; groupingMat.ptr<float>(i)[j] = wgc;
groupingMat.ptr<float>(j)[i] = wgc; groupingMat.ptr<float>(j)[i] = wgc;
} }
@ -1149,35 +1149,35 @@ private:
group_t allMatchesInds; group_t allMatchesInds;
for(int i = 0; i < matchesSize; ++i) for(int i = 0; i < matchesSize; ++i)
allMatchesInds.insert(i); allMatchesInds.insert(i);
vector<float> buf(matchesSize); vector<float> buf(matchesSize);
float *buf_beg = &buf[0]; float *buf_beg = &buf[0];
vector<group_t> groups; vector<group_t> groups;
for(int g = 0; g < matchesSize; ++g) for(int g = 0; g < matchesSize; ++g)
{ {
if (out) if (g % 100 == 0) *out << "G = " << g << endl; if (out) if (g % 100 == 0) *out << "G = " << g << endl;
group_t left = allMatchesInds; group_t left = allMatchesInds;
group_t group; group_t group;
left.erase(g); left.erase(g);
group.insert(g); group.insert(g);
for(;;) for(;;)
{ {
size_t left_size = left.size(); size_t left_size = left.size();
if (left_size == 0) if (left_size == 0)
break; break;
std::transform(left.begin(), left.end(), buf_beg, WgcHelper(group, groupingMat)); std::transform(left.begin(), left.end(), buf_beg, WgcHelper(group, groupingMat));
size_t minInd = min_element(buf_beg, buf_beg + left_size) - buf_beg; size_t minInd = min_element(buf_beg, buf_beg + left_size) - buf_beg;
if (buf[minInd] < model.T_GroupingCorespondances) /* can add corespondance to group */ if (buf[minInd] < model.T_GroupingCorespondances) /* can add corespondance to group */
{ {
iter pos = left.begin(); iter pos = left.begin();
advance(pos, minInd); advance(pos, minInd);
group.insert(*pos); group.insert(*pos);
left.erase(pos); left.erase(pos);
} }
@ -1199,16 +1199,16 @@ private:
{ {
const Match& m = allMatches[*pos]; const Match& m = allMatches[*pos];
outgrp.push_back(Vec2i(subset[m.modelInd], scene.subset[m.sceneInd])); outgrp.push_back(Vec2i(subset[m.modelInd], scene.subset[m.sceneInd]));
} }
result.push_back(outgrp); result.push_back(outgrp);
} }
} }
cv::TickMeter::TickMeter() { reset(); } cv::TickMeter::TickMeter() { reset(); }
int64 cv::TickMeter::getTimeTicks() const { return sumTime; } int64 cv::TickMeter::getTimeTicks() const { return sumTime; }
double cv::TickMeter::getTimeMicro() const { return (double)getTimeTicks()/cvGetTickFrequency(); } double cv::TickMeter::getTimeMicro() const { return (double)getTimeTicks()/cvGetTickFrequency(); }
double cv::TickMeter::getTimeMilli() const { return getTimeMicro()*1e-3; } double cv::TickMeter::getTimeMilli() const { return getTimeMicro()*1e-3; }
double cv::TickMeter::getTimeSec() const { return getTimeMilli()*1e-3; } double cv::TickMeter::getTimeSec() const { return getTimeMilli()*1e-3; }
int64 cv::TickMeter::getCounter() const { return counter; } int64 cv::TickMeter::getCounter() const { return counter; }
void cv::TickMeter::reset() {startTime = 0; sumTime = 0; counter = 0; } void cv::TickMeter::reset() {startTime = 0; sumTime = 0; counter = 0; }

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

@ -46,14 +46,14 @@
Proceedings of the 5th International Symposium on Visual Computing, Vegas, USA Proceedings of the 5th International Symposium on Visual Computing, Vegas, USA
This code is written by Sergey G. Kosov for "Visir PX" application as part of Project X (www.project-10.de) This code is written by Sergey G. Kosov for "Visir PX" application as part of Project X (www.project-10.de)
*/ */
#include "precomp.hpp" #include "precomp.hpp"
#include <limits.h> #include <limits.h>
namespace cv namespace cv
{ {
StereoVar::StereoVar() : levels(3), pyrScale(0.5), nIt(5), minDisp(0), maxDisp(16), poly_n(3), poly_sigma(0), fi(25.0f), lambda(0.03f), penalization(PENALIZATION_TICHONOV), cycle(CYCLE_V), flags(USE_SMART_ID | USE_AUTO_PARAMS) StereoVar::StereoVar() : levels(3), pyrScale(0.5), nIt(5), minDisp(0), maxDisp(16), poly_n(3), poly_sigma(0), fi(25.0f), lambda(0.03f), penalization(PENALIZATION_TICHONOV), cycle(CYCLE_V), flags(USE_SMART_ID | USE_AUTO_PARAMS)
{ {
} }
@ -67,9 +67,9 @@ StereoVar::~StereoVar()
static Mat diffX(Mat &src) static Mat diffX(Mat &src)
{ {
register int x, y, cols = src.cols - 1; register int x, y, cols = src.cols - 1;
Mat dst(src.size(), src.type()); Mat dst(src.size(), src.type());
for(y = 0; y < src.rows; y++){ for(y = 0; y < src.rows; y++){
const float* pSrc = src.ptr<float>(y); const float* pSrc = src.ptr<float>(y);
float* pDst = dst.ptr<float>(y); float* pDst = dst.ptr<float>(y);
#if CV_SSE2 #if CV_SSE2
@ -92,319 +92,319 @@ static Mat diffX(Mat &src)
static Mat getGradient(Mat &src) static Mat getGradient(Mat &src)
{ {
register int x, y; register int x, y;
Mat dst(src.size(), src.type()); Mat dst(src.size(), src.type());
dst.setTo(0); dst.setTo(0);
for (y = 0; y < src.rows - 1; y++) { for (y = 0; y < src.rows - 1; y++) {
float *pSrc = src.ptr<float>(y); float *pSrc = src.ptr<float>(y);
float *pSrcF = src.ptr<float>(y + 1); float *pSrcF = src.ptr<float>(y + 1);
float *pDst = dst.ptr<float>(y); float *pDst = dst.ptr<float>(y);
for (x = 0; x < src.cols - 1; x++) for (x = 0; x < src.cols - 1; x++)
pDst[x] = fabs(pSrc[x + 1] - pSrc[x]) + fabs(pSrcF[x] - pSrc[x]); pDst[x] = fabs(pSrc[x + 1] - pSrc[x]) + fabs(pSrcF[x] - pSrc[x]);
} }
return dst; return dst;
} }
static Mat getG_c(Mat &src, float l) static Mat getG_c(Mat &src, float l)
{ {
Mat dst(src.size(), src.type()); Mat dst(src.size(), src.type());
for (register int y = 0; y < src.rows; y++) { for (register int y = 0; y < src.rows; y++) {
float *pSrc = src.ptr<float>(y); float *pSrc = src.ptr<float>(y);
float *pDst = dst.ptr<float>(y); float *pDst = dst.ptr<float>(y);
for (register int x = 0; x < src.cols; x++) for (register int x = 0; x < src.cols; x++)
pDst[x] = 0.5f*l / sqrtf(l*l + pSrc[x]*pSrc[x]); pDst[x] = 0.5f*l / sqrtf(l*l + pSrc[x]*pSrc[x]);
} }
return dst; return dst;
} }
static Mat getG_p(Mat &src, float l) static Mat getG_p(Mat &src, float l)
{ {
Mat dst(src.size(), src.type()); Mat dst(src.size(), src.type());
for (register int y = 0; y < src.rows; y++) { for (register int y = 0; y < src.rows; y++) {
float *pSrc = src.ptr<float>(y); float *pSrc = src.ptr<float>(y);
float *pDst = dst.ptr<float>(y); float *pDst = dst.ptr<float>(y);
for (register int x = 0; x < src.cols; x++) for (register int x = 0; x < src.cols; x++)
pDst[x] = 0.5f*l*l / (l*l + pSrc[x]*pSrc[x]); pDst[x] = 0.5f*l*l / (l*l + pSrc[x]*pSrc[x]);
} }
return dst; return dst;
} }
void StereoVar::VariationalSolver(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level) void StereoVar::VariationalSolver(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level)
{ {
register int n, x, y; register int n, x, y;
float gl = 1, gr = 1, gu = 1, gd = 1, gc = 4; float gl = 1, gr = 1, gu = 1, gd = 1, gc = 4;
Mat g_c, g_p; Mat g_c, g_p;
Mat U; Mat U;
u.copyTo(U); u.copyTo(U);
int N = nIt; int N = nIt;
float l = lambda; float l = lambda;
float Fi = fi; float Fi = fi;
if (flags & USE_SMART_ID) {
double scale = pow(pyrScale, (double) level) * (1 + pyrScale);
N = (int) (N / scale);
}
double scale = pow(pyrScale, (double) level); if (flags & USE_SMART_ID) {
Fi /= (float) scale; double scale = pow(pyrScale, (double) level) * (1 + pyrScale);
l *= (float) scale; N = (int) (N / scale);
}
int width = u.cols - 1; double scale = pow(pyrScale, (double) level);
int height = u.rows - 1; Fi /= (float) scale;
for (n = 0; n < N; n++) { l *= (float) scale;
if (penalization != PENALIZATION_TICHONOV) {
Mat gradient = getGradient(U);
switch (penalization) {
case PENALIZATION_CHARBONNIER: g_c = getG_c(gradient, l); break;
case PENALIZATION_PERONA_MALIK: g_p = getG_p(gradient, l); break;
}
gradient.release();
}
for (y = 1 ; y < height; y++) {
float *pU = U.ptr<float>(y);
float *pUu = U.ptr<float>(y + 1);
float *pUd = U.ptr<float>(y - 1);
float *pu = u.ptr<float>(y);
float *pI1 = I1.ptr<float>(y);
float *pI2 = I2.ptr<float>(y);
float *pI2x = I2x.ptr<float>(y);
float *pG_c = NULL, *pG_cu = NULL, *pG_cd = NULL;
float *pG_p = NULL, *pG_pu = NULL, *pG_pd = NULL;
switch (penalization) {
case PENALIZATION_CHARBONNIER:
pG_c = g_c.ptr<float>(y);
pG_cu = g_c.ptr<float>(y + 1);
pG_cd = g_c.ptr<float>(y - 1);
break;
case PENALIZATION_PERONA_MALIK:
pG_p = g_p.ptr<float>(y);
pG_pu = g_p.ptr<float>(y + 1);
pG_pd = g_p.ptr<float>(y - 1);
break;
}
for (x = 1; x < width; x++) {
switch (penalization) {
case PENALIZATION_CHARBONNIER:
gc = pG_c[x];
gl = gc + pG_c[x - 1];
gr = gc + pG_c[x + 1];
gu = gc + pG_cu[x];
gd = gc + pG_cd[x];
gc = gl + gr + gu + gd;
break;
case PENALIZATION_PERONA_MALIK:
gc = pG_p[x];
gl = gc + pG_p[x - 1];
gr = gc + pG_p[x + 1];
gu = gc + pG_pu[x];
gd = gc + pG_pd[x];
gc = gl + gr + gu + gd;
break;
}
float fi = Fi; int width = u.cols - 1;
if (maxDisp > minDisp) { int height = u.rows - 1;
if (pU[x] > maxDisp * scale) {fi *= 1000; pU[x] = static_cast<float>(maxDisp * scale);} for (n = 0; n < N; n++) {
if (pU[x] < minDisp * scale) {fi *= 1000; pU[x] = static_cast<float>(minDisp * scale);} if (penalization != PENALIZATION_TICHONOV) {
} Mat gradient = getGradient(U);
switch (penalization) {
case PENALIZATION_CHARBONNIER: g_c = getG_c(gradient, l); break;
case PENALIZATION_PERONA_MALIK: g_p = getG_p(gradient, l); break;
}
gradient.release();
}
for (y = 1 ; y < height; y++) {
float *pU = U.ptr<float>(y);
float *pUu = U.ptr<float>(y + 1);
float *pUd = U.ptr<float>(y - 1);
float *pu = u.ptr<float>(y);
float *pI1 = I1.ptr<float>(y);
float *pI2 = I2.ptr<float>(y);
float *pI2x = I2x.ptr<float>(y);
float *pG_c = NULL, *pG_cu = NULL, *pG_cd = NULL;
float *pG_p = NULL, *pG_pu = NULL, *pG_pd = NULL;
switch (penalization) {
case PENALIZATION_CHARBONNIER:
pG_c = g_c.ptr<float>(y);
pG_cu = g_c.ptr<float>(y + 1);
pG_cd = g_c.ptr<float>(y - 1);
break;
case PENALIZATION_PERONA_MALIK:
pG_p = g_p.ptr<float>(y);
pG_pu = g_p.ptr<float>(y + 1);
pG_pd = g_p.ptr<float>(y - 1);
break;
}
for (x = 1; x < width; x++) {
switch (penalization) {
case PENALIZATION_CHARBONNIER:
gc = pG_c[x];
gl = gc + pG_c[x - 1];
gr = gc + pG_c[x + 1];
gu = gc + pG_cu[x];
gd = gc + pG_cd[x];
gc = gl + gr + gu + gd;
break;
case PENALIZATION_PERONA_MALIK:
gc = pG_p[x];
gl = gc + pG_p[x - 1];
gr = gc + pG_p[x + 1];
gu = gc + pG_pu[x];
gd = gc + pG_pd[x];
gc = gl + gr + gu + gd;
break;
}
int A = static_cast<int>(pU[x]); float _fi = Fi;
int neg = 0; if (pU[x] <= 0) neg = -1; if (maxDisp > minDisp) {
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 (x + A > width) int A = static_cast<int>(pU[x]);
pu[x] = pU[width - A]; int neg = 0; if (pU[x] <= 0) neg = -1;
else if (x + A + neg < 0)
pu[x] = pU[- A + 2]; if (x + A > width)
else { pu[x] = pU[width - A];
pu[x] = A + (pI2x[x + A + neg] * (pI1[x] - pI2[x + A]) else if (x + A + neg < 0)
+ fi * (gr * pU[x + 1] + gl * pU[x - 1] + gu * pUu[x] + gd * pUd[x] - gc * A)) pu[x] = pU[- A + 2];
/ (pI2x[x + A + neg] * pI2x[x + A + neg] + gc * fi) ; else {
} pu[x] = A + (pI2x[x + A + neg] * (pI1[x] - pI2[x + A])
}// x + _fi * (gr * pU[x + 1] + gl * pU[x - 1] + gu * pUu[x] + gd * pUd[x] - gc * A))
pu[0] = pu[1]; / (pI2x[x + A + neg] * pI2x[x + A + neg] + gc * _fi) ;
pu[width] = pu[width - 1]; }
}// y }// x
for (x = 0; x <= width; x++) { pu[0] = pu[1];
u.at<float>(0, x) = u.at<float>(1, x); pu[width] = pu[width - 1];
u.at<float>(height, x) = u.at<float>(height - 1, x); }// y
} for (x = 0; x <= width; x++) {
u.copyTo(U); u.at<float>(0, x) = u.at<float>(1, x);
if (!g_c.empty()) g_c.release(); u.at<float>(height, x) = u.at<float>(height - 1, x);
if (!g_p.empty()) g_p.release(); }
}//n u.copyTo(U);
if (!g_c.empty()) g_c.release();
if (!g_p.empty()) g_p.release();
}//n
} }
void StereoVar::VCycle_MyFAS(Mat &I1, Mat &I2, Mat &I2x, Mat &_u, int level) void StereoVar::VCycle_MyFAS(Mat &I1, Mat &I2, Mat &I2x, Mat &_u, int level)
{ {
CvSize imgSize = _u.size(); CvSize imgSize = _u.size();
CvSize frmSize = cvSize((int) (imgSize.width * pyrScale + 0.5), (int) (imgSize.height * pyrScale + 0.5)); CvSize frmSize = cvSize((int) (imgSize.width * pyrScale + 0.5), (int) (imgSize.height * pyrScale + 0.5));
Mat I1_h, I2_h, I2x_h, u_h, U, U_h; Mat I1_h, I2_h, I2x_h, u_h, U, U_h;
//PRE relaxation //PRE relaxation
VariationalSolver(I1, I2, I2x, _u, level); VariationalSolver(I1, I2, I2x, _u, level);
if (level >= levels - 1) return; if (level >= levels - 1) return;
level ++; level ++;
//scaling DOWN //scaling DOWN
resize(I1, I1_h, frmSize, 0, 0, INTER_AREA); resize(I1, I1_h, frmSize, 0, 0, INTER_AREA);
resize(I2, I2_h, frmSize, 0, 0, INTER_AREA); resize(I2, I2_h, frmSize, 0, 0, INTER_AREA);
resize(_u, u_h, frmSize, 0, 0, INTER_AREA); resize(_u, u_h, frmSize, 0, 0, INTER_AREA);
u_h.convertTo(u_h, u_h.type(), pyrScale); u_h.convertTo(u_h, u_h.type(), pyrScale);
I2x_h = diffX(I2_h); I2x_h = diffX(I2_h);
//Next level //Next level
U_h = u_h.clone(); U_h = u_h.clone();
VCycle_MyFAS(I1_h, I2_h, I2x_h, U_h, level); VCycle_MyFAS(I1_h, I2_h, I2x_h, U_h, level);
subtract(U_h, u_h, U_h); subtract(U_h, u_h, U_h);
U_h.convertTo(U_h, U_h.type(), 1.0 / pyrScale); U_h.convertTo(U_h, U_h.type(), 1.0 / pyrScale);
//scaling UP //scaling UP
resize(U_h, U, imgSize); resize(U_h, U, imgSize);
//correcting the solution //correcting the solution
add(_u, U, _u); add(_u, U, _u);
//POST relaxation //POST relaxation
VariationalSolver(I1, I2, I2x, _u, level - 1); VariationalSolver(I1, I2, I2x, _u, level - 1);
if (flags & USE_MEDIAN_FILTERING) medianBlur(_u, _u, 3); if (flags & USE_MEDIAN_FILTERING) medianBlur(_u, _u, 3);
I1_h.release(); I1_h.release();
I2_h.release(); I2_h.release();
I2x_h.release(); I2x_h.release();
u_h.release(); u_h.release();
U.release(); U.release();
U_h.release(); U_h.release();
} }
void StereoVar::FMG(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level) void StereoVar::FMG(Mat &I1, Mat &I2, Mat &I2x, Mat &u, int level)
{ {
double scale = pow(pyrScale, (double) level); double scale = pow(pyrScale, (double) level);
CvSize frmSize = cvSize((int) (u.cols * scale + 0.5), (int) (u.rows * scale + 0.5)); CvSize frmSize = cvSize((int) (u.cols * scale + 0.5), (int) (u.rows * scale + 0.5));
Mat I1_h, I2_h, I2x_h, u_h; Mat I1_h, I2_h, I2x_h, u_h;
//scaling DOWN //scaling DOWN
resize(I1, I1_h, frmSize, 0, 0, INTER_AREA); resize(I1, I1_h, frmSize, 0, 0, INTER_AREA);
resize(I2, I2_h, frmSize, 0, 0, INTER_AREA); resize(I2, I2_h, frmSize, 0, 0, INTER_AREA);
resize(u, u_h, frmSize, 0, 0, INTER_AREA); resize(u, u_h, frmSize, 0, 0, INTER_AREA);
u_h.convertTo(u_h, u_h.type(), scale); u_h.convertTo(u_h, u_h.type(), scale);
I2x_h = diffX(I2_h); I2x_h = diffX(I2_h);
switch (cycle) { switch (cycle) {
case CYCLE_O: case CYCLE_O:
VariationalSolver(I1_h, I2_h, I2x_h, u_h, level); VariationalSolver(I1_h, I2_h, I2x_h, u_h, level);
break; break;
case CYCLE_V: case CYCLE_V:
VCycle_MyFAS(I1_h, I2_h, I2x_h, u_h, level); VCycle_MyFAS(I1_h, I2_h, I2x_h, u_h, level);
break; break;
} }
u_h.convertTo(u_h, u_h.type(), 1.0 / scale); u_h.convertTo(u_h, u_h.type(), 1.0 / scale);
//scaling UP //scaling UP
resize(u_h, u, u.size(), 0, 0, INTER_CUBIC); resize(u_h, u, u.size(), 0, 0, INTER_CUBIC);
I1_h.release(); I1_h.release();
I2_h.release(); I2_h.release();
I2x_h.release(); I2x_h.release();
u_h.release(); u_h.release();
level--; level--;
if ((flags & USE_AUTO_PARAMS) && (level < levels / 3)) { if ((flags & USE_AUTO_PARAMS) && (level < levels / 3)) {
penalization = PENALIZATION_PERONA_MALIK; penalization = PENALIZATION_PERONA_MALIK;
fi *= 100; fi *= 100;
flags -= USE_AUTO_PARAMS; flags -= USE_AUTO_PARAMS;
autoParams(); autoParams();
} }
if (flags & USE_MEDIAN_FILTERING) medianBlur(u, u, 3); if (flags & USE_MEDIAN_FILTERING) medianBlur(u, u, 3);
if (level >= 0) FMG(I1, I2, I2x, u, level); if (level >= 0) FMG(I1, I2, I2x, u, level);
} }
void StereoVar::autoParams() void StereoVar::autoParams()
{ {
int maxD = MAX(labs(maxDisp), labs(minDisp)); int maxD = MAX(labs(maxDisp), labs(minDisp));
if (!maxD) pyrScale = 0.85;
else if (maxD < 8) pyrScale = 0.5;
else if (maxD < 64) pyrScale = 0.5 + static_cast<double>(maxD - 8) * 0.00625;
else pyrScale = 0.85;
if (maxD) {
levels = 0;
while ( pow(pyrScale, levels) * maxD > 1.5) levels ++;
levels++;
}
switch(penalization) { if (!maxD) pyrScale = 0.85;
case PENALIZATION_TICHONOV: cycle = CYCLE_V; break; else if (maxD < 8) pyrScale = 0.5;
case PENALIZATION_CHARBONNIER: cycle = CYCLE_O; break; else if (maxD < 64) pyrScale = 0.5 + static_cast<double>(maxD - 8) * 0.00625;
case PENALIZATION_PERONA_MALIK: cycle = CYCLE_O; break; else pyrScale = 0.85;
}
if (maxD) {
levels = 0;
while ( pow(pyrScale, levels) * maxD > 1.5) levels ++;
levels++;
}
switch(penalization) {
case PENALIZATION_TICHONOV: cycle = CYCLE_V; break;
case PENALIZATION_CHARBONNIER: cycle = CYCLE_O; break;
case PENALIZATION_PERONA_MALIK: cycle = CYCLE_O; break;
}
} }
void StereoVar::operator ()( const Mat& left, const Mat& right, Mat& disp ) void StereoVar::operator ()( const Mat& left, const Mat& right, Mat& disp )
{ {
CV_Assert(left.size() == right.size() && left.type() == right.type()); CV_Assert(left.size() == right.size() && left.type() == right.type());
CvSize imgSize = left.size(); CvSize imgSize = left.size();
int MaxD = MAX(labs(minDisp), labs(maxDisp)); int MaxD = MAX(labs(minDisp), labs(maxDisp));
int SignD = 1; if (MIN(minDisp, maxDisp) < 0) SignD = -1; int SignD = 1; if (MIN(minDisp, maxDisp) < 0) SignD = -1;
if (minDisp >= maxDisp) {MaxD = 256; SignD = 1;} if (minDisp >= maxDisp) {MaxD = 256; SignD = 1;}
Mat u;
if ((flags & USE_INITIAL_DISPARITY) && (!disp.empty())) {
CV_Assert(disp.size() == left.size() && disp.type() == CV_8UC1);
disp.convertTo(u, CV_32FC1, static_cast<double>(SignD * MaxD) / 256);
} else {
u.create(imgSize, CV_32FC1);
u.setTo(0);
}
// Preprocessing Mat u;
Mat leftgray, rightgray; if ((flags & USE_INITIAL_DISPARITY) && (!disp.empty())) {
if (left.type() != CV_8UC1) { CV_Assert(disp.size() == left.size() && disp.type() == CV_8UC1);
cvtColor(left, leftgray, CV_BGR2GRAY); disp.convertTo(u, CV_32FC1, static_cast<double>(SignD * MaxD) / 256);
cvtColor(right, rightgray, CV_BGR2GRAY); } else {
} else { u.create(imgSize, CV_32FC1);
left.copyTo(leftgray); u.setTo(0);
right.copyTo(rightgray); }
}
if (flags & USE_EQUALIZE_HIST) {
equalizeHist(leftgray, leftgray);
equalizeHist(rightgray, rightgray);
}
if (poly_sigma > 0.0001) {
GaussianBlur(leftgray, leftgray, cvSize(poly_n, poly_n), poly_sigma);
GaussianBlur(rightgray, rightgray, cvSize(poly_n, poly_n), poly_sigma);
}
if (flags & USE_AUTO_PARAMS) {
penalization = PENALIZATION_TICHONOV;
autoParams();
}
Mat I1, I2; // Preprocessing
leftgray.convertTo(I1, CV_32FC1); Mat leftgray, rightgray;
rightgray.convertTo(I2, CV_32FC1); if (left.type() != CV_8UC1) {
leftgray.release(); cvtColor(left, leftgray, CV_BGR2GRAY);
rightgray.release(); cvtColor(right, rightgray, CV_BGR2GRAY);
} else {
left.copyTo(leftgray);
right.copyTo(rightgray);
}
if (flags & USE_EQUALIZE_HIST) {
equalizeHist(leftgray, leftgray);
equalizeHist(rightgray, rightgray);
}
if (poly_sigma > 0.0001) {
GaussianBlur(leftgray, leftgray, cvSize(poly_n, poly_n), poly_sigma);
GaussianBlur(rightgray, rightgray, cvSize(poly_n, poly_n), poly_sigma);
}
Mat I2x = diffX(I2); if (flags & USE_AUTO_PARAMS) {
penalization = PENALIZATION_TICHONOV;
FMG(I1, I2, I2x, u, levels - 1); autoParams();
}
I1.release();
I2.release();
I2x.release();
disp.create( left.size(), CV_8UC1 );
u = abs(u);
u.convertTo(disp, disp.type(), 256 / MaxD, 0);
u.release(); Mat I1, I2;
leftgray.convertTo(I1, CV_32FC1);
rightgray.convertTo(I2, CV_32FC1);
leftgray.release();
rightgray.release();
Mat I2x = diffX(I2);
FMG(I1, I2, I2x, u, levels - 1);
I1.release();
I2.release();
I2x.release();
disp.create( left.size(), CV_8UC1 );
u = abs(u);
u.convertTo(disp, disp.type(), 256 / MaxD, 0);
u.release();
} }
} // namespace } // namespace

6
modules/core/CMakeLists.txt
View File

@ -5,13 +5,11 @@ 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()
set(lib_cuda "") set(lib_cuda "")

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

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

File diff suppressed because it is too large Load Diff

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

@ -47,282 +47,287 @@
#include "opencv2/core/core.hpp" #include "opencv2/core/core.hpp"
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:
enum Usage
{ {
public: ARRAY_BUFFER = 0x8892, // buffer will use for OpenGL arrays (vertices, colors, normals, etc)
enum Usage TEXTURE_BUFFER = 0x88EC // buffer will ise for OpenGL textures
{
ARRAY_BUFFER = 0x8892, // buffer will use for OpenGL arrays (vertices, colors, normals, etc)
TEXTURE_BUFFER = 0x88EC // buffer will ise for OpenGL textures
};
//! create empty buffer
explicit GlBuffer(Usage usage);
//! create buffer
GlBuffer(int rows, int cols, int type, Usage usage);
GlBuffer(Size size, int type, Usage usage);
//! copy from host/device memory
GlBuffer(InputArray mat, 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); }
inline void create(int rows, int cols, int type) { create(rows, cols, type, usage()); }
inline void create(Size size, int type) { create(size.height, size.width, type, usage()); }
void release();
//! copy from host/device memory
void copyFrom(InputArray mat);
void bind() const;
void unbind() const;
//! map to host memory
Mat mapHost();
void unmapHost();
//! map to device memory
gpu::GpuMat mapDevice();
void unmapDevice();
inline int rows() const { return rows_; }
inline int cols() const { return cols_; }
inline Size size() const { return Size(cols_, rows_); }
inline bool empty() const { return rows_ == 0 || cols_ == 0; }
inline int type() const { return type_; }
inline int depth() const { return CV_MAT_DEPTH(type_); }
inline int channels() const { return CV_MAT_CN(type_); }
inline int elemSize() const { return CV_ELEM_SIZE(type_); }
inline int elemSize1() const { return CV_ELEM_SIZE1(type_); }
inline Usage usage() const { return usage_; }
class Impl;
private:
int rows_;
int cols_;
int type_;
Usage usage_;
Ptr<Impl> impl_;
}; };
template <> CV_EXPORTS void Ptr<GlBuffer::Impl>::delete_obj(); //! create empty buffer
explicit GlBuffer(Usage usage);
//! Smart pointer for OpenGL 2d texture memory with reference counting. //! create buffer
class CV_EXPORTS GlTexture GlBuffer(int rows, int cols, int type, Usage usage);
GlBuffer(Size size, int type, Usage usage);
//! copy from host/device memory
GlBuffer(InputArray mat, Usage usage);
void create(int rows, int cols, int type, Usage usage);
void create(Size size, int type, Usage usage);
void create(int rows, int cols, int type);
void create(Size size, int type);
void release();
//! copy from host/device memory
void copyFrom(InputArray mat);
void bind() const;
void unbind() const;
//! map to host memory
Mat mapHost();
void unmapHost();
//! map to device memory
gpu::GpuMat mapDevice();
void unmapDevice();
inline int rows() const { return rows_; }
inline int cols() const { return cols_; }
inline Size size() const { return Size(cols_, rows_); }
inline bool empty() const { return rows_ == 0 || cols_ == 0; }
inline int type() const { return type_; }
inline int depth() const { return CV_MAT_DEPTH(type_); }
inline int channels() const { return CV_MAT_CN(type_); }
inline int elemSize() const { return CV_ELEM_SIZE(type_); }
inline int elemSize1() const { return CV_ELEM_SIZE1(type_); }
inline Usage usage() const { return usage_; }
class Impl;
private:
int rows_;
int cols_;
int type_;
Usage usage_;
Ptr<Impl> impl_;
};
template <> CV_EXPORTS void Ptr<GlBuffer::Impl>::delete_obj();
//! Smart pointer for OpenGL 2d texture memory with reference counting.
class CV_EXPORTS GlTexture
{
public:
//! create empty texture
GlTexture();
//! create texture
GlTexture(int rows, int cols, int type);
GlTexture(Size size, int type);
//! copy from host/device memory
explicit GlTexture(InputArray mat, bool bgra = true);
void create(int rows, int cols, int type);
void create(Size size, int type);
void release();
//! copy from host/device memory
void copyFrom(InputArray mat, bool bgra = true);
void bind() const;
void unbind() const;
inline int rows() const { return rows_; }
inline int cols() const { return cols_; }
inline Size size() const { return Size(cols_, rows_); }
inline bool empty() const { return rows_ == 0 || cols_ == 0; }
inline int type() const { return type_; }
inline int depth() const { return CV_MAT_DEPTH(type_); }
inline int channels() const { return CV_MAT_CN(type_); }
inline int elemSize() const { return CV_ELEM_SIZE(type_); }
inline int elemSize1() const { return CV_ELEM_SIZE1(type_); }
class Impl;
private:
int rows_;
int cols_;
int type_;
Ptr<Impl> impl_;
GlBuffer buf_;
};
template <> CV_EXPORTS void Ptr<GlTexture::Impl>::delete_obj();
//! OpenGL Arrays
class CV_EXPORTS GlArrays
{
public:
inline GlArrays()
: vertex_(GlBuffer::ARRAY_BUFFER), color_(GlBuffer::ARRAY_BUFFER), bgra_(true), normal_(GlBuffer::ARRAY_BUFFER), texCoord_(GlBuffer::ARRAY_BUFFER)
{ {
public:
//! create empty texture
GlTexture();
//! create texture
GlTexture(int rows, int cols, int type);
GlTexture(Size size, int type);
//! copy from host/device memory
explicit GlTexture(InputArray mat, bool bgra = true);
void create(int rows, int cols, int type);
inline void create(Size size, int type) { create(size.height, size.width, type); }
void release();
//! copy from host/device memory
void copyFrom(InputArray mat, bool bgra = true);
void bind() const;
void unbind() const;
inline int rows() const { return rows_; }
inline int cols() const { return cols_; }
inline Size size() const { return Size(cols_, rows_); }
inline bool empty() const { return rows_ == 0 || cols_ == 0; }
inline int type() const { return type_; }
inline int depth() const { return CV_MAT_DEPTH(type_); }
inline int channels() const { return CV_MAT_CN(type_); }
inline int elemSize() const { return CV_ELEM_SIZE(type_); }
inline int elemSize1() const { return CV_ELEM_SIZE1(type_); }
class Impl;
private:
int rows_;
int cols_;
int type_;
Ptr<Impl> impl_;
GlBuffer buf_;
};
template <> CV_EXPORTS void Ptr<GlTexture::Impl>::delete_obj();
//! OpenGL Arrays
class CV_EXPORTS GlArrays
{
public:
inline GlArrays()
: vertex_(GlBuffer::ARRAY_BUFFER), color_(GlBuffer::ARRAY_BUFFER), bgra_(true), normal_(GlBuffer::ARRAY_BUFFER), texCoord_(GlBuffer::ARRAY_BUFFER)
{
}
void setVertexArray(InputArray vertex);
inline void resetVertexArray() { vertex_.release(); }
void setColorArray(InputArray color, bool bgra = true);
inline void resetColorArray() { color_.release(); }
void setNormalArray(InputArray normal);
inline void resetNormalArray() { normal_.release(); }
void setTexCoordArray(InputArray texCoord);
inline void resetTexCoordArray() { texCoord_.release(); }
void bind() const;
void unbind() const;
inline int rows() const { return vertex_.rows(); }
inline int cols() const { return vertex_.cols(); }
inline Size size() const { return vertex_.size(); }
inline bool empty() const { return vertex_.empty(); }
private:
GlBuffer vertex_;
GlBuffer color_;
bool bgra_;
GlBuffer normal_;
GlBuffer texCoord_;
};
//! OpenGL Font
class CV_EXPORTS GlFont
{
public:
enum Weight
{
WEIGHT_LIGHT = 300,
WEIGHT_NORMAL = 400,
WEIGHT_SEMIBOLD = 600,
WEIGHT_BOLD = 700,
WEIGHT_BLACK = 900
};
enum Style
{
STYLE_NORMAL = 0,
STYLE_ITALIC = 1,
STYLE_UNDERLINE = 2
};
static Ptr<GlFont> get(const std::string& family, int height = 12, Weight weight = WEIGHT_NORMAL, Style style = STYLE_NORMAL);
void draw(const char* str, size_t len) const;
inline const std::string& family() const { return family_; }
inline int height() const { return height_; }
inline Weight weight() const { return weight_; }
inline Style style() const { return style_; }
private:
GlFont(const std::string& family, int height, Weight weight, Style style);
std::string family_;
int height_;
Weight weight_;
Style style_;
unsigned int base_;
GlFont(const GlFont&);
GlFont& operator =(const GlFont&);
};
//! render functions
//! render texture rectangle in window
CV_EXPORTS void render(const GlTexture& tex,
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));
//! render mode
namespace RenderMode {
enum {
POINTS = 0x0000,
LINES = 0x0001,
LINE_LOOP = 0x0002,
LINE_STRIP = 0x0003,
TRIANGLES = 0x0004,
TRIANGLE_STRIP = 0x0005,
TRIANGLE_FAN = 0x0006,
QUADS = 0x0007,
QUAD_STRIP = 0x0008,
POLYGON = 0x0009
};
} }
//! render OpenGL arrays void setVertexArray(InputArray vertex);
CV_EXPORTS void render(const GlArrays& arr, int mode = RenderMode::POINTS, Scalar color = Scalar::all(255)); inline void resetVertexArray() { vertex_.release(); }
CV_EXPORTS void render(const std::string& str, const Ptr<GlFont>& font, Scalar color, Point2d pos); void setColorArray(InputArray color, bool bgra = true);
inline void resetColorArray() { color_.release(); }
//! OpenGL camera void setNormalArray(InputArray normal);
class CV_EXPORTS GlCamera inline void resetNormalArray() { normal_.release(); }
void setTexCoordArray(InputArray texCoord);
inline void resetTexCoordArray() { texCoord_.release(); }
void bind() const;
void unbind() const;
inline int rows() const { return vertex_.rows(); }
inline int cols() const { return vertex_.cols(); }
inline Size size() const { return vertex_.size(); }
inline bool empty() const { return vertex_.empty(); }
private:
GlBuffer vertex_;
GlBuffer color_;
bool bgra_;
GlBuffer normal_;
GlBuffer texCoord_;
};
//! OpenGL Font
class CV_EXPORTS GlFont
{
public:
enum Weight
{ {
public: WEIGHT_LIGHT = 300,
GlCamera(); WEIGHT_NORMAL = 400,
WEIGHT_SEMIBOLD = 600,
void lookAt(Point3d eye, Point3d center, Point3d up); WEIGHT_BOLD = 700,
void setCameraPos(Point3d pos, double yaw, double pitch, double roll); WEIGHT_BLACK = 900
void setScale(Point3d scale);
void setProjectionMatrix(const Mat& projectionMatrix, bool transpose = true);
void setPerspectiveProjection(double fov, double aspect, double zNear, double zFar);
void setOrthoProjection(double left, double right, double bottom, double top, double zNear, double zFar);
void setupProjectionMatrix() const;
void setupModelViewMatrix() const;
private:
Point3d eye_;
Point3d center_;
Point3d up_;
Point3d pos_;
double yaw_;
double pitch_;
double roll_;
bool useLookAtParams_;
Point3d scale_;
Mat projectionMatrix_;
double fov_;
double aspect_;
double left_;
double right_;
double bottom_;
double top_;
double zNear_;
double zFar_;
bool perspectiveProjection_;
}; };
namespace gpu enum Style
{ {
//! set a CUDA device to use OpenGL interoperability STYLE_NORMAL = 0,
CV_EXPORTS void setGlDevice(int device = 0); STYLE_ITALIC = 1,
} STYLE_UNDERLINE = 2
};
static Ptr<GlFont> get(const std::string& family, int height = 12, Weight weight = WEIGHT_NORMAL, Style style = STYLE_NORMAL);
void draw(const char* str, size_t len) const;
inline const std::string& family() const { return family_; }
inline int height() const { return height_; }
inline Weight weight() const { return weight_; }
inline Style style() const { return style_; }
private:
GlFont(const std::string& family, int height, Weight weight, Style style);
std::string family_;
int height_;
Weight weight_;
Style style_;
unsigned int base_;
GlFont(const GlFont&);
GlFont& operator =(const GlFont&);
};
//! render functions
//! render texture rectangle in window
CV_EXPORTS void render(const GlTexture& tex,
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));
//! render mode
namespace RenderMode {
enum {
POINTS = 0x0000,
LINES = 0x0001,
LINE_LOOP = 0x0002,
LINE_STRIP = 0x0003,
TRIANGLES = 0x0004,
TRIANGLE_STRIP = 0x0005,
TRIANGLE_FAN = 0x0006,
QUADS = 0x0007,
QUAD_STRIP = 0x0008,
POLYGON = 0x0009
};
}
//! render OpenGL arrays
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);
//! OpenGL camera
class CV_EXPORTS GlCamera
{
public:
GlCamera();
void lookAt(Point3d eye, Point3d center, Point3d up);
void setCameraPos(Point3d pos, double yaw, double pitch, double roll);
void setScale(Point3d scale);
void setProjectionMatrix(const Mat& projectionMatrix, bool transpose = true);
void setPerspectiveProjection(double fov, double aspect, double zNear, double zFar);
void setOrthoProjection(double left, double right, double bottom, double top, double zNear, double zFar);
void setupProjectionMatrix() const;
void setupModelViewMatrix() const;
private:
Point3d eye_;
Point3d center_;
Point3d up_;
Point3d pos_;
double yaw_;
double pitch_;
double roll_;
bool useLookAtParams_;
Point3d scale_;
Mat projectionMatrix_;
double fov_;
double aspect_;
double left_;
double right_;
double bottom_;
double top_;
double zNear_;
double zFar_;
bool perspectiveProjection_;
};
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
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;
} }

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

@ -7,7 +7,7 @@
// copy or use the software. // copy or use the software.
// //
// //
// License Agreement // License Agreement
// For Open Source Computer Vision Library // For Open Source Computer Vision Library
// //
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved. // Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
@ -46,7 +46,7 @@ namespace cv
{ {
using std::pair; using std::pair;
template<typename _KeyTp, typename _ValueTp> struct sorted_vector template<typename _KeyTp, typename _ValueTp> struct sorted_vector
{ {
sorted_vector() {} sorted_vector() {}
@ -54,7 +54,7 @@ template<typename _KeyTp, typename _ValueTp> struct sorted_vector
size_t size() const { return vec.size(); } size_t size() const { return vec.size(); }
_ValueTp& operator [](size_t idx) { return vec[idx]; } _ValueTp& operator [](size_t idx) { return vec[idx]; }
const _ValueTp& operator [](size_t idx) const { return vec[idx]; } const _ValueTp& operator [](size_t idx) const { return vec[idx]; }
void add(const _KeyTp& k, const _ValueTp& val) void add(const _KeyTp& k, const _ValueTp& val)
{ {
pair<_KeyTp, _ValueTp> p(k, val); pair<_KeyTp, _ValueTp> p(k, val);
@ -64,7 +64,7 @@ template<typename _KeyTp, typename _ValueTp> struct sorted_vector
std::swap(vec[i-1], vec[i]); std::swap(vec[i-1], vec[i]);
CV_Assert( i == 0 || vec[i].first != vec[i-1].first ); CV_Assert( i == 0 || vec[i].first != vec[i-1].first );
} }
bool find(const _KeyTp& key, _ValueTp& value) const bool find(const _KeyTp& key, _ValueTp& value) const
{ {
size_t a = 0, b = vec.size(); size_t a = 0, b = vec.size();
@ -76,7 +76,7 @@ template<typename _KeyTp, typename _ValueTp> struct sorted_vector
else else
b = c; b = c;
} }
if( a < vec.size() && vec[a].first == key ) if( a < vec.size() && vec[a].first == key )
{ {
value = vec[a].second; value = vec[a].second;
@ -84,26 +84,26 @@ template<typename _KeyTp, typename _ValueTp> struct sorted_vector
} }
return false; return false;
} }
void get_keys(vector<_KeyTp>& keys) const void get_keys(vector<_KeyTp>& keys) const
{ {
size_t i = 0, n = vec.size(); size_t i = 0, n = vec.size();
keys.resize(n); keys.resize(n);
for( i = 0; i < n; i++ ) for( i = 0; i < n; i++ )
keys[i] = vec[i].first; keys[i] = vec[i].first;
} }
vector<pair<_KeyTp, _ValueTp> > vec; vector<pair<_KeyTp, _ValueTp> > vec;
}; };
template<typename _ValueTp> inline const _ValueTp* findstr(const sorted_vector<string, _ValueTp>& vec, template<typename _ValueTp> inline const _ValueTp* findstr(const sorted_vector<string, _ValueTp>& vec,
const char* key) const char* key)
{ {
if( !key ) if( !key )
return 0; return 0;
size_t a = 0, b = vec.vec.size(); size_t a = 0, b = vec.vec.size();
while( b > a ) while( b > a )
{ {
@ -113,13 +113,13 @@ template<typename _ValueTp> inline const _ValueTp* findstr(const sorted_vector<s
else else
b = c; b = c;
} }
if( strcmp(vec.vec[a].first.c_str(), key) == 0 ) if( strcmp(vec.vec[a].first.c_str(), key) == 0 )
return &vec.vec[a].second; return &vec.vec[a].second;
return 0; return 0;
} }
Param::Param() Param::Param()
{ {
type = 0; type = 0;
@ -129,7 +129,7 @@ Param::Param()
setter = 0; setter = 0;
} }
Param::Param(int _type, bool _readonly, int _offset, Param::Param(int _type, bool _readonly, int _offset,
Algorithm::Getter _getter, Algorithm::Setter _setter, Algorithm::Getter _getter, Algorithm::Setter _setter,
const string& _help) const string& _help)
@ -148,7 +148,7 @@ struct CV_EXPORTS AlgorithmInfoData
string _name; string _name;
}; };
static sorted_vector<string, Algorithm::Constructor>& alglist() static sorted_vector<string, Algorithm::Constructor>& alglist()
{ {
static sorted_vector<string, Algorithm::Constructor> alglist_var; static sorted_vector<string, Algorithm::Constructor> alglist_var;
@ -171,152 +171,152 @@ Ptr<Algorithm> Algorithm::_create(const string& name)
Algorithm::Algorithm() Algorithm::Algorithm()
{ {
} }
Algorithm::~Algorithm() Algorithm::~Algorithm()
{ {
} }
string Algorithm::name() const 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)
{
info()->set(this, name.c_str(), ParamType<Algorithm>::type, &value);
} }
void Algorithm::set(const char* name, int value) void Algorithm::set(const string& parameter, const Ptr<Algorithm>& value)
{ {
info()->set(this, name, ParamType<int>::type, &value); info()->set(this, parameter.c_str(), ParamType<Algorithm>::type, &value);
} }
void Algorithm::set(const char* name, double value) void Algorithm::set(const char* parameter, int value)
{ {
info()->set(this, name, ParamType<double>::type, &value); info()->set(this, parameter, ParamType<int>::type, &value);
} }
void Algorithm::set(const char* name, bool value) void Algorithm::set(const char* parameter, double value)
{ {
info()->set(this, name, ParamType<bool>::type, &value); info()->set(this, parameter, ParamType<double>::type, &value);
} }
void Algorithm::set(const char* name, const string& value) void Algorithm::set(const char* parameter, bool value)
{ {
info()->set(this, name, ParamType<string>::type, &value); info()->set(this, parameter, ParamType<bool>::type, &value);
} }
void Algorithm::set(const char* name, const Mat& value) void Algorithm::set(const char* parameter, const string& value)
{ {
info()->set(this, name, ParamType<Mat>::type, &value); info()->set(this, parameter, ParamType<string>::type, &value);
} }
void Algorithm::set(const char* name, const vector<Mat>& value) void Algorithm::set(const char* parameter, const Mat& value)
{ {
info()->set(this, name, ParamType<vector<Mat> >::type, &value); info()->set(this, parameter, ParamType<Mat>::type, &value);
}
void Algorithm::set(const char* name, const Ptr<Algorithm>& value)
{
info()->set(this, name, ParamType<Algorithm>::type, &value);
}
int Algorithm::getInt(const string& name) const
{
return get<int>(name);
}
double Algorithm::getDouble(const string& name) const
{
return get<double>(name);
} }
bool Algorithm::getBool(const string& name) const void Algorithm::set(const char* parameter, const vector<Mat>& value)
{ {
return get<bool>(name); info()->set(this, parameter, ParamType<vector<Mat> >::type, &value);
} }
string Algorithm::getString(const string& name) const void Algorithm::set(const char* parameter, const Ptr<Algorithm>& value)
{ {
return get<string>(name); info()->set(this, parameter, ParamType<Algorithm>::type, &value);
} }
Mat Algorithm::getMat(const string& name) const int Algorithm::getInt(const string& parameter) const
{ {
return get<Mat>(name); return get<int>(parameter);
} }
vector<Mat> Algorithm::getMatVector(const string& name) const double Algorithm::getDouble(const string& parameter) const
{ {
return get<vector<Mat> >(name); return get<double>(parameter);
} }
Ptr<Algorithm> Algorithm::getAlgorithm(const string& name) const bool Algorithm::getBool(const string& parameter) const
{ {
return get<Algorithm>(name); return get<bool>(parameter);
}
string Algorithm::paramHelp(const string& name) const
{
return info()->paramHelp(name.c_str());
}
int Algorithm::paramType(const string& name) const
{
return info()->paramType(name.c_str());
} }
int Algorithm::paramType(const char* name) const string Algorithm::getString(const string& parameter) const
{ {
return info()->paramType(name); return get<string>(parameter);
} }
Mat Algorithm::getMat(const string& parameter) const
{
return get<Mat>(parameter);
}
vector<Mat> Algorithm::getMatVector(const string& parameter) const
{
return get<vector<Mat> >(parameter);
}
Ptr<Algorithm> Algorithm::getAlgorithm(const string& parameter) const
{
return get<Algorithm>(parameter);
}
string Algorithm::paramHelp(const string& parameter) const
{
return info()->paramHelp(parameter.c_str());
}
int Algorithm::paramType(const string& parameter) const
{
return info()->paramType(parameter.c_str());
}
int Algorithm::paramType(const char* parameter) const
{
return info()->paramType(parameter);
}
void Algorithm::getParams(vector<string>& names) const void Algorithm::getParams(vector<string>& names) const
{ {
info()->getParams(names); info()->getParams(names);
} }
void Algorithm::write(FileStorage& fs) const void Algorithm::write(FileStorage& fs) const
{ {
info()->write(this, fs); info()->write(this, fs);
} }
void Algorithm::read(const FileNode& fn) void Algorithm::read(const FileNode& fn)
{ {
info()->read(this, fn); info()->read(this, fn);
} }
AlgorithmInfo::AlgorithmInfo(const string& _name, Algorithm::Constructor create) AlgorithmInfo::AlgorithmInfo(const string& _name, Algorithm::Constructor create)
{ {
data = new AlgorithmInfoData; data = new AlgorithmInfoData;
@ -327,8 +327,8 @@ AlgorithmInfo::AlgorithmInfo(const string& _name, Algorithm::Constructor create)
AlgorithmInfo::~AlgorithmInfo() AlgorithmInfo::~AlgorithmInfo()
{ {
delete data; delete data;
} }
void AlgorithmInfo::write(const Algorithm* algo, FileStorage& fs) const void AlgorithmInfo::write(const Algorithm* algo, FileStorage& fs) const
{ {
size_t i = 0, nparams = data->params.vec.size(); size_t i = 0, nparams = data->params.vec.size();
@ -364,7 +364,7 @@ void AlgorithmInfo::read(Algorithm* algo, const FileNode& fn) const
{ {
size_t i = 0, nparams = data->params.vec.size(); size_t i = 0, nparams = data->params.vec.size();
AlgorithmInfo* info = algo->info(); AlgorithmInfo* info = algo->info();
for( i = 0; i < nparams; i++ ) for( i = 0; i < nparams; i++ )
{ {
const Param& p = data->params.vec[i].second; const Param& p = data->params.vec[i].second;
@ -414,13 +414,13 @@ void AlgorithmInfo::read(Algorithm* algo, const FileNode& fn) const
else else
CV_Error( CV_StsUnsupportedFormat, "unknown/unsupported parameter type"); CV_Error( CV_StsUnsupportedFormat, "unknown/unsupported parameter type");
} }
} }
string AlgorithmInfo::name() const string AlgorithmInfo::name() const
{ {
return data->_name; return data->_name;
} }
union GetSetParam union GetSetParam
{ {
int (Algorithm::*get_int)() const; int (Algorithm::*get_int)() const;
@ -430,7 +430,7 @@ union GetSetParam
Mat (Algorithm::*get_mat)() const; Mat (Algorithm::*get_mat)() const;
vector<Mat> (Algorithm::*get_mat_vector)() const; vector<Mat> (Algorithm::*get_mat_vector)() const;
Ptr<Algorithm> (Algorithm::*get_algo)() const; Ptr<Algorithm> (Algorithm::*get_algo)() const;
void (Algorithm::*set_int)(int); void (Algorithm::*set_int)(int);
void (Algorithm::*set_bool)(bool); void (Algorithm::*set_bool)(bool);
void (Algorithm::*set_double)(double); void (Algorithm::*set_double)(double);
@ -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;
@ -531,23 +531,23 @@ void AlgorithmInfo::set(Algorithm* algo, const char* name, int argType, const vo
else else
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;
if( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL ) if( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL )
{ {
if( p->type == Param::INT ) if( p->type == Param::INT )
{ {
CV_Assert( argType == Param::INT || argType == Param::REAL ); CV_Assert( argType == Param::INT || argType == Param::REAL );
int val = p->getter ? (algo->*f.get_int)() : *(int*)((uchar*)algo + p->offset); int val = p->getter ? (algo->*f.get_int)() : *(int*)((uchar*)algo + p->offset);
if( argType == Param::INT ) if( argType == Param::INT )
*(int*)value = val; *(int*)value = val;
else else
@ -557,7 +557,7 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* name, int argType, vo
{ {
CV_Assert( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL ); CV_Assert( argType == Param::INT || argType == Param::BOOLEAN || argType == Param::REAL );
bool val = p->getter ? (algo->*f.get_bool)() : *(bool*)((uchar*)algo + p->offset); bool val = p->getter ? (algo->*f.get_bool)() : *(bool*)((uchar*)algo + p->offset);
if( argType == Param::INT ) if( argType == Param::INT )
*(int*)value = (int)val; *(int*)value = (int)val;
else if( argType == Param::BOOLEAN ) else if( argType == Param::BOOLEAN )
@ -569,35 +569,35 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* name, int argType, vo
{ {
CV_Assert( argType == Param::REAL ); CV_Assert( argType == Param::REAL );
double val = p->getter ? (algo->*f.get_double)() : *(double*)((uchar*)algo + p->offset); double val = p->getter ? (algo->*f.get_double)() : *(double*)((uchar*)algo + p->offset);
*(double*)value = val; *(double*)value = val;
} }
} }
else if( argType == Param::STRING ) else if( argType == Param::STRING )
{ {
CV_Assert( p->type == Param::STRING ); CV_Assert( p->type == Param::STRING );
*(string*)value = p->getter ? (algo->*f.get_string)() : *(string*)value = p->getter ? (algo->*f.get_string)() :
*(string*)((uchar*)algo + p->offset); *(string*)((uchar*)algo + p->offset);
} }
else if( argType == Param::MAT ) else if( argType == Param::MAT )
{ {
CV_Assert( p->type == Param::MAT ); CV_Assert( p->type == Param::MAT );
*(Mat*)value = p->getter ? (algo->*f.get_mat)() : *(Mat*)value = p->getter ? (algo->*f.get_mat)() :
*(Mat*)((uchar*)algo + p->offset); *(Mat*)((uchar*)algo + p->offset);
} }
else if( argType == Param::MAT_VECTOR ) else if( argType == Param::MAT_VECTOR )
{ {
CV_Assert( p->type == Param::MAT_VECTOR ); CV_Assert( p->type == Param::MAT_VECTOR );
*(vector<Mat>*)value = p->getter ? (algo->*f.get_mat_vector)() : *(vector<Mat>*)value = p->getter ? (algo->*f.get_mat_vector)() :
*(vector<Mat>*)((uchar*)algo + p->offset); *(vector<Mat>*)((uchar*)algo + p->offset);
} }
else if( argType == Param::ALGORITHM ) else if( argType == Param::ALGORITHM )
{ {
CV_Assert( p->type == Param::ALGORITHM ); CV_Assert( p->type == Param::ALGORITHM );
*(Ptr<Algorithm>*)value = p->getter ? (algo->*f.get_algo)() : *(Ptr<Algorithm>*)value = p->getter ? (algo->*f.get_algo)() :
*(Ptr<Algorithm>*)((uchar*)algo + p->offset); *(Ptr<Algorithm>*)((uchar*)algo + p->offset);
} }
@ -605,21 +605,21 @@ void AlgorithmInfo::get(const Algorithm* algo, const char* name, int argType, vo
CV_Error(CV_StsBadArg, "Unknown/unsupported parameter type"); CV_Error(CV_StsBadArg, "Unknown/unsupported parameter type");
} }
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;
} }
@ -628,10 +628,10 @@ void AlgorithmInfo::getParams(vector<string>& names) const
{ {
data->params.get_keys(names); data->params.get_keys(names);
} }
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,82 +639,82 @@ 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);
} }
} }
/* End of file. */ /* End of file. */

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

@ -88,7 +88,7 @@ split_( const T* src, T** dst, int len, int cn )
dst2[i] = src[j+2]; dst3[i] = src[j+3]; dst2[i] = src[j+2]; dst3[i] = src[j+3];
} }
} }
for( ; k < cn; k += 4 ) for( ; k < cn; k += 4 )
{ {
T *dst0 = dst[k], *dst1 = dst[k+1], *dst2 = dst[k+2], *dst3 = dst[k+3]; T *dst0 = dst[k], *dst1 = dst[k+1], *dst2 = dst[k+2], *dst3 = dst[k+3];
@ -99,7 +99,7 @@ split_( const T* src, T** dst, int len, int cn )
} }
} }
} }
template<typename T> static void template<typename T> static void
merge_( const T** src, T* dst, int len, int cn ) merge_( const T** src, T* dst, int len, int cn )
{ {
@ -139,7 +139,7 @@ merge_( const T** src, T* dst, int len, int cn )
dst[j+2] = src2[i]; dst[j+3] = src3[i]; dst[j+2] = src2[i]; dst[j+3] = src3[i];
} }
} }
for( ; k < cn; k += 4 ) for( ; k < cn; k += 4 )
{ {
const T *src0 = src[k], *src1 = src[k+1], *src2 = src[k+2], *src3 = src[k+3]; const T *src0 = src[k], *src1 = src[k+1], *src2 = src[k+2], *src3 = src[k+3];
@ -165,7 +165,7 @@ static void split32s(const int* src, int** dst, int len, int cn )
{ {
split_(src, dst, len, cn); split_(src, dst, len, cn);
} }
static void split64s(const int64* src, int64** dst, int len, int cn ) static void split64s(const int64* src, int64** dst, int len, int cn )
{ {
split_(src, dst, len, cn); split_(src, dst, len, cn);
@ -189,7 +189,7 @@ static void merge32s(const int** src, int* dst, int len, int cn )
static void merge64s(const int64** src, int64* dst, int len, int cn ) static void merge64s(const int64** src, int64* dst, int len, int cn )
{ {
merge_(src, dst, len, cn); merge_(src, dst, len, cn);
} }
typedef void (*SplitFunc)(const uchar* src, uchar** dst, int len, int cn); typedef void (*SplitFunc)(const uchar* src, uchar** dst, int len, int cn);
typedef void (*MergeFunc)(const uchar** src, uchar* dst, int len, int cn); typedef void (*MergeFunc)(const uchar** src, uchar* dst, int len, int cn);
@ -205,9 +205,9 @@ static MergeFunc mergeTab[] =
(MergeFunc)GET_OPTIMIZED(merge8u), (MergeFunc)GET_OPTIMIZED(merge8u), (MergeFunc)GET_OPTIMIZED(merge16u), (MergeFunc)GET_OPTIMIZED(merge16u), (MergeFunc)GET_OPTIMIZED(merge8u), (MergeFunc)GET_OPTIMIZED(merge8u), (MergeFunc)GET_OPTIMIZED(merge16u), (MergeFunc)GET_OPTIMIZED(merge16u),
(MergeFunc)GET_OPTIMIZED(merge32s), (MergeFunc)GET_OPTIMIZED(merge32s), (MergeFunc)GET_OPTIMIZED(merge64s), 0 (MergeFunc)GET_OPTIMIZED(merge32s), (MergeFunc)GET_OPTIMIZED(merge32s), (MergeFunc)GET_OPTIMIZED(merge64s), 0
}; };
} }
void cv::split(const Mat& src, Mat* mv) void cv::split(const Mat& src, Mat* mv)
{ {
int k, depth = src.depth(), cn = src.channels(); int k, depth = src.depth(), cn = src.channels();
@ -219,30 +219,30 @@ void cv::split(const Mat& src, Mat* mv)
SplitFunc func = splitTab[depth]; SplitFunc func = splitTab[depth];
CV_Assert( func != 0 ); CV_Assert( func != 0 );
int esz = (int)src.elemSize(), esz1 = (int)src.elemSize1(); int esz = (int)src.elemSize(), esz1 = (int)src.elemSize1();
int blocksize0 = (BLOCK_SIZE + esz-1)/esz; int blocksize0 = (BLOCK_SIZE + esz-1)/esz;
AutoBuffer<uchar> _buf((cn+1)*(sizeof(Mat*) + sizeof(uchar*)) + 16); AutoBuffer<uchar> _buf((cn+1)*(sizeof(Mat*) + sizeof(uchar*)) + 16);
const Mat** arrays = (const Mat**)(uchar*)_buf; const Mat** arrays = (const Mat**)(uchar*)_buf;
uchar** ptrs = (uchar**)alignPtr(arrays + cn + 1, 16); uchar** ptrs = (uchar**)alignPtr(arrays + cn + 1, 16);
arrays[0] = &src; arrays[0] = &src;
for( k = 0; k < cn; k++ ) for( k = 0; k < cn; k++ )
{ {
mv[k].create(src.dims, src.size, depth); mv[k].create(src.dims, src.size, depth);
arrays[k+1] = &mv[k]; arrays[k+1] = &mv[k];
} }
NAryMatIterator it(arrays, ptrs, cn+1); NAryMatIterator it(arrays, ptrs, cn+1);
int total = (int)it.size, blocksize = cn <= 4 ? total : std::min(total, blocksize0); int total = (int)it.size, blocksize = cn <= 4 ? total : std::min(total, 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 += blocksize ) for( int j = 0; j < total; j += blocksize )
{ {
int bsz = std::min(total - j, blocksize); int bsz = std::min(total - j, blocksize);
func( ptrs[0], &ptrs[1], bsz, cn ); func( ptrs[0], &ptrs[1], bsz, cn );
if( j + blocksize < total ) if( j + blocksize < total )
{ {
ptrs[0] += bsz*esz; ptrs[0] += bsz*esz;
@ -252,7 +252,7 @@ void cv::split(const Mat& src, Mat* mv)
} }
} }
} }
void cv::split(InputArray _m, OutputArrayOfArrays _mv) void cv::split(InputArray _m, OutputArrayOfArrays _mv)
{ {
Mat m = _m.getMat(); Mat m = _m.getMat();
@ -266,38 +266,38 @@ void cv::split(InputArray _m, OutputArrayOfArrays _mv)
Mat* dst = &_mv.getMatRef(0); Mat* dst = &_mv.getMatRef(0);
split(m, dst); split(m, dst);
} }
void cv::merge(const Mat* mv, size_t n, OutputArray _dst) void cv::merge(const Mat* mv, size_t n, OutputArray _dst)
{ {
CV_Assert( mv && n > 0 ); CV_Assert( mv && n > 0 );
int depth = mv[0].depth(); int depth = mv[0].depth();
bool allch1 = true; bool allch1 = true;
int k, cn = 0; int k, cn = 0;
size_t i; size_t i;
for( i = 0; i < n; i++ ) for( i = 0; i < n; i++ )
{ {
CV_Assert(mv[i].size == mv[0].size && mv[i].depth() == depth); CV_Assert(mv[i].size == mv[0].size && mv[i].depth() == depth);
allch1 = allch1 && mv[i].channels() == 1; allch1 = allch1 && mv[i].channels() == 1;
cn += mv[i].channels(); cn += mv[i].channels();
} }
CV_Assert( 0 < cn && cn <= CV_CN_MAX ); CV_Assert( 0 < cn && cn <= CV_CN_MAX );
_dst.create(mv[0].dims, mv[0].size, CV_MAKETYPE(depth, cn)); _dst.create(mv[0].dims, mv[0].size, CV_MAKETYPE(depth, cn));
Mat dst = _dst.getMat(); Mat dst = _dst.getMat();
if( n == 1 ) if( n == 1 )
{ {
mv[0].copyTo(dst); mv[0].copyTo(dst);
return; return;
} }
if( !allch1 ) if( !allch1 )
{ {
AutoBuffer<int> pairs(cn*2); AutoBuffer<int> pairs(cn*2);
int j, ni=0; int j, ni=0;
for( i = 0, j = 0; i < n; i++, j += ni ) for( i = 0, j = 0; i < n; i++, j += ni )
{ {
ni = mv[i].channels(); ni = mv[i].channels();
@ -310,33 +310,33 @@ void cv::merge(const Mat* mv, size_t n, OutputArray _dst)
mixChannels( mv, n, &dst, 1, &pairs[0], cn ); mixChannels( mv, n, &dst, 1, &pairs[0], cn );
return; return;
} }
size_t esz = dst.elemSize(), esz1 = dst.elemSize1(); size_t esz = dst.elemSize(), esz1 = dst.elemSize1();
int blocksize0 = (int)((BLOCK_SIZE + esz-1)/esz); int blocksize0 = (int)((BLOCK_SIZE + esz-1)/esz);
AutoBuffer<uchar> _buf((cn+1)*(sizeof(Mat*) + sizeof(uchar*)) + 16); AutoBuffer<uchar> _buf((cn+1)*(sizeof(Mat*) + sizeof(uchar*)) + 16);
const Mat** arrays = (const Mat**)(uchar*)_buf; const Mat** arrays = (const Mat**)(uchar*)_buf;
uchar** ptrs = (uchar**)alignPtr(arrays + cn + 1, 16); uchar** ptrs = (uchar**)alignPtr(arrays + cn + 1, 16);
arrays[0] = &dst; arrays[0] = &dst;
for( k = 0; k < cn; k++ ) for( k = 0; k < cn; k++ )
arrays[k+1] = &mv[k]; arrays[k+1] = &mv[k];
NAryMatIterator it(arrays, ptrs, cn+1); NAryMatIterator it(arrays, ptrs, cn+1);
int total = (int)it.size, blocksize = cn <= 4 ? total : std::min(total, blocksize0); int total = (int)it.size, blocksize = cn <= 4 ? total : std::min(total, blocksize0);
MergeFunc func = mergeTab[depth]; MergeFunc func = mergeTab[depth];
for( i = 0; i < it.nplanes; i++, ++it ) for( i = 0; i < it.nplanes; i++, ++it )
{ {
for( int j = 0; j < total; j += blocksize ) for( int j = 0; j < total; j += blocksize )
{ {
int bsz = std::min(total - j, blocksize); int bsz = std::min(total - j, blocksize);
func( (const uchar**)&ptrs[1], ptrs[0], bsz, cn ); func( (const uchar**)&ptrs[1], ptrs[0], bsz, cn );
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;
} }
} }
} }
@ -347,7 +347,7 @@ void cv::merge(InputArrayOfArrays _mv, OutputArray _dst)
vector<Mat> mv; vector<Mat> mv;
_mv.getMatVector(mv); _mv.getMatVector(mv);
merge(!mv.empty() ? &mv[0] : 0, mv.size(), _dst); merge(!mv.empty() ? &mv[0] : 0, mv.size(), _dst);
} }
/****************************************************************************************\ /****************************************************************************************\
* Generalized split/merge: mixing channels * * Generalized split/merge: mixing channels *
@ -387,7 +387,7 @@ mixChannels_( const T** src, const int* sdelta,
} }
} }
static void mixChannels8u( const uchar** src, const int* sdelta, static void mixChannels8u( const uchar** src, const int* sdelta,
uchar** dst, const int* ddelta, uchar** dst, const int* ddelta,
int len, int npairs ) int len, int npairs )
@ -408,14 +408,14 @@ static void mixChannels32s( const int** src, const int* sdelta,
{ {
mixChannels_(src, sdelta, dst, ddelta, len, npairs); mixChannels_(src, sdelta, dst, ddelta, len, npairs);
} }
static void mixChannels64s( const int64** src, const int* sdelta, static void mixChannels64s( const int64** src, const int* sdelta,
int64** dst, const int* ddelta, int64** dst, const int* ddelta,
int len, int npairs ) int len, int npairs )
{ {
mixChannels_(src, sdelta, dst, ddelta, len, npairs); mixChannels_(src, sdelta, dst, ddelta, len, npairs);
} }
typedef void (*MixChannelsFunc)( const uchar** src, const int* sdelta, typedef void (*MixChannelsFunc)( const uchar** src, const int* sdelta,
uchar** dst, const int* ddelta, int len, int npairs ); uchar** dst, const int* ddelta, int len, int npairs );
@ -423,17 +423,17 @@ static MixChannelsFunc mixchTab[] =
{ {
(MixChannelsFunc)mixChannels8u, (MixChannelsFunc)mixChannels8u, (MixChannelsFunc)mixChannels16u, (MixChannelsFunc)mixChannels8u, (MixChannelsFunc)mixChannels8u, (MixChannelsFunc)mixChannels16u,
(MixChannelsFunc)mixChannels16u, (MixChannelsFunc)mixChannels32s, (MixChannelsFunc)mixChannels32s, (MixChannelsFunc)mixChannels16u, (MixChannelsFunc)mixChannels32s, (MixChannelsFunc)mixChannels32s,
(MixChannelsFunc)mixChannels64s, 0 (MixChannelsFunc)mixChannels64s, 0
}; };
} }
void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, const int* fromTo, size_t npairs ) void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, const int* fromTo, size_t npairs )
{ {
if( npairs == 0 ) if( npairs == 0 )
return; return;
CV_Assert( src && nsrcs > 0 && dst && ndsts > 0 && fromTo && npairs > 0 ); CV_Assert( src && nsrcs > 0 && dst && ndsts > 0 && fromTo && npairs > 0 );
size_t i, j, k, esz1 = dst[0].elemSize1(); size_t i, j, k, esz1 = dst[0].elemSize1();
int depth = dst[0].depth(); int depth = dst[0].depth();
@ -444,13 +444,13 @@ void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, cons
uchar** dsts = (uchar**)(srcs + npairs); uchar** dsts = (uchar**)(srcs + npairs);
int* tab = (int*)(dsts + npairs); int* tab = (int*)(dsts + npairs);
int *sdelta = (int*)(tab + npairs*4), *ddelta = sdelta + npairs; int *sdelta = (int*)(tab + npairs*4), *ddelta = sdelta + npairs;
for( i = 0; i < nsrcs; i++ ) for( i = 0; i < nsrcs; i++ )
arrays[i] = &src[i]; arrays[i] = &src[i];
for( i = 0; i < ndsts; i++ ) for( i = 0; i < ndsts; i++ )
arrays[i + nsrcs] = &dst[i]; arrays[i + nsrcs] = &dst[i];
ptrs[nsrcs + ndsts] = 0; ptrs[nsrcs + ndsts] = 0;
for( i = 0; i < npairs; i++ ) for( i = 0; i < npairs; i++ )
{ {
int i0 = fromTo[i*2], i1 = fromTo[i*2+1]; int i0 = fromTo[i*2], i1 = fromTo[i*2+1];
@ -468,7 +468,7 @@ void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, cons
tab[i*4] = (int)(nsrcs + ndsts); tab[i*4+1] = 0; tab[i*4] = (int)(nsrcs + ndsts); tab[i*4+1] = 0;
sdelta[i] = 0; sdelta[i] = 0;
} }
for( j = 0; j < ndsts; i1 -= dst[j].channels(), j++ ) for( j = 0; j < ndsts; i1 -= dst[j].channels(), j++ )
if( i1 < dst[j].channels() ) if( i1 < dst[j].channels() )
break; break;
@ -480,7 +480,7 @@ void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, cons
NAryMatIterator it(arrays, ptrs, (int)(nsrcs + ndsts)); NAryMatIterator it(arrays, ptrs, (int)(nsrcs + ndsts));
int total = (int)it.size, blocksize = std::min(total, (int)((BLOCK_SIZE + esz1-1)/esz1)); int total = (int)it.size, blocksize = std::min(total, (int)((BLOCK_SIZE + esz1-1)/esz1));
MixChannelsFunc func = mixchTab[depth]; MixChannelsFunc func = mixchTab[depth];
for( i = 0; i < it.nplanes; i++, ++it ) for( i = 0; i < it.nplanes; i++, ++it )
{ {
for( k = 0; k < npairs; k++ ) for( k = 0; k < npairs; k++ )
@ -488,13 +488,13 @@ void cv::mixChannels( const Mat* src, size_t nsrcs, Mat* dst, size_t ndsts, cons
srcs[k] = ptrs[tab[k*4]] + tab[k*4+1]; srcs[k] = ptrs[tab[k*4]] + tab[k*4+1];
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;
@ -524,7 +524,7 @@ void cv::mixChannels(InputArrayOfArrays src, InputArrayOfArrays dst,
int i; int i;
int nsrc = src_is_mat ? 1 : (int)src.total(); int nsrc = src_is_mat ? 1 : (int)src.total();
int ndst = dst_is_mat ? 1 : (int)dst.total(); int ndst = dst_is_mat ? 1 : (int)dst.total();
CV_Assert(fromTo.size()%2 == 0 && nsrc > 0 && ndst > 0); CV_Assert(fromTo.size()%2 == 0 && nsrc > 0 && ndst > 0);
cv::AutoBuffer<Mat> _buf(nsrc + ndst); cv::AutoBuffer<Mat> _buf(nsrc + ndst);
Mat* buf = _buf; Mat* buf = _buf;
@ -568,7 +568,7 @@ cvtScaleAbs_( const T* src, size_t sstep,
{ {
sstep /= sizeof(src[0]); sstep /= sizeof(src[0]);
dstep /= sizeof(dst[0]); dstep /= sizeof(dst[0]);
for( ; size.height--; src += sstep, dst += dstep ) for( ; size.height--; src += sstep, dst += dstep )
{ {
int x = 0; int x = 0;
@ -583,11 +583,11 @@ cvtScaleAbs_( const T* src, size_t sstep,
t1 = saturate_cast<DT>(std::abs(src[x+3]*scale + shift)); t1 = saturate_cast<DT>(std::abs(src[x+3]*scale + shift));
dst[x+2] = t0; dst[x+3] = t1; dst[x+2] = t0; dst[x+3] = t1;
} }
#endif #endif
for( ; x < size.width; x++ ) for( ; x < size.width; x++ )
dst[x] = saturate_cast<DT>(std::abs(src[x]*scale + shift)); dst[x] = saturate_cast<DT>(std::abs(src[x]*scale + shift));
} }
} }
template<typename T, typename DT, typename WT> static void template<typename T, typename DT, typename WT> static void
@ -597,7 +597,7 @@ cvtScale_( const T* src, size_t sstep,
{ {
sstep /= sizeof(src[0]); sstep /= sizeof(src[0]);
dstep /= sizeof(dst[0]); dstep /= sizeof(dst[0]);
for( ; size.height--; src += sstep, dst += dstep ) for( ; size.height--; src += sstep, dst += dstep )
{ {
int x = 0; int x = 0;
@ -623,38 +623,38 @@ cvtScale_( const T* src, size_t sstep,
template<> void template<> void
cvtScale_<short, short, float>( const short* src, size_t sstep, cvtScale_<short, short, float>( const short* src, size_t sstep,
short* dst, size_t dstep, Size size, short* dst, size_t dstep, Size size,
float scale, float shift ) float scale, float shift )
{ {
sstep /= sizeof(src[0]); sstep /= sizeof(src[0]);
dstep /= sizeof(dst[0]); dstep /= sizeof(dst[0]);
for( ; size.height--; src += sstep, dst += dstep ) for( ; size.height--; src += sstep, dst += dstep )
{ {
int x = 0; int x = 0;
#if CV_SSE2 #if CV_SSE2
if(USE_SSE2) if(USE_SSE2)
{ {
__m128 scale128 = _mm_set1_ps (scale); __m128 scale128 = _mm_set1_ps (scale);
__m128 shift128 = _mm_set1_ps (shift); __m128 shift128 = _mm_set1_ps (shift);
for(; x <= size.width - 8; x += 8 ) for(; x <= size.width - 8; x += 8 )
{ {
__m128i r0 = _mm_loadl_epi64((const __m128i*)(src + x)); __m128i r0 = _mm_loadl_epi64((const __m128i*)(src + x));
__m128i r1 = _mm_loadl_epi64((const __m128i*)(src + x + 4)); __m128i r1 = _mm_loadl_epi64((const __m128i*)(src + x + 4));
__m128 rf0 =_mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(r0, r0), 16)); __m128 rf0 =_mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(r0, r0), 16));
__m128 rf1 =_mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(r1, r1), 16)); __m128 rf1 =_mm_cvtepi32_ps(_mm_srai_epi32(_mm_unpacklo_epi16(r1, r1), 16));
rf0 = _mm_add_ps(_mm_mul_ps(rf0, scale128), shift128); rf0 = _mm_add_ps(_mm_mul_ps(rf0, scale128), shift128);
rf1 = _mm_add_ps(_mm_mul_ps(rf1, scale128), shift128); rf1 = _mm_add_ps(_mm_mul_ps(rf1, scale128), shift128);
r0 = _mm_cvtps_epi32(rf0); r0 = _mm_cvtps_epi32(rf0);
r1 = _mm_cvtps_epi32(rf1); r1 = _mm_cvtps_epi32(rf1);
r0 = _mm_packs_epi32(r0, r1); r0 = _mm_packs_epi32(r0, r1);
_mm_storeu_si128((__m128i*)(dst + x), r0); _mm_storeu_si128((__m128i*)(dst + x), r0);
} }
} }
#endif #endif
for(; x < size.width; x++ ) for(; x < size.width; x++ )
dst[x] = saturate_cast<short>(src[x]*scale + shift); dst[x] = saturate_cast<short>(src[x]*scale + shift);
} }
} }
@ -664,21 +664,21 @@ cvt_( const T* src, size_t sstep,
{ {
sstep /= sizeof(src[0]); sstep /= sizeof(src[0]);
dstep /= sizeof(dst[0]); dstep /= sizeof(dst[0]);
for( ; size.height--; src += sstep, dst += dstep ) for( ; size.height--; src += sstep, dst += dstep )
{ {
int x = 0; int x = 0;
#if CV_ENABLE_UNROLLED #if CV_ENABLE_UNROLLED
for( ; x <= size.width - 4; x += 4 ) for( ; x <= size.width - 4; x += 4 )
{ {
DT t0, t1; DT t0, t1;
t0 = saturate_cast<DT>(src[x]); t0 = saturate_cast<DT>(src[x]);
t1 = saturate_cast<DT>(src[x+1]); t1 = saturate_cast<DT>(src[x+1]);
dst[x] = t0; dst[x+1] = t1; dst[x] = t0; dst[x+1] = t1;
t0 = saturate_cast<DT>(src[x+2]); t0 = saturate_cast<DT>(src[x+2]);
t1 = saturate_cast<DT>(src[x+3]); t1 = saturate_cast<DT>(src[x+3]);
dst[x+2] = t0; dst[x+3] = t1; dst[x+2] = t0; dst[x+3] = t1;
} }
#endif #endif
for( ; x < size.width; x++ ) for( ; x < size.width; x++ )
dst[x] = saturate_cast<DT>(src[x]); dst[x] = saturate_cast<DT>(src[x]);
@ -692,24 +692,24 @@ cvt_<float, short>( const float* src, size_t sstep,
{ {
sstep /= sizeof(src[0]); sstep /= sizeof(src[0]);
dstep /= sizeof(dst[0]); dstep /= sizeof(dst[0]);
for( ; size.height--; src += sstep, dst += dstep ) for( ; size.height--; src += sstep, dst += dstep )
{ {
int x = 0; int x = 0;
#if CV_SSE2 #if CV_SSE2
if(USE_SSE2){ if(USE_SSE2){
for( ; x <= size.width - 8; x += 8 ) for( ; x <= size.width - 8; x += 8 )
{ {
__m128 src128 = _mm_loadu_ps (src + x); __m128 src128 = _mm_loadu_ps (src + x);
__m128i src_int128 = _mm_cvtps_epi32 (src128); __m128i src_int128 = _mm_cvtps_epi32 (src128);
src128 = _mm_loadu_ps (src + x + 4); src128 = _mm_loadu_ps (src + x + 4);
__m128i src1_int128 = _mm_cvtps_epi32 (src128); __m128i src1_int128 = _mm_cvtps_epi32 (src128);
src1_int128 = _mm_packs_epi32(src_int128, src1_int128); src1_int128 = _mm_packs_epi32(src_int128, src1_int128);
_mm_storeu_si128((__m128i*)(dst + x),src1_int128); _mm_storeu_si128((__m128i*)(dst + x),src1_int128);
} }
} }
#endif #endif
for( ; x < size.width; x++ ) for( ; x < size.width; x++ )
dst[x] = saturate_cast<short>(src[x]); dst[x] = saturate_cast<short>(src[x]);
@ -723,11 +723,11 @@ cpy_( const T* src, size_t sstep, T* dst, size_t dstep, Size size )
{ {
sstep /= sizeof(src[0]); sstep /= sizeof(src[0]);
dstep /= sizeof(dst[0]); dstep /= sizeof(dst[0]);
for( ; size.height--; src += sstep, dst += dstep ) for( ; size.height--; src += sstep, dst += dstep )
memcpy(dst, src, size.width*sizeof(src[0])); memcpy(dst, src, size.width*sizeof(src[0]));
} }
#define DEF_CVT_SCALE_ABS_FUNC(suffix, tfunc, stype, dtype, wtype) \ #define DEF_CVT_SCALE_ABS_FUNC(suffix, tfunc, stype, dtype, wtype) \
static void cvtScaleAbs##suffix( const stype* src, size_t sstep, const uchar*, size_t, \ static void cvtScaleAbs##suffix( const stype* src, size_t sstep, const uchar*, size_t, \
dtype* dst, size_t dstep, Size size, double* scale) \ dtype* dst, size_t dstep, Size size, double* scale) \
@ -741,8 +741,8 @@ dtype* dst, size_t dstep, Size size, double* scale) \
{ \ { \
cvtScale_(src, sstep, dst, dstep, size, (wtype)scale[0], (wtype)scale[1]); \ cvtScale_(src, sstep, dst, dstep, size, (wtype)scale[0], (wtype)scale[1]); \
} }
#define DEF_CVT_FUNC(suffix, stype, dtype) \ #define DEF_CVT_FUNC(suffix, stype, dtype) \
static void cvt##suffix( const stype* src, size_t sstep, const uchar*, size_t, \ static void cvt##suffix( const stype* src, size_t sstep, const uchar*, size_t, \
dtype* dst, size_t dstep, Size size, double*) \ dtype* dst, size_t dstep, Size size, double*) \
@ -756,15 +756,15 @@ stype* dst, size_t dstep, Size size, double*) \
{ \ { \
cpy_(src, sstep, dst, dstep, size); \ cpy_(src, sstep, dst, dstep, size); \
} }
DEF_CVT_SCALE_ABS_FUNC(8u, cvtScaleAbs_, uchar, uchar, float); DEF_CVT_SCALE_ABS_FUNC(8u, cvtScaleAbs_, uchar, uchar, float);
DEF_CVT_SCALE_ABS_FUNC(8s8u, cvtScaleAbs_, schar, uchar, float); DEF_CVT_SCALE_ABS_FUNC(8s8u, cvtScaleAbs_, schar, uchar, float);
DEF_CVT_SCALE_ABS_FUNC(16u8u, cvtScaleAbs_, ushort, uchar, float); DEF_CVT_SCALE_ABS_FUNC(16u8u, cvtScaleAbs_, ushort, uchar, float);
DEF_CVT_SCALE_ABS_FUNC(16s8u, cvtScaleAbs_, short, uchar, float); DEF_CVT_SCALE_ABS_FUNC(16s8u, cvtScaleAbs_, short, uchar, float);
DEF_CVT_SCALE_ABS_FUNC(32s8u, cvtScaleAbs_, int, uchar, float); DEF_CVT_SCALE_ABS_FUNC(32s8u, cvtScaleAbs_, int, uchar, float);
DEF_CVT_SCALE_ABS_FUNC(32f8u, cvtScaleAbs_, float, uchar, float); DEF_CVT_SCALE_ABS_FUNC(32f8u, cvtScaleAbs_, float, uchar, float);
DEF_CVT_SCALE_ABS_FUNC(64f8u, cvtScaleAbs_, double, uchar, float); DEF_CVT_SCALE_ABS_FUNC(64f8u, cvtScaleAbs_, double, uchar, float);
DEF_CVT_SCALE_FUNC(8u, uchar, uchar, float); DEF_CVT_SCALE_FUNC(8u, uchar, uchar, float);
DEF_CVT_SCALE_FUNC(8s8u, schar, uchar, float); DEF_CVT_SCALE_FUNC(8s8u, schar, uchar, float);
@ -772,7 +772,7 @@ DEF_CVT_SCALE_FUNC(16u8u, ushort, uchar, float);
DEF_CVT_SCALE_FUNC(16s8u, short, uchar, float); DEF_CVT_SCALE_FUNC(16s8u, short, uchar, float);
DEF_CVT_SCALE_FUNC(32s8u, int, uchar, float); DEF_CVT_SCALE_FUNC(32s8u, int, uchar, float);
DEF_CVT_SCALE_FUNC(32f8u, float, uchar, float); DEF_CVT_SCALE_FUNC(32f8u, float, uchar, float);
DEF_CVT_SCALE_FUNC(64f8u, double, uchar, float); DEF_CVT_SCALE_FUNC(64f8u, double, uchar, float);
DEF_CVT_SCALE_FUNC(8u8s, uchar, schar, float); DEF_CVT_SCALE_FUNC(8u8s, uchar, schar, float);
DEF_CVT_SCALE_FUNC(8s, schar, schar, float); DEF_CVT_SCALE_FUNC(8s, schar, schar, float);
@ -780,7 +780,7 @@ DEF_CVT_SCALE_FUNC(16u8s, ushort, schar, float);
DEF_CVT_SCALE_FUNC(16s8s, short, schar, float); DEF_CVT_SCALE_FUNC(16s8s, short, schar, float);
DEF_CVT_SCALE_FUNC(32s8s, int, schar, float); DEF_CVT_SCALE_FUNC(32s8s, int, schar, float);
DEF_CVT_SCALE_FUNC(32f8s, float, schar, float); DEF_CVT_SCALE_FUNC(32f8s, float, schar, float);
DEF_CVT_SCALE_FUNC(64f8s, double, schar, float); DEF_CVT_SCALE_FUNC(64f8s, double, schar, float);
DEF_CVT_SCALE_FUNC(8u16u, uchar, ushort, float); DEF_CVT_SCALE_FUNC(8u16u, uchar, ushort, float);
DEF_CVT_SCALE_FUNC(8s16u, schar, ushort, float); DEF_CVT_SCALE_FUNC(8s16u, schar, ushort, float);
@ -788,7 +788,7 @@ DEF_CVT_SCALE_FUNC(16u, ushort, ushort, float);
DEF_CVT_SCALE_FUNC(16s16u, short, ushort, float); DEF_CVT_SCALE_FUNC(16s16u, short, ushort, float);
DEF_CVT_SCALE_FUNC(32s16u, int, ushort, float); DEF_CVT_SCALE_FUNC(32s16u, int, ushort, float);
DEF_CVT_SCALE_FUNC(32f16u, float, ushort, float); DEF_CVT_SCALE_FUNC(32f16u, float, ushort, float);
DEF_CVT_SCALE_FUNC(64f16u, double, ushort, float); DEF_CVT_SCALE_FUNC(64f16u, double, ushort, float);
DEF_CVT_SCALE_FUNC(8u16s, uchar, short, float); DEF_CVT_SCALE_FUNC(8u16s, uchar, short, float);
DEF_CVT_SCALE_FUNC(8s16s, schar, short, float); DEF_CVT_SCALE_FUNC(8s16s, schar, short, float);
@ -797,7 +797,7 @@ DEF_CVT_SCALE_FUNC(16s, short, short, float);
DEF_CVT_SCALE_FUNC(32s16s, int, short, float); DEF_CVT_SCALE_FUNC(32s16s, int, short, float);
DEF_CVT_SCALE_FUNC(32f16s, float, short, float); DEF_CVT_SCALE_FUNC(32f16s, float, short, float);
DEF_CVT_SCALE_FUNC(64f16s, double, short, float); DEF_CVT_SCALE_FUNC(64f16s, double, short, float);
DEF_CVT_SCALE_FUNC(8u32s, uchar, int, float); DEF_CVT_SCALE_FUNC(8u32s, uchar, int, float);
DEF_CVT_SCALE_FUNC(8s32s, schar, int, float); DEF_CVT_SCALE_FUNC(8s32s, schar, int, float);
DEF_CVT_SCALE_FUNC(16u32s, ushort, int, float); DEF_CVT_SCALE_FUNC(16u32s, ushort, int, float);
@ -874,7 +874,7 @@ DEF_CVT_FUNC(16s64f, short, double);
DEF_CVT_FUNC(32s64f, int, double); DEF_CVT_FUNC(32s64f, int, double);
DEF_CVT_FUNC(32f64f, float, double); DEF_CVT_FUNC(32f64f, float, double);
DEF_CPY_FUNC(64s, int64); DEF_CPY_FUNC(64s, int64);
static BinaryFunc cvtScaleAbsTab[] = static BinaryFunc cvtScaleAbsTab[] =
{ {
(BinaryFunc)cvtScaleAbs8u, (BinaryFunc)cvtScaleAbs8s8u, (BinaryFunc)cvtScaleAbs16u8u, (BinaryFunc)cvtScaleAbs8u, (BinaryFunc)cvtScaleAbs8s8u, (BinaryFunc)cvtScaleAbs16u8u,
@ -965,7 +965,7 @@ static BinaryFunc cvtTab[][8] =
0, 0, 0, 0, 0, 0, 0, 0 0, 0, 0, 0, 0, 0, 0, 0
} }
}; };
BinaryFunc getConvertFunc(int sdepth, int ddepth) BinaryFunc getConvertFunc(int sdepth, int ddepth)
{ {
return cvtTab[CV_MAT_DEPTH(ddepth)][CV_MAT_DEPTH(sdepth)]; return cvtTab[CV_MAT_DEPTH(ddepth)][CV_MAT_DEPTH(sdepth)];
@ -974,10 +974,10 @@ BinaryFunc getConvertFunc(int sdepth, int ddepth)
BinaryFunc getConvertScaleFunc(int sdepth, int ddepth) BinaryFunc getConvertScaleFunc(int sdepth, int ddepth)
{ {
return cvtScaleTab[CV_MAT_DEPTH(ddepth)][CV_MAT_DEPTH(sdepth)]; return cvtScaleTab[CV_MAT_DEPTH(ddepth)][CV_MAT_DEPTH(sdepth)];
}
} }
}
void cv::convertScaleAbs( InputArray _src, OutputArray _dst, double alpha, double beta ) void cv::convertScaleAbs( InputArray _src, OutputArray _dst, double alpha, double beta )
{ {
Mat src = _src.getMat(); Mat src = _src.getMat();
@ -987,7 +987,7 @@ void cv::convertScaleAbs( InputArray _src, OutputArray _dst, double alpha, doubl
Mat dst = _dst.getMat(); Mat dst = _dst.getMat();
BinaryFunc func = cvtScaleAbsTab[src.depth()]; BinaryFunc func = cvtScaleAbsTab[src.depth()];
CV_Assert( func != 0 ); CV_Assert( func != 0 );
if( src.dims <= 2 ) if( src.dims <= 2 )
{ {
Size sz = getContinuousSize(src, dst, cn); Size sz = getContinuousSize(src, dst, cn);
@ -999,7 +999,7 @@ void cv::convertScaleAbs( InputArray _src, OutputArray _dst, double alpha, doubl
uchar* ptrs[2]; uchar* ptrs[2];
NAryMatIterator it(arrays, ptrs); NAryMatIterator it(arrays, ptrs);
Size sz((int)it.size*cn, 1); Size sz((int)it.size*cn, 1);
for( size_t i = 0; i < it.nplanes; i++, ++it ) for( size_t i = 0; i < it.nplanes; i++, ++it )
func( ptrs[0], 0, 0, 0, ptrs[1], 0, sz, scale ); func( ptrs[0], 0, 0, 0, ptrs[1], 0, sz, scale );
} }
@ -1022,12 +1022,12 @@ void cv::Mat::convertTo(OutputArray _dst, int _type, double alpha, double beta)
} }
Mat src = *this; Mat src = *this;
BinaryFunc func = noScale ? getConvertFunc(sdepth, ddepth) : getConvertScaleFunc(sdepth, ddepth); BinaryFunc func = noScale ? getConvertFunc(sdepth, ddepth) : getConvertScaleFunc(sdepth, ddepth);
double scale[] = {alpha, beta}; double scale[] = {alpha, beta};
int cn = channels(); int cn = channels();
CV_Assert( func != 0 ); CV_Assert( func != 0 );
if( dims <= 2 ) if( dims <= 2 )
{ {
_dst.create( size(), _type ); _dst.create( size(), _type );
@ -1043,7 +1043,7 @@ void cv::Mat::convertTo(OutputArray _dst, int _type, double alpha, double beta)
uchar* ptrs[2]; uchar* ptrs[2];
NAryMatIterator it(arrays, ptrs); NAryMatIterator it(arrays, ptrs);
Size sz((int)(it.size*cn), 1); Size sz((int)(it.size*cn), 1);
for( size_t i = 0; i < it.nplanes; i++, ++it ) for( size_t i = 0; i < it.nplanes; i++, ++it )
func(ptrs[0], 0, 0, 0, ptrs[1], 0, sz, scale); func(ptrs[0], 0, 0, 0, ptrs[1], 0, sz, scale);
} }
@ -1105,10 +1105,10 @@ static void LUT8u_32f( const uchar* src, const float* lut, float* dst, int len,
static void LUT8u_64f( const uchar* src, const double* lut, double* dst, int len, int cn, int lutcn ) static void LUT8u_64f( const uchar* src, const double* lut, double* dst, int len, int cn, int lutcn )
{ {
LUT8u_( src, lut, dst, len, cn, lutcn ); LUT8u_( src, lut, dst, len, cn, lutcn );
} }
typedef void (*LUTFunc)( const uchar* src, const uchar* lut, uchar* dst, int len, int cn, int lutcn ); typedef void (*LUTFunc)( const uchar* src, const uchar* lut, uchar* dst, int len, int cn, int lutcn );
static LUTFunc lutTab[] = static LUTFunc lutTab[] =
{ {
(LUTFunc)LUT8u_8u, (LUTFunc)LUT8u_8s, (LUTFunc)LUT8u_16u, (LUTFunc)LUT8u_16s, (LUTFunc)LUT8u_8u, (LUTFunc)LUT8u_8s, (LUTFunc)LUT8u_16u, (LUTFunc)LUT8u_16s,
@ -1116,7 +1116,7 @@ static LUTFunc lutTab[] =
}; };
} }
void cv::LUT( InputArray _src, InputArray _lut, OutputArray _dst, int interpolation ) void cv::LUT( InputArray _src, InputArray _lut, OutputArray _dst, int interpolation )
{ {
Mat src = _src.getMat(), lut = _lut.getMat(); Mat src = _src.getMat(), lut = _lut.getMat();
@ -1132,12 +1132,12 @@ void cv::LUT( InputArray _src, InputArray _lut, OutputArray _dst, int interpolat
LUTFunc func = lutTab[lut.depth()]; LUTFunc func = lutTab[lut.depth()];
CV_Assert( func != 0 ); CV_Assert( func != 0 );
const Mat* arrays[] = {&src, &dst, 0}; const Mat* arrays[] = {&src, &dst, 0};
uchar* ptrs[2]; uchar* ptrs[2];
NAryMatIterator it(arrays, ptrs); NAryMatIterator it(arrays, ptrs);
int len = (int)it.size; int len = (int)it.size;
for( size_t i = 0; i < it.nplanes; i++, ++it ) for( size_t i = 0; i < it.nplanes; i++, ++it )
func(ptrs[0], lut.data, ptrs[1], len, cn, lutcn); func(ptrs[0], lut.data, ptrs[1], len, cn, lutcn);
} }
@ -1147,7 +1147,7 @@ void cv::normalize( InputArray _src, OutputArray _dst, double a, double b,
int norm_type, int rtype, InputArray _mask ) int norm_type, int rtype, InputArray _mask )
{ {
Mat src = _src.getMat(), mask = _mask.getMat(); Mat src = _src.getMat(), mask = _mask.getMat();
double scale = 1, shift = 0; double scale = 1, shift = 0;
if( norm_type == CV_MINMAX ) if( norm_type == CV_MINMAX )
{ {
@ -1165,13 +1165,13 @@ void cv::normalize( InputArray _src, OutputArray _dst, double a, double b,
} }
else else
CV_Error( CV_StsBadArg, "Unknown/unsupported norm type" ); CV_Error( CV_StsBadArg, "Unknown/unsupported norm type" );
if( rtype < 0 ) if( rtype < 0 )
rtype = _dst.fixedType() ? _dst.depth() : src.depth(); rtype = _dst.fixedType() ? _dst.depth() : src.depth();
_dst.create(src.dims, src.size, CV_MAKETYPE(rtype, src.channels())); _dst.create(src.dims, src.size, CV_MAKETYPE(rtype, src.channels()));
Mat dst = _dst.getMat(); Mat dst = _dst.getMat();
if( !mask.data ) if( !mask.data )
src.convertTo( dst, rtype, scale, shift ); src.convertTo( dst, rtype, scale, shift );
else else
@ -1282,7 +1282,7 @@ cvConvertScale( const void* srcarr, void* dstarr,
double scale, double shift ) double scale, double shift )
{ {
cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr); cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr);
CV_Assert( src.size == dst.size && src.channels() == dst.channels() ); CV_Assert( src.size == dst.size && src.channels() == dst.channels() );
src.convertTo(dst, dst.type(), scale, shift); src.convertTo(dst, dst.type(), scale, shift);
} }

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

@ -59,7 +59,7 @@ copyMask_(const uchar* _src, size_t sstep, const uchar* mask, size_t mstep, ucha
const T* src = (const T*)_src; const T* src = (const T*)_src;
T* dst = (T*)_dst; T* dst = (T*)_dst;
int x = 0; int x = 0;
#if CV_ENABLE_UNROLLED #if CV_ENABLE_UNROLLED
for( ; x <= size.width - 4; x += 4 ) for( ; x <= size.width - 4; x += 4 )
{ {
if( mask[x] ) if( mask[x] )
@ -96,16 +96,16 @@ copyMaskGeneric(const uchar* _src, size_t sstep, const uchar* mask, size_t mstep
} }
} }
} }
#define DEF_COPY_MASK(suffix, type) \ #define DEF_COPY_MASK(suffix, type) \
static void copyMask##suffix(const uchar* src, size_t sstep, const uchar* mask, size_t mstep, \ static void copyMask##suffix(const uchar* src, size_t sstep, const uchar* mask, size_t mstep, \
uchar* dst, size_t dstep, Size size, void*) \ uchar* dst, size_t dstep, Size size, void*) \
{ \ { \
copyMask_<type>(src, sstep, mask, mstep, dst, dstep, size); \ copyMask_<type>(src, sstep, mask, mstep, dst, dstep, size); \
} }
DEF_COPY_MASK(8u, uchar); DEF_COPY_MASK(8u, uchar);
DEF_COPY_MASK(16u, ushort); DEF_COPY_MASK(16u, ushort);
DEF_COPY_MASK(8uC3, Vec3b); DEF_COPY_MASK(8uC3, Vec3b);
@ -116,7 +116,7 @@ DEF_COPY_MASK(32sC3, Vec3i);
DEF_COPY_MASK(32sC4, Vec4i); DEF_COPY_MASK(32sC4, Vec4i);
DEF_COPY_MASK(32sC6, Vec6i); DEF_COPY_MASK(32sC6, Vec6i);
DEF_COPY_MASK(32sC8, Vec8i); DEF_COPY_MASK(32sC8, Vec8i);
BinaryFunc copyMaskTab[] = BinaryFunc copyMaskTab[] =
{ {
0, 0,
@ -137,7 +137,7 @@ BinaryFunc copyMaskTab[] =
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
copyMask32sC8 copyMask32sC8
}; };
BinaryFunc getCopyMaskFunc(size_t esz) BinaryFunc getCopyMaskFunc(size_t esz)
{ {
return esz <= 32 && copyMaskTab[esz] ? copyMaskTab[esz] : copyMaskGeneric; return esz <= 32 && copyMaskTab[esz] ? copyMaskTab[esz] : copyMaskGeneric;
@ -152,51 +152,51 @@ void Mat::copyTo( OutputArray _dst ) const
convertTo( _dst, dtype ); convertTo( _dst, dtype );
return; return;
} }
if( empty() ) if( empty() )
{ {
_dst.release(); _dst.release();
return; return;
} }
if( dims <= 2 ) if( dims <= 2 )
{ {
_dst.create( rows, cols, type() ); _dst.create( rows, cols, type() );
Mat dst = _dst.getMat(); Mat dst = _dst.getMat();
if( data == dst.data ) if( data == dst.data )
return; return;
if( rows > 0 && cols > 0 ) if( rows > 0 && cols > 0 )
{ {
const uchar* sptr = data; const uchar* sptr = data;
uchar* dptr = dst.data; uchar* dptr = dst.data;
// to handle the copying 1xn matrix => nx1 std vector. // to handle the copying 1xn matrix => nx1 std vector.
Size sz = size() == dst.size() ? Size sz = size() == dst.size() ?
getContinuousSize(*this, dst) : getContinuousSize(*this, dst) :
getContinuousSize(*this); getContinuousSize(*this);
size_t len = sz.width*elemSize(); size_t len = sz.width*elemSize();
for( ; sz.height--; sptr += step, dptr += dst.step ) for( ; sz.height--; sptr += step, dptr += dst.step )
memcpy( dptr, sptr, len ); memcpy( dptr, sptr, len );
} }
return; return;
} }
_dst.create( dims, size, type() ); _dst.create( dims, size, type() );
Mat dst = _dst.getMat(); Mat dst = _dst.getMat();
if( data == dst.data ) if( data == dst.data )
return; return;
if( total() != 0 ) if( total() != 0 )
{ {
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);
} }
} }
@ -208,33 +208,33 @@ void Mat::copyTo( OutputArray _dst, InputArray _mask ) const
copyTo(_dst); copyTo(_dst);
return; return;
} }
int cn = channels(), mcn = mask.channels(); int cn = channels(), mcn = mask.channels();
CV_Assert( mask.depth() == CV_8U && (mcn == 1 || mcn == cn) ); CV_Assert( mask.depth() == CV_8U && (mcn == 1 || mcn == cn) );
bool colorMask = mcn > 1; bool colorMask = mcn > 1;
size_t esz = colorMask ? elemSize1() : elemSize(); size_t esz = colorMask ? elemSize1() : elemSize();
BinaryFunc copymask = getCopyMaskFunc(esz); BinaryFunc copymask = getCopyMaskFunc(esz);
uchar* data0 = _dst.getMat().data; uchar* data0 = _dst.getMat().data;
_dst.create( dims, size, type() ); _dst.create( dims, size, type() );
Mat dst = _dst.getMat(); Mat dst = _dst.getMat();
if( dst.data != data0 ) // do not leave dst uninitialized if( dst.data != data0 ) // do not leave dst uninitialized
dst = Scalar(0); dst = Scalar(0);
if( dims <= 2 ) if( dims <= 2 )
{ {
Size sz = getContinuousSize(*this, dst, mask, mcn); Size sz = getContinuousSize(*this, dst, mask, mcn);
copymask(data, step, mask.data, mask.step, dst.data, dst.step, sz, &esz); copymask(data, step, mask.data, mask.step, dst.data, dst.step, sz, &esz);
return; return;
} }
const Mat* arrays[] = { this, &dst, &mask, 0 }; const Mat* arrays[] = { this, &dst, &mask, 0 };
uchar* ptrs[3]; uchar* ptrs[3];
NAryMatIterator it(arrays, ptrs); NAryMatIterator it(arrays, ptrs);
Size sz((int)(it.size*mcn), 1); Size sz((int)(it.size*mcn), 1);
for( size_t i = 0; i < it.nplanes; i++, ++it ) for( size_t i = 0; i < it.nplanes; i++, ++it )
copymask(ptrs[0], 0, ptrs[2], 0, ptrs[1], 0, sz, &esz); copymask(ptrs[0], 0, ptrs[2], 0, ptrs[1], 0, sz, &esz);
} }
@ -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
{ {
@ -258,50 +258,50 @@ Mat& Mat::operator = (const Scalar& s)
double scalar[12]; double scalar[12];
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;
} }
Mat& Mat::setTo(InputArray _value, InputArray _mask) Mat& Mat::setTo(InputArray _value, InputArray _mask)
{ {
if( !data ) if( !data )
return *this; return *this;
Mat value = _value.getMat(), mask = _mask.getMat(); Mat value = _value.getMat(), mask = _mask.getMat();
CV_Assert( checkScalar(value, type(), _value.kind(), _InputArray::MAT )); CV_Assert( checkScalar(value, type(), _value.kind(), _InputArray::MAT ));
CV_Assert( mask.empty() || mask.type() == CV_8U ); CV_Assert( mask.empty() || mask.type() == CV_8U );
size_t esz = elemSize(); size_t esz = elemSize();
BinaryFunc copymask = getCopyMaskFunc(esz); BinaryFunc copymask = getCopyMaskFunc(esz);
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] )
{ {
@ -323,7 +323,7 @@ flipHoriz( const uchar* src, size_t sstep, uchar* dst, size_t dstep, Size size,
int i, j, limit = (int)(((size.width + 1)/2)*esz); int i, j, limit = (int)(((size.width + 1)/2)*esz);
AutoBuffer<int> _tab(size.width*esz); AutoBuffer<int> _tab(size.width*esz);
int* tab = _tab; int* tab = _tab;
for( i = 0; i < size.width; i++ ) for( i = 0; i < size.width; i++ )
for( size_t k = 0; k < esz; k++ ) for( size_t k = 0; k < esz; k++ )
tab[i*esz + k] = (int)((size.width - i - 1)*esz + k); tab[i*esz + k] = (int)((size.width - i - 1)*esz + k);
@ -403,7 +403,7 @@ flipVert( const uchar* src0, size_t sstep, uchar* dst0, size_t dstep, Size size,
void flip( InputArray _src, OutputArray _dst, int flip_mode ) void flip( InputArray _src, OutputArray _dst, int flip_mode )
{ {
Mat src = _src.getMat(); Mat src = _src.getMat();
CV_Assert( src.dims <= 2 ); CV_Assert( src.dims <= 2 );
_dst.create( src.size(), src.type() ); _dst.create( src.size(), src.type() );
Mat dst = _dst.getMat(); Mat dst = _dst.getMat();
@ -413,7 +413,7 @@ void flip( InputArray _src, OutputArray _dst, int flip_mode )
flipVert( src.data, src.step, dst.data, dst.step, src.size(), esz ); flipVert( src.data, src.step, dst.data, dst.step, src.size(), esz );
else else
flipHoriz( src.data, src.step, dst.data, dst.step, src.size(), esz ); flipHoriz( src.data, src.step, dst.data, dst.step, src.size(), esz );
if( flip_mode < 0 ) if( flip_mode < 0 )
flipHoriz( dst.data, dst.step, dst.data, dst.step, dst.size(), esz ); flipHoriz( dst.data, dst.step, dst.data, dst.step, dst.size(), esz );
} }
@ -423,7 +423,7 @@ void repeat(InputArray _src, int ny, int nx, OutputArray _dst)
{ {
Mat src = _src.getMat(); Mat src = _src.getMat();
CV_Assert( src.dims <= 2 ); CV_Assert( src.dims <= 2 );
_dst.create(src.rows*ny, src.cols*nx, src.type()); _dst.create(src.rows*ny, src.cols*nx, src.type());
Mat dst = _dst.getMat(); Mat dst = _dst.getMat();
Size ssize = src.size(), dsize = dst.size(); Size ssize = src.size(), dsize = dst.size();
@ -493,25 +493,25 @@ cvCopy( const void* srcarr, void* dstarr, const void* maskarr )
} }
cv::Mat src = cv::cvarrToMat(srcarr, false, true, 1), dst = cv::cvarrToMat(dstarr, false, true, 1); cv::Mat src = cv::cvarrToMat(srcarr, false, true, 1), dst = cv::cvarrToMat(dstarr, false, true, 1);
CV_Assert( src.depth() == dst.depth() && src.size == dst.size ); CV_Assert( src.depth() == dst.depth() && src.size == dst.size );
int coi1 = 0, coi2 = 0; int coi1 = 0, coi2 = 0;
if( CV_IS_IMAGE(srcarr) ) if( CV_IS_IMAGE(srcarr) )
coi1 = cvGetImageCOI((const IplImage*)srcarr); coi1 = cvGetImageCOI((const IplImage*)srcarr);
if( CV_IS_IMAGE(dstarr) ) if( CV_IS_IMAGE(dstarr) )
coi2 = cvGetImageCOI((const IplImage*)dstarr); coi2 = cvGetImageCOI((const IplImage*)dstarr);
if( coi1 || coi2 ) if( coi1 || coi2 )
{ {
CV_Assert( (coi1 != 0 || src.channels() == 1) && CV_Assert( (coi1 != 0 || src.channels() == 1) &&
(coi2 != 0 || dst.channels() == 1) ); (coi2 != 0 || dst.channels() == 1) );
int pair[] = { std::max(coi1-1, 0), std::max(coi2-1, 0) }; int pair[] = { std::max(coi1-1, 0), std::max(coi2-1, 0) };
cv::mixChannels( &src, 1, &dst, 1, pair, 1 ); cv::mixChannels( &src, 1, &dst, 1, pair, 1 );
return; return;
} }
else else
CV_Assert( src.channels() == dst.channels() ); CV_Assert( src.channels() == dst.channels() );
if( !maskarr ) if( !maskarr )
src.copyTo(dst); src.copyTo(dst);
else else
@ -548,12 +548,12 @@ cvFlip( const CvArr* srcarr, CvArr* dstarr, int flip_mode )
{ {
cv::Mat src = cv::cvarrToMat(srcarr); cv::Mat src = cv::cvarrToMat(srcarr);
cv::Mat dst; cv::Mat dst;
if (!dstarr) if (!dstarr)
dst = src; dst = src;
else else
dst = cv::cvarrToMat(dstarr); dst = cv::cvarrToMat(dstarr);
CV_Assert( src.type() == dst.type() && src.size() == dst.size() ); CV_Assert( src.type() == dst.type() && src.size() == dst.size() );
cv::flip( src, dst, flip_mode ); cv::flip( src, dst, flip_mode );
} }

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

@ -3349,7 +3349,7 @@ cvTreeToNodeSeq( const void* first, int header_size, CvMemStorage* storage )
} }
} }
return allseq; return allseq;
} }
@ -3531,9 +3531,9 @@ namespace cv
// both cv (CvFeatureTree) and ml (kNN). // both cv (CvFeatureTree) and ml (kNN).
// The algorithm is taken from: // The algorithm is taken from:
// J.S. Beis and D.G. Lowe. Shape indexing using approximate nearest-neighbor search // J.S. Beis and D.G. Lowe. Shape indexing using approximate nearest-neighbor search
// in highdimensional spaces. In Proc. IEEE Conf. Comp. Vision Patt. Recog., // in highdimensional spaces. In Proc. IEEE Conf. Comp. Vision Patt. Recog.,
// pages 1000--1006, 1997. http://citeseer.ist.psu.edu/beis97shape.html // pages 1000--1006, 1997. http://citeseer.ist.psu.edu/beis97shape.html
const int MAX_TREE_DEPTH = 32; const int MAX_TREE_DEPTH = 32;
@ -3555,8 +3555,8 @@ KDTree::KDTree(InputArray _points, InputArray _labels, bool _copyData)
maxDepth = -1; maxDepth = -1;
normType = NORM_L2; normType = NORM_L2;
build(_points, _labels, _copyData); build(_points, _labels, _copyData);
} }
struct SubTree struct SubTree
{ {
SubTree() : first(0), last(0), nodeIdx(0), depth(0) {} SubTree() : first(0), last(0), nodeIdx(0), depth(0) {}
@ -3596,7 +3596,7 @@ medianPartition( size_t* ofs, int a, int b, const float* vals )
else else
a = i0; a = i0;
} }
float pivot = vals[ofs[middle]]; float pivot = vals[ofs[middle]];
int less = 0, more = 0; int less = 0, more = 0;
for( k = a0; k < middle; k++ ) for( k = a0; k < middle; k++ )
@ -3632,7 +3632,7 @@ computeSums( const Mat& points, const size_t* ofs, int a, int b, double* sums )
} }
} }
void KDTree::build(InputArray _points, bool _copyData) void KDTree::build(InputArray _points, bool _copyData)
{ {
build(_points, noArray(), _copyData); build(_points, noArray(), _copyData);
@ -3652,8 +3652,8 @@ void KDTree::build(InputArray __points, InputArray __labels, bool _copyData)
points.release(); points.release();
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();
@ -3661,7 +3661,7 @@ void KDTree::build(InputArray __points, InputArray __labels, bool _copyData)
int ptpos = 0; int ptpos = 0;
labels.resize(n); labels.resize(n);
const int* _labels_data = 0; const int* _labels_data = 0;
if( !_labels.empty() ) if( !_labels.empty() )
{ {
int nlabels = _labels.checkVector(1, CV_32S, true); int nlabels = _labels.checkVector(1, CV_32S, true);
@ -3669,9 +3669,9 @@ 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);
size_t* ptofs = &_ptofs[0]; size_t* ptofs = &_ptofs[0];
@ -3682,7 +3682,7 @@ void KDTree::build(InputArray __points, InputArray __labels, bool _copyData)
computeSums(points, ptofs, 0, n-1, sumstack.ptr<double>(top)); computeSums(points, ptofs, 0, n-1, sumstack.ptr<double>(top));
stack[top++] = SubTree(0, n-1, 0, 0); stack[top++] = SubTree(0, n-1, 0, 0);
int _maxDepth = 0; int _maxDepth = 0;
while( --top >= 0 ) while( --top >= 0 )
{ {
int first = stack[top].first, last = stack[top].last; int first = stack[top].first, last = stack[top].last;
@ -3700,16 +3700,16 @@ 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;
_maxDepth = std::max(_maxDepth, depth); _maxDepth = std::max(_maxDepth, depth);
continue; continue;
} }
// 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);
@ -3752,13 +3752,13 @@ struct PQueueElem
int KDTree::findNearest(InputArray _vec, int K, int emax, int KDTree::findNearest(InputArray _vec, int K, int emax,
OutputArray _neighborsIdx, OutputArray _neighbors, OutputArray _neighborsIdx, OutputArray _neighbors,
OutputArray _dist, OutputArray _labels) const OutputArray _dist, OutputArray _labels) const
{ {
Mat vecmat = _vec.getMat(); Mat vecmat = _vec.getMat();
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));
@ -3776,7 +3776,7 @@ int KDTree::findNearest(InputArray _vec, int K, int emax,
{ {
float d, alt_d = 0.f; float d, alt_d = 0.f;
int nidx; int nidx;
if( e == 0 ) if( e == 0 )
nidx = 0; nidx = 0;
else else
@ -3803,7 +3803,7 @@ int KDTree::findNearest(InputArray _vec, int K, int emax,
i = left; i = left;
} }
} }
if( ncount == K && alt_d > dist[ncount-1] ) if( ncount == K && alt_d > dist[ncount-1] )
continue; continue;
} }
@ -3813,21 +3813,21 @@ int KDTree::findNearest(InputArray _vec, int K, int emax,
if( nidx < 0 ) if( nidx < 0 )
break; break;
const Node& n = nodes[nidx]; const Node& n = nodes[nidx];
if( n.idx < 0 ) if( n.idx < 0 )
{ {
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;
idx[ncount] = i; idx[ncount] = i;
for( i = ncount-1; i >= 0; i-- ) for( i = ncount-1; i >= 0; i-- )
@ -3839,9 +3839,9 @@ int KDTree::findNearest(InputArray _vec, int K, int emax,
} }
ncount += ncount < K; ncount += ncount < K;
e++; e++;
break; break;
} }
int alt; int alt;
if( vec[n.idx] <= n.boundary ) if( vec[n.idx] <= n.boundary )
{ {
@ -3853,7 +3853,7 @@ int KDTree::findNearest(InputArray _vec, int K, int emax,
nidx = n.right; nidx = n.right;
alt = n.left; alt = n.left;
} }
d = vec[n.idx] - n.boundary; d = vec[n.idx] - n.boundary;
if( normType == NORM_L2 ) if( normType == NORM_L2 )
d = d*d + alt_d; d = d*d + alt_d;
@ -3898,22 +3898,22 @@ 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>();
vector<int> idx; vector<int> idx;
AutoBuffer<int> _stack(MAX_TREE_DEPTH*2 + 1); AutoBuffer<int> _stack(MAX_TREE_DEPTH*2 + 1);
int* stack = _stack; int* stack = _stack;
int top = 0; int top = 0;
stack[top++] = 0; stack[top++] = 0;
while( --top >= 0 ) while( --top >= 0 )
@ -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;
} }
@ -3948,7 +3948,7 @@ void KDTree::findOrthoRange(InputArray _lowerBound,
getPoints( idx, _neighbors, _labels ); getPoints( idx, _neighbors, _labels );
} }
void KDTree::getPoints(InputArray _idx, OutputArray _pts, OutputArray _labels) const void KDTree::getPoints(InputArray _idx, OutputArray _pts, OutputArray _labels) const
{ {
Mat idxmat = _idx.getMat(), pts, labelsmat; Mat idxmat = _idx.getMat(), pts, labelsmat;
@ -3956,8 +3956,8 @@ void KDTree::getPoints(InputArray _idx, OutputArray _pts, OutputArray _labels) c
(idxmat.cols == 1 || idxmat.rows == 1) ); (idxmat.cols == 1 || idxmat.rows == 1) );
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 )
{ {
@ -3965,13 +3965,13 @@ void KDTree::getPoints(InputArray _idx, OutputArray _pts, OutputArray _labels) c
_labels.release(); _labels.release();
return; return;
} }
if( _pts.needed() ) if( _pts.needed() )
{ {
_pts.create( nidx, dims, points.type()); _pts.create( nidx, ptdims, points.type());
pts = _pts.getMat(); pts = _pts.getMat();
} }
if(_labels.needed()) if(_labels.needed())
{ {
_labels.create(nidx, 1, CV_32S, -1, true); _labels.create(nidx, 1, CV_32S, -1, true);
@ -3980,14 +3980,14 @@ void KDTree::getPoints(InputArray _idx, OutputArray _pts, OutputArray _labels) c
dstlabels = labelsmat.ptr<int>(); dstlabels = labelsmat.ptr<int>();
} }
const int* srclabels = !labels.empty() ? &labels[0] : 0; const int* srclabels = !labels.empty() ? &labels[0] : 0;
for( i = 0; i < nidx; i++ ) for( i = 0; i < nidx; i++ )
{ {
int k = idx[i]; int k = idx[i];
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;
} }
@ -4007,9 +4007,9 @@ int KDTree::dims() const
{ {
return !points.empty() ? points.cols : 0; return !points.empty() ? points.cols : 0;
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
schar* seqPush( CvSeq* seq, const void* element ) schar* seqPush( CvSeq* seq, const void* element )
{ {
return cvSeqPush(seq, element); return cvSeqPush(seq, element);

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;
} }

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

@ -63,7 +63,7 @@ GEMM_CopyBlock( const uchar* src, size_t src_step,
for( ; size.height--; src += src_step, dst += dst_step ) for( ; size.height--; src += src_step, dst += dst_step )
{ {
j=0; j=0;
#if CV_ENABLE_UNROLLED #if CV_ENABLE_UNROLLED
for( ; j <= size.width - 4; j += 4 ) for( ; j <= size.width - 4; j += 4 )
{ {
@ -345,7 +345,7 @@ GEMMSingleMul( const T* a_data, size_t a_step,
for( k = 0; k < n; k++, b_data += b_step ) for( k = 0; k < n; k++, b_data += b_step )
{ {
WT al(a_data[k]); WT al(a_data[k]);
j=0; j=0;
#if CV_ENABLE_UNROLLED #if CV_ENABLE_UNROLLED
for(; j <= m - 4; j += 4 ) for(; j <= m - 4; j += 4 )
{ {
@ -513,8 +513,8 @@ GEMMStore( const T* c_data, size_t c_step,
if( _c_data ) if( _c_data )
{ {
c_data = _c_data; c_data = _c_data;
j=0; j=0;
#if CV_ENABLE_UNROLLED #if CV_ENABLE_UNROLLED
for(; j <= d_size.width - 4; j += 4, c_data += 4*c_step1 ) for(; j <= d_size.width - 4; j += 4, c_data += 4*c_step1 )
{ {
WT t0 = alpha*d_buf[j]; WT t0 = alpha*d_buf[j];
@ -539,8 +539,8 @@ GEMMStore( const T* c_data, size_t c_step,
} }
else else
{ {
j = 0; j = 0;
#if CV_ENABLE_UNROLLED #if CV_ENABLE_UNROLLED
for( ; j <= d_size.width - 4; j += 4 ) for( ; j <= d_size.width - 4; j += 4 )
{ {
WT t0 = alpha*d_buf[j]; WT t0 = alpha*d_buf[j];
@ -552,7 +552,7 @@ GEMMStore( const T* c_data, size_t c_step,
d_data[j+2] = T(t0); d_data[j+2] = T(t0);
d_data[j+3] = T(t1); d_data[j+3] = T(t1);
} }
#endif #endif
for( ; j < d_size.width; j++ ) for( ; j < d_size.width; j++ )
d_data[j] = T(alpha*d_buf[j]); d_data[j] = T(alpha*d_buf[j]);
} }
@ -597,7 +597,7 @@ static void GEMMSingleMul_64f( const double* a_data, size_t a_step,
alpha, beta, flags); alpha, beta, flags);
} }
static void GEMMSingleMul_32fc( const Complexf* a_data, size_t a_step, static void GEMMSingleMul_32fc( const Complexf* a_data, size_t a_step,
const Complexf* b_data, size_t b_step, const Complexf* b_data, size_t b_step,
const Complexf* c_data, size_t c_step, const Complexf* c_data, size_t c_step,
@ -620,7 +620,7 @@ static void GEMMSingleMul_64fc( const Complexd* a_data, size_t a_step,
GEMMSingleMul<Complexd,Complexd>(a_data, a_step, b_data, b_step, c_data, GEMMSingleMul<Complexd,Complexd>(a_data, a_step, b_data, b_step, c_data,
c_step, d_data, d_step, a_size, d_size, c_step, d_data, d_step, a_size, d_size,
alpha, beta, flags); alpha, beta, flags);
} }
static void GEMMBlockMul_32f( const float* a_data, size_t a_step, static void GEMMBlockMul_32f( const float* a_data, size_t a_step,
const float* b_data, size_t b_step, const float* b_data, size_t b_step,
@ -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 );
@ -2008,7 +2008,7 @@ static void scaleAdd_32f(const float* src1, const float* src2, float* dst,
t1 = src1[i+3]*alpha + src2[i+3]; t1 = src1[i+3]*alpha + src2[i+3];
dst[i+2] = t0; dst[i+3] = t1; dst[i+2] = t0; dst[i+3] = t1;
} }
for(; i < len; i++ ) for(; i < len; i++ )
dst[i] = src1[i]*alpha + src2[i]; dst[i] = src1[i]*alpha + src2[i];
} }
@ -2035,7 +2035,7 @@ static void scaleAdd_64f(const double* src1, const double* src2, double* dst,
} }
else else
#endif #endif
//vz why do we need unroll here? //vz why do we need unroll here?
for( ; i <= len - 4; i += 4 ) for( ; i <= len - 4; i += 4 )
{ {
double t0, t1; double t0, t1;
@ -2046,7 +2046,7 @@ static void scaleAdd_64f(const double* src1, const double* src2, double* dst,
t1 = src1[i+3]*alpha + src2[i+3]; t1 = src1[i+3]*alpha + src2[i+3];
dst[i+2] = t0; dst[i+3] = t1; dst[i+2] = t0; dst[i+3] = t1;
} }
for(; i < len; i++ ) for(; i < len; i++ )
dst[i] = src1[i]*alpha + src2[i]; dst[i] = src1[i]*alpha + src2[i];
} }
@ -2072,7 +2072,7 @@ void cv::scaleAdd( InputArray _src1, double alpha, InputArray _src2, OutputArray
float falpha = (float)alpha; float falpha = (float)alpha;
void* palpha = depth == CV_32F ? (void*)&falpha : (void*)&alpha; void* palpha = depth == CV_32F ? (void*)&falpha : (void*)&alpha;
ScaleAddFunc func = depth == CV_32F ? (ScaleAddFunc)scaleAdd_32f : (ScaleAddFunc)scaleAdd_64f; ScaleAddFunc func = depth == CV_32F ? (ScaleAddFunc)scaleAdd_32f : (ScaleAddFunc)scaleAdd_64f;
if( src1.isContinuous() && src2.isContinuous() && dst.isContinuous() ) if( src1.isContinuous() && src2.isContinuous() && dst.isContinuous() )
{ {
@ -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();
} }
@ -2223,7 +2223,7 @@ void cv::calcCovarMatrix( InputArray _data, OutputArray _covar, InputOutputArray
double cv::Mahalanobis( InputArray _v1, InputArray _v2, InputArray _icovar ) double cv::Mahalanobis( InputArray _v1, InputArray _v2, InputArray _icovar )
{ {
Mat v1 = _v1.getMat(), v2 = _v2.getMat(), icovar = _icovar.getMat(); Mat v1 = _v1.getMat(), v2 = _v2.getMat(), icovar = _icovar.getMat();
int type = v1.type(), depth = v1.depth(); int type = v1.type(), depth = v1.depth();
Size sz = v1.size(); Size sz = v1.size();
int i, j, len = sz.width*sz.height*v1.channels(); int i, j, len = sz.width*sz.height*v1.channels();
@ -2261,7 +2261,7 @@ double cv::Mahalanobis( InputArray _v1, InputArray _v2, InputArray _icovar )
{ {
double row_sum = 0; double row_sum = 0;
j = 0; j = 0;
#if CV_ENABLE_UNROLLED #if CV_ENABLE_UNROLLED
for(; j <= len - 4; j += 4 ) for(; j <= len - 4; j += 4 )
row_sum += diff[j]*mat[j] + diff[j+1]*mat[j+1] + row_sum += diff[j]*mat[j] + diff[j+1]*mat[j+1] +
diff[j+2]*mat[j+2] + diff[j+3]*mat[j+3]; diff[j+2]*mat[j+2] + diff[j+3]*mat[j+3];
@ -2292,7 +2292,7 @@ double cv::Mahalanobis( InputArray _v1, InputArray _v2, InputArray _icovar )
{ {
double row_sum = 0; double row_sum = 0;
j = 0; j = 0;
#if CV_ENABLE_UNROLLED #if CV_ENABLE_UNROLLED
for(; j <= len - 4; j += 4 ) for(; j <= len - 4; j += 4 )
row_sum += diff[j]*mat[j] + diff[j+1]*mat[j+1] + row_sum += diff[j]*mat[j] + diff[j+1]*mat[j+1] +
diff[j+2]*mat[j+2] + diff[j+3]*mat[j+3]; diff[j+2]*mat[j+2] + diff[j+3]*mat[j+3];
@ -2642,7 +2642,7 @@ dotProd_(const T* src1, const T* src2, int len)
{ {
int i = 0; int i = 0;
double result = 0; double result = 0;
#if CV_ENABLE_UNROLLED #if CV_ENABLE_UNROLLED
for( ; i <= len - 4; i += 4 ) for( ; i <= len - 4; i += 4 )
result += (double)src1[i]*src2[i] + (double)src1[i+1]*src2[i+1] + result += (double)src1[i]*src2[i] + (double)src1[i+1]*src2[i+1] +
(double)src1[i+2]*src2[i+2] + (double)src1[i+3]*src2[i+3]; (double)src1[i+2]*src2[i+2] + (double)src1[i+3]*src2[i+3];
@ -2674,7 +2674,7 @@ static double dotProd_8u(const uchar* src1, const uchar* src2, int len)
{ {
blockSize = std::min(len0 - i, blockSize0); blockSize = std::min(len0 - i, blockSize0);
__m128i s = _mm_setzero_si128(); __m128i s = _mm_setzero_si128();
j = 0; j = 0;
for( ; j <= blockSize - 16; j += 16 ) for( ; j <= blockSize - 16; j += 16 )
{ {
__m128i b0 = _mm_loadu_si128((const __m128i*)(src1 + j)); __m128i b0 = _mm_loadu_si128((const __m128i*)(src1 + j));
@ -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)
@ -2964,7 +2964,7 @@ void cv::PCACompute(InputArray data, InputOutputArray mean,
pca.mean.copyTo(mean); pca.mean.copyTo(mean);
pca.eigenvectors.copyTo(eigenvectors); pca.eigenvectors.copyTo(eigenvectors);
} }
void cv::PCAProject(InputArray data, InputArray mean, void cv::PCAProject(InputArray data, InputArray mean,
InputArray eigenvectors, OutputArray result) InputArray eigenvectors, OutputArray result)
{ {

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

File diff suppressed because it is too large Load Diff

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;

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

@ -163,11 +163,11 @@ void icvSetOpenGlFuncTab(const CvOpenGlFuncTab* tab)
void cv::gpu::setGlDevice(int device) void cv::gpu::setGlDevice(int device)
{ {
#ifndef HAVE_CUDA #ifndef HAVE_CUDA
(void)device; (void)device;
throw_nocuda; throw_nocuda;
#else #else
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)device; (void)device;
throw_nogl; throw_nogl;
#else #else
if (!glFuncTab()->isGlContextInitialized()) if (!glFuncTab()->isGlContextInitialized())
@ -287,7 +287,7 @@ class cv::GlBuffer::Impl
{ {
public: public:
static const Ptr<Impl>& empty(); static const Ptr<Impl>& empty();
Impl(int rows, int cols, int type, unsigned int target); Impl(int rows, int cols, int type, unsigned int target);
Impl(const Mat& m, unsigned int target); Impl(const Mat& m, unsigned int target);
~Impl(); ~Impl();
@ -311,7 +311,7 @@ public:
private: private:
Impl(); Impl();
unsigned int buffer_; unsigned int buffer_;
#ifdef HAVE_CUDA #ifdef HAVE_CUDA
@ -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
} }
@ -590,14 +590,14 @@ void cv::GlBuffer::release()
void cv::GlBuffer::copyFrom(InputArray mat_) void cv::GlBuffer::copyFrom(InputArray mat_)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)mat_; (void)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)
{ {
@ -728,7 +728,7 @@ public:
private: private:
Impl(); Impl();
GLuint tex_; GLuint tex_;
}; };
@ -926,45 +926,45 @@ 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
} }
cv::GlTexture::GlTexture(InputArray mat_, bool bgra) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER) cv::GlTexture::GlTexture(InputArray mat_, bool bgra) : rows_(0), cols_(0), type_(0), buf_(GlBuffer::TEXTURE_BUFFER)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)mat_; (void)mat_;
(void)bgra; (void)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();
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
} }
@ -1030,15 +1030,15 @@ void cv::GlTexture::release()
void cv::GlTexture::copyFrom(InputArray mat_, bool bgra) void cv::GlTexture::copyFrom(InputArray mat_, bool bgra)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)mat_; (void)mat_;
(void)bgra; (void)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
} }
@ -1283,7 +1283,7 @@ namespace
class FontCompare : public unary_function<Ptr<GlFont>, bool> class FontCompare : public unary_function<Ptr<GlFont>, bool>
{ {
public: public:
inline FontCompare(const string& family, int height, GlFont::Weight weight, GlFont::Style style) inline FontCompare(const string& family, int height, GlFont::Weight weight, GlFont::Style style)
: family_(family), height_(height), weight_(weight), style_(style) : family_(family), height_(height), weight_(weight), style_(style)
{ {
} }
@ -1304,10 +1304,10 @@ namespace
Ptr<GlFont> cv::GlFont::get(const std::string& family, int height, Weight weight, Style style) Ptr<GlFont> cv::GlFont::get(const std::string& family, int height, Weight weight, Style style)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)family; (void)family;
(void)height; (void)height;
(void)weight; (void)weight;
(void)style; (void)style;
throw_nogl; throw_nogl;
return Ptr<GlFont>(); return Ptr<GlFont>();
#else #else
@ -1333,9 +1333,9 @@ Ptr<GlFont> cv::GlFont::get(const std::string& family, int height, Weight weight
void cv::render(const GlTexture& tex, Rect_<double> wndRect, Rect_<double> texRect) void cv::render(const GlTexture& tex, Rect_<double> wndRect, Rect_<double> texRect)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)tex; (void)tex;
(void)wndRect; (void)wndRect;
(void)texRect; (void)texRect;
throw_nogl; throw_nogl;
#else #else
if (!tex.empty()) if (!tex.empty())
@ -1368,9 +1368,9 @@ void cv::render(const GlTexture& tex, Rect_<double> wndRect, Rect_<double> texRe
void cv::render(const GlArrays& arr, int mode, Scalar color) void cv::render(const GlArrays& arr, int mode, Scalar color)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)arr; (void)arr;
(void)mode; (void)mode;
(void)color; (void)color;
throw_nogl; throw_nogl;
#else #else
glColor3d(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0); glColor3d(color[0] / 255.0, color[1] / 255.0, color[2] / 255.0);
@ -1386,10 +1386,10 @@ void cv::render(const GlArrays& arr, int mode, Scalar color)
void cv::render(const string& str, const Ptr<GlFont>& font, Scalar color, Point2d pos) void cv::render(const string& str, const Ptr<GlFont>& font, Scalar color, Point2d pos)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)str; (void)str;
(void)font; (void)font;
(void)color; (void)color;
(void)pos; (void)pos;
throw_nogl; throw_nogl;
#else #else
glPushAttrib(GL_DEPTH_BUFFER_BIT); glPushAttrib(GL_DEPTH_BUFFER_BIT);
@ -1544,9 +1544,9 @@ void cv::GlCamera::setupModelViewMatrix() const
bool icvCheckGlError(const char* file, const int line, const char* func) bool icvCheckGlError(const char* file, const int line, const char* func)
{ {
#ifndef HAVE_OPENGL #ifndef HAVE_OPENGL
(void)file; (void)file;
(void)line; (void)line;
(void)func; (void)func;
return true; return true;
#else #else
GLenum err = glGetError(); GLenum err = glGetError();

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

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

@ -22,25 +22,25 @@ void testReduce( const Mat& src, Mat& sum, Mat& avg, Mat& max, Mat& min, int dim
assert( src.channels() == 1 ); assert( src.channels() == 1 );
if( dim == 0 ) // row if( dim == 0 ) // row
{ {
sum.create( 1, src.cols, CV_64FC1 ); sum.create( 1, src.cols, CV_64FC1 );
max.create( 1, src.cols, CV_64FC1 ); max.create( 1, src.cols, CV_64FC1 );
min.create( 1, src.cols, CV_64FC1 ); min.create( 1, src.cols, CV_64FC1 );
} }
else else
{ {
sum.create( src.rows, 1, CV_64FC1 ); sum.create( src.rows, 1, CV_64FC1 );
max.create( src.rows, 1, CV_64FC1 ); max.create( src.rows, 1, CV_64FC1 );
min.create( src.rows, 1, CV_64FC1 ); min.create( src.rows, 1, CV_64FC1 );
} }
sum.setTo(Scalar(0)); sum.setTo(Scalar(0));
max.setTo(Scalar(-DBL_MAX)); max.setTo(Scalar(-DBL_MAX));
min.setTo(Scalar(DBL_MAX)); min.setTo(Scalar(DBL_MAX));
const Mat_<Type>& src_ = src; const Mat_<Type>& src_ = src;
Mat_<double>& sum_ = (Mat_<double>&)sum; Mat_<double>& sum_ = (Mat_<double>&)sum;
Mat_<double>& min_ = (Mat_<double>&)min; Mat_<double>& min_ = (Mat_<double>&)min;
Mat_<double>& max_ = (Mat_<double>&)max; Mat_<double>& max_ = (Mat_<double>&)max;
if( dim == 0 ) if( dim == 0 )
{ {
for( int ri = 0; ri < src.rows; ri++ ) for( int ri = 0; ri < src.rows; ri++ )
@ -128,7 +128,7 @@ int Core_ReduceTest::checkOp( const Mat& src, int dstType, int opType, const Mat
else if ( dstType == CV_32S ) else if ( dstType == CV_32S )
eps = 0.6; eps = 0.6;
} }
assert( opRes.type() == CV_64FC1 ); assert( opRes.type() == CV_64FC1 );
Mat _dst, dst, diff; Mat _dst, dst, diff;
reduce( src, _dst, dim, opType, dstType ); reduce( src, _dst, dim, opType, dstType );
@ -151,7 +151,7 @@ int Core_ReduceTest::checkOp( const Mat& src, int dstType, int opType, const Mat
getMatTypeStr( src.type(), srcTypeStr ); getMatTypeStr( src.type(), srcTypeStr );
getMatTypeStr( dstType, dstTypeStr ); getMatTypeStr( dstType, dstTypeStr );
const char* dimStr = dim == 0 ? "ROWS" : "COLS"; const char* dimStr = dim == 0 ? "ROWS" : "COLS";
sprintf( msg, "bad accuracy with srcType = %s, dstType = %s, opType = %s, dim = %s", sprintf( msg, "bad accuracy with srcType = %s, dstType = %s, opType = %s, dim = %s",
srcTypeStr.c_str(), dstTypeStr.c_str(), opTypeStr, dimStr ); srcTypeStr.c_str(), dstTypeStr.c_str(), opTypeStr, dimStr );
ts->printf( cvtest::TS::LOG, msg ); ts->printf( cvtest::TS::LOG, msg );
@ -164,10 +164,10 @@ int Core_ReduceTest::checkCase( int srcType, int dstType, int dim, Size sz )
{ {
int code = cvtest::TS::OK, tempCode; int code = cvtest::TS::OK, tempCode;
Mat src, sum, avg, max, min; Mat src, sum, avg, max, min;
src.create( sz, srcType ); src.create( sz, srcType );
randu( src, Scalar(0), Scalar(100) ); randu( src, Scalar(0), Scalar(100) );
if( srcType == CV_8UC1 ) if( srcType == CV_8UC1 )
testReduce<uchar>( src, sum, avg, max, min, dim ); testReduce<uchar>( src, sum, avg, max, min, dim );
else if( srcType == CV_8SC1 ) else if( srcType == CV_8SC1 )
@ -182,110 +182,108 @@ int Core_ReduceTest::checkCase( int srcType, int dstType, int dim, Size sz )
testReduce<float>( src, sum, avg, max, min, dim ); testReduce<float>( src, sum, avg, max, min, dim );
else if( srcType == CV_64FC1 ) else if( srcType == CV_64FC1 )
testReduce<double>( src, sum, avg, max, min, dim ); testReduce<double>( src, sum, avg, max, min, dim );
else else
assert( 0 ); assert( 0 );
// 1. sum // 1. sum
tempCode = checkOp( src, dstType, CV_REDUCE_SUM, sum, dim ); tempCode = checkOp( src, dstType, CV_REDUCE_SUM, sum, dim );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
// 2. avg // 2. avg
tempCode = checkOp( src, dstType, CV_REDUCE_AVG, avg, dim ); tempCode = checkOp( src, dstType, CV_REDUCE_AVG, avg, dim );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
// 3. max // 3. max
tempCode = checkOp( src, dstType, CV_REDUCE_MAX, max, dim ); tempCode = checkOp( src, dstType, CV_REDUCE_MAX, max, dim );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
// 4. min // 4. min
tempCode = checkOp( src, dstType, CV_REDUCE_MIN, min, dim ); tempCode = checkOp( src, dstType, CV_REDUCE_MIN, min, dim );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
return code; return code;
} }
int Core_ReduceTest::checkDim( int dim, Size sz ) int Core_ReduceTest::checkDim( int dim, Size sz )
{ {
int code = cvtest::TS::OK, tempCode; int code = cvtest::TS::OK, tempCode;
// CV_8UC1 // CV_8UC1
tempCode = checkCase( CV_8UC1, CV_8UC1, dim, sz ); tempCode = checkCase( CV_8UC1, CV_8UC1, dim, sz );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
tempCode = checkCase( CV_8UC1, CV_32SC1, dim, sz ); tempCode = checkCase( CV_8UC1, CV_32SC1, dim, sz );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
tempCode = checkCase( CV_8UC1, CV_32FC1, dim, sz ); tempCode = checkCase( CV_8UC1, CV_32FC1, dim, sz );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
tempCode = checkCase( CV_8UC1, CV_64FC1, dim, sz ); tempCode = checkCase( CV_8UC1, CV_64FC1, dim, sz );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
// CV_16UC1 // CV_16UC1
tempCode = checkCase( CV_16UC1, CV_32FC1, dim, sz ); tempCode = checkCase( CV_16UC1, CV_32FC1, dim, sz );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
tempCode = checkCase( CV_16UC1, CV_64FC1, dim, sz ); tempCode = checkCase( CV_16UC1, CV_64FC1, dim, sz );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
// CV_16SC1 // CV_16SC1
tempCode = checkCase( CV_16SC1, CV_32FC1, dim, sz ); tempCode = checkCase( CV_16SC1, CV_32FC1, dim, sz );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
tempCode = checkCase( CV_16SC1, CV_64FC1, dim, sz ); tempCode = checkCase( CV_16SC1, CV_64FC1, dim, sz );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
// CV_32FC1 // CV_32FC1
tempCode = checkCase( CV_32FC1, CV_32FC1, dim, sz ); tempCode = checkCase( CV_32FC1, CV_32FC1, dim, sz );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
tempCode = checkCase( CV_32FC1, CV_64FC1, dim, sz ); tempCode = checkCase( CV_32FC1, CV_64FC1, dim, sz );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
// CV_64FC1 // CV_64FC1
tempCode = checkCase( CV_64FC1, CV_64FC1, dim, sz ); tempCode = checkCase( CV_64FC1, CV_64FC1, dim, sz );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
return code; return code;
} }
int Core_ReduceTest::checkSize( Size sz ) int Core_ReduceTest::checkSize( Size sz )
{ {
int code = cvtest::TS::OK, tempCode; int code = cvtest::TS::OK, tempCode;
tempCode = checkDim( 0, sz ); // rows tempCode = checkDim( 0, sz ); // rows
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
tempCode = checkDim( 1, sz ); // cols tempCode = checkDim( 1, sz ); // cols
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
return code; return code;
} }
void Core_ReduceTest::run( int ) void Core_ReduceTest::run( int )
{ {
int code = cvtest::TS::OK, tempCode; int code = cvtest::TS::OK, tempCode;
tempCode = checkSize( Size(1,1) ); tempCode = checkSize( Size(1,1) );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
tempCode = checkSize( Size(1,100) ); tempCode = checkSize( Size(1,100) );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
tempCode = checkSize( Size(100,1) ); tempCode = checkSize( Size(100,1) );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
tempCode = checkSize( Size(1000,500) ); tempCode = checkSize( Size(1000,500) );
code = tempCode != cvtest::TS::OK ? tempCode : code; code = tempCode != cvtest::TS::OK ? tempCode : code;
ts->set_failed_test_info( code ); ts->set_failed_test_info( code );
} }
#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,41 +291,43 @@ 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;
int maxComponents = 100; int maxComponents = 100;
Mat rPoints(sz, CV_32FC1), rTestPoints(sz, CV_32FC1); Mat rPoints(sz, CV_32FC1), rTestPoints(sz, CV_32FC1);
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
rng.fill( rPoints, RNG::UNIFORM, Scalar::all(0.0), Scalar::all(1.0) ); rng.fill( rPoints, RNG::UNIFORM, Scalar::all(0.0), Scalar::all(1.0) );
rng.fill( rTestPoints, RNG::UNIFORM, Scalar::all(0.0), Scalar::all(1.0) ); rng.fill( rTestPoints, RNG::UNIFORM, Scalar::all(0.0), Scalar::all(1.0) );
PCA rPCA( rPoints, Mat(), CV_PCA_DATA_AS_ROW, maxComponents ), cPCA; PCA rPCA( rPoints, Mat(), CV_PCA_DATA_AS_ROW, maxComponents ), cPCA;
// 1. check C++ PCA & ROW // 1. check C++ PCA & ROW
Mat rPrjTestPoints = rPCA.project( rTestPoints ); Mat rPrjTestPoints = rPCA.project( rTestPoints );
Mat rBackPrjTestPoints = rPCA.backProject( rPrjTestPoints ); Mat rBackPrjTestPoints = rPCA.backProject( rPrjTestPoints );
Mat avg(1, sz.width, CV_32FC1 ); Mat avg(1, sz.width, CV_32FC1 );
reduce( rPoints, avg, 0, CV_REDUCE_AVG ); reduce( rPoints, avg, 0, CV_REDUCE_AVG );
Mat Q = rPoints - repeat( avg, rPoints.rows, 1 ), Qt = Q.t(), eval, evec; Mat Q = rPoints - repeat( avg, rPoints.rows, 1 ), Qt = Q.t(), eval, evec;
Q = Qt * Q; Q = Qt * Q;
Q = Q /(float)rPoints.rows; Q = Q /(float)rPoints.rows;
eigen( Q, eval, evec ); eigen( Q, eval, evec );
/*SVD svd(Q); /*SVD svd(Q);
evec = svd.vt; evec = svd.vt;
eval = svd.w;*/ eval = svd.w;*/
Mat subEval( maxComponents, 1, eval.type(), eval.data ), Mat subEval( maxComponents, 1, eval.type(), eval.data ),
subEvec( maxComponents, evec.cols, evec.type(), evec.data ); subEvec( maxComponents, evec.cols, evec.type(), evec.data );
#ifdef CHECK_C #ifdef CHECK_C
Mat prjTestPoints, backPrjTestPoints, cPoints = rPoints.t(), cTestPoints = rTestPoints.t(); Mat prjTestPoints, backPrjTestPoints, cPoints = rPoints.t(), cTestPoints = rTestPoints.t();
CvMat _points, _testPoints, _avg, _eval, _evec, _prjTestPoints, _backPrjTestPoints; CvMat _points, _testPoints, _avg, _eval, _evec, _prjTestPoints, _backPrjTestPoints;
#endif #endif
// check eigen() // check eigen()
double eigenEps = 1e-6; double eigenEps = 1e-6;
double err; double err;
@ -335,7 +335,7 @@ protected:
{ {
Mat v = evec.row(i).t(); Mat v = evec.row(i).t();
Mat Qv = Q * v; Mat Qv = Q * v;
Mat lv = eval.at<float>(i,0) * v; Mat lv = eval.at<float>(i,0) * v;
err = norm( Qv, lv ); err = norm( Qv, lv );
if( err > eigenEps ) if( err > eigenEps )
@ -370,7 +370,7 @@ protected:
absdiff(rPCA.eigenvectors, subEvec, tmp); absdiff(rPCA.eigenvectors, subEvec, tmp);
double mval = 0; Point mloc; double mval = 0; Point mloc;
minMaxLoc(tmp, 0, &mval, 0, &mloc); minMaxLoc(tmp, 0, &mval, 0, &mloc);
ts->printf( cvtest::TS::LOG, "pca.eigenvectors is incorrect (CV_PCA_DATA_AS_ROW); err = %f\n", err ); ts->printf( cvtest::TS::LOG, "pca.eigenvectors is incorrect (CV_PCA_DATA_AS_ROW); err = %f\n", err );
ts->printf( cvtest::TS::LOG, "max diff is %g at (i=%d, j=%d) (%g vs %g)\n", ts->printf( cvtest::TS::LOG, "max diff is %g at (i=%d, j=%d) (%g vs %g)\n",
mval, mloc.y, mloc.x, rPCA.eigenvectors.at<float>(mloc.y, mloc.x), mval, mloc.y, mloc.x, rPCA.eigenvectors.at<float>(mloc.y, mloc.x),
@ -380,7 +380,7 @@ protected:
} }
} }
} }
prjEps = 1.265, backPrjEps = 1.265; prjEps = 1.265, backPrjEps = 1.265;
for( int i = 0; i < rTestPoints.rows; i++ ) for( int i = 0; i < rTestPoints.rows; i++ )
{ {
@ -404,7 +404,7 @@ protected:
return; return;
} }
} }
// 2. check C++ PCA & COL // 2. check C++ PCA & COL
cPCA( rPoints.t(), Mat(), CV_PCA_DATA_AS_COL, maxComponents ); cPCA( rPoints.t(), Mat(), CV_PCA_DATA_AS_COL, maxComponents );
diffPrjEps = 1, diffBackPrjEps = 1; diffPrjEps = 1, diffBackPrjEps = 1;
@ -423,7 +423,7 @@ protected:
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY ); ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return; return;
} }
#ifdef CHECK_C #ifdef CHECK_C
// 3. check C PCA & ROW // 3. check C PCA & ROW
_points = rPoints; _points = rPoints;
@ -435,11 +435,11 @@ protected:
backPrjTestPoints.create(rPoints.size(), rPoints.type() ); backPrjTestPoints.create(rPoints.size(), rPoints.type() );
_prjTestPoints = prjTestPoints; _prjTestPoints = prjTestPoints;
_backPrjTestPoints = backPrjTestPoints; _backPrjTestPoints = backPrjTestPoints;
cvCalcPCA( &_points, &_avg, &_eval, &_evec, CV_PCA_DATA_AS_ROW ); cvCalcPCA( &_points, &_avg, &_eval, &_evec, CV_PCA_DATA_AS_ROW );
cvProjectPCA( &_testPoints, &_avg, &_evec, &_prjTestPoints ); cvProjectPCA( &_testPoints, &_avg, &_evec, &_prjTestPoints );
cvBackProjectPCA( &_prjTestPoints, &_avg, &_evec, &_backPrjTestPoints ); cvBackProjectPCA( &_prjTestPoints, &_avg, &_evec, &_backPrjTestPoints );
err = norm(prjTestPoints, rPrjTestPoints, CV_RELATIVE_L2); err = norm(prjTestPoints, rPrjTestPoints, CV_RELATIVE_L2);
if( err > diffPrjEps ) if( err > diffPrjEps )
{ {
@ -454,7 +454,7 @@ protected:
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY ); ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return; return;
} }
// 3. check C PCA & COL // 3. check C PCA & COL
_points = cPoints; _points = cPoints;
_testPoints = cTestPoints; _testPoints = cTestPoints;
@ -463,11 +463,11 @@ protected:
evec = evec.t(); _evec = evec; evec = evec.t(); _evec = evec;
prjTestPoints = prjTestPoints.t(); _prjTestPoints = prjTestPoints; prjTestPoints = prjTestPoints.t(); _prjTestPoints = prjTestPoints;
backPrjTestPoints = backPrjTestPoints.t(); _backPrjTestPoints = backPrjTestPoints; backPrjTestPoints = backPrjTestPoints.t(); _backPrjTestPoints = backPrjTestPoints;
cvCalcPCA( &_points, &_avg, &_eval, &_evec, CV_PCA_DATA_AS_COL ); cvCalcPCA( &_points, &_avg, &_eval, &_evec, CV_PCA_DATA_AS_COL );
cvProjectPCA( &_testPoints, &_avg, &_evec, &_prjTestPoints ); cvProjectPCA( &_testPoints, &_avg, &_evec, &_prjTestPoints );
cvBackProjectPCA( &_prjTestPoints, &_avg, &_evec, &_backPrjTestPoints ); cvBackProjectPCA( &_prjTestPoints, &_avg, &_evec, &_backPrjTestPoints );
err = norm(cv::abs(prjTestPoints), cv::abs(rPrjTestPoints.t()), CV_RELATIVE_L2 ); err = norm(cv::abs(prjTestPoints), cv::abs(rPrjTestPoints.t()), CV_RELATIVE_L2 );
if( err > diffPrjEps ) if( err > diffPrjEps )
{ {
@ -490,9 +490,9 @@ class Core_ArrayOpTest : public cvtest::BaseTest
{ {
public: public:
Core_ArrayOpTest(); Core_ArrayOpTest();
~Core_ArrayOpTest(); ~Core_ArrayOpTest();
protected: protected:
void run(int); void run(int);
}; };
@ -536,7 +536,7 @@ static double getValue(SparseMat& M, const int* idx, RNG& rng)
d == 3 ? M.hash(idx[0], idx[1], idx[2]) : M.hash(idx); d == 3 ? M.hash(idx[0], idx[1], idx[2]) : M.hash(idx);
phv = &hv; phv = &hv;
} }
const uchar* ptr = d == 2 ? M.ptr(idx[0], idx[1], false, phv) : const uchar* ptr = d == 2 ? M.ptr(idx[0], idx[1], false, phv) :
d == 3 ? M.ptr(idx[0], idx[1], idx[2], false, phv) : d == 3 ? M.ptr(idx[0], idx[1], idx[2], false, phv) :
M.ptr(idx, false, phv); M.ptr(idx, false, phv);
@ -560,7 +560,7 @@ static void eraseValue(SparseMat& M, const int* idx, RNG& rng)
d == 3 ? M.hash(idx[0], idx[1], idx[2]) : M.hash(idx); d == 3 ? M.hash(idx[0], idx[1], idx[2]) : M.hash(idx);
phv = &hv; phv = &hv;
} }
if( d == 2 ) if( d == 2 )
M.erase(idx[0], idx[1], phv); M.erase(idx[0], idx[1], phv);
else if( d == 3 ) else if( d == 3 )
@ -584,7 +584,7 @@ static void setValue(SparseMat& M, const int* idx, double value, RNG& rng)
d == 3 ? M.hash(idx[0], idx[1], idx[2]) : M.hash(idx); d == 3 ? M.hash(idx[0], idx[1], idx[2]) : M.hash(idx);
phv = &hv; phv = &hv;
} }
uchar* ptr = d == 2 ? M.ptr(idx[0], idx[1], true, phv) : uchar* ptr = d == 2 ? M.ptr(idx[0], idx[1], true, phv) :
d == 3 ? M.ptr(idx[0], idx[1], idx[2], true, phv) : d == 3 ? M.ptr(idx[0], idx[1], idx[2], true, phv) :
M.ptr(idx, true, phv); M.ptr(idx, true, phv);
@ -599,7 +599,7 @@ static void setValue(SparseMat& M, const int* idx, double value, RNG& rng)
void Core_ArrayOpTest::run( int /* start_from */) void Core_ArrayOpTest::run( int /* start_from */)
{ {
int errcount = 0; int errcount = 0;
// dense matrix operations // dense matrix operations
{ {
int sz3[] = {5, 10, 15}; int sz3[] = {5, 10, 15};
@ -608,7 +608,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
RNG rng; RNG rng;
rng.fill(A, CV_RAND_UNI, Scalar::all(-10), Scalar::all(10)); rng.fill(A, CV_RAND_UNI, Scalar::all(-10), Scalar::all(10));
rng.fill(B, CV_RAND_UNI, Scalar::all(-10), Scalar::all(10)); rng.fill(B, CV_RAND_UNI, Scalar::all(-10), Scalar::all(10));
int idx0[] = {3,4,5}, idx1[] = {0, 9, 7}; int idx0[] = {3,4,5}, idx1[] = {0, 9, 7};
float val0 = 130; float val0 = 130;
Scalar val1(-1000, 30, 3, 8); Scalar val1(-1000, 30, 3, 8);
@ -617,12 +617,12 @@ void Core_ArrayOpTest::run( int /* start_from */)
cvSetND(&matB, idx0, val1); cvSetND(&matB, idx0, val1);
cvSet3D(&matB, idx1[0], idx1[1], idx1[2], -val1); cvSet3D(&matB, idx1[0], idx1[1], idx1[2], -val1);
Ptr<CvMatND> matC = cvCloneMatND(&matB); Ptr<CvMatND> matC = cvCloneMatND(&matB);
if( A.at<float>(idx0[0], idx0[1], idx0[2]) != val0 || if( A.at<float>(idx0[0], idx0[1], idx0[2]) != val0 ||
A.at<float>(idx1[0], idx1[1], idx1[2]) != -val0 || A.at<float>(idx1[0], idx1[1], idx1[2]) != -val0 ||
cvGetReal3D(&matA, idx0[0], idx0[1], idx0[2]) != val0 || cvGetReal3D(&matA, idx0[0], idx0[1], idx0[2]) != val0 ||
cvGetRealND(&matA, idx1) != -val0 || cvGetRealND(&matA, idx1) != -val0 ||
Scalar(B.at<Vec4s>(idx0[0], idx0[1], idx0[2])) != val1 || Scalar(B.at<Vec4s>(idx0[0], idx0[1], idx0[2])) != val1 ||
Scalar(B.at<Vec4s>(idx1[0], idx1[1], idx1[2])) != -val1 || Scalar(B.at<Vec4s>(idx1[0], idx1[1], idx1[2])) != -val1 ||
Scalar(cvGet3D(matC, idx0[0], idx0[1], idx0[2])) != val1 || Scalar(cvGet3D(matC, idx0[0], idx0[1], idx0[2])) != val1 ||
@ -633,7 +633,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
errcount++; errcount++;
} }
} }
RNG rng; RNG rng;
const int MAX_DIM = 5, MAX_DIM_SZ = 10; const int MAX_DIM = 5, MAX_DIM_SZ = 10;
// sparse matrix operations // sparse matrix operations
@ -647,7 +647,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
vector<double> all_vals2; vector<double> all_vals2;
string sidx, min_sidx, max_sidx; string sidx, min_sidx, max_sidx;
double min_val=0, max_val=0; double min_val=0, max_val=0;
int p = 1; int p = 1;
for( k = 0; k < dims; k++ ) for( k = 0; k < dims; k++ )
{ {
@ -656,7 +656,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
} }
SparseMat M( dims, size, depth ); SparseMat M( dims, size, depth );
map<string, double> M0; map<string, double> M0;
int nz0 = (unsigned)rng % max(p/5,10); int nz0 = (unsigned)rng % max(p/5,10);
nz0 = min(max(nz0, 1), p); nz0 = min(max(nz0, 1), p);
all_vals.resize(nz0); all_vals.resize(nz0);
@ -676,12 +676,12 @@ void Core_ArrayOpTest::run( int /* start_from */)
_all_vals2.convertTo(_all_vals2_f, CV_32F); _all_vals2.convertTo(_all_vals2_f, CV_32F);
_all_vals2_f.convertTo(_all_vals2, CV_64F); _all_vals2_f.convertTo(_all_vals2, CV_64F);
} }
minMaxLoc(_all_vals, &min_val, &max_val); minMaxLoc(_all_vals, &min_val, &max_val);
double _norm0 = norm(_all_vals, CV_C); double _norm0 = norm(_all_vals, CV_C);
double _norm1 = norm(_all_vals, CV_L1); double _norm1 = norm(_all_vals, CV_L1);
double _norm2 = norm(_all_vals, CV_L2); double _norm2 = norm(_all_vals, CV_L2);
for( i = 0; i < nz0; i++ ) for( i = 0; i < nz0; i++ )
{ {
for(;;) for(;;)
@ -708,18 +708,18 @@ void Core_ArrayOpTest::run( int /* start_from */)
break; break;
} }
} }
Ptr<CvSparseMat> M2 = (CvSparseMat*)M; Ptr<CvSparseMat> M2 = (CvSparseMat*)M;
MatND Md; MatND Md;
M.copyTo(Md); M.copyTo(Md);
SparseMat M3; SparseMat(Md).convertTo(M3, Md.type(), 2); SparseMat M3; SparseMat(Md).convertTo(M3, Md.type(), 2);
int nz1 = (int)M.nzcount(), nz2 = (int)M3.nzcount(); int nz1 = (int)M.nzcount(), nz2 = (int)M3.nzcount();
double norm0 = norm(M, CV_C); double norm0 = norm(M, CV_C);
double norm1 = norm(M, CV_L1); double norm1 = norm(M, CV_L1);
double norm2 = norm(M, CV_L2); double norm2 = norm(M, CV_L2);
double eps = depth == CV_32F ? FLT_EPSILON*100 : DBL_EPSILON*1000; double eps = depth == CV_32F ? FLT_EPSILON*100 : DBL_EPSILON*1000;
if( nz1 != nz0 || nz2 != nz0) if( nz1 != nz0 || nz2 != nz0)
{ {
errcount++; errcount++;
@ -727,7 +727,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
si, nz1, nz2, nz0 ); si, nz1, nz2, nz0 );
break; break;
} }
if( fabs(norm0 - _norm0) > fabs(_norm0)*eps || if( fabs(norm0 - _norm0) > fabs(_norm0)*eps ||
fabs(norm1 - _norm1) > fabs(_norm1)*eps || fabs(norm1 - _norm1) > fabs(_norm1)*eps ||
fabs(norm2 - _norm2) > fabs(_norm2)*eps ) fabs(norm2 - _norm2) > fabs(_norm2)*eps )
@ -737,10 +737,10 @@ void Core_ArrayOpTest::run( int /* start_from */)
si, norm0, norm1, norm2, _norm0, _norm1, _norm2 ); si, norm0, norm1, norm2, _norm0, _norm1, _norm2 );
break; break;
} }
int n = (unsigned)rng % max(p/5,10); int n = (unsigned)rng % max(p/5,10);
n = min(max(n, 1), p) + nz0; n = min(max(n, 1), p) + nz0;
for( i = 0; i < n; i++ ) for( i = 0; i < n; i++ )
{ {
double val1, val2, val3, val0; double val1, val2, val3, val0;
@ -760,7 +760,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
val1 = getValue(M, idx, rng); val1 = getValue(M, idx, rng);
val2 = getValue(M2, idx); val2 = getValue(M2, idx);
val3 = getValue(M3, idx, rng); val3 = getValue(M3, idx, rng);
if( val1 != val0 || val2 != val0 || fabs(val3 - val0*2) > fabs(val0*2)*FLT_EPSILON ) if( val1 != val0 || val2 != val0 || fabs(val3 - val0*2) > fabs(val0*2)*FLT_EPSILON )
{ {
errcount++; errcount++;
@ -768,7 +768,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
break; break;
} }
} }
for( i = 0; i < n; i++ ) for( i = 0; i < n; i++ )
{ {
double val1, val2; double val1, val2;
@ -792,9 +792,9 @@ void Core_ArrayOpTest::run( int /* start_from */)
errcount++; errcount++;
ts->printf(cvtest::TS::LOG, "SparseMat: after deleting M[%s], it is =%g/%g (while it should be 0)\n", sidx.c_str(), val1, val2 ); ts->printf(cvtest::TS::LOG, "SparseMat: after deleting M[%s], it is =%g/%g (while it should be 0)\n", sidx.c_str(), val1, val2 );
break; break;
} }
} }
int nz = (int)M.nzcount(); int nz = (int)M.nzcount();
if( nz != 0 ) if( nz != 0 )
{ {
@ -802,7 +802,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
ts->printf(cvtest::TS::LOG, "The number of non-zero elements after removing all the elements = %d (while it should be 0)\n", nz ); ts->printf(cvtest::TS::LOG, "The number of non-zero elements after removing all the elements = %d (while it should be 0)\n", nz );
break; break;
} }
int idx1[MAX_DIM], idx2[MAX_DIM]; int idx1[MAX_DIM], idx2[MAX_DIM];
double val1 = 0, val2 = 0; double val1 = 0, val2 = 0;
M3 = SparseMat(Md); M3 = SparseMat(Md);
@ -816,7 +816,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
min_val, max_val, min_sidx.c_str(), max_sidx.c_str()); min_val, max_val, min_sidx.c_str(), max_sidx.c_str());
break; break;
} }
minMaxIdx(Md, &val1, &val2, idx1, idx2); minMaxIdx(Md, &val1, &val2, idx1, idx2);
s1 = idx2string(idx1, dims), s2 = idx2string(idx2, dims); s1 = idx2string(idx1, dims), s2 = idx2string(idx2, dims);
if( (min_val < 0 && (val1 != min_val || s1 != min_sidx)) || if( (min_val < 0 && (val1 != min_val || s1 != min_sidx)) ||
@ -829,7 +829,7 @@ void Core_ArrayOpTest::run( int /* start_from */)
break; break;
} }
} }
ts->set_failed_test_info(errcount == 0 ? cvtest::TS::OK : cvtest::TS::FAIL_INVALID_OUTPUT); ts->set_failed_test_info(errcount == 0 ? cvtest::TS::OK : cvtest::TS::FAIL_INVALID_OUTPUT);
} }

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

@ -27,7 +27,7 @@ static double chi2_p95(int n)
36.42f, 37.65f, 38.89f, 40.11f, 41.34f, 42.56f, 43.77f }; 36.42f, 37.65f, 38.89f, 40.11f, 41.34f, 42.56f, 43.77f };
static const double xp = 1.64; static const double xp = 1.64;
CV_Assert(n >= 1); CV_Assert(n >= 1);
if( n <= 30 ) if( n <= 30 )
return chi2_tab95[n-1]; return chi2_tab95[n-1];
return n + sqrt((double)2*n)*xp + 0.6666666666666*(xp*xp - 1); return n + sqrt((double)2*n)*xp + 0.6666666666666*(xp*xp - 1);
@ -40,12 +40,12 @@ bool Core_RandTest::check_pdf(const Mat& hist, double scale,
const int* H = (const int*)hist.data; const int* H = (const int*)hist.data;
float* H0 = ((float*)hist0.data); float* H0 = ((float*)hist0.data);
int i, hsz = hist.cols; int i, hsz = hist.cols;
double sum = 0; double sum = 0;
for( i = 0; i < hsz; i++ ) for( i = 0; i < hsz; i++ )
sum += H[i]; sum += H[i];
CV_Assert( fabs(1./sum - scale) < FLT_EPSILON ); CV_Assert( fabs(1./sum - scale) < FLT_EPSILON );
if( dist_type == CV_RAND_UNI ) if( dist_type == CV_RAND_UNI )
{ {
float scale0 = (float)(1./hsz); float scale0 = (float)(1./hsz);
@ -54,19 +54,19 @@ 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;
for( i = 0; i < hsz; i++ ) for( i = 0; i < hsz; i++ )
{ {
@ -76,7 +76,7 @@ bool Core_RandTest::check_pdf(const Mat& hist, double scale,
chi2 += (a - b)*(a - b)/(a + b); chi2 += (a - b)*(a - b)/(a + b);
} }
realval = chi2; realval = chi2;
double chi2_pval = chi2_p95(hsz - 1 - (dist_type == CV_RAND_NORMAL ? 2 : 0)); double chi2_pval = chi2_p95(hsz - 1 - (dist_type == CV_RAND_NORMAL ? 2 : 0));
refval = chi2_pval*0.01; refval = chi2_pval*0.01;
return realval <= refval; return realval <= refval;
@ -87,22 +87,22 @@ void Core_RandTest::run( int )
static int _ranges[][2] = static int _ranges[][2] =
{{ 0, 256 }, { -128, 128 }, { 0, 65536 }, { -32768, 32768 }, {{ 0, 256 }, { -128, 128 }, { 0, 65536 }, { -32768, 32768 },
{ -1000000, 1000000 }, { -1000, 1000 }, { -1000, 1000 }}; { -1000000, 1000000 }, { -1000, 1000 }, { -1000, 1000 }};
const int MAX_SDIM = 10; const int MAX_SDIM = 10;
const int N = 2000000; const int N = 2000000;
const int maxSlice = 1000; const int maxSlice = 1000;
const int MAX_HIST_SIZE = 1000; const int MAX_HIST_SIZE = 1000;
int progress = 0; int progress = 0;
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
RNG tested_rng = theRNG(); RNG tested_rng = theRNG();
test_case_count = 200; test_case_count = 200;
for( int idx = 0; idx < test_case_count; idx++ ) for( int idx = 0; idx < test_case_count; idx++ )
{ {
progress = update_progress( progress, idx, test_case_count, 0 ); progress = update_progress( progress, idx, test_case_count, 0 );
ts->update_context( this, idx, false ); ts->update_context( this, idx, false );
int depth = cvtest::randInt(rng) % (CV_64F+1); int depth = cvtest::randInt(rng) % (CV_64F+1);
int c, cn = (cvtest::randInt(rng) % 4) + 1; int c, cn = (cvtest::randInt(rng) % 4) + 1;
int type = CV_MAKETYPE(depth, cn); int type = CV_MAKETYPE(depth, cn);
@ -113,15 +113,15 @@ void Core_RandTest::run( int )
double eps = 1.e-4; double eps = 1.e-4;
if (depth == CV_64F) if (depth == CV_64F)
eps = 1.e-7; eps = 1.e-7;
bool do_sphere_test = dist_type == CV_RAND_UNI; bool do_sphere_test = dist_type == CV_RAND_UNI;
Mat arr[2], hist[4]; Mat arr[2], hist[4];
int W[] = {0,0,0,0}; int W[] = {0,0,0,0};
arr[0].create(1, SZ, type); arr[0].create(1, SZ, type);
arr[1].create(1, SZ, type); arr[1].create(1, SZ, type);
bool fast_algo = dist_type == CV_RAND_UNI && depth < CV_32F; bool fast_algo = dist_type == CV_RAND_UNI && depth < CV_32F;
for( c = 0; c < cn; c++ ) for( c = 0; c < cn; c++ )
{ {
int a, b, hsz; int a, b, hsz;
@ -137,7 +137,7 @@ void Core_RandTest::run( int )
while( abs(a-b) <= 1 ); while( abs(a-b) <= 1 );
if( a > b ) if( a > b )
std::swap(a, b); std::swap(a, b);
unsigned r = (unsigned)(b - a); unsigned r = (unsigned)(b - a);
fast_algo = fast_algo && r <= 256 && (r & (r-1)) == 0; fast_algo = fast_algo && r <= 256 && (r & (r-1)) == 0;
hsz = min((unsigned)(b - a), (unsigned)MAX_HIST_SIZE); hsz = min((unsigned)(b - a), (unsigned)MAX_HIST_SIZE);
@ -149,7 +149,7 @@ void Core_RandTest::run( int )
int meanrange = vrange/16; int meanrange = vrange/16;
int mindiv = MAX(vrange/20, 5); int mindiv = MAX(vrange/20, 5);
int maxdiv = MIN(vrange/8, 10000); int maxdiv = MIN(vrange/8, 10000);
a = cvtest::randInt(rng) % meanrange - meanrange/2 + a = cvtest::randInt(rng) % meanrange - meanrange/2 +
(_ranges[depth][0] + _ranges[depth][1])/2; (_ranges[depth][0] + _ranges[depth][1])/2;
b = cvtest::randInt(rng) % (maxdiv - mindiv) + mindiv; b = cvtest::randInt(rng) % (maxdiv - mindiv) + mindiv;
@ -157,9 +157,9 @@ void Core_RandTest::run( int )
} }
A[c] = a; A[c] = a;
B[c] = b; B[c] = b;
hist[c].create(1, hsz, CV_32S); hist[c].create(1, hsz, CV_32S);
} }
cv::RNG saved_rng = tested_rng; cv::RNG saved_rng = tested_rng;
int maxk = fast_algo ? 0 : 1; int maxk = fast_algo ? 0 : 1;
for( k = 0; k <= maxk; k++ ) for( k = 0; k <= maxk; k++ )
@ -173,14 +173,14 @@ void Core_RandTest::run( int )
tested_rng.fill(aslice, dist_type, A, B); tested_rng.fill(aslice, dist_type, A, B);
} }
} }
if( maxk >= 1 && norm(arr[0], arr[1], NORM_INF) > eps) if( maxk >= 1 && norm(arr[0], arr[1], NORM_INF) > eps)
{ {
ts->printf( cvtest::TS::LOG, "RNG output depends on the array lengths (some generated numbers get lost?)" ); ts->printf( cvtest::TS::LOG, "RNG output depends on the array lengths (some generated numbers get lost?)" );
ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT ); ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_OUTPUT );
return; return;
} }
for( c = 0; c < cn; c++ ) for( c = 0; c < cn; c++ )
{ {
const uchar* data = arr[0].data; const uchar* data = arr[0].data;
@ -190,9 +190,9 @@ void Core_RandTest::run( int )
double maxVal = dist_type == CV_RAND_UNI ? B[c] : A[c] + B[c]*4; double maxVal = dist_type == CV_RAND_UNI ? B[c] : A[c] + B[c]*4;
double scale = HSZ/(maxVal - minVal); double scale = HSZ/(maxVal - minVal);
double delta = -minVal*scale; double delta = -minVal*scale;
hist[c] = Scalar::all(0); hist[c] = Scalar::all(0);
for( i = c; i < SZ*cn; i += cn ) for( i = c; i < SZ*cn; i += cn )
{ {
double val = depth == CV_8U ? ((const uchar*)data)[i] : double val = depth == CV_8U ? ((const uchar*)data)[i] :
@ -221,7 +221,7 @@ void Core_RandTest::run( int )
} }
} }
} }
if( dist_type == CV_RAND_UNI && W[c] != SZ ) if( dist_type == CV_RAND_UNI && W[c] != SZ )
{ {
ts->printf( cvtest::TS::LOG, "Uniform RNG gave values out of the range [%g,%g) on channel %d/%d\n", ts->printf( cvtest::TS::LOG, "Uniform RNG gave values out of the range [%g,%g) on channel %d/%d\n",
@ -237,7 +237,7 @@ void Core_RandTest::run( int )
return; return;
} }
double refval = 0, realval = 0; double refval = 0, realval = 0;
if( !check_pdf(hist[c], 1./W[c], dist_type, refval, realval) ) if( !check_pdf(hist[c], 1./W[c], dist_type, refval, realval) )
{ {
ts->printf( cvtest::TS::LOG, "RNG failed Chi-square test " ts->printf( cvtest::TS::LOG, "RNG failed Chi-square test "
@ -247,13 +247,13 @@ void Core_RandTest::run( int )
return; return;
} }
} }
// Monte-Carlo test. Compute volume of SDIM-dimensional sphere // Monte-Carlo test. Compute volume of SDIM-dimensional sphere
// inscribed in [-1,1]^SDIM cube. // inscribed in [-1,1]^SDIM cube.
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];
@ -262,7 +262,7 @@ void Core_RandTest::run( int )
scale[c] = 2./(B[c] - A[c]); scale[c] = 2./(B[c] - A[c]);
delta[c] = -A[c]*scale[c] - 1; delta[c] = -A[c]*scale[c] - 1;
} }
for( i = k = c = 0; i <= SZ*cn - SDIM; i++, k++, c++ ) for( i = k = c = 0; i <= SZ*cn - SDIM; i++, k++, c++ )
{ {
double val = depth == CV_8U ? ((const uchar*)data)[i] : double val = depth == CV_8U ? ((const uchar*)data)[i] :
@ -276,20 +276,20 @@ 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;
double V0 = sdim + 1; double V0 = sdim + 1;
for( sdim += 2; sdim <= SDIM; sdim += 2 ) for( sdim += 2; sdim <= SDIM; sdim += 2 )
V0 *= 2*CV_PI/sdim; V0 *= 2*CV_PI/sdim;
if( fabs(V - V0) > 0.3*fabs(V0) ) if( fabs(V - V0) > 0.3*fabs(V0) )
{ {
ts->printf( cvtest::TS::LOG, "RNG failed %d-dim sphere volume test (got %g instead of %g)\n", ts->printf( cvtest::TS::LOG, "RNG failed %d-dim sphere volume test (got %g instead of %g)\n",
@ -309,7 +309,7 @@ class Core_RandRangeTest : public cvtest::BaseTest
{ {
public: public:
Core_RandRangeTest() {} Core_RandRangeTest() {}
~Core_RandRangeTest() {} ~Core_RandRangeTest() {}
protected: protected:
void run(int) void run(int)
{ {
@ -319,7 +319,7 @@ protected:
theRNG().fill(af, RNG::UNIFORM, -DBL_MAX, DBL_MAX); theRNG().fill(af, RNG::UNIFORM, -DBL_MAX, DBL_MAX);
int n0 = 0, n255 = 0, nx = 0; int n0 = 0, n255 = 0, nx = 0;
int nfmin = 0, nfmax = 0, nfx = 0; int nfmin = 0, nfmax = 0, nfx = 0;
for( int i = 0; i < a.rows; i++ ) for( int i = 0; i < a.rows; i++ )
for( int j = 0; j < a.cols; j++ ) for( int j = 0; j < a.cols; j++ )
{ {

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]++;
} }

14
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 );
} }
} }
@ -178,9 +178,9 @@ static inline void _drawMatch( Mat& outImg, Mat& outImg1, Mat& outImg2 ,
pt2 = kp2.pt, pt2 = kp2.pt,
dpt2 = Point2f( std::min(pt2.x+outImg1.cols, float(outImg.cols-1)), pt2.y ); dpt2 = Point2f( std::min(pt2.x+outImg1.cols, float(outImg.cols-1)), pt2.y );
line( outImg, line( outImg,
Point(cvRound(pt1.x*draw_multiplier), cvRound(pt1.y*draw_multiplier)), Point(cvRound(pt1.x*draw_multiplier), cvRound(pt1.y*draw_multiplier)),
Point(cvRound(dpt2.x*draw_multiplier), cvRound(dpt2.y*draw_multiplier)), Point(cvRound(dpt2.x*draw_multiplier), cvRound(dpt2.y*draw_multiplier)),
color, 1, CV_AA, draw_shift_bits ); color, 1, CV_AA, draw_shift_bits );
} }

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];

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

@ -48,13 +48,13 @@ static void
computeIntegralImages( const Mat& matI, Mat& matS, Mat& matT, Mat& _FT ) computeIntegralImages( const Mat& matI, Mat& matS, Mat& matT, Mat& _FT )
{ {
CV_Assert( matI.type() == CV_8U ); CV_Assert( matI.type() == CV_8U );
int x, y, rows = matI.rows, cols = matI.cols; int x, y, rows = matI.rows, cols = matI.cols;
matS.create(rows + 1, cols + 1, CV_32S); matS.create(rows + 1, cols + 1, CV_32S);
matT.create(rows + 1, cols + 1, CV_32S); matT.create(rows + 1, cols + 1, CV_32S);
_FT.create(rows + 1, cols + 1, CV_32S); _FT.create(rows + 1, cols + 1, CV_32S);
const uchar* I = matI.ptr<uchar>(); const uchar* I = matI.ptr<uchar>();
int *S = matS.ptr<int>(), *T = matT.ptr<int>(), *FT = _FT.ptr<int>(); int *S = matS.ptr<int>(), *T = matT.ptr<int>(), *FT = _FT.ptr<int>();
int istep = (int)matI.step, step = (int)(matS.step/sizeof(S[0])); int istep = (int)matI.step, step = (int)(matS.step/sizeof(S[0]));
@ -121,29 +121,28 @@ 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 );
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,24 +168,24 @@ 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;
invSizes[i][0] = 1.f/outerArea; invSizes[i][0] = 1.f/outerArea;
invSizes[i][1] = 1.f/innerArea; invSizes[i][1] = 1.f/innerArea;
} }
#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
@ -197,7 +196,7 @@ StarDetectorComputeResponses( const Mat& img, Mat& responses, Mat& sizes, int ma
float* r_ptr2 = responses.ptr<float>(rows - 1 - y); float* r_ptr2 = responses.ptr<float>(rows - 1 - y);
short* s_ptr = sizes.ptr<short>(y); short* s_ptr = sizes.ptr<short>(y);
short* s_ptr2 = sizes.ptr<short>(rows - 1 - y); short* s_ptr2 = sizes.ptr<short>(rows - 1 - y);
memset( r_ptr, 0, cols*sizeof(r_ptr[0])); memset( r_ptr, 0, cols*sizeof(r_ptr[0]));
memset( r_ptr2, 0, cols*sizeof(r_ptr2[0])); memset( r_ptr2, 0, cols*sizeof(r_ptr2[0]));
memset( s_ptr, 0, cols*sizeof(s_ptr[0])); memset( s_ptr, 0, cols*sizeof(s_ptr[0]));
@ -206,10 +205,10 @@ 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);
memset( r_ptr, 0, border*sizeof(r_ptr[0])); memset( r_ptr, 0, border*sizeof(r_ptr[0]));
memset( s_ptr, 0, border*sizeof(s_ptr[0])); memset( s_ptr, 0, border*sizeof(s_ptr[0]));
memset( r_ptr + cols - border, 0, border*sizeof(r_ptr[0])); memset( r_ptr + cols - border, 0, border*sizeof(r_ptr[0]));
@ -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);
@ -260,7 +259,7 @@ StarDetectorComputeResponses( const Mat& img, Mat& responses, Mat& sizes, int ma
_mm_packs_epi32(_mm_cvtps_epi32(bestSize),_mm_setzero_si128())); _mm_packs_epi32(_mm_cvtps_epi32(bestSize),_mm_setzero_si128()));
} }
} }
#endif #endif
for( ; x < cols - border; x++ ) for( ; x < cols - border; x++ )
{ {
int ofs = y*step + x; int ofs = y*step + x;
@ -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;
@ -306,7 +305,7 @@ static bool StarDetectorSuppressLines( const Mat& responses, const Mat& sizes, P
int x, y, delta = sz/4, radius = delta*4; int x, y, delta = sz/4, radius = delta*4;
float Lxx = 0, Lyy = 0, Lxy = 0; float Lxx = 0, Lyy = 0, Lxy = 0;
int Lxxb = 0, Lyyb = 0, Lxyb = 0; int Lxxb = 0, Lyyb = 0, Lxyb = 0;
for( y = pt.y - radius; y <= pt.y + radius; y += delta ) for( y = pt.y - radius; y <= pt.y + radius; y += delta )
for( x = pt.x - radius; x <= pt.x + radius; x += delta ) for( x = pt.x - radius; x <= pt.x + radius; x += delta )
{ {
@ -314,7 +313,7 @@ static bool StarDetectorSuppressLines( const Mat& responses, const Mat& sizes, P
float Ly = r_ptr[(y+1)*rstep + x] - r_ptr[(y-1)*rstep + x]; float Ly = r_ptr[(y+1)*rstep + x] - r_ptr[(y-1)*rstep + x];
Lxx += Lx*Lx; Lyy += Ly*Ly; Lxy += Lx*Ly; Lxx += Lx*Lx; Lyy += Ly*Ly; Lxy += Lx*Ly;
} }
if( (Lxx + Lyy)*(Lxx + Lyy) >= lineThresholdProjected*(Lxx*Lyy - Lxy*Lxy) ) if( (Lxx + Lyy)*(Lxx + Lyy) >= lineThresholdProjected*(Lxx*Lyy - Lxy*Lxy) )
return true; return true;
@ -415,7 +414,7 @@ StarDetectorSuppressNonmax( const Mat& responses, const Mat& sizes,
; ;
} }
} }
StarDetector::StarDetector(int _maxSize, int _responseThreshold, StarDetector::StarDetector(int _maxSize, int _responseThreshold,
int _lineThresholdProjected, int _lineThresholdProjected,
int _lineThresholdBinarized, int _lineThresholdBinarized,
@ -431,10 +430,10 @@ void StarDetector::detectImpl( const Mat& image, vector<KeyPoint>& keypoints, co
{ {
Mat grayImage = image; Mat grayImage = image;
if( image.type() != CV_8U ) cvtColor( image, grayImage, CV_BGR2GRAY ); if( image.type() != CV_8U ) cvtColor( image, grayImage, CV_BGR2GRAY );
(*this)(grayImage, keypoints); (*this)(grayImage, keypoints);
KeyPointsFilter::runByPixelsMask( keypoints, mask ); KeyPointsFilter::runByPixelsMask( keypoints, mask );
} }
void StarDetector::operator()(const Mat& img, vector<KeyPoint>& keypoints) const void StarDetector::operator()(const Mat& img, vector<KeyPoint>& keypoints) const
{ {
@ -446,5 +445,5 @@ void StarDetector::operator()(const Mat& img, vector<KeyPoint>& keypoints) const
responseThreshold, lineThresholdProjected, responseThreshold, lineThresholdProjected,
lineThresholdBinarized, suppressNonmaxSize ); lineThresholdBinarized, suppressNonmaxSize );
} }
} }

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)

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

@ -283,7 +283,7 @@ void CvCapture_GStreamer::newPad(GstElement *uridecodebin,
sinkpad = gst_element_get_static_pad (color, "sink"); sinkpad = gst_element_get_static_pad (color, "sink");
// printf("linking dynamic pad to colourconverter %p %p\n", uridecodebin, pad); // printf("linking dynamic pad to colourconverter %p %p\n", uridecodebin, pad);
gst_pad_link (pad, sinkpad); gst_pad_link (pad, sinkpad);
@ -357,13 +357,13 @@ bool CvCapture_GStreamer::open( int type, const char* filename )
if(manualpipeline) { if(manualpipeline) {
GstIterator *it = gst_bin_iterate_sinks(GST_BIN(uridecodebin)); GstIterator *it = gst_bin_iterate_sinks(GST_BIN(uridecodebin));
if(gst_iterator_next(it, (gpointer *)&sink) != GST_ITERATOR_OK) { if(gst_iterator_next(it, (gpointer *)&sink) != GST_ITERATOR_OK) {
CV_ERROR(CV_StsError, "GStreamer: cannot find appsink in manual pipeline\n"); CV_ERROR(CV_StsError, "GStreamer: cannot find appsink in manual pipeline\n");
return false; return false;
} }
pipeline = uridecodebin; pipeline = uridecodebin;
} else { } else {
pipeline = gst_pipeline_new (NULL); pipeline = gst_pipeline_new (NULL);
color = gst_element_factory_make("ffmpegcolorspace", NULL); color = gst_element_factory_make("ffmpegcolorspace", NULL);
sink = gst_element_factory_make("appsink", NULL); sink = gst_element_factory_make("appsink", NULL);
@ -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; "red_mask", G_TYPE_INT, 0x0000FF,
caps = gst_caps_new_simple("video/x-raw-rgb", "green_mask", G_TYPE_INT, 0x00FF00,
"red_mask", G_TYPE_INT, 0x0000FF, "blue_mask", G_TYPE_INT, 0xFF0000,
"green_mask", G_TYPE_INT, 0x00FF00, NULL));
"blue_mask", G_TYPE_INT, 0xFF0000,
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) {

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

@ -779,9 +779,9 @@ static int _capture_V4L2 (CvCaptureCAM_V4L *capture, char *deviceName)
return -1; return -1;
} else { } else {
buffer_number--; buffer_number--;
fprintf (stderr, "Insufficient buffer memory on %s -- decreaseing buffers\n", deviceName); fprintf (stderr, "Insufficient buffer memory on %s -- decreaseing buffers\n", deviceName);
goto try_again; goto try_again;
} }
} }
@ -824,8 +824,8 @@ static int _capture_V4L2 (CvCaptureCAM_V4L *capture, char *deviceName)
if (capture->buffers[MAX_V4L_BUFFERS].start) { if (capture->buffers[MAX_V4L_BUFFERS].start) {
free(capture->buffers[MAX_V4L_BUFFERS].start); free(capture->buffers[MAX_V4L_BUFFERS].start);
capture->buffers[MAX_V4L_BUFFERS].start = NULL; capture->buffers[MAX_V4L_BUFFERS].start = NULL;
} }
capture->buffers[MAX_V4L_BUFFERS].start = malloc(buf.length); capture->buffers[MAX_V4L_BUFFERS].start = malloc(buf.length);
capture->buffers[MAX_V4L_BUFFERS].length = buf.length; capture->buffers[MAX_V4L_BUFFERS].length = buf.length;
}; };
@ -1080,11 +1080,11 @@ static int read_frame_v4l2(CvCaptureCAM_V4L* capture) {
#ifdef USE_TEMP_BUFFER #ifdef USE_TEMP_BUFFER
memcpy(capture->buffers[MAX_V4L_BUFFERS].start, memcpy(capture->buffers[MAX_V4L_BUFFERS].start,
capture->buffers[buf.index].start, capture->buffers[buf.index].start,
capture->buffers[MAX_V4L_BUFFERS].length ); capture->buffers[MAX_V4L_BUFFERS].length );
capture->bufferIndex = MAX_V4L_BUFFERS; capture->bufferIndex = MAX_V4L_BUFFERS;
//printf("got data in buff %d, len=%d, flags=0x%X, seq=%d, used=%d)\n", //printf("got data in buff %d, len=%d, flags=0x%X, seq=%d, used=%d)\n",
// buf.index, buf.length, buf.flags, buf.sequence, buf.bytesused); // buf.index, buf.length, buf.flags, buf.sequence, buf.bytesused);
#else #else
capture->bufferIndex = buf.index; capture->bufferIndex = buf.index;
#endif #endif
@ -1211,9 +1211,9 @@ static int icvGrabFrameCAM_V4L(CvCaptureCAM_V4L* capture) {
capture->mmaps[capture->bufferIndex].format = capture->imageProperties.palette; capture->mmaps[capture->bufferIndex].format = capture->imageProperties.palette;
if (v4l1_ioctl (capture->deviceHandle, VIDIOCMCAPTURE, if (v4l1_ioctl (capture->deviceHandle, VIDIOCMCAPTURE,
&capture->mmaps[capture->bufferIndex]) == -1) { &capture->mmaps[capture->bufferIndex]) == -1) {
/* capture is on the way, so just exit */ /* capture is on the way, so just exit */
return 1; return 1;
} }
++capture->bufferIndex; ++capture->bufferIndex;
@ -1273,11 +1273,11 @@ static IplImage* icvRetrieveFrameCAM_V4L( CvCaptureCAM_V4L* capture, int) {
if (capture->is_v4l2_device == 1) if (capture->is_v4l2_device == 1)
{ {
if(capture->buffers[capture->bufferIndex].start){ if(capture->buffers[capture->bufferIndex].start){
memcpy((char *)capture->frame.imageData, memcpy((char *)capture->frame.imageData,
(char *)capture->buffers[capture->bufferIndex].start, (char *)capture->buffers[capture->bufferIndex].start,
capture->frame.imageSize); capture->frame.imageSize);
} }
} else } else
#endif /* HAVE_CAMV4L2 */ #endif /* HAVE_CAMV4L2 */
@ -1353,7 +1353,7 @@ static double icvGetPropertyCAM_V4L (CvCaptureCAM_V4L* capture,
sprintf(name, "<unknown property string>"); sprintf(name, "<unknown property string>");
capture->control.id = property_id; capture->control.id = property_id;
} }
if(v4l2_ioctl(capture->deviceHandle, VIDIOC_G_CTRL, &capture->control) == 0) { if(v4l2_ioctl(capture->deviceHandle, VIDIOC_G_CTRL, &capture->control) == 0) {
/* all went well */ /* all went well */
is_v4l2_device = 1; is_v4l2_device = 1;
@ -1519,7 +1519,7 @@ static int icvSetControl (CvCaptureCAM_V4L* capture, int property_id, double val
CLEAR (capture->control); CLEAR (capture->control);
CLEAR (capture->queryctrl); CLEAR (capture->queryctrl);
/* get current values */ /* get current values */
switch (property_id) { switch (property_id) {
case CV_CAP_PROP_BRIGHTNESS: case CV_CAP_PROP_BRIGHTNESS:
@ -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");
} }
} }

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

@ -157,22 +157,22 @@ 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;
if( bit_depth <= 8 || bit_depth == 16 ) if( bit_depth <= 8 || bit_depth == 16 )
{ {
switch(color_type) switch(color_type)
{ {
case PNG_COLOR_TYPE_RGB: case PNG_COLOR_TYPE_RGB:
case PNG_COLOR_TYPE_PALETTE: case PNG_COLOR_TYPE_PALETTE:
@ -224,7 +224,7 @@ bool PngDecoder::readData( Mat& img )
else if( !isBigEndian() ) else if( !isBigEndian() )
png_set_swap( png_ptr ); png_set_swap( png_ptr );
if(img.channels() < 4) if(img.channels() < 4)
{ {
/* observation: png_read_image() writes 400 bytes beyond /* observation: png_read_image() writes 400 bytes beyond
* end of data when reading a 400x118 color png * end of data when reading a 400x118 color png
@ -247,7 +247,7 @@ bool PngDecoder::readData( Mat& img )
#else #else
png_set_gray_1_2_4_to_8( png_ptr ); png_set_gray_1_2_4_to_8( png_ptr );
#endif #endif
if( CV_MAT_CN(m_type) > 1 && color ) if( CV_MAT_CN(m_type) > 1 && color )
png_set_bgr( png_ptr ); // convert RGB to BGR png_set_bgr( png_ptr ); // convert RGB to BGR
else if( color ) else if( color )
@ -330,7 +330,7 @@ bool PngEncoder::write( const Mat& img, const vector<int>& params )
if( params[i] == CV_IMWRITE_PNG_STRATEGY ) if( params[i] == CV_IMWRITE_PNG_STRATEGY )
{ {
compression_strategy = params[i+1]; compression_strategy = params[i+1];
compression_strategy = MIN(MAX(compression_strategy, 0), Z_FIXED); compression_strategy = MIN(MAX(compression_strategy, 0), Z_FIXED);
} }
} }

24
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)))
@ -169,7 +169,7 @@ bool TiffDecoder::readData( Mat& img )
bool color = img.channels() > 1; bool color = img.channels() > 1;
uchar* data = img.data; uchar* data = img.data;
int step = (int)img.step; int step = (int)img.step;
if( img.depth() != CV_8U && img.depth() != CV_16U && img.depth() != CV_32F && img.depth() != CV_64F ) if( img.depth() != CV_8U && img.depth() != CV_16U && img.depth() != CV_32F && img.depth() != CV_64F )
return false; return false;
@ -422,9 +422,9 @@ bool TiffEncoder::writeLibTiff( const Mat& img, const vector<int>& /*params*/)
default: default:
{ {
return false; return false;
} }
} }
const int bitsPerByte = 8; const int bitsPerByte = 8;
size_t fileStep = (width * channels * bitsPerChannel) / bitsPerByte; size_t fileStep = (width * channels * bitsPerChannel) / bitsPerByte;
int rowsPerStrip = (int)((1 << 13)/fileStep); int rowsPerStrip = (int)((1 << 13)/fileStep);
@ -443,7 +443,7 @@ bool TiffEncoder::writeLibTiff( const Mat& img, const vector<int>& /*params*/)
{ {
return false; return false;
} }
// defaults for now, maybe base them on params in the future // defaults for now, maybe base them on params in the future
int compression = COMPRESSION_LZW; int compression = COMPRESSION_LZW;
int predictor = PREDICTOR_HORIZONTAL; int predictor = PREDICTOR_HORIZONTAL;
@ -516,7 +516,7 @@ bool TiffEncoder::writeLibTiff( const Mat& img, const vector<int>& /*params*/)
return false; return false;
} }
} }
TIFFClose(pTiffHandle); TIFFClose(pTiffHandle);
return true; return true;
} }
@ -546,7 +546,7 @@ bool TiffEncoder::write( const Mat& img, const vector<int>& /*params*/)
if( !strm.open(*m_buf) ) if( !strm.open(*m_buf) )
return false; return false;
} }
else else
{ {
#ifdef HAVE_TIFF #ifdef HAVE_TIFF
return writeLibTiff(img, params); return writeLibTiff(img, params);

16
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 );
@ -415,30 +415,30 @@ class CV_FillConvexPolyTest : public cvtest::BaseTest
{ {
public: public:
CV_FillConvexPolyTest() {} CV_FillConvexPolyTest() {}
~CV_FillConvexPolyTest() {} ~CV_FillConvexPolyTest() {}
protected: protected:
void run(int) void run(int)
{ {
vector<Point> line1; vector<Point> line1;
vector<Point> line2; vector<Point> line2;
line1.push_back(Point(1, 1)); line1.push_back(Point(1, 1));
line1.push_back(Point(5, 1)); line1.push_back(Point(5, 1));
line1.push_back(Point(5, 8)); line1.push_back(Point(5, 8));
line1.push_back(Point(1, 8)); line1.push_back(Point(1, 8));
line2.push_back(Point(2, 2)); line2.push_back(Point(2, 2));
line2.push_back(Point(10, 2)); line2.push_back(Point(10, 2));
line2.push_back(Point(10, 16)); line2.push_back(Point(10, 16));
line2.push_back(Point(2, 16)); line2.push_back(Point(2, 16));
Mat gray0(10,10,CV_8U, Scalar(0)); Mat gray0(10,10,CV_8U, Scalar(0));
fillConvexPoly(gray0, line1, Scalar(255), 8, 0); fillConvexPoly(gray0, line1, Scalar(255), 8, 0);
int nz1 = countNonZero(gray0); int nz1 = countNonZero(gray0);
fillConvexPoly(gray0, line2, Scalar(0), 8, 1); fillConvexPoly(gray0, line2, Scalar(0), 8, 1);
int nz2 = countNonZero(gray0)/255; int nz2 = countNonZero(gray0)/255;
CV_Assert( nz1 == 40 && nz2 == 0 ); CV_Assert( nz1 == 40 && nz2 == 0 );
} }
}; };

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

@ -53,7 +53,7 @@ string fourccToString(int fourcc)
{ {
return format("%c%c%c%c", fourcc & 255, (fourcc >> 8) & 255, (fourcc >> 16) & 255, (fourcc >> 24) & 255); return format("%c%c%c%c", fourcc & 255, (fourcc >> 8) & 255, (fourcc >> 16) & 255, (fourcc >> 24) & 255);
} }
const VideoFormat g_specific_fmt_list[] = const VideoFormat g_specific_fmt_list[] =
{ {
VideoFormat("avi", CV_FOURCC('X', 'V', 'I', 'D')), VideoFormat("avi", CV_FOURCC('X', 'V', 'I', 'D')),
@ -63,11 +63,11 @@ const VideoFormat g_specific_fmt_list[] =
VideoFormat("mkv", CV_FOURCC('X', 'V', 'I', 'D')), VideoFormat("mkv", CV_FOURCC('X', 'V', 'I', 'D')),
VideoFormat("mkv", CV_FOURCC('M', 'P', 'E', 'G')), VideoFormat("mkv", CV_FOURCC('M', 'P', 'E', 'G')),
VideoFormat("mkv", CV_FOURCC('M', 'J', 'P', 'G')), VideoFormat("mkv", CV_FOURCC('M', 'J', 'P', 'G')),
VideoFormat("mov", CV_FOURCC('m', 'p', '4', 'v')), VideoFormat("mov", CV_FOURCC('m', 'p', '4', 'v')),
VideoFormat() VideoFormat()
}; };
} }
class CV_HighGuiTest : public cvtest::BaseTest class CV_HighGuiTest : public cvtest::BaseTest
@ -246,7 +246,7 @@ void CV_HighGuiTest::VideoTest(const string& dir, const cvtest::VideoFormat& fmt
if (!img) if (!img)
break; break;
frames.push_back(Mat(img).clone()); frames.push_back(Mat(img).clone());
if (writer == 0) if (writer == 0)
@ -393,7 +393,7 @@ void CV_HighGuiTest::SpecificVideoTest(const string& dir, const cvtest::VideoFor
{ {
string ext = fmt.ext; string ext = fmt.ext;
int fourcc = fmt.fourcc; int fourcc = fmt.fourcc;
string fourcc_str = cvtest::fourccToString(fourcc); string fourcc_str = cvtest::fourccToString(fourcc);
const string video_file = "video_" + fourcc_str + "." + ext; const string video_file = "video_" + fourcc_str + "." + ext;
@ -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);
@ -412,7 +412,7 @@ void CV_HighGuiTest::SpecificVideoTest(const string& dir, const cvtest::VideoFor
const size_t IMAGE_COUNT = 30; const size_t IMAGE_COUNT = 30;
vector<Mat> images; vector<Mat> images;
for( size_t i = 0; i < IMAGE_COUNT; ++i ) for( size_t i = 0; i < IMAGE_COUNT; ++i )
{ {
string file_path = format("%s../python/images/QCIF_%02d.bmp", dir.c_str(), i); string file_path = format("%s../python/images/QCIF_%02d.bmp", dir.c_str(), i);
@ -432,7 +432,7 @@ void CV_HighGuiTest::SpecificVideoTest(const string& dir, const cvtest::VideoFor
if (img.at<Vec3b>(k, l) == Vec3b::all(0)) if (img.at<Vec3b>(k, l) == Vec3b::all(0))
img.at<Vec3b>(k, l) = Vec3b(0, 255, 0); img.at<Vec3b>(k, l) = Vec3b(0, 255, 0);
else img.at<Vec3b>(k, l) = Vec3b(0, 0, 255); else img.at<Vec3b>(k, l) = Vec3b(0, 0, 255);
resize(img, img, frame_size, 0.0, 0.0, INTER_CUBIC); resize(img, img, frame_size, 0.0, 0.0, INTER_CUBIC);
images.push_back(img); images.push_back(img);

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

File diff suppressed because it is too large Load Diff

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

@ -48,11 +48,11 @@
/* /*
Various border types, image boundaries are denoted with '|' Various border types, image boundaries are denoted with '|'
* BORDER_REPLICATE: aaaaaa|abcdefgh|hhhhhhh * BORDER_REPLICATE: aaaaaa|abcdefgh|hhhhhhh
* BORDER_REFLECT: fedcba|abcdefgh|hgfedcb * BORDER_REFLECT: fedcba|abcdefgh|hgfedcb
* BORDER_REFLECT_101: gfedcb|abcdefgh|gfedcba * BORDER_REFLECT_101: gfedcb|abcdefgh|gfedcba
* BORDER_WRAP: cdefgh|abcdefgh|abcdefg * BORDER_WRAP: cdefgh|abcdefgh|abcdefg
* BORDER_CONSTANT: iiiiii|abcdefgh|iiiiiii with some specified 'i' * BORDER_CONSTANT: iiiiii|abcdefgh|iiiiiii with some specified 'i'
*/ */
int cv::borderInterpolate( int p, int len, int borderType ) int cv::borderInterpolate( int p, int len, int borderType )
@ -113,7 +113,7 @@ FilterEngine::FilterEngine()
wholeSize = Size(-1,-1); wholeSize = Size(-1,-1);
} }
FilterEngine::FilterEngine( const Ptr<BaseFilter>& _filter2D, FilterEngine::FilterEngine( const Ptr<BaseFilter>& _filter2D,
const Ptr<BaseRowFilter>& _rowFilter, const Ptr<BaseRowFilter>& _rowFilter,
@ -125,7 +125,7 @@ FilterEngine::FilterEngine( const Ptr<BaseFilter>& _filter2D,
init(_filter2D, _rowFilter, _columnFilter, _srcType, _dstType, _bufType, init(_filter2D, _rowFilter, _columnFilter, _srcType, _dstType, _bufType,
_rowBorderType, _columnBorderType, _borderValue); _rowBorderType, _columnBorderType, _borderValue);
} }
FilterEngine::~FilterEngine() FilterEngine::~FilterEngine()
{ {
} }
@ -141,24 +141,24 @@ void FilterEngine::init( const Ptr<BaseFilter>& _filter2D,
_srcType = CV_MAT_TYPE(_srcType); _srcType = CV_MAT_TYPE(_srcType);
_bufType = CV_MAT_TYPE(_bufType); _bufType = CV_MAT_TYPE(_bufType);
_dstType = CV_MAT_TYPE(_dstType); _dstType = CV_MAT_TYPE(_dstType);
srcType = _srcType; srcType = _srcType;
int srcElemSize = (int)getElemSize(srcType); int srcElemSize = (int)getElemSize(srcType);
dstType = _dstType; dstType = _dstType;
bufType = _bufType; bufType = _bufType;
filter2D = _filter2D; filter2D = _filter2D;
rowFilter = _rowFilter; rowFilter = _rowFilter;
columnFilter = _columnFilter; columnFilter = _columnFilter;
if( _columnBorderType < 0 ) if( _columnBorderType < 0 )
_columnBorderType = _rowBorderType; _columnBorderType = _rowBorderType;
rowBorderType = _rowBorderType; rowBorderType = _rowBorderType;
columnBorderType = _columnBorderType; columnBorderType = _columnBorderType;
CV_Assert( columnBorderType != BORDER_WRAP ); CV_Assert( columnBorderType != BORDER_WRAP );
if( isSeparable() ) if( isSeparable() )
{ {
CV_Assert( !rowFilter.empty() && !columnFilter.empty() ); CV_Assert( !rowFilter.empty() && !columnFilter.empty() );
@ -175,7 +175,7 @@ void FilterEngine::init( const Ptr<BaseFilter>& _filter2D,
CV_Assert( 0 <= anchor.x && anchor.x < ksize.width && CV_Assert( 0 <= anchor.x && anchor.x < ksize.width &&
0 <= anchor.y && anchor.y < ksize.height ); 0 <= anchor.y && anchor.y < ksize.height );
borderElemSize = srcElemSize/(CV_MAT_DEPTH(srcType) >= CV_32S ? sizeof(int) : 1); borderElemSize = srcElemSize/(CV_MAT_DEPTH(srcType) >= CV_32S ? sizeof(int) : 1);
int borderLength = std::max(ksize.width - 1, 1); int borderLength = std::max(ksize.width - 1, 1);
borderTab.resize(borderLength*borderElemSize); borderTab.resize(borderLength*borderElemSize);
@ -198,7 +198,7 @@ static const int VEC_ALIGN = CV_MALLOC_ALIGN;
int FilterEngine::start(Size _wholeSize, Rect _roi, int _maxBufRows) int FilterEngine::start(Size _wholeSize, Rect _roi, int _maxBufRows)
{ {
int i, j; int i, j;
wholeSize = _wholeSize; wholeSize = _wholeSize;
roi = _roi; roi = _roi;
CV_Assert( roi.x >= 0 && roi.y >= 0 && roi.width >= 0 && roi.height >= 0 && CV_Assert( roi.x >= 0 && roi.y >= 0 && roi.width >= 0 && roi.height >= 0 &&
@ -226,7 +226,7 @@ int FilterEngine::start(Size _wholeSize, Rect _roi, int _maxBufRows)
int n = (int)constBorderValue.size(), N; int n = (int)constBorderValue.size(), N;
N = (maxWidth + ksize.width - 1)*esz; N = (maxWidth + ksize.width - 1)*esz;
tdst = isSeparable() ? &srcRow[0] : dst; tdst = isSeparable() ? &srcRow[0] : dst;
for( i = 0; i < N; i += n ) for( i = 0; i < N; i += n )
{ {
n = std::min( n, N - i ); n = std::min( n, N - i );
@ -237,7 +237,7 @@ int FilterEngine::start(Size _wholeSize, Rect _roi, int _maxBufRows)
if( isSeparable() ) if( isSeparable() )
(*rowFilter)(&srcRow[0], dst, maxWidth, cn); (*rowFilter)(&srcRow[0], dst, maxWidth, cn);
} }
int maxBufStep = bufElemSize*(int)alignSize(maxWidth + int maxBufStep = bufElemSize*(int)alignSize(maxWidth +
(!isSeparable() ? ksize.width - 1 : 0),VEC_ALIGN); (!isSeparable() ? ksize.width - 1 : 0),VEC_ALIGN);
ringBuf.resize(maxBufStep*rows.size()+VEC_ALIGN); ringBuf.resize(maxBufStep*rows.size()+VEC_ALIGN);
@ -265,10 +265,10 @@ int FilterEngine::start(Size _wholeSize, Rect _roi, int _maxBufRows)
else else
{ {
int xofs1 = std::min(roi.x, anchor.x) - roi.x; int xofs1 = std::min(roi.x, anchor.x) - roi.x;
int btab_esz = borderElemSize, wholeWidth = wholeSize.width; int btab_esz = borderElemSize, wholeWidth = wholeSize.width;
int* btab = (int*)&borderTab[0]; int* btab = (int*)&borderTab[0];
for( i = 0; i < dx1; i++ ) for( i = 0; i < dx1; i++ )
{ {
int p0 = (borderInterpolate(i-dx1, wholeWidth, rowBorderType) + xofs1)*btab_esz; int p0 = (borderInterpolate(i-dx1, wholeWidth, rowBorderType) + xofs1)*btab_esz;
@ -301,20 +301,20 @@ int FilterEngine::start(const Mat& src, const Rect& _srcRoi,
bool isolated, int maxBufRows) bool isolated, int maxBufRows)
{ {
Rect srcRoi = _srcRoi; Rect srcRoi = _srcRoi;
if( srcRoi == Rect(0,0,-1,-1) ) if( srcRoi == Rect(0,0,-1,-1) )
srcRoi = Rect(0,0,src.cols,src.rows); srcRoi = Rect(0,0,src.cols,src.rows);
CV_Assert( srcRoi.x >= 0 && srcRoi.y >= 0 && CV_Assert( srcRoi.x >= 0 && srcRoi.y >= 0 &&
srcRoi.width >= 0 && srcRoi.height >= 0 && srcRoi.width >= 0 && srcRoi.height >= 0 &&
srcRoi.x + srcRoi.width <= src.cols && srcRoi.x + srcRoi.width <= src.cols &&
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;
} }
@ -334,7 +334,7 @@ int FilterEngine::proceed( const uchar* src, int srcstep, int count,
uchar* dst, int dststep ) uchar* dst, int dststep )
{ {
CV_Assert( wholeSize.width > 0 && wholeSize.height > 0 ); CV_Assert( wholeSize.width > 0 && wholeSize.height > 0 );
const int *btab = &borderTab[0]; const int *btab = &borderTab[0];
int esz = (int)getElemSize(srcType), btab_esz = borderElemSize; int esz = (int)getElemSize(srcType), btab_esz = borderElemSize;
uchar** brows = &rows[0]; uchar** brows = &rows[0];
@ -365,7 +365,7 @@ int FilterEngine::proceed( const uchar* src, int srcstep, int count,
int bi = (startY - startY0 + rowCount) % bufRows; int bi = (startY - startY0 + rowCount) % bufRows;
uchar* brow = alignPtr(&ringBuf[0], VEC_ALIGN) + bi*bufStep; uchar* brow = alignPtr(&ringBuf[0], VEC_ALIGN) + bi*bufStep;
uchar* row = isSep ? &srcRow[0] : brow; uchar* row = isSep ? &srcRow[0] : brow;
if( ++rowCount > bufRows ) if( ++rowCount > bufRows )
{ {
--rowCount; --rowCount;
@ -394,7 +394,7 @@ int FilterEngine::proceed( const uchar* src, int srcstep, int count,
row[i + (width1 - _dx2)*esz] = src[btab[i+_dx1*esz]]; row[i + (width1 - _dx2)*esz] = src[btab[i+_dx1*esz]];
} }
} }
if( isSep ) if( isSep )
(*rowFilter)(row, brow, width, CV_MAT_CN(srcType)); (*rowFilter)(row, brow, width, CV_MAT_CN(srcType));
} }
@ -434,11 +434,11 @@ void FilterEngine::apply(const Mat& src, Mat& dst,
const Rect& _srcRoi, Point dstOfs, bool isolated) const Rect& _srcRoi, Point dstOfs, bool isolated)
{ {
CV_Assert( src.type() == srcType && dst.type() == dstType ); CV_Assert( src.type() == srcType && dst.type() == dstType );
Rect srcRoi = _srcRoi; Rect srcRoi = _srcRoi;
if( srcRoi == Rect(0,0,-1,-1) ) if( srcRoi == Rect(0,0,-1,-1) )
srcRoi = Rect(0,0,src.cols,src.rows); srcRoi = Rect(0,0,src.cols,src.rows);
if( srcRoi.area() == 0 ) if( srcRoi.area() == 0 )
return; return;
@ -560,7 +560,7 @@ struct RowVec_8u32s
{ {
if( !checkHardwareSupport(CV_CPU_SSE2) ) if( !checkHardwareSupport(CV_CPU_SSE2) )
return 0; return 0;
int i = 0, k, _ksize = kernel.rows + kernel.cols - 1; int i = 0, k, _ksize = kernel.rows + kernel.cols - 1;
int* dst = (int*)_dst; int* dst = (int*)_dst;
const int* _kx = (const int*)kernel.data; const int* _kx = (const int*)kernel.data;
@ -593,7 +593,7 @@ struct RowVec_8u32s
s2 = _mm_add_epi32(s2, _mm_unpacklo_epi16(x2, x3)); s2 = _mm_add_epi32(s2, _mm_unpacklo_epi16(x2, x3));
s3 = _mm_add_epi32(s3, _mm_unpackhi_epi16(x2, x3)); s3 = _mm_add_epi32(s3, _mm_unpackhi_epi16(x2, x3));
} }
_mm_store_si128((__m128i*)(dst + i), s0); _mm_store_si128((__m128i*)(dst + i), s0);
_mm_store_si128((__m128i*)(dst + i + 4), s1); _mm_store_si128((__m128i*)(dst + i + 4), s1);
_mm_store_si128((__m128i*)(dst + i + 8), s2); _mm_store_si128((__m128i*)(dst + i + 8), s2);
@ -652,7 +652,7 @@ struct SymmRowSmallVec_8u32s
{ {
if( !checkHardwareSupport(CV_CPU_SSE2) ) if( !checkHardwareSupport(CV_CPU_SSE2) )
return 0; return 0;
int i = 0, j, k, _ksize = kernel.rows + kernel.cols - 1; int i = 0, j, k, _ksize = kernel.rows + kernel.cols - 1;
int* dst = (int*)_dst; int* dst = (int*)_dst;
bool symmetrical = (symmetryType & KERNEL_SYMMETRICAL) != 0; bool symmetrical = (symmetryType & KERNEL_SYMMETRICAL) != 0;
@ -973,7 +973,7 @@ struct SymmColumnVec_32s8u
{ {
if( !checkHardwareSupport(CV_CPU_SSE2) ) if( !checkHardwareSupport(CV_CPU_SSE2) )
return 0; return 0;
int ksize2 = (kernel.rows + kernel.cols - 1)/2; int ksize2 = (kernel.rows + kernel.cols - 1)/2;
const float* ky = (const float*)kernel.data + ksize2; const float* ky = (const float*)kernel.data + ksize2;
int i = 0, k; int i = 0, k;
@ -1121,7 +1121,7 @@ struct SymmColumnSmallVec_32s16s
{ {
if( !checkHardwareSupport(CV_CPU_SSE2) ) if( !checkHardwareSupport(CV_CPU_SSE2) )
return 0; return 0;
int ksize2 = (kernel.rows + kernel.cols - 1)/2; int ksize2 = (kernel.rows + kernel.cols - 1)/2;
const float* ky = (const float*)kernel.data + ksize2; const float* ky = (const float*)kernel.data + ksize2;
int i = 0; int i = 0;
@ -1237,9 +1237,9 @@ struct SymmColumnSmallVec_32s16s
Mat kernel; Mat kernel;
}; };
/////////////////////////////////////// 16s ////////////////////////////////// /////////////////////////////////////// 16s //////////////////////////////////
struct RowVec_16s32f struct RowVec_16s32f
{ {
RowVec_16s32f() {} RowVec_16s32f() {}
@ -1248,17 +1248,17 @@ struct RowVec_16s32f
kernel = _kernel; kernel = _kernel;
sse2_supported = checkHardwareSupport(CV_CPU_SSE2); sse2_supported = checkHardwareSupport(CV_CPU_SSE2);
} }
int operator()(const uchar* _src, uchar* _dst, int width, int cn) const int operator()(const uchar* _src, uchar* _dst, int width, int cn) const
{ {
if( !sse2_supported ) if( !sse2_supported )
return 0; return 0;
int i = 0, k, _ksize = kernel.rows + kernel.cols - 1; int i = 0, k, _ksize = kernel.rows + kernel.cols - 1;
float* dst = (float*)_dst; float* dst = (float*)_dst;
const float* _kx = (const float*)kernel.data; const float* _kx = (const float*)kernel.data;
width *= cn; width *= cn;
for( ; i <= width - 8; i += 8 ) for( ; i <= width - 8; i += 8 )
{ {
const short* src = (const short*)_src + i; const short* src = (const short*)_src + i;
@ -1267,7 +1267,7 @@ struct RowVec_16s32f
{ {
f = _mm_load_ss(_kx+k); f = _mm_load_ss(_kx+k);
f = _mm_shuffle_ps(f, f, 0); f = _mm_shuffle_ps(f, f, 0);
__m128i x0i = _mm_loadu_si128((const __m128i*)src); __m128i x0i = _mm_loadu_si128((const __m128i*)src);
__m128i x1i = _mm_srai_epi32(_mm_unpackhi_epi16(x0i, x0i), 16); __m128i x1i = _mm_srai_epi32(_mm_unpackhi_epi16(x0i, x0i), 16);
x0i = _mm_srai_epi32(_mm_unpacklo_epi16(x0i, x0i), 16); x0i = _mm_srai_epi32(_mm_unpacklo_epi16(x0i, x0i), 16);
@ -1281,12 +1281,12 @@ struct RowVec_16s32f
} }
return i; return i;
} }
Mat kernel; Mat kernel;
bool sse2_supported; bool sse2_supported;
}; };
struct SymmColumnVec_32f16s struct SymmColumnVec_32f16s
{ {
SymmColumnVec_32f16s() { symmetryType=0; } SymmColumnVec_32f16s() { symmetryType=0; }
@ -1298,12 +1298,12 @@ struct SymmColumnVec_32f16s
CV_Assert( (symmetryType & (KERNEL_SYMMETRICAL | KERNEL_ASYMMETRICAL)) != 0 ); CV_Assert( (symmetryType & (KERNEL_SYMMETRICAL | KERNEL_ASYMMETRICAL)) != 0 );
sse2_supported = checkHardwareSupport(CV_CPU_SSE2); sse2_supported = checkHardwareSupport(CV_CPU_SSE2);
} }
int operator()(const uchar** _src, uchar* _dst, int width) const int operator()(const uchar** _src, uchar* _dst, int width) const
{ {
if( !sse2_supported ) if( !sse2_supported )
return 0; return 0;
int ksize2 = (kernel.rows + kernel.cols - 1)/2; int ksize2 = (kernel.rows + kernel.cols - 1)/2;
const float* ky = (const float*)kernel.data + ksize2; const float* ky = (const float*)kernel.data + ksize2;
int i = 0, k; int i = 0, k;
@ -1312,7 +1312,7 @@ struct SymmColumnVec_32f16s
const float *S, *S2; const float *S, *S2;
short* dst = (short*)_dst; short* dst = (short*)_dst;
__m128 d4 = _mm_set1_ps(delta); __m128 d4 = _mm_set1_ps(delta);
if( symmetrical ) if( symmetrical )
{ {
for( ; i <= width - 16; i += 16 ) for( ; i <= width - 16; i += 16 )
@ -1330,7 +1330,7 @@ struct SymmColumnVec_32f16s
s3 = _mm_load_ps(S+12); s3 = _mm_load_ps(S+12);
s2 = _mm_add_ps(_mm_mul_ps(s2, f), d4); s2 = _mm_add_ps(_mm_mul_ps(s2, f), d4);
s3 = _mm_add_ps(_mm_mul_ps(s3, f), d4); s3 = _mm_add_ps(_mm_mul_ps(s3, f), d4);
for( k = 1; k <= ksize2; k++ ) for( k = 1; k <= ksize2; k++ )
{ {
S = src[k] + i; S = src[k] + i;
@ -1346,23 +1346,23 @@ struct SymmColumnVec_32f16s
s2 = _mm_add_ps(s2, _mm_mul_ps(x0, f)); s2 = _mm_add_ps(s2, _mm_mul_ps(x0, f));
s3 = _mm_add_ps(s3, _mm_mul_ps(x1, f)); s3 = _mm_add_ps(s3, _mm_mul_ps(x1, f));
} }
__m128i s0i = _mm_cvtps_epi32(s0); __m128i s0i = _mm_cvtps_epi32(s0);
__m128i s1i = _mm_cvtps_epi32(s1); __m128i s1i = _mm_cvtps_epi32(s1);
__m128i s2i = _mm_cvtps_epi32(s2); __m128i s2i = _mm_cvtps_epi32(s2);
__m128i s3i = _mm_cvtps_epi32(s3); __m128i s3i = _mm_cvtps_epi32(s3);
_mm_storeu_si128((__m128i*)(dst + i), _mm_packs_epi32(s0i, s1i)); _mm_storeu_si128((__m128i*)(dst + i), _mm_packs_epi32(s0i, s1i));
_mm_storeu_si128((__m128i*)(dst + i + 8), _mm_packs_epi32(s2i, s3i)); _mm_storeu_si128((__m128i*)(dst + i + 8), _mm_packs_epi32(s2i, s3i));
} }
for( ; i <= width - 4; i += 4 ) for( ; i <= width - 4; i += 4 )
{ {
__m128 f = _mm_load_ss(ky); __m128 f = _mm_load_ss(ky);
f = _mm_shuffle_ps(f, f, 0); f = _mm_shuffle_ps(f, f, 0);
__m128 x0, s0 = _mm_load_ps(src[0] + i); __m128 x0, s0 = _mm_load_ps(src[0] + i);
s0 = _mm_add_ps(_mm_mul_ps(s0, f), d4); s0 = _mm_add_ps(_mm_mul_ps(s0, f), d4);
for( k = 1; k <= ksize2; k++ ) for( k = 1; k <= ksize2; k++ )
{ {
f = _mm_load_ss(ky+k); f = _mm_load_ss(ky+k);
@ -1372,7 +1372,7 @@ struct SymmColumnVec_32f16s
x0 = _mm_add_ps(_mm_load_ps(src[k]+i), _mm_load_ps(src[-k] + i)); x0 = _mm_add_ps(_mm_load_ps(src[k]+i), _mm_load_ps(src[-k] + i));
s0 = _mm_add_ps(s0, _mm_mul_ps(x0, f)); s0 = _mm_add_ps(s0, _mm_mul_ps(x0, f));
} }
__m128i s0i = _mm_cvtps_epi32(s0); __m128i s0i = _mm_cvtps_epi32(s0);
_mm_storel_epi64((__m128i*)(dst + i), _mm_packs_epi32(s0i, s0i)); _mm_storel_epi64((__m128i*)(dst + i), _mm_packs_epi32(s0i, s0i));
} }
@ -1384,7 +1384,7 @@ struct SymmColumnVec_32f16s
__m128 f, s0 = d4, s1 = d4, s2 = d4, s3 = d4; __m128 f, s0 = d4, s1 = d4, s2 = d4, s3 = d4;
__m128 x0, x1; __m128 x0, x1;
S = src[0] + i; S = src[0] + i;
for( k = 1; k <= ksize2; k++ ) for( k = 1; k <= ksize2; k++ )
{ {
S = src[k] + i; S = src[k] + i;
@ -1400,20 +1400,20 @@ struct SymmColumnVec_32f16s
s2 = _mm_add_ps(s2, _mm_mul_ps(x0, f)); s2 = _mm_add_ps(s2, _mm_mul_ps(x0, f));
s3 = _mm_add_ps(s3, _mm_mul_ps(x1, f)); s3 = _mm_add_ps(s3, _mm_mul_ps(x1, f));
} }
__m128i s0i = _mm_cvtps_epi32(s0); __m128i s0i = _mm_cvtps_epi32(s0);
__m128i s1i = _mm_cvtps_epi32(s1); __m128i s1i = _mm_cvtps_epi32(s1);
__m128i s2i = _mm_cvtps_epi32(s2); __m128i s2i = _mm_cvtps_epi32(s2);
__m128i s3i = _mm_cvtps_epi32(s3); __m128i s3i = _mm_cvtps_epi32(s3);
_mm_storeu_si128((__m128i*)(dst + i), _mm_packs_epi32(s0i, s1i)); _mm_storeu_si128((__m128i*)(dst + i), _mm_packs_epi32(s0i, s1i));
_mm_storeu_si128((__m128i*)(dst + i + 8), _mm_packs_epi32(s2i, s3i)); _mm_storeu_si128((__m128i*)(dst + i + 8), _mm_packs_epi32(s2i, s3i));
} }
for( ; i <= width - 4; i += 4 ) for( ; i <= width - 4; i += 4 )
{ {
__m128 f, x0, s0 = d4; __m128 f, x0, s0 = d4;
for( k = 1; k <= ksize2; k++ ) for( k = 1; k <= ksize2; k++ )
{ {
f = _mm_load_ss(ky+k); f = _mm_load_ss(ky+k);
@ -1421,21 +1421,21 @@ struct SymmColumnVec_32f16s
x0 = _mm_sub_ps(_mm_load_ps(src[k]+i), _mm_load_ps(src[-k] + i)); x0 = _mm_sub_ps(_mm_load_ps(src[k]+i), _mm_load_ps(src[-k] + i));
s0 = _mm_add_ps(s0, _mm_mul_ps(x0, f)); s0 = _mm_add_ps(s0, _mm_mul_ps(x0, f));
} }
__m128i s0i = _mm_cvtps_epi32(s0); __m128i s0i = _mm_cvtps_epi32(s0);
_mm_storel_epi64((__m128i*)(dst + i), _mm_packs_epi32(s0i, s0i)); _mm_storel_epi64((__m128i*)(dst + i), _mm_packs_epi32(s0i, s0i));
} }
} }
return i; return i;
} }
int symmetryType; int symmetryType;
float delta; float delta;
Mat kernel; Mat kernel;
bool sse2_supported; bool sse2_supported;
}; };
/////////////////////////////////////// 32f ////////////////////////////////// /////////////////////////////////////// 32f //////////////////////////////////
@ -1451,7 +1451,7 @@ struct RowVec_32f
{ {
if( !checkHardwareSupport(CV_CPU_SSE) ) if( !checkHardwareSupport(CV_CPU_SSE) )
return 0; return 0;
int i = 0, k, _ksize = kernel.rows + kernel.cols - 1; int i = 0, k, _ksize = kernel.rows + kernel.cols - 1;
float* dst = (float*)_dst; float* dst = (float*)_dst;
const float* _kx = (const float*)kernel.data; const float* _kx = (const float*)kernel.data;
@ -1494,7 +1494,7 @@ struct SymmRowSmallVec_32f
{ {
if( !checkHardwareSupport(CV_CPU_SSE) ) if( !checkHardwareSupport(CV_CPU_SSE) )
return 0; return 0;
int i = 0, _ksize = kernel.rows + kernel.cols - 1; int i = 0, _ksize = kernel.rows + kernel.cols - 1;
float* dst = (float*)_dst; float* dst = (float*)_dst;
const float* src = (const float*)_src + (_ksize/2)*cn; const float* src = (const float*)_src + (_ksize/2)*cn;
@ -1594,12 +1594,12 @@ struct SymmRowSmallVec_32f
y0 = _mm_mul_ps(_mm_add_ps(y0, y2), k1); y0 = _mm_mul_ps(_mm_add_ps(y0, y2), k1);
x0 = _mm_add_ps(x0, _mm_mul_ps(x1, k0)); x0 = _mm_add_ps(x0, _mm_mul_ps(x1, k0));
y0 = _mm_add_ps(y0, _mm_mul_ps(y1, k0)); y0 = _mm_add_ps(y0, _mm_mul_ps(y1, k0));
x2 = _mm_add_ps(_mm_loadu_ps(src + cn*2), _mm_loadu_ps(src - cn*2)); x2 = _mm_add_ps(_mm_loadu_ps(src + cn*2), _mm_loadu_ps(src - cn*2));
y2 = _mm_add_ps(_mm_loadu_ps(src + cn*2 + 4), _mm_loadu_ps(src - cn*2 + 4)); y2 = _mm_add_ps(_mm_loadu_ps(src + cn*2 + 4), _mm_loadu_ps(src - cn*2 + 4));
x0 = _mm_add_ps(x0, _mm_mul_ps(x2, k2)); x0 = _mm_add_ps(x0, _mm_mul_ps(x2, k2));
y0 = _mm_add_ps(y0, _mm_mul_ps(y2, k2)); y0 = _mm_add_ps(y0, _mm_mul_ps(y2, k2));
_mm_store_ps(dst + i, x0); _mm_store_ps(dst + i, x0);
_mm_store_ps(dst + i + 4, y0); _mm_store_ps(dst + i + 4, y0);
} }
@ -1654,12 +1654,12 @@ struct SymmRowSmallVec_32f
x0 = _mm_mul_ps(_mm_sub_ps(x0, x2), k1); x0 = _mm_mul_ps(_mm_sub_ps(x0, x2), k1);
y0 = _mm_mul_ps(_mm_sub_ps(y0, y2), k1); y0 = _mm_mul_ps(_mm_sub_ps(y0, y2), k1);
x2 = _mm_sub_ps(_mm_loadu_ps(src + cn*2), _mm_loadu_ps(src - cn*2)); x2 = _mm_sub_ps(_mm_loadu_ps(src + cn*2), _mm_loadu_ps(src - cn*2));
y2 = _mm_sub_ps(_mm_loadu_ps(src + cn*2 + 4), _mm_loadu_ps(src - cn*2 + 4)); y2 = _mm_sub_ps(_mm_loadu_ps(src + cn*2 + 4), _mm_loadu_ps(src - cn*2 + 4));
x0 = _mm_add_ps(x0, _mm_mul_ps(x2, k2)); x0 = _mm_add_ps(x0, _mm_mul_ps(x2, k2));
y0 = _mm_add_ps(y0, _mm_mul_ps(y2, k2)); y0 = _mm_add_ps(y0, _mm_mul_ps(y2, k2));
_mm_store_ps(dst + i, x0); _mm_store_ps(dst + i, x0);
_mm_store_ps(dst + i + 4, y0); _mm_store_ps(dst + i + 4, y0);
} }
@ -1689,7 +1689,7 @@ struct SymmColumnVec_32f
{ {
if( !checkHardwareSupport(CV_CPU_SSE) ) if( !checkHardwareSupport(CV_CPU_SSE) )
return 0; return 0;
int ksize2 = (kernel.rows + kernel.cols - 1)/2; int ksize2 = (kernel.rows + kernel.cols - 1)/2;
const float* ky = (const float*)kernel.data + ksize2; const float* ky = (const float*)kernel.data + ksize2;
int i = 0, k; int i = 0, k;
@ -1829,7 +1829,7 @@ struct SymmColumnSmallVec_32f
{ {
if( !checkHardwareSupport(CV_CPU_SSE) ) if( !checkHardwareSupport(CV_CPU_SSE) )
return 0; return 0;
int ksize2 = (kernel.rows + kernel.cols - 1)/2; int ksize2 = (kernel.rows + kernel.cols - 1)/2;
const float* ky = (const float*)kernel.data + ksize2; const float* ky = (const float*)kernel.data + ksize2;
int i = 0; int i = 0;
@ -1963,7 +1963,7 @@ struct FilterVec_8u
{ {
if( !checkHardwareSupport(CV_CPU_SSE2) ) if( !checkHardwareSupport(CV_CPU_SSE2) )
return 0; return 0;
const float* kf = (const float*)&coeffs[0]; const float* kf = (const float*)&coeffs[0];
int i = 0, k, nz = _nz; int i = 0, k, nz = _nz;
__m128 d4 = _mm_set1_ps(delta); __m128 d4 = _mm_set1_ps(delta);
@ -2046,7 +2046,7 @@ struct FilterVec_8u16s
{ {
if( !checkHardwareSupport(CV_CPU_SSE2) ) if( !checkHardwareSupport(CV_CPU_SSE2) )
return 0; return 0;
const float* kf = (const float*)&coeffs[0]; const float* kf = (const float*)&coeffs[0];
short* dst = (short*)_dst; short* dst = (short*)_dst;
int i = 0, k, nz = _nz; int i = 0, k, nz = _nz;
@ -2127,7 +2127,7 @@ struct FilterVec_32f
{ {
if( !checkHardwareSupport(CV_CPU_SSE) ) if( !checkHardwareSupport(CV_CPU_SSE) )
return 0; return 0;
const float* kf = (const float*)&coeffs[0]; const float* kf = (const float*)&coeffs[0];
const float** src = (const float**)_src; const float** src = (const float**)_src;
float* dst = (float*)_dst; float* dst = (float*)_dst;
@ -2217,7 +2217,7 @@ template<typename ST, typename DT, class VecOp> struct RowFilter : public BaseRo
(kernel.rows == 1 || kernel.cols == 1)); (kernel.rows == 1 || kernel.cols == 1));
vecOp = _vecOp; vecOp = _vecOp;
} }
void operator()(const uchar* src, uchar* dst, int width, int cn) void operator()(const uchar* src, uchar* dst, int width, int cn)
{ {
int _ksize = ksize; int _ksize = ksize;
@ -2242,7 +2242,7 @@ template<typename ST, typename DT, class VecOp> struct RowFilter : public BaseRo
s0 += f*S[0]; s1 += f*S[1]; s0 += f*S[0]; s1 += f*S[1];
s2 += f*S[2]; s3 += f*S[3]; s2 += f*S[2]; s3 += f*S[3];
} }
D[i] = s0; D[i+1] = s1; D[i] = s0; D[i+1] = s1;
D[i+2] = s2; D[i+3] = s3; D[i+2] = s2; D[i+3] = s3;
} }
@ -2275,7 +2275,7 @@ template<typename ST, typename DT, class VecOp> struct SymmRowSmallFilter :
symmetryType = _symmetryType; symmetryType = _symmetryType;
CV_Assert( (symmetryType & (KERNEL_SYMMETRICAL | KERNEL_ASYMMETRICAL)) != 0 && this->ksize <= 5 ); CV_Assert( (symmetryType & (KERNEL_SYMMETRICAL | KERNEL_ASYMMETRICAL)) != 0 && this->ksize <= 5 );
} }
void operator()(const uchar* src, uchar* dst, int width, int cn) void operator()(const uchar* src, uchar* dst, int width, int cn)
{ {
int ksize2 = this->ksize/2, ksize2n = ksize2*cn; int ksize2 = this->ksize/2, ksize2n = ksize2*cn;
@ -2397,7 +2397,7 @@ template<class CastOp, class VecOp> struct ColumnFilter : public BaseColumnFilte
{ {
typedef typename CastOp::type1 ST; typedef typename CastOp::type1 ST;
typedef typename CastOp::rtype DT; typedef typename CastOp::rtype DT;
ColumnFilter( const Mat& _kernel, int _anchor, ColumnFilter( const Mat& _kernel, int _anchor,
double _delta, const CastOp& _castOp=CastOp(), double _delta, const CastOp& _castOp=CastOp(),
const VecOp& _vecOp=VecOp() ) const VecOp& _vecOp=VecOp() )
@ -2427,7 +2427,7 @@ template<class CastOp, class VecOp> struct ColumnFilter : public BaseColumnFilte
{ {
DT* D = (DT*)dst; DT* D = (DT*)dst;
i = vecOp(src, dst, width); i = vecOp(src, dst, width);
#if CV_ENABLE_UNROLLED #if CV_ENABLE_UNROLLED
for( ; i <= width - 4; i += 4 ) for( ; i <= width - 4; i += 4 )
{ {
ST f = ky[0]; ST f = ky[0];
@ -2574,7 +2574,7 @@ struct SymmColumnSmallFilter : public SymmColumnFilter<CastOp, VecOp>
{ {
typedef typename CastOp::type1 ST; typedef typename CastOp::type1 ST;
typedef typename CastOp::rtype DT; typedef typename CastOp::rtype DT;
SymmColumnSmallFilter( const Mat& _kernel, int _anchor, SymmColumnSmallFilter( const Mat& _kernel, int _anchor,
double _delta, int _symmetryType, double _delta, int _symmetryType,
const CastOp& _castOp=CastOp(), const CastOp& _castOp=CastOp(),
@ -2610,7 +2610,7 @@ struct SymmColumnSmallFilter : public SymmColumnFilter<CastOp, VecOp>
{ {
if( is_1_2_1 ) if( is_1_2_1 )
{ {
#if CV_ENABLE_UNROLLED #if CV_ENABLE_UNROLLED
for( ; i <= width - 4; i += 4 ) for( ; i <= width - 4; i += 4 )
{ {
ST s0 = S0[i] + S1[i]*2 + S2[i] + _delta; ST s0 = S0[i] + S1[i]*2 + S2[i] + _delta;
@ -2624,7 +2624,7 @@ struct SymmColumnSmallFilter : public SymmColumnFilter<CastOp, VecOp>
D[i+3] = castOp(s1); D[i+3] = castOp(s1);
} }
#else #else
for( ; i < width; i ++ ) for( ; i < width; i ++ )
{ {
ST s0 = S0[i] + S1[i]*2 + S2[i] + _delta; ST s0 = S0[i] + S1[i]*2 + S2[i] + _delta;
D[i] = castOp(s0); D[i] = castOp(s0);
@ -2633,7 +2633,7 @@ struct SymmColumnSmallFilter : public SymmColumnFilter<CastOp, VecOp>
} }
else if( is_1_m2_1 ) else if( is_1_m2_1 )
{ {
#if CV_ENABLE_UNROLLED #if CV_ENABLE_UNROLLED
for( ; i <= width - 4; i += 4 ) for( ; i <= width - 4; i += 4 )
{ {
ST s0 = S0[i] - S1[i]*2 + S2[i] + _delta; ST s0 = S0[i] - S1[i]*2 + S2[i] + _delta;
@ -2647,7 +2647,7 @@ struct SymmColumnSmallFilter : public SymmColumnFilter<CastOp, VecOp>
D[i+3] = castOp(s1); D[i+3] = castOp(s1);
} }
#else #else
for( ; i < width; i ++ ) for( ; i < width; i ++ )
{ {
ST s0 = S0[i] - S1[i]*2 + S2[i] + _delta; ST s0 = S0[i] - S1[i]*2 + S2[i] + _delta;
D[i] = castOp(s0); D[i] = castOp(s0);
@ -2700,7 +2700,7 @@ struct SymmColumnSmallFilter : public SymmColumnFilter<CastOp, VecOp>
D[i+3] = castOp(s1); D[i+3] = castOp(s1);
} }
#else #else
for( ; i < width; i ++ ) for( ; i < width; i ++ )
{ {
ST s0 = S2[i] - S0[i] + _delta; ST s0 = S2[i] - S0[i] + _delta;
D[i] = castOp(s0); D[i] = castOp(s0);
@ -2763,7 +2763,7 @@ template<typename ST, typename DT> struct FixedPtCastEx
}; };
} }
cv::Ptr<cv::BaseRowFilter> cv::getLinearRowFilter( int srcType, int bufType, cv::Ptr<cv::BaseRowFilter> cv::getLinearRowFilter( int srcType, int bufType,
InputArray _kernel, int anchor, InputArray _kernel, int anchor,
int symmetryType ) int symmetryType )
@ -2785,7 +2785,7 @@ cv::Ptr<cv::BaseRowFilter> cv::getLinearRowFilter( int srcType, int bufType,
return Ptr<BaseRowFilter>(new SymmRowSmallFilter<float, float, SymmRowSmallVec_32f> return Ptr<BaseRowFilter>(new SymmRowSmallFilter<float, float, SymmRowSmallVec_32f>
(kernel, anchor, symmetryType, SymmRowSmallVec_32f(kernel, symmetryType))); (kernel, anchor, symmetryType, SymmRowSmallVec_32f(kernel, symmetryType)));
} }
if( sdepth == CV_8U && ddepth == CV_32S ) if( sdepth == CV_8U && ddepth == CV_32S )
return Ptr<BaseRowFilter>(new RowFilter<uchar, int, RowVec_8u32s> return Ptr<BaseRowFilter>(new RowFilter<uchar, int, RowVec_8u32s>
(kernel, anchor, RowVec_8u32s(kernel))); (kernel, anchor, RowVec_8u32s(kernel)));
@ -2820,7 +2820,7 @@ cv::Ptr<cv::BaseRowFilter> cv::getLinearRowFilter( int srcType, int bufType,
cv::Ptr<cv::BaseColumnFilter> cv::getLinearColumnFilter( int bufType, int dstType, cv::Ptr<cv::BaseColumnFilter> cv::getLinearColumnFilter( int bufType, int dstType,
InputArray _kernel, int anchor, InputArray _kernel, int anchor,
int symmetryType, double delta, int symmetryType, double delta,
int bits ) int bits )
{ {
Mat kernel = _kernel.getMat(); Mat kernel = _kernel.getMat();
@ -3045,7 +3045,7 @@ template<typename ST, class CastOp, class VecOp> struct Filter2D : public BaseFi
{ {
typedef typename CastOp::type1 KT; typedef typename CastOp::type1 KT;
typedef typename CastOp::rtype DT; typedef typename CastOp::rtype DT;
Filter2D( const Mat& _kernel, Point _anchor, Filter2D( const Mat& _kernel, Point _anchor,
double _delta, const CastOp& _castOp=CastOp(), double _delta, const CastOp& _castOp=CastOp(),
const VecOp& _vecOp=VecOp() ) const VecOp& _vecOp=VecOp() )
@ -3143,7 +3143,7 @@ cv::Ptr<cv::BaseFilter> cv::getLinearFilter(int srcType, int dstType,
kernel = _kernel; kernel = _kernel;
else else
_kernel.convertTo(kernel, kdepth, _kernel.type() == CV_32S ? 1./(1 << bits) : 1.); _kernel.convertTo(kernel, kdepth, _kernel.type() == CV_32S ? 1./(1 << bits) : 1.);
if( sdepth == CV_8U && ddepth == CV_8U ) if( sdepth == CV_8U && ddepth == CV_8U )
return Ptr<BaseFilter>(new Filter2D<uchar, Cast<float, uchar>, FilterVec_8u> return Ptr<BaseFilter>(new Filter2D<uchar, Cast<float, uchar>, FilterVec_8u>
(kernel, anchor, delta, Cast<float, uchar>(), FilterVec_8u(kernel, 0, delta))); (kernel, anchor, delta, Cast<float, uchar>(), FilterVec_8u(kernel, 0, delta)));
@ -3203,7 +3203,7 @@ cv::Ptr<cv::FilterEngine> cv::createLinearFilter( int _srcType, int _dstType,
{ {
Mat _kernel = filter_kernel.getMat(); Mat _kernel = filter_kernel.getMat();
_srcType = CV_MAT_TYPE(_srcType); _srcType = CV_MAT_TYPE(_srcType);
_dstType = CV_MAT_TYPE(_dstType); _dstType = CV_MAT_TYPE(_dstType);
int cn = CV_MAT_CN(_srcType); int cn = CV_MAT_CN(_srcType);
CV_Assert( cn == CV_MAT_CN(_dstType) ); CV_Assert( cn == CV_MAT_CN(_dstType) );
@ -3211,14 +3211,14 @@ cv::Ptr<cv::FilterEngine> cv::createLinearFilter( int _srcType, int _dstType,
int bits = 0; int bits = 0;
/*int sdepth = CV_MAT_DEPTH(_srcType), ddepth = CV_MAT_DEPTH(_dstType); /*int sdepth = CV_MAT_DEPTH(_srcType), ddepth = CV_MAT_DEPTH(_dstType);
int ktype = _kernel.depth() == CV_32S ? KERNEL_INTEGER : getKernelType(_kernel, _anchor); int ktype = _kernel.depth() == CV_32S ? KERNEL_INTEGER : getKernelType(_kernel, _anchor);
if( sdepth == CV_8U && (ddepth == CV_8U || ddepth == CV_16S) && if( sdepth == CV_8U && (ddepth == CV_8U || ddepth == CV_16S) &&
_kernel.rows*_kernel.cols <= (1 << 10) ) _kernel.rows*_kernel.cols <= (1 << 10) )
{ {
bits = (ktype & KERNEL_INTEGER) ? 0 : 11; bits = (ktype & KERNEL_INTEGER) ? 0 : 11;
_kernel.convertTo(kernel, CV_32S, 1 << bits); _kernel.convertTo(kernel, CV_32S, 1 << bits);
}*/ }*/
Ptr<BaseFilter> _filter2D = getLinearFilter(_srcType, _dstType, Ptr<BaseFilter> _filter2D = getLinearFilter(_srcType, _dstType,
kernel, _anchor, _delta, bits); kernel, _anchor, _delta, bits);
@ -3233,7 +3233,7 @@ void cv::filter2D( InputArray _src, OutputArray _dst, int ddepth,
double delta, int borderType ) double delta, int borderType )
{ {
Mat src = _src.getMat(), kernel = _kernel.getMat(); Mat src = _src.getMat(), kernel = _kernel.getMat();
if( ddepth < 0 ) if( ddepth < 0 )
ddepth = src.depth(); ddepth = src.depth();
@ -3279,7 +3279,7 @@ void cv::sepFilter2D( InputArray _src, OutputArray _dst, int ddepth,
double delta, int borderType ) double delta, int borderType )
{ {
Mat src = _src.getMat(), kernelX = _kernelX.getMat(), kernelY = _kernelY.getMat(); Mat src = _src.getMat(), kernelX = _kernelX.getMat(), kernelY = _kernelY.getMat();
if( ddepth < 0 ) if( ddepth < 0 )
ddepth = src.depth(); ddepth = src.depth();

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

@ -64,7 +64,7 @@ private:
int ts; int ts;
int dist; int dist;
TWeight weight; TWeight weight;
uchar t; uchar t;
}; };
class Edge class Edge
{ {
@ -174,7 +174,7 @@ TWeight GCGraph<TWeight>::maxFlow()
v->t = v->weight < 0; v->t = v->weight < 0;
} }
else else
v->parent = 0; v->parent = 0;
} }
first = first->next; first = first->next;
last->next = nilNode; last->next = nilNode;
@ -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;

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

File diff suppressed because it is too large Load Diff

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 );
} }
} }
} }

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

@ -106,7 +106,7 @@ static void icvContourMoments( CvSeq* contour, CvMoments* moments )
yi_1 = ((CvPoint2D32f*)(reader.ptr))->y; yi_1 = ((CvPoint2D32f*)(reader.ptr))->y;
} }
CV_NEXT_SEQ_ELEM( contour->elem_size, reader ); CV_NEXT_SEQ_ELEM( contour->elem_size, reader );
xi_12 = xi_1 * xi_1; xi_12 = xi_1 * xi_1;
yi_12 = yi_1 * yi_1; yi_12 = yi_1 * yi_1;
@ -208,7 +208,7 @@ static void momentsInTile( const cv::Mat& img, double* moments )
const T* ptr = (const T*)(img.data + y*img.step); const T* ptr = (const T*)(img.data + y*img.step);
WT x0 = 0, x1 = 0, x2 = 0; WT x0 = 0, x1 = 0, x2 = 0;
MT x3 = 0; MT x3 = 0;
for( x = 0; x < size.width; x++ ) for( x = 0; x < size.width; x++ )
{ {
WT p = ptr[x]; WT p = ptr[x];
@ -248,21 +248,21 @@ 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);
for( y = 0; y < size.height; y++ ) for( y = 0; y < size.height; y++ )
{ {
const T* ptr = img.ptr<T>(y); const T* ptr = img.ptr<T>(y);
int x0 = 0, x1 = 0, x2 = 0, x3 = 0, x = 0; int x0 = 0, x1 = 0, x2 = 0, x3 = 0, x = 0;
if( useSIMD ) if( useSIMD )
{ {
__m128i qx_init = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7); __m128i qx_init = _mm_setr_epi16(0, 1, 2, 3, 4, 5, 6, 7);
__m128i dx = _mm_set1_epi16(8); __m128i dx = _mm_set1_epi16(8);
__m128i z = _mm_setzero_si128(), qx0 = z, qx1 = z, qx2 = z, qx3 = z, qx = qx_init; __m128i z = _mm_setzero_si128(), qx0 = z, qx1 = z, qx2 = z, qx3 = z, qx = qx_init;
for( ; x <= size.width - 8; x += 8 ) for( ; x <= size.width - 8; x += 8 )
{ {
__m128i p = _mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i*)(ptr + x)), z); __m128i p = _mm_unpacklo_epi8(_mm_loadl_epi64((const __m128i*)(ptr + x)), z);
@ -272,34 +272,34 @@ template<> void momentsInTile<uchar, int, int>( const cv::Mat& img, double* mome
qx1 = _mm_add_epi32(qx1, _mm_madd_epi16(p, qx)); qx1 = _mm_add_epi32(qx1, _mm_madd_epi16(p, qx));
qx2 = _mm_add_epi32(qx2, _mm_madd_epi16(p, sx)); qx2 = _mm_add_epi32(qx2, _mm_madd_epi16(p, sx));
qx3 = _mm_add_epi32(qx3, _mm_madd_epi16(px, sx)); qx3 = _mm_add_epi32(qx3, _mm_madd_epi16(px, sx));
qx = _mm_add_epi16(qx, dx); qx = _mm_add_epi16(qx, dx);
} }
int CV_DECL_ALIGNED(16) buf[4]; int CV_DECL_ALIGNED(16) buf[4];
_mm_store_si128((__m128i*)buf, qx0); _mm_store_si128((__m128i*)buf, qx0);
x0 = buf[0] + buf[1] + buf[2] + buf[3]; x0 = buf[0] + buf[1] + buf[2] + buf[3];
_mm_store_si128((__m128i*)buf, qx1); _mm_store_si128((__m128i*)buf, qx1);
x1 = buf[0] + buf[1] + buf[2] + buf[3]; x1 = buf[0] + buf[1] + buf[2] + buf[3];
_mm_store_si128((__m128i*)buf, qx2); _mm_store_si128((__m128i*)buf, qx2);
x2 = buf[0] + buf[1] + buf[2] + buf[3]; x2 = buf[0] + buf[1] + buf[2] + buf[3];
_mm_store_si128((__m128i*)buf, qx3); _mm_store_si128((__m128i*)buf, qx3);
x3 = buf[0] + buf[1] + buf[2] + buf[3]; x3 = buf[0] + buf[1] + buf[2] + buf[3];
} }
for( ; x < size.width; x++ ) for( ; x < size.width; x++ )
{ {
WT p = ptr[x]; WT p = ptr[x];
WT xp = x * p, xxp; WT xp = x * p, xxp;
x0 += p; x0 += p;
x1 += xp; x1 += xp;
xxp = xp * x; xxp = xp * x;
x2 += xxp; x2 += xxp;
x3 += xxp * x; x3 += xxp * x;
} }
WT py = y * x0, sy = y*y; WT py = y * x0, sy = y*y;
mom[9] += ((MT)py) * sy; // m03 mom[9] += ((MT)py) * sy; // m03
mom[8] += ((MT)x1) * sy; // m12 mom[8] += ((MT)x1) * sy; // m12
mom[7] += ((MT)x2) * y; // m21 mom[7] += ((MT)x2) * y; // m21
@ -311,8 +311,8 @@ template<> void momentsInTile<uchar, int, int>( const cv::Mat& img, double* mome
mom[1] += x1; // m10 mom[1] += x1; // m10
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];
} }
@ -366,7 +366,7 @@ CV_IMPL void cvMoments( const void* array, CvMoments* moments, int binary )
type = CV_MAT_TYPE( mat->type ); type = CV_MAT_TYPE( mat->type );
depth = CV_MAT_DEPTH( type ); depth = CV_MAT_DEPTH( type );
cn = CV_MAT_CN( type ); cn = CV_MAT_CN( type );
cv::Size size = cvGetMatSize( mat ); cv::Size size = cvGetMatSize( mat );
if( cn > 1 && coi == 0 ) if( cn > 1 && coi == 0 )
@ -387,14 +387,14 @@ CV_IMPL void cvMoments( const void* array, CvMoments* moments, int binary )
func = momentsInTile<double, double, double>; func = momentsInTile<double, double, double>;
else else
CV_Error( CV_StsUnsupportedFormat, "" ); CV_Error( CV_StsUnsupportedFormat, "" );
cv::Mat src0(mat); cv::Mat src0(mat);
for( int y = 0; y < size.height; y += TILE_SIZE ) for( int y = 0; y < size.height; y += TILE_SIZE )
{ {
cv::Size tileSize; cv::Size tileSize;
tileSize.height = std::min(TILE_SIZE, size.height - y); tileSize.height = std::min(TILE_SIZE, size.height - y);
for( int x = 0; x < size.width; x += TILE_SIZE ) for( int x = 0; x < size.width; x += TILE_SIZE )
{ {
tileSize.width = std::min(TILE_SIZE, size.width - x); tileSize.width = std::min(TILE_SIZE, size.width - x);
@ -413,20 +413,20 @@ CV_IMPL void cvMoments( const void* array, CvMoments* moments, int binary )
cv::compare( src, 0, tmp, CV_CMP_NE ); cv::compare( src, 0, tmp, CV_CMP_NE );
src = tmp; src = tmp;
} }
double mom[10]; double mom[10];
func( src, mom ); func( src, mom );
if(binary) if(binary)
{ {
double s = 1./255; double s = 1./255;
for( int k = 0; k < 10; k++ ) for( int k = 0; k < 10; k++ )
mom[k] *= s; mom[k] *= s;
} }
double xm = x * mom[0], ym = y * mom[0]; double xm = x * mom[0], ym = y * mom[0];
// accumulate moments computed in each tile // accumulate moments computed in each tile
// + m00 ( = m00' ) // + m00 ( = m00' )
moments->m00 += mom[0]; moments->m00 += mom[0];
@ -451,7 +451,7 @@ CV_IMPL void cvMoments( const void* array, CvMoments* moments, int binary )
// + m21 ( = m21' + x*(2*m11' + 2*y*m10' + x*m01' + x*y*m00') + y*m20') // + m21 ( = m21' + x*(2*m11' + 2*y*m10' + x*m01' + x*y*m00') + y*m20')
moments->m21 += mom[7] + x * (2 * (mom[4] + y * mom[1]) + x * (mom[2] + ym)) + y * mom[3]; moments->m21 += mom[7] + x * (2 * (mom[4] + y * mom[1]) + x * (mom[2] + ym)) + y * mom[3];
// + m12 ( = m12' + y*(2*m11' + 2*x*m01' + y*m10' + x*y*m00') + x*m02') // + m12 ( = m12' + y*(2*m11' + 2*x*m01' + y*m10' + x*y*m00') + x*m02')
moments->m12 += mom[8] + y * (2 * (mom[4] + x * mom[2]) + y * (mom[1] + xm)) + x * mom[5]; moments->m12 += mom[8] + y * (2 * (mom[4] + x * mom[2]) + y * (mom[1] + xm)) + x * mom[5];
@ -601,9 +601,9 @@ Moments::operator CvMoments() const
return m; return m;
} }
} }
cv::Moments cv::moments( InputArray _array, bool binaryImage ) cv::Moments cv::moments( InputArray _array, bool binaryImage )
{ {
CvMoments om; CvMoments om;

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

@ -49,7 +49,7 @@ cvArcLength( const void *array, CvSlice slice, int is_closed )
int i, j = 0, count; int i, j = 0, count;
const int N = 16; const int N = 16;
float buf[N]; float buf[N];
CvMat buffer = cvMat( 1, N, CV_32F, buf ); CvMat buffer = cvMat( 1, N, CV_32F, buf );
CvSeqReader reader; CvSeqReader reader;
CvContour contour_header; CvContour contour_header;
CvSeq* contour = 0; CvSeq* contour = 0;
@ -74,7 +74,7 @@ cvArcLength( const void *array, CvSlice slice, int is_closed )
if( contour->total > 1 ) if( contour->total > 1 )
{ {
int is_float = CV_SEQ_ELTYPE( contour ) == CV_32FC2; int is_float = CV_SEQ_ELTYPE( contour ) == CV_32FC2;
cvStartReadSeq( contour, &reader, 0 ); cvStartReadSeq( contour, &reader, 0 );
cvSetSeqReaderPos( &reader, slice.start_index ); cvSetSeqReaderPos( &reader, slice.start_index );
count = cvSliceLength( slice, contour ); count = cvSliceLength( slice, contour );
@ -110,7 +110,7 @@ cvArcLength( const void *array, CvSlice slice, int is_closed )
CV_NEXT_SEQ_ELEM( contour->elem_size, reader ); CV_NEXT_SEQ_ELEM( contour->elem_size, reader );
// Bugfix by Axel at rubico.com 2010-03-22, affects closed slices only // Bugfix by Axel at rubico.com 2010-03-22, affects closed slices only
// wraparound not handled by CV_NEXT_SEQ_ELEM // wraparound not handled by CV_NEXT_SEQ_ELEM
if( is_closed && i == count - 2 ) if( is_closed && i == count - 2 )
cvSetSeqReaderPos( &reader, slice.start_index ); cvSetSeqReaderPos( &reader, slice.start_index );
buffer.data.fl[j] = dx * dx + dy * dy; buffer.data.fl[j] = dx * dx + dy * dy;
@ -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 );
@ -375,14 +375,14 @@ cvMinEnclosingCircle( const void* array, CvPoint2D32f * _center, float *_radius
for( k = 0; k < max_iters; k++ ) for( k = 0; k < max_iters; k++ )
{ {
double min_delta = 0, delta; double min_delta = 0, delta;
CvPoint2D32f ptfl, farAway = { 0, 0}; CvPoint2D32f ptfl, farAway = { 0, 0};
/*only for first iteration because the alg is repared at the loop's foot*/ /*only for first iteration because the alg is repared at the loop's foot*/
if(k==0) if(k==0)
icvFindEnslosingCicle4pts_32f( pts, &center, &radius ); icvFindEnslosingCicle4pts_32f( pts, &center, &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 )
{ {
@ -406,22 +406,22 @@ cvMinEnclosingCircle( const void* array, CvPoint2D32f * _center, float *_radius
if( result ) if( result )
break; break;
CvPoint2D32f ptsCopy[4]; CvPoint2D32f ptsCopy[4];
/* find good replacement partner for the point which is at most far away, /* find good replacement partner for the point which is at most far away,
starting with the one that lays in the actual circle (i=3) */ starting with the one that lays in the actual circle (i=3) */
for(int i = 3; i >=0; i-- ) for(int i = 3; i >=0; i-- )
{ {
for(int j = 0; j < 4; j++ ) for(int j = 0; j < 4; j++ )
{ {
ptsCopy[j]=(i != j)? pts[j]: farAway; ptsCopy[j]=(i != j)? pts[j]: farAway;
} }
icvFindEnslosingCicle4pts_32f(ptsCopy, &center, &radius ); icvFindEnslosingCicle4pts_32f(ptsCopy, &center, &radius );
if( icvIsPtInCircle( pts[i], center, radius )>=0){ // replaced one again in the new circle? if( icvIsPtInCircle( pts[i], center, radius )>=0){ // replaced one again in the new circle?
pts[i] = farAway; pts[i] = farAway;
break; break;
} }
} }
} }
if( !result ) if( !result )
@ -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;
@ -486,7 +486,7 @@ icvContourArea( const CvSeq* contour, double *area )
yi_1 = ((CvPoint2D32f*)(reader.ptr))->y; yi_1 = ((CvPoint2D32f*)(reader.ptr))->y;
} }
CV_NEXT_SEQ_ELEM( contour->elem_size, reader ); CV_NEXT_SEQ_ELEM( contour->elem_size, reader );
while( lpt-- > 0 ) while( lpt-- > 0 )
{ {
double dxy, xi, yi; double dxy, xi, yi;
@ -520,7 +520,7 @@ icvContourArea( const CvSeq* contour, double *area )
/****************************************************************************************\ /****************************************************************************************\
copy data from one buffer to other buffer copy data from one buffer to other buffer
\****************************************************************************************/ \****************************************************************************************/
@ -797,9 +797,9 @@ cvFitEllipse2( const CvArr* array )
n = ptseq->total; n = ptseq->total;
if( n < 5 ) if( n < 5 )
CV_Error( CV_StsBadSize, "Number of points should be >= 5" ); CV_Error( CV_StsBadSize, "Number of points should be >= 5" );
/* /*
* New fitellipse algorithm, contributed by Dr. Daniel Weiss * New fitellipse algorithm, contributed by Dr. Daniel Weiss
*/ */
CvPoint2D32f c = {0,0}; CvPoint2D32f c = {0,0};
double gfp[5], rp[5], t; double gfp[5], rp[5], t;
@ -818,7 +818,7 @@ cvFitEllipse2( const CvArr* array )
cvStartReadSeq( ptseq, &reader ); cvStartReadSeq( ptseq, &reader );
is_float = CV_SEQ_ELTYPE(ptseq) == CV_32FC2; is_float = CV_SEQ_ELTYPE(ptseq) == CV_32FC2;
for( i = 0; i < n; i++ ) for( i = 0; i < n; i++ )
{ {
CvPoint2D32f p; CvPoint2D32f p;
@ -857,7 +857,7 @@ cvFitEllipse2( const CvArr* array )
Ad[i*5 + 3] = p.x; Ad[i*5 + 3] = p.x;
Ad[i*5 + 4] = p.y; Ad[i*5 + 4] = p.y;
} }
cvSolve( &A, &b, &x, CV_SVD ); cvSolve( &A, &b, &x, CV_SVD );
// now use general-form parameters A - E to find the ellipse center: // now use general-form parameters A - E to find the ellipse center:
@ -1069,7 +1069,7 @@ cvBoundingRect( CvArr* array, int update )
xmin = ymin = 0; xmin = ymin = 0;
} }
else if( ptseq->total ) else if( ptseq->total )
{ {
int is_float = CV_SEQ_ELTYPE(ptseq) == CV_32FC2; int is_float = CV_SEQ_ELTYPE(ptseq) == CV_32FC2;
cvStartReadSeq( ptseq, &reader, 0 ); cvStartReadSeq( ptseq, &reader, 0 );
@ -1082,12 +1082,12 @@ cvBoundingRect( CvArr* array, int update )
ymin = ymax = pt.y; ymin = ymax = pt.y;
for( i = 1; i < ptseq->total; i++ ) for( i = 1; i < ptseq->total; i++ )
{ {
CV_READ_SEQ_ELEM( pt, reader ); CV_READ_SEQ_ELEM( pt, reader );
if( xmin > pt.x ) if( xmin > pt.x )
xmin = pt.x; xmin = pt.x;
if( xmax < pt.x ) if( xmax < pt.x )
xmax = pt.x; xmax = pt.x;
@ -1108,14 +1108,14 @@ cvBoundingRect( CvArr* array, int update )
ymin = ymax = CV_TOGGLE_FLT(pt.y); ymin = ymax = CV_TOGGLE_FLT(pt.y);
for( i = 1; i < ptseq->total; i++ ) for( i = 1; i < ptseq->total; i++ )
{ {
CV_READ_SEQ_ELEM( pt, reader ); CV_READ_SEQ_ELEM( pt, reader );
pt.x = CV_TOGGLE_FLT(pt.x); pt.x = CV_TOGGLE_FLT(pt.x);
pt.y = CV_TOGGLE_FLT(pt.y); pt.y = CV_TOGGLE_FLT(pt.y);
if( xmin > pt.x ) if( xmin > pt.x )
xmin = pt.x; xmin = pt.x;
if( xmax < pt.x ) if( xmax < pt.x )
xmax = pt.x; xmax = pt.x;
@ -1144,7 +1144,7 @@ cvBoundingRect( CvArr* array, int update )
if( update ) if( update )
((CvContour*)ptseq)->rect = rect; ((CvContour*)ptseq)->rect = rect;
return rect; return rect;
} }

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

@ -48,7 +48,7 @@ cv::Mat cv::getDefaultNewCameraMatrix( InputArray _cameraMatrix, Size imgsize,
Mat cameraMatrix = _cameraMatrix.getMat(); Mat cameraMatrix = _cameraMatrix.getMat();
if( !centerPrincipalPoint && cameraMatrix.type() == CV_64F ) if( !centerPrincipalPoint && cameraMatrix.type() == CV_64F )
return cameraMatrix; return cameraMatrix;
Mat newCameraMatrix; Mat newCameraMatrix;
cameraMatrix.convertTo(newCameraMatrix, CV_64F); cameraMatrix.convertTo(newCameraMatrix, CV_64F);
if( centerPrincipalPoint ) if( centerPrincipalPoint )
@ -65,7 +65,7 @@ void cv::initUndistortRectifyMap( InputArray _cameraMatrix, InputArray _distCoef
{ {
Mat cameraMatrix = _cameraMatrix.getMat(), distCoeffs = _distCoeffs.getMat(); Mat cameraMatrix = _cameraMatrix.getMat(), distCoeffs = _distCoeffs.getMat();
Mat matR = _matR.getMat(), newCameraMatrix = _newCameraMatrix.getMat(); Mat matR = _matR.getMat(), newCameraMatrix = _newCameraMatrix.getMat();
if( m1type <= 0 ) if( m1type <= 0 )
m1type = CV_16SC2; m1type = CV_16SC2;
CV_Assert( m1type == CV_16SC2 || m1type == CV_32FC1 || m1type == CV_32FC2 ); CV_Assert( m1type == CV_16SC2 || m1type == CV_32FC1 || m1type == CV_32FC2 );
@ -106,7 +106,7 @@ void cv::initUndistortRectifyMap( InputArray _cameraMatrix, InputArray _distCoef
double u0 = A(0, 2), v0 = A(1, 2); double u0 = A(0, 2), v0 = A(1, 2);
double fx = A(0, 0), fy = A(1, 1); double fx = A(0, 0), fy = A(1, 1);
CV_Assert( distCoeffs.size() == Size(1, 4) || distCoeffs.size() == Size(4, 1) || CV_Assert( distCoeffs.size() == Size(1, 4) || distCoeffs.size() == Size(4, 1) ||
distCoeffs.size() == Size(1, 5) || distCoeffs.size() == Size(5, 1) || distCoeffs.size() == Size(1, 5) || distCoeffs.size() == Size(5, 1) ||
distCoeffs.size() == Size(1, 8) || distCoeffs.size() == Size(8, 1)); distCoeffs.size() == Size(1, 8) || distCoeffs.size() == Size(8, 1));
@ -166,10 +166,10 @@ void cv::undistort( InputArray _src, OutputArray _dst, InputArray _cameraMatrix,
{ {
Mat src = _src.getMat(), cameraMatrix = _cameraMatrix.getMat(); Mat src = _src.getMat(), cameraMatrix = _cameraMatrix.getMat();
Mat distCoeffs = _distCoeffs.getMat(), newCameraMatrix = _newCameraMatrix.getMat(); Mat distCoeffs = _distCoeffs.getMat(), newCameraMatrix = _newCameraMatrix.getMat();
_dst.create( src.size(), src.type() ); _dst.create( src.size(), src.type() );
Mat dst = _dst.getMat(); Mat dst = _dst.getMat();
CV_Assert( dst.data != src.data ); CV_Assert( dst.data != src.data );
int stripe_size0 = std::min(std::max(1, (1 << 12) / std::max(src.cols, 1)), src.rows); int stripe_size0 = std::min(std::max(1, (1 << 12) / std::max(src.cols, 1)), src.rows);
@ -289,11 +289,11 @@ void cvUndistortPoints( const CvMat* _src, CvMat* _dst, const CvMat* _cameraMatr
(_distCoeffs->rows == 1 || _distCoeffs->cols == 1) && (_distCoeffs->rows == 1 || _distCoeffs->cols == 1) &&
(_distCoeffs->rows*_distCoeffs->cols == 4 || (_distCoeffs->rows*_distCoeffs->cols == 4 ||
_distCoeffs->rows*_distCoeffs->cols == 5 || _distCoeffs->rows*_distCoeffs->cols == 5 ||
_distCoeffs->rows*_distCoeffs->cols == 8)); _distCoeffs->rows*_distCoeffs->cols == 8));
_Dk = cvMat( _distCoeffs->rows, _distCoeffs->cols, _Dk = cvMat( _distCoeffs->rows, _distCoeffs->cols,
CV_MAKETYPE(CV_64F,CV_MAT_CN(_distCoeffs->type)), k); CV_MAKETYPE(CV_64F,CV_MAT_CN(_distCoeffs->type)), k);
cvConvert( _distCoeffs, &_Dk ); cvConvert( _distCoeffs, &_Dk );
iters = 5; iters = 5;
} }
@ -389,13 +389,13 @@ void cv::undistortPoints( InputArray _src, OutputArray _dst,
{ {
Mat src = _src.getMat(), cameraMatrix = _cameraMatrix.getMat(); Mat src = _src.getMat(), cameraMatrix = _cameraMatrix.getMat();
Mat distCoeffs = _distCoeffs.getMat(), R = _Rmat.getMat(), P = _Pmat.getMat(); Mat distCoeffs = _distCoeffs.getMat(), R = _Rmat.getMat(), P = _Pmat.getMat();
CV_Assert( src.isContinuous() && (src.depth() == CV_32F || src.depth() == CV_64F) && CV_Assert( src.isContinuous() && (src.depth() == CV_32F || src.depth() == CV_64F) &&
((src.rows == 1 && src.channels() == 2) || src.cols*src.channels() == 2)); ((src.rows == 1 && src.channels() == 2) || src.cols*src.channels() == 2));
_dst.create(src.size(), src.type(), -1, true); _dst.create(src.size(), src.type(), -1, true);
Mat dst = _dst.getMat(); Mat dst = _dst.getMat();
CvMat _csrc = src, _cdst = dst, _ccameraMatrix = cameraMatrix; CvMat _csrc = src, _cdst = dst, _ccameraMatrix = cameraMatrix;
CvMat matR, matP, _cdistCoeffs, *pR=0, *pP=0, *pD=0; CvMat matR, matP, _cdistCoeffs, *pR=0, *pP=0, *pD=0;
if( R.data ) if( R.data )
@ -416,11 +416,11 @@ static Point2f mapPointSpherical(const Point2f& p, float alpha, Vec4d* J, int pr
double beta = 1 + 2*alpha; double beta = 1 + 2*alpha;
double v = x*x + y*y + 1, iv = 1/v; double v = x*x + y*y + 1, iv = 1/v;
double u = sqrt(beta*v + alpha*alpha); double u = sqrt(beta*v + alpha*alpha);
double k = (u - alpha)*iv; double k = (u - alpha)*iv;
double kv = (v*beta/u - (u - alpha)*2)*iv*iv; double kv = (v*beta/u - (u - alpha)*2)*iv*iv;
double kx = kv*x, ky = kv*y; double kx = kv*x, ky = kv*y;
if( projType == PROJ_SPHERICAL_ORTHO ) if( projType == PROJ_SPHERICAL_ORTHO )
{ {
if(J) if(J)
@ -433,7 +433,7 @@ static Point2f mapPointSpherical(const Point2f& p, float alpha, Vec4d* J, int pr
double iR = 1/(alpha + 1); double iR = 1/(alpha + 1);
double x1 = std::max(std::min(x*k*iR, 1.), -1.); double x1 = std::max(std::min(x*k*iR, 1.), -1.);
double y1 = std::max(std::min(y*k*iR, 1.), -1.); double y1 = std::max(std::min(y*k*iR, 1.), -1.);
if(J) if(J)
{ {
double fx1 = iR/sqrt(1 - x1*x1); double fx1 = iR/sqrt(1 - x1*x1);
@ -446,35 +446,35 @@ static Point2f mapPointSpherical(const Point2f& p, float alpha, Vec4d* J, int pr
return Point2f(); return Point2f();
} }
static Point2f invMapPointSpherical(Point2f _p, float alpha, int projType) static Point2f invMapPointSpherical(Point2f _p, float alpha, int projType)
{ {
static int avgiter = 0, avgn = 0; static int avgiter = 0, avgn = 0;
double eps = 1e-12; double eps = 1e-12;
Vec2d p(_p.x, _p.y), q(_p.x, _p.y), err; Vec2d p(_p.x, _p.y), q(_p.x, _p.y), err;
Vec4d J; Vec4d J;
int i, maxiter = 5; int i, maxiter = 5;
for( i = 0; i < maxiter; i++ ) for( i = 0; i < maxiter; i++ )
{ {
Point2f p1 = mapPointSpherical(Point2f((float)q[0], (float)q[1]), alpha, &J, projType); Point2f p1 = mapPointSpherical(Point2f((float)q[0], (float)q[1]), alpha, &J, projType);
err = Vec2d(p1.x, p1.y) - p; err = Vec2d(p1.x, p1.y) - p;
if( err[0]*err[0] + err[1]*err[1] < eps ) if( err[0]*err[0] + err[1]*err[1] < eps )
break; break;
Vec4d JtJ(J[0]*J[0] + J[2]*J[2], J[0]*J[1] + J[2]*J[3], Vec4d JtJ(J[0]*J[0] + J[2]*J[2], J[0]*J[1] + J[2]*J[3],
J[0]*J[1] + J[2]*J[3], J[1]*J[1] + J[3]*J[3]); J[0]*J[1] + J[2]*J[3], J[1]*J[1] + J[3]*J[3]);
double d = JtJ[0]*JtJ[3] - JtJ[1]*JtJ[2]; double d = JtJ[0]*JtJ[3] - JtJ[1]*JtJ[2];
d = d ? 1./d : 0; d = d ? 1./d : 0;
Vec4d iJtJ(JtJ[3]*d, -JtJ[1]*d, -JtJ[2]*d, JtJ[0]*d); Vec4d iJtJ(JtJ[3]*d, -JtJ[1]*d, -JtJ[2]*d, JtJ[0]*d);
Vec2d JtErr(J[0]*err[0] + J[2]*err[1], J[1]*err[0] + J[3]*err[1]); Vec2d JtErr(J[0]*err[0] + J[2]*err[1], J[1]*err[0] + J[3]*err[1]);
q -= Vec2d(iJtJ[0]*JtErr[0] + iJtJ[1]*JtErr[1], iJtJ[2]*JtErr[0] + iJtJ[3]*JtErr[1]); q -= Vec2d(iJtJ[0]*JtErr[0] + iJtJ[1]*JtErr[1], iJtJ[2]*JtErr[0] + iJtJ[3]*JtErr[1]);
//Matx22d J(kx*x + k, kx*y, ky*x, ky*y + k); //Matx22d J(kx*x + k, kx*y, ky*x, ky*y + k);
//q -= Vec2d((J.t()*J).inv()*(J.t()*err)); //q -= Vec2d((J.t()*J).inv()*(J.t()*err));
} }
if( i < maxiter ) if( i < maxiter )
{ {
avgiter += i; avgiter += i;
@ -482,12 +482,12 @@ static Point2f invMapPointSpherical(Point2f _p, float alpha, int projType)
if( avgn == 1500 ) if( avgn == 1500 )
printf("avg iters = %g\n", (double)avgiter/avgn); printf("avg iters = %g\n", (double)avgiter/avgn);
} }
return i < maxiter ? Point2f((float)q[0], (float)q[1]) : Point2f(-FLT_MAX, -FLT_MAX); return i < maxiter ? Point2f((float)q[0], (float)q[1]) : Point2f(-FLT_MAX, -FLT_MAX);
} }
} }
float cv::initWideAngleProjMap( InputArray _cameraMatrix0, InputArray _distCoeffs0, float cv::initWideAngleProjMap( InputArray _cameraMatrix0, InputArray _distCoeffs0,
Size imageSize, int destImageWidth, int m1type, Size imageSize, int destImageWidth, int m1type,
OutputArray _map1, OutputArray _map2, int projType, double _alpha ) OutputArray _map1, OutputArray _map2, int projType, double _alpha )
@ -500,40 +500,40 @@ 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();
CV_Assert((distCoeffs0.cols == 1 || distCoeffs0.rows == 1) && CV_Assert((distCoeffs0.cols == 1 || distCoeffs0.rows == 1) &&
(ndcoeffs == 4 || ndcoeffs == 5 || ndcoeffs == 8)); (ndcoeffs == 4 || ndcoeffs == 5 || ndcoeffs == 8));
CV_Assert(cameraMatrix0.size() == Size(3,3)); CV_Assert(cameraMatrix0.size() == Size(3,3));
distCoeffs0.convertTo(distCoeffs,CV_64F); distCoeffs0.convertTo(distCoeffs,CV_64F);
cameraMatrix0.convertTo(cameraMatrix,CV_64F); cameraMatrix0.convertTo(cameraMatrix,CV_64F);
alpha = std::min(alpha, 0.999f); alpha = std::min(alpha, 0.999f);
for( int i = 0; i < N; i++ ) for( int i = 0; i < N; i++ )
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;
if( ymax < q.y ) ymax = q.y; if( ymax < q.y ) ymax = q.y;
} }
float scale = (float)std::min(dcenter.x/fabs(xmax), dcenter.x/fabs(xmin)); float scale = (float)std::min(dcenter.x/fabs(xmax), dcenter.x/fabs(xmin));
Size dsize(destImageWidth, cvCeil(std::max(scale*fabs(ymin)*2, scale*fabs(ymax)*2))); Size dsize(destImageWidth, cvCeil(std::max(scale*fabs(ymin)*2, scale*fabs(ymax)*2)));
dcenter.y = (dsize.height - 1)*0.5f; dcenter.y = (dsize.height - 1)*0.5f;
Mat mapxy(dsize, CV_32FC2); Mat mapxy(dsize, CV_32FC2);
double k1 = k[0], k2 = k[1], k3 = k[2], p1 = k[3], p2 = k[4], k4 = k[5], k5 = k[6], k6 = k[7]; double k1 = k[0], k2 = k[1], k3 = k[2], p1 = k[3], p2 = k[4], k4 = k[5], k5 = k[6], k6 = k[7];
double fx = cameraMatrix.at<double>(0,0), fy = cameraMatrix.at<double>(1,1), cx = scenter.x, cy = scenter.y; double fx = cameraMatrix.at<double>(0,0), fy = cameraMatrix.at<double>(1,1), cx = scenter.x, cy = scenter.y;
for( int y = 0; y < dsize.height; y++ ) for( int y = 0; y < dsize.height; y++ )
{ {
Point2f* mxy = mapxy.ptr<Point2f>(y); Point2f* mxy = mapxy.ptr<Point2f>(y);
@ -551,11 +551,11 @@ float cv::initWideAngleProjMap( InputArray _cameraMatrix0, InputArray _distCoeff
double kr = 1 + ((k3*r2 + k2)*r2 + k1)*r2/(1 + ((k6*r2 + k5)*r2 + k4)*r2); double kr = 1 + ((k3*r2 + k2)*r2 + k1)*r2/(1 + ((k6*r2 + k5)*r2 + k4)*r2);
double u = fx*(q.x*kr + p1*_2xy + p2*(r2 + 2*x2)) + cx; double u = fx*(q.x*kr + p1*_2xy + p2*(r2 + 2*x2)) + cx;
double v = fy*(q.y*kr + p1*(r2 + 2*y2) + p2*_2xy) + cy; double v = fy*(q.y*kr + p1*(r2 + 2*y2) + p2*_2xy) + cy;
mxy[x] = Point2f((float)u, (float)v); mxy[x] = Point2f((float)u, (float)v);
} }
} }
if(m1type == CV_32FC2) if(m1type == CV_32FC2)
{ {
_map1.create(mapxy.size(), mapxy.type()); _map1.create(mapxy.size(), mapxy.type());
@ -565,7 +565,7 @@ float cv::initWideAngleProjMap( InputArray _cameraMatrix0, InputArray _distCoeff
} }
else else
convertMaps(mapxy, Mat(), _map1, _map2, m1type, false); convertMaps(mapxy, Mat(), _map1, _map2, m1type, false);
return scale; return scale;
} }

8
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 );
@ -284,7 +284,7 @@ int CV_FindContourTest::validate_test_results( int /*test_case_idx*/ )
Mat _img[4]; Mat _img[4];
for( int i = 0; i < 4; i++ ) for( int i = 0; i < 4; i++ )
_img[i] = cvarrToMat(img[i]); _img[i] = cvarrToMat(img[i]);
code = cvtest::cmpEps2(ts, _img[0], _img[3], 0, true, "Comparing original image with the map of filled contours" ); code = cvtest::cmpEps2(ts, _img[0], _img[3], 0, true, "Comparing original image with the map of filled contours" );
if( code < 0 ) if( code < 0 )
@ -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;

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

@ -193,7 +193,7 @@ protected:
void* result; void* result;
double low_high_range; double low_high_range;
CvScalar low, high; CvScalar low, high;
bool test_cpp; bool test_cpp;
}; };
@ -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);
@ -362,7 +362,7 @@ int CV_BaseShapeDescrTest::prepare_test_case( int test_case_idx )
} }
generate_point_set( points ); generate_point_set( points );
test_cpp = (cvtest::randInt(rng) & 16) == 0; test_cpp = (cvtest::randInt(rng) & 16) == 0;
return 1; return 1;
} }
@ -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);
@ -1171,7 +1171,7 @@ class CV_FitEllipseSmallTest : public cvtest::BaseTest
{ {
public: public:
CV_FitEllipseSmallTest() {} CV_FitEllipseSmallTest() {}
~CV_FitEllipseSmallTest() {} ~CV_FitEllipseSmallTest() {}
protected: protected:
void run(int) void run(int)
{ {
@ -1188,7 +1188,7 @@ protected:
c[0].push_back(Point(8, 6)*scale+ofs); c[0].push_back(Point(8, 6)*scale+ofs);
c[0].push_back(Point(8, 2)*scale+ofs); c[0].push_back(Point(8, 2)*scale+ofs);
c[0].push_back(Point(6, 0)*scale+ofs); c[0].push_back(Point(6, 0)*scale+ofs);
RotatedRect e = fitEllipse(c[0]); RotatedRect e = fitEllipse(c[0]);
CV_Assert( fabs(e.center.x - 4) <= 1. && CV_Assert( fabs(e.center.x - 4) <= 1. &&
fabs(e.center.y - 4) <= 1. && fabs(e.center.y - 4) <= 1. &&
@ -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;
@ -1614,8 +1614,8 @@ class CV_PerimeterAreaSliceTest : public cvtest::BaseTest
{ {
public: public:
CV_PerimeterAreaSliceTest(); CV_PerimeterAreaSliceTest();
~CV_PerimeterAreaSliceTest(); ~CV_PerimeterAreaSliceTest();
protected: protected:
void run(int); void run(int);
}; };
@ -1629,7 +1629,7 @@ void CV_PerimeterAreaSliceTest::run( int )
Ptr<CvMemStorage> storage = cvCreateMemStorage(); Ptr<CvMemStorage> storage = cvCreateMemStorage();
RNG& rng = theRNG(); RNG& rng = theRNG();
const double min_r = 90, max_r = 120; const double min_r = 90, max_r = 120;
for( int i = 0; i < 100; i++ ) for( int i = 0; i < 100; i++ )
{ {
ts->update_context( this, i, true ); ts->update_context( this, i, true );
@ -1640,7 +1640,7 @@ void CV_PerimeterAreaSliceTest::run( int )
CvPoint center; CvPoint center;
center.x = rng.uniform(cvCeil(max_r), cvFloor(640-max_r)); center.x = rng.uniform(cvCeil(max_r), cvFloor(640-max_r));
center.y = rng.uniform(cvCeil(max_r), cvFloor(480-max_r)); center.y = rng.uniform(cvCeil(max_r), cvFloor(480-max_r));
for( int j = 0; j < n; j++ ) for( int j = 0; j < n; j++ )
{ {
CvPoint pt; CvPoint pt;
@ -1650,7 +1650,7 @@ void CV_PerimeterAreaSliceTest::run( int )
pt.y = cvRound(center.y - r*sin(phi)); pt.y = cvRound(center.y - r*sin(phi));
cvSeqPush(contour, &pt); cvSeqPush(contour, &pt);
} }
CvSlice slice; CvSlice slice;
for(;;) for(;;)
{ {
@ -1664,14 +1664,14 @@ void CV_PerimeterAreaSliceTest::run( int )
/*printf( "%d. (%d, %d) of %d, length = %d, length1 = %d\n", /*printf( "%d. (%d, %d) of %d, length = %d, length1 = %d\n",
i, slice.start_index, slice.end_index, i, slice.start_index, slice.end_index,
contour->total, cvSliceLength(slice, contour), cslice->total ); contour->total, cvSliceLength(slice, contour), cslice->total );
double area0 = cvContourArea(cslice); double area0 = cvContourArea(cslice);
double area1 = cvContourArea(contour, slice); double area1 = cvContourArea(contour, slice);
if( area0 != area1 ) if( area0 != area1 )
{ {
ts->printf(cvtest::TS::LOG, ts->printf(cvtest::TS::LOG,
"The contour area slice is computed differently (%g vs %g)\n", area0, area1 ); "The contour area slice is computed differently (%g vs %g)\n", area0, area1 );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY ); ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return; return;
}*/ }*/
@ -1681,7 +1681,7 @@ void CV_PerimeterAreaSliceTest::run( int )
{ {
ts->printf(cvtest::TS::LOG, ts->printf(cvtest::TS::LOG,
"The contour arc length is computed differently (%g vs %g)\n", len0, len1 ); "The contour arc length is computed differently (%g vs %g)\n", len0, len1 );
ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY ); ts->set_failed_test_info( cvtest::TS::FAIL_BAD_ACCURACY );
return; return;
} }
} }

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

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

@ -56,7 +56,7 @@ protected:
void prepare_to_validation( int ); void prepare_to_validation( int );
void fill_array( int test_case_idx, int i, int j, Mat& arr ); void fill_array( int test_case_idx, int i, int j, Mat& arr );
/*int write_default_params(CvFileStorage* fs); /*int write_default_params(CvFileStorage* fs);
void get_timing_test_array_types_and_sizes( int test_case_idx, vector<vector<Size> >& sizes, vector<vector<int> >& types void get_timing_test_array_types_and_sizes( int test_case_idx, vector<vector<Size> >& sizes, vector<vector<int> >& types
CvSize** whole_sizes, bool *are_images ); CvSize** whole_sizes, bool *are_images );
@ -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;
@ -111,7 +111,7 @@ void CV_FloodFillTest::get_test_array_types_and_sizes( int test_case_idx,
types[INPUT_OUTPUT][1] = types[REF_INPUT_OUTPUT][1] = CV_8UC1; types[INPUT_OUTPUT][1] = types[REF_INPUT_OUTPUT][1] = CV_8UC1;
types[OUTPUT][0] = types[REF_OUTPUT][0] = CV_64FC1; types[OUTPUT][0] = types[REF_OUTPUT][0] = CV_64FC1;
sizes[OUTPUT][0] = sizes[REF_OUTPUT][0] = cvSize(9,1); sizes[OUTPUT][0] = sizes[REF_OUTPUT][0] = cvSize(9,1);
if( !use_mask ) if( !use_mask )
sizes[INPUT_OUTPUT][1] = sizes[REF_INPUT_OUTPUT][1] = cvSize(0,0); sizes[INPUT_OUTPUT][1] = sizes[REF_INPUT_OUTPUT][1] = cvSize(0,0);
else else
@ -119,7 +119,7 @@ void CV_FloodFillTest::get_test_array_types_and_sizes( int test_case_idx,
CvSize sz = sizes[INPUT_OUTPUT][0]; CvSize sz = sizes[INPUT_OUTPUT][0];
sizes[INPUT_OUTPUT][1] = sizes[REF_INPUT_OUTPUT][1] = cvSize(sz.width+2,sz.height+2); sizes[INPUT_OUTPUT][1] = sizes[REF_INPUT_OUTPUT][1] = cvSize(sz.width+2,sz.height+2);
} }
seed_pt.x = cvtest::randInt(rng) % sizes[INPUT_OUTPUT][0].width; seed_pt.x = cvtest::randInt(rng) % sizes[INPUT_OUTPUT][0].width;
seed_pt.y = cvtest::randInt(rng) % sizes[INPUT_OUTPUT][0].height; seed_pt.y = cvtest::randInt(rng) % sizes[INPUT_OUTPUT][0].height;
@ -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++ )
{ {
@ -139,7 +139,7 @@ void CV_FloodFillTest::get_test_array_types_and_sizes( int test_case_idx,
new_val = Scalar::all(0.); new_val = Scalar::all(0.);
for( i = 0; i < cn; i++ ) for( i = 0; i < cn; i++ )
new_val.val[i] = cvtest::randReal(rng)*255; new_val.val[i] = cvtest::randReal(rng)*255;
test_cpp = (cvtest::randInt(rng) & 256) == 0; test_cpp = (cvtest::randInt(rng) & 256) == 0;
} }
@ -153,13 +153,13 @@ double CV_FloodFillTest::get_success_error_level( int /*test_case_idx*/, int i,
void CV_FloodFillTest::fill_array( int test_case_idx, int i, int j, Mat& arr ) void CV_FloodFillTest::fill_array( int test_case_idx, int i, int j, Mat& arr )
{ {
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
if( i != INPUT && i != INPUT_OUTPUT ) if( i != INPUT && i != INPUT_OUTPUT )
{ {
cvtest::ArrayTest::fill_array( test_case_idx, i, j, arr ); cvtest::ArrayTest::fill_array( test_case_idx, i, j, arr );
return; return;
} }
if( j == 0 ) if( j == 0 )
{ {
Mat tmp = arr; Mat tmp = arr;
@ -191,7 +191,7 @@ void CV_FloodFillTest::run_func()
int flags = connectivity + (mask_only ? CV_FLOODFILL_MASK_ONLY : 0) + int flags = connectivity + (mask_only ? CV_FLOODFILL_MASK_ONLY : 0) +
(range_type == 1 ? CV_FLOODFILL_FIXED_RANGE : 0) + (new_mask_val << 8); (range_type == 1 ? CV_FLOODFILL_FIXED_RANGE : 0) + (new_mask_val << 8);
double* odata = test_mat[OUTPUT][0].ptr<double>(); double* odata = test_mat[OUTPUT][0].ptr<double>();
if(!test_cpp) if(!test_cpp)
{ {
CvConnectedComp comp; CvConnectedComp comp;
@ -255,7 +255,7 @@ cvTsFloodFill( CvMat* _img, CvPoint seed_pt, CvScalar new_val,
int cols = _img->cols, rows = _img->rows; int cols = _img->cols, rows = _img->rows;
int u0 = 0, u1 = 0, u2 = 0; int u0 = 0, u1 = 0, u2 = 0;
double s0 = 0, s1 = 0, s2 = 0; double s0 = 0, s1 = 0, s2 = 0;
if( CV_MAT_DEPTH(_img->type) == CV_8U || CV_MAT_DEPTH(_img->type) == CV_32S ) if( CV_MAT_DEPTH(_img->type) == CV_8U || CV_MAT_DEPTH(_img->type) == CV_32S )
{ {
tmp = cvCreateMat( rows, cols, CV_MAKETYPE(CV_32F,CV_MAT_CN(_img->type)) ); tmp = cvCreateMat( rows, cols, CV_MAKETYPE(CV_32F,CV_MAT_CN(_img->type)) );
@ -395,7 +395,7 @@ cvTsFloodFill( CvMat* _img, CvPoint seed_pt, CvScalar new_val,
cvSeqPush( seq, &p ); cvSeqPush( seq, &p );
} }
} }
} }
} }
r.x = r.width = seed_pt.x; r.x = r.width = seed_pt.x;

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

@ -59,7 +59,7 @@ protected:
int prepare_test_case( int test_case_idx ); int prepare_test_case( int test_case_idx );
int validate_test_results( int test_case_idx ); int validate_test_results( int test_case_idx );
virtual void init_hist( int test_case_idx, int i ); virtual void init_hist( int test_case_idx, int i );
virtual void get_hist_params( int test_case_idx ); virtual void get_hist_params( int test_case_idx );
virtual float** get_hist_ranges( int test_case_idx ); virtual float** get_hist_ranges( int test_case_idx );
@ -73,7 +73,7 @@ protected:
int uniform; int uniform;
int gen_random_hist; int gen_random_hist;
double gen_hist_max_val, gen_hist_sparse_nz_ratio; double gen_hist_max_val, gen_hist_sparse_nz_ratio;
int init_ranges; int init_ranges;
int img_type; int img_type;
int img_max_log_size; int img_max_log_size;
@ -127,7 +127,7 @@ int CV_BaseHistTest::read_params( CvFileStorage* fs )
max_log_size = cvtest::clipInt( max_log_size, 1, 20 ); max_log_size = cvtest::clipInt( max_log_size, 1, 20 );
img_max_log_size = cvReadInt( find_param( fs, "max_log_array_size" ), img_max_log_size ); img_max_log_size = cvReadInt( find_param( fs, "max_log_array_size" ), img_max_log_size );
img_max_log_size = cvtest::clipInt( img_max_log_size, 1, 9 ); img_max_log_size = cvtest::clipInt( img_max_log_size, 1, 9 );
max_cdims = cvReadInt( find_param( fs, "max_cdims" ), max_cdims ); max_cdims = cvReadInt( find_param( fs, "max_cdims" ), max_cdims );
max_cdims = cvtest::clipInt( max_cdims, 1, 6 ); max_cdims = cvtest::clipInt( max_cdims, 1, 6 );
@ -146,13 +146,13 @@ void CV_BaseHistTest::get_hist_params( int /*test_case_idx*/ )
max_dim_size = cvRound(pow(hist_size,1./cdims)); max_dim_size = cvRound(pow(hist_size,1./cdims));
total_size = 1; total_size = 1;
uniform = cvtest::randInt(rng) % 2; uniform = cvtest::randInt(rng) % 2;
hist_type = cvtest::randInt(rng) % 2 ? CV_HIST_SPARSE : CV_HIST_ARRAY; hist_type = cvtest::randInt(rng) % 2 ? CV_HIST_SPARSE : CV_HIST_ARRAY;
for( i = 0; i < cdims; i++ ) for( i = 0; i < cdims; i++ )
{ {
dims[i] = cvtest::randInt(rng) % (max_dim_size + 2) + 2; dims[i] = cvtest::randInt(rng) % (max_dim_size + 2) + 2;
if( !uniform ) if( !uniform )
dims[i] = MIN(dims[i], max_ni_dim_size); dims[i] = MIN(dims[i], max_ni_dim_size);
total_size *= dims[i]; total_size *= dims[i];
} }
@ -178,12 +178,12 @@ void CV_BaseHistTest::get_hist_params( int /*test_case_idx*/ )
float** CV_BaseHistTest::get_hist_ranges( int /*test_case_idx*/ ) float** CV_BaseHistTest::get_hist_ranges( int /*test_case_idx*/ )
{ {
double _low = low + range_delta, _high = high - range_delta; double _low = low + range_delta, _high = high - range_delta;
if( !init_ranges ) if( !init_ranges )
return 0; return 0;
ranges.resize(cdims); ranges.resize(cdims);
if( uniform ) if( uniform )
{ {
_ranges.resize(cdims*2); _ranges.resize(cdims*2);
@ -200,7 +200,7 @@ float** CV_BaseHistTest::get_hist_ranges( int /*test_case_idx*/ )
for( i = 0; i < cdims; i++ ) for( i = 0; i < cdims; i++ )
dims_sum += dims[i] + 1; dims_sum += dims[i] + 1;
_ranges.resize(dims_sum); _ranges.resize(dims_sum);
for( i = 0; i < cdims; i++ ) for( i = 0; i < cdims; i++ )
{ {
int j, n = dims[i]; int j, n = dims[i];
@ -212,7 +212,7 @@ float** CV_BaseHistTest::get_hist_ranges( int /*test_case_idx*/ )
if( (pow(q,(double)n)-1)/(q-1.) >= _high-_low ) if( (pow(q,(double)n)-1)/(q-1.) >= _high-_low )
break; break;
} }
if( j == 0 ) if( j == 0 )
{ {
delta = (_high-_low)/n; delta = (_high-_low)/n;
@ -223,9 +223,9 @@ float** CV_BaseHistTest::get_hist_ranges( int /*test_case_idx*/ )
q = 1 + j*0.1; q = 1 + j*0.1;
delta = cvFloor((_high-_low)*(q-1)/(pow(q,(double)n) - 1)); delta = cvFloor((_high-_low)*(q-1)/(pow(q,(double)n) - 1));
delta = MAX(delta, 1.); delta = MAX(delta, 1.);
} }
val = _low; val = _low;
for( j = 0; j <= n; j++ ) for( j = 0; j <= n; j++ )
{ {
_ranges[j+ofs] = (float)MIN(val,_high); _ranges[j+ofs] = (float)MIN(val,_high);
@ -236,7 +236,7 @@ float** CV_BaseHistTest::get_hist_ranges( int /*test_case_idx*/ )
ofs += n + 1; ofs += n + 1;
} }
} }
return &ranges[0]; return &ranges[0];
} }
@ -246,7 +246,7 @@ void CV_BaseHistTest::init_hist( int /*test_case_idx*/, int hist_i )
if( gen_random_hist ) if( gen_random_hist )
{ {
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
if( hist_type == CV_HIST_ARRAY ) if( hist_type == CV_HIST_ARRAY )
{ {
Mat h = cvarrToMat(hist[hist_i]->bins); Mat h = cvarrToMat(hist[hist_i]->bins);
@ -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++ )
@ -286,7 +286,7 @@ int CV_BaseHistTest::prepare_test_case( int test_case_idx )
get_hist_params( test_case_idx ); get_hist_params( test_case_idx );
r = get_hist_ranges( test_case_idx ); r = get_hist_ranges( test_case_idx );
hist.resize(hist_count); hist.resize(hist_count);
for( i = 0; i < hist_count; i++ ) for( i = 0; i < hist_count; i++ )
{ {
hist[i] = cvCreateHist( cdims, dims, hist_type, r, uniform ); hist[i] = cvCreateHist( cdims, dims, hist_type, r, uniform );
@ -323,7 +323,7 @@ protected:
int prepare_test_case( int test_case_idx ); int prepare_test_case( int test_case_idx );
int validate_test_results( int test_case_idx ); int validate_test_results( int test_case_idx );
void init_hist( int test_case_idx, int i ); void init_hist( int test_case_idx, int i );
CvMat* indices; CvMat* indices;
CvMat* values; CvMat* values;
CvMat* values0; CvMat* values0;
@ -376,7 +376,7 @@ int CV_QueryHistTest::prepare_test_case( int test_case_idx )
iters = (cvtest::randInt(rng) % MAX(total_size/10,100)) + 1; iters = (cvtest::randInt(rng) % MAX(total_size/10,100)) + 1;
iters = MIN( iters, total_size*9/10 + 1 ); iters = MIN( iters, total_size*9/10 + 1 );
indices = cvCreateMat( 1, iters*cdims, CV_32S ); indices = cvCreateMat( 1, iters*cdims, CV_32S );
values = cvCreateMat( 1, iters, CV_32F ); values = cvCreateMat( 1, iters, CV_32F );
values0 = cvCreateMat( 1, iters, CV_32F ); values0 = cvCreateMat( 1, iters, CV_32F );
@ -422,7 +422,7 @@ int CV_QueryHistTest::prepare_test_case( int test_case_idx )
if( GET_BIT(lin_idx) ) if( GET_BIT(lin_idx) )
values0->data.fl[i] = (float)(lin_idx+1); values0->data.fl[i] = (float)(lin_idx+1);
} }
cvReleaseMat( &bit_mask ); cvReleaseMat( &bit_mask );
} }
@ -539,7 +539,7 @@ int CV_QueryHistTest::validate_test_results( int /*test_case_idx*/ )
{ {
int code = cvtest::TS::OK; int code = cvtest::TS::OK;
int i, j, iters = values->cols; int i, j, iters = values->cols;
for( i = 0; i < iters; i++ ) for( i = 0; i < iters; i++ )
{ {
float v = values->data.fl[i], v0 = values0->data.fl[i]; float v = values->data.fl[i], v0 = values0->data.fl[i];
@ -613,7 +613,7 @@ void CV_MinMaxHistTest::init_hist(int test_case_idx, int hist_i)
} }
if( !eq || total_size == 1 ) if( !eq || total_size == 1 )
break; break;
} }
min_val0 = (float)(-cvtest::randReal(rng)*10 - FLT_EPSILON); min_val0 = (float)(-cvtest::randReal(rng)*10 - FLT_EPSILON);
max_val0 = (float)(cvtest::randReal(rng)*10 + FLT_EPSILON + gen_hist_max_val); max_val0 = (float)(cvtest::randReal(rng)*10 + FLT_EPSILON + gen_hist_max_val);
@ -644,7 +644,7 @@ void CV_MinMaxHistTest::run_func(void)
int CV_MinMaxHistTest::validate_test_results( int /*test_case_idx*/ ) int CV_MinMaxHistTest::validate_test_results( int /*test_case_idx*/ )
{ {
int code = cvtest::TS::OK; int code = cvtest::TS::OK;
if( cvIsNaN(min_val) || cvIsInf(min_val) || if( cvIsNaN(min_val) || cvIsInf(min_val) ||
cvIsNaN(max_val) || cvIsInf(max_val) ) cvIsNaN(max_val) || cvIsInf(max_val) )
{ {
@ -728,7 +728,7 @@ void CV_NormHistTest::run_func(void)
if( hist_type != CV_HIST_ARRAY && test_cpp ) if( hist_type != CV_HIST_ARRAY && test_cpp )
{ {
cv::SparseMat h((CvSparseMat*)hist[0]->bins); cv::SparseMat h((CvSparseMat*)hist[0]->bins);
cv::normalize(h, h, factor, CV_L1); cv::normalize(h, h, factor, CV_L1);
cvReleaseSparseMat((CvSparseMat**)&hist[0]->bins); cvReleaseSparseMat((CvSparseMat**)&hist[0]->bins);
hist[0]->bins = (CvSparseMat*)h; hist[0]->bins = (CvSparseMat*)h;
} }
@ -741,7 +741,7 @@ int CV_NormHistTest::validate_test_results( int /*test_case_idx*/ )
{ {
int code = cvtest::TS::OK; int code = cvtest::TS::OK;
double sum = 0; double sum = 0;
if( hist_type == CV_HIST_ARRAY ) if( hist_type == CV_HIST_ARRAY )
{ {
int i; int i;
@ -755,7 +755,7 @@ int CV_NormHistTest::validate_test_results( int /*test_case_idx*/ )
CvSparseMat* sparse = (CvSparseMat*)hist[0]->bins; CvSparseMat* sparse = (CvSparseMat*)hist[0]->bins;
CvSparseMatIterator iterator; CvSparseMatIterator iterator;
CvSparseNode *node; CvSparseNode *node;
for( node = cvInitSparseMatIterator( sparse, &iterator ); for( node = cvInitSparseMatIterator( sparse, &iterator );
node != 0; node = cvGetNextSparseNode( &iterator )) node != 0; node = cvGetNextSparseNode( &iterator ))
{ {
@ -839,7 +839,7 @@ int CV_ThreshHistTest::prepare_test_case( int test_case_idx )
if( hist_type == CV_HIST_ARRAY ) if( hist_type == CV_HIST_ARRAY )
{ {
orig_nz_count = total_size; orig_nz_count = total_size;
values = cvCreateMat( 1, total_size, CV_32F ); values = cvCreateMat( 1, total_size, CV_32F );
memcpy( values->data.fl, cvPtr1D( hist[0]->bins, 0 ), total_size*sizeof(float) ); memcpy( values->data.fl, cvPtr1D( hist[0]->bins, 0 ), total_size*sizeof(float) );
} }
@ -859,7 +859,7 @@ int CV_ThreshHistTest::prepare_test_case( int test_case_idx )
node != 0; node = cvGetNextSparseNode( &iterator ), i++ ) node != 0; node = cvGetNextSparseNode( &iterator ), i++ )
{ {
const int* idx = CV_NODE_IDX(sparse,node); const int* idx = CV_NODE_IDX(sparse,node);
OPENCV_ASSERT( i < orig_nz_count, "CV_ThreshHistTest::prepare_test_case", "Buffer overflow" ); OPENCV_ASSERT( i < orig_nz_count, "CV_ThreshHistTest::prepare_test_case", "Buffer overflow" );
values->data.fl[i] = *(float*)CV_NODE_VAL(sparse,node); values->data.fl[i] = *(float*)CV_NODE_VAL(sparse,node);
@ -924,7 +924,7 @@ int CV_ThreshHistTest::validate_test_results( int /*test_case_idx*/ )
} }
} }
} }
if( code > 0 && hist_type == CV_HIST_SPARSE ) if( code > 0 && hist_type == CV_HIST_SPARSE )
{ {
if( sparse->heap->active_count > 0 ) if( sparse->heap->active_count > 0 )
@ -1003,7 +1003,7 @@ int CV_CompareHistTest::validate_test_results( int /*test_case_idx*/ )
{ {
float* ptr0 = (float*)cvPtr1D( hist[0]->bins, 0 ); float* ptr0 = (float*)cvPtr1D( hist[0]->bins, 0 );
float* ptr1 = (float*)cvPtr1D( hist[1]->bins, 0 ); float* ptr1 = (float*)cvPtr1D( hist[1]->bins, 0 );
for( i = 0; i < total_size; i++ ) for( i = 0; i < total_size; i++ )
{ {
double v0 = ptr0[i], v1 = ptr1[i]; double v0 = ptr0[i], v1 = ptr1[i];
@ -1031,7 +1031,7 @@ int CV_CompareHistTest::validate_test_results( int /*test_case_idx*/ )
const int* idx = CV_NODE_IDX(sparse0, node); const int* idx = CV_NODE_IDX(sparse0, node);
double v0 = *(float*)CV_NODE_VAL(sparse0, node); double v0 = *(float*)CV_NODE_VAL(sparse0, node);
double v1 = (float)cvGetRealND(sparse1, idx); double v1 = (float)cvGetRealND(sparse1, idx);
result0[CV_COMP_CORREL] += v0*v1; result0[CV_COMP_CORREL] += v0*v1;
result0[CV_COMP_INTERSECT] += MIN(v0,v1); result0[CV_COMP_INTERSECT] += MIN(v0,v1);
if( fabs(v0) > DBL_EPSILON ) if( fabs(v0) > DBL_EPSILON )
@ -1134,7 +1134,7 @@ CV_CalcHistTest::~CV_CalcHistTest()
void CV_CalcHistTest::clear() void CV_CalcHistTest::clear()
{ {
int i; int i;
for( i = 0; i <= CV_MAX_DIM; i++ ) for( i = 0; i <= CV_MAX_DIM; i++ )
cvReleaseImage( &images[i] ); cvReleaseImage( &images[i] );
@ -1160,7 +1160,7 @@ int CV_CalcHistTest::prepare_test_case( int test_case_idx )
img_type == CV_8U ? IPL_DEPTH_8U : IPL_DEPTH_32F, nch ); img_type == CV_8U ? IPL_DEPTH_8U : IPL_DEPTH_32F, nch );
channels[i] = cvtest::randInt(rng) % nch; channels[i] = cvtest::randInt(rng) % nch;
Mat images_i = cvarrToMat(images[i]); Mat images_i = cvarrToMat(images[i]);
cvtest::randUni( rng, images_i, Scalar::all(low), Scalar::all(high) ); cvtest::randUni( rng, images_i, Scalar::all(low), Scalar::all(high) );
} }
else if( i == CV_MAX_DIM && cvtest::randInt(rng) % 2 ) else if( i == CV_MAX_DIM && cvtest::randInt(rng) % 2 )
@ -1168,7 +1168,7 @@ int CV_CalcHistTest::prepare_test_case( int test_case_idx )
// create mask // create mask
images[i] = cvCreateImage( img_size, IPL_DEPTH_8U, 1 ); images[i] = cvCreateImage( img_size, IPL_DEPTH_8U, 1 );
Mat images_i = cvarrToMat(images[i]); Mat images_i = cvarrToMat(images[i]);
// make ~25% pixels in the mask non-zero // make ~25% pixels in the mask non-zero
cvtest::randUni( rng, images_i, Scalar::all(-2), Scalar::all(2) ); cvtest::randUni( rng, images_i, Scalar::all(-2), Scalar::all(2) );
} }
@ -1230,7 +1230,7 @@ cvTsCalcHist( IplImage** _images, CvHistogram* hist, IplImage* _mask, int* chann
{ {
float val[CV_MAX_DIM]; float val[CV_MAX_DIM];
int idx[CV_MAX_DIM]; int idx[CV_MAX_DIM];
if( mptr && !mptr[x] ) if( mptr && !mptr[x] )
continue; continue;
if( img_depth == IPL_DEPTH_8U ) if( img_depth == IPL_DEPTH_8U )
@ -1288,7 +1288,7 @@ int CV_CalcHistTest::validate_test_results( int /*test_case_idx*/ )
{ {
ts->printf( cvtest::TS::LOG, "The histogram does not match to the reference one\n" ); ts->printf( cvtest::TS::LOG, "The histogram does not match to the reference one\n" );
code = cvtest::TS::FAIL_BAD_ACCURACY; code = cvtest::TS::FAIL_BAD_ACCURACY;
} }
if( code < 0 ) if( code < 0 )
@ -1345,7 +1345,7 @@ CV_CalcBackProjectTest::~CV_CalcBackProjectTest()
void CV_CalcBackProjectTest::clear() void CV_CalcBackProjectTest::clear()
{ {
int i; int i;
for( i = 0; i < CV_MAX_DIM+3; i++ ) for( i = 0; i < CV_MAX_DIM+3; i++ )
cvReleaseImage( &images[i] ); cvReleaseImage( &images[i] );
@ -1399,7 +1399,7 @@ int CV_CalcBackProjectTest::prepare_test_case( int test_case_idx )
{ {
int idx = cvtest::randInt(rng) % img_len; int idx = cvtest::randInt(rng) % img_len;
double val = cvtest::randReal(rng)*(high - low) + low; double val = cvtest::randReal(rng)*(high - low) + low;
if( img_type == CV_8U ) if( img_type == CV_8U )
((uchar*)data)[idx] = (uchar)cvRound(val); ((uchar*)data)[idx] = (uchar)cvRound(val);
else else
@ -1453,7 +1453,7 @@ cvTsCalcBackProject( IplImage** images, IplImage* dst, CvHistogram* hist, int* c
float val[CV_MAX_DIM]; float val[CV_MAX_DIM];
float bin_val = 0; float bin_val = 0;
int idx[CV_MAX_DIM]; int idx[CV_MAX_DIM];
if( img_depth == IPL_DEPTH_8U ) if( img_depth == IPL_DEPTH_8U )
for( k = 0; k < cdims; k++ ) for( k = 0; k < cdims; k++ )
val[k] = plane[k].ptr[x*nch[k]]; val[k] = plane[k].ptr[x*nch[k]];
@ -1569,7 +1569,7 @@ CV_CalcBackProjectPatchTest::~CV_CalcBackProjectPatchTest()
void CV_CalcBackProjectPatchTest::clear() void CV_CalcBackProjectPatchTest::clear()
{ {
int i; int i;
for( i = 0; i < CV_MAX_DIM+2; i++ ) for( i = 0; i < CV_MAX_DIM+2; i++ )
cvReleaseImage( &images[i] ); cvReleaseImage( &images[i] );
@ -1627,7 +1627,7 @@ int CV_CalcBackProjectPatchTest::prepare_test_case( int test_case_idx )
{ {
int idx = cvtest::randInt(rng) % img_len; int idx = cvtest::randInt(rng) % img_len;
double val = cvtest::randReal(rng)*(high - low) + low; double val = cvtest::randReal(rng)*(high - low) + low;
if( img_type == CV_8U ) if( img_type == CV_8U )
((uchar*)data)[idx] = (uchar)cvRound(val); ((uchar*)data)[idx] = (uchar)cvRound(val);
else else
@ -1652,7 +1652,7 @@ cvTsCalcBackProjectPatch( IplImage** images, IplImage* dst, CvSize patch_size,
double factor, int* channels ) double factor, int* channels )
{ {
CvHistogram* model = 0; CvHistogram* model = 0;
IplImage imgstub[CV_MAX_DIM], *img[CV_MAX_DIM]; IplImage imgstub[CV_MAX_DIM], *img[CV_MAX_DIM];
IplROI roi; IplROI roi;
int i, dims; int i, dims;
@ -1679,7 +1679,7 @@ cvTsCalcBackProjectPatch( IplImage** images, IplImage* dst, CvSize patch_size,
for( x = 0; x < size.width; x++ ) for( x = 0; x < size.width; x++ )
{ {
double result; double result;
roi.xOffset = x; roi.xOffset = x;
roi.yOffset = y; roi.yOffset = y;
roi.width = patch_size.width; roi.width = patch_size.width;
@ -1703,7 +1703,7 @@ int CV_CalcBackProjectPatchTest::validate_test_results( int /*test_case_idx*/ )
cvTsCalcBackProjectPatch( images, images[CV_MAX_DIM+1], cvTsCalcBackProjectPatch( images, images[CV_MAX_DIM+1],
patch_size, hist[0], method, factor, channels ); patch_size, hist[0], method, factor, channels );
Mat a = cvarrToMat(images[CV_MAX_DIM]), b = cvarrToMat(images[CV_MAX_DIM+1]); Mat a = cvarrToMat(images[CV_MAX_DIM]), b = cvarrToMat(images[CV_MAX_DIM+1]);
code = cvtest::cmpEps2( ts, a, b, err_level, true, "BackProjectPatch result" ); code = cvtest::cmpEps2( ts, a, b, err_level, true, "BackProjectPatch result" );
@ -1756,7 +1756,7 @@ void CV_BayesianProbTest::init_hist( int test_case_idx, int hist_i )
int CV_BayesianProbTest::prepare_test_case( int test_case_idx ) int CV_BayesianProbTest::prepare_test_case( int test_case_idx )
{ {
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
hist_count = (cvtest::randInt(rng) % (MAX_HIST/2-1) + 2)*2; hist_count = (cvtest::randInt(rng) % (MAX_HIST/2-1) + 2)*2;
hist_count = MIN( hist_count, MAX_HIST ); hist_count = MIN( hist_count, MAX_HIST );
int code = CV_BaseHistTest::prepare_test_case( test_case_idx ); int code = CV_BaseHistTest::prepare_test_case( test_case_idx );
@ -1833,5 +1833,5 @@ TEST(Imgproc_Hist_MinMaxVal, accuracy) { CV_MinMaxHistTest test; test.safe_run()
TEST(Imgproc_Hist_CalcBackProject, accuracy) { CV_CalcBackProjectTest test; test.safe_run(); } TEST(Imgproc_Hist_CalcBackProject, accuracy) { CV_CalcBackProjectTest test; test.safe_run(); }
TEST(Imgproc_Hist_CalcBackProjectPatch, accuracy) { CV_CalcBackProjectPatchTest test; test.safe_run(); } TEST(Imgproc_Hist_CalcBackProjectPatch, accuracy) { CV_CalcBackProjectPatchTest test; test.safe_run(); }
TEST(Imgproc_Hist_BayesianProb, accuracy) { CV_BayesianProbTest test; test.safe_run(); } TEST(Imgproc_Hist_BayesianProb, accuracy) { CV_BayesianProbTest test; test.safe_run(); }
/* End Of File */ /* End Of File */

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

@ -135,7 +135,7 @@ int CV_ImgWarpBaseTest::prepare_test_case( int test_case_idx )
if( test_mat[INPUT_OUTPUT][0].cols >= img.cols && if( test_mat[INPUT_OUTPUT][0].cols >= img.cols &&
test_mat[INPUT_OUTPUT][0].rows >= img.rows ) test_mat[INPUT_OUTPUT][0].rows >= img.rows )
space_scale = spatial_scale_zoom; space_scale = spatial_scale_zoom;
for( i = 0; i < img.rows; i++ ) for( i = 0; i < img.rows; i++ )
{ {
uchar* ptr = img.ptr(i); uchar* ptr = img.ptr(i);
@ -192,7 +192,7 @@ int CV_ImgWarpBaseTest::prepare_test_case( int test_case_idx )
}*/ }*/
cv::Mat src(1, cols*cn, CV_32F, &buffer[0]); cv::Mat src(1, cols*cn, CV_32F, &buffer[0]);
cv::Mat dst(1, cols*cn, depth, ptr); cv::Mat dst(1, cols*cn, depth, ptr);
src.convertTo(dst, dst.type()); src.convertTo(dst, dst.type());
} }
return code; return code;
@ -279,7 +279,7 @@ void CV_ResizeTest::prepare_to_validation( int /*test_case_idx*/ )
CvMat* x_idx = cvCreateMat( 1, dst->cols, CV_32SC1 ); CvMat* x_idx = cvCreateMat( 1, dst->cols, CV_32SC1 );
CvMat* y_idx = cvCreateMat( 1, dst->rows, CV_32SC1 ); CvMat* y_idx = cvCreateMat( 1, dst->rows, CV_32SC1 );
int* x_tab = x_idx->data.i; int* x_tab = x_idx->data.i;
int elem_size = CV_ELEM_SIZE(src->type); int elem_size = CV_ELEM_SIZE(src->type);
int drows = dst->rows, dcols = dst->cols; int drows = dst->rows, dcols = dst->cols;
if( interpolation == CV_INTER_NN ) if( interpolation == CV_INTER_NN )
@ -302,7 +302,7 @@ void CV_ResizeTest::prepare_to_validation( int /*test_case_idx*/ )
{ {
double scale_x = (double)src->cols/dcols; double scale_x = (double)src->cols/dcols;
double scale_y = (double)src->rows/drows; double scale_y = (double)src->rows/drows;
for( j = 0; j < dcols; j++ ) for( j = 0; j < dcols; j++ )
{ {
double f = ((j+0.5)*scale_x - 0.5); double f = ((j+0.5)*scale_x - 0.5);
@ -322,7 +322,7 @@ void CV_ResizeTest::prepare_to_validation( int /*test_case_idx*/ )
{ {
uchar* dptr = dst->data.ptr + dst->step*i; uchar* dptr = dst->data.ptr + dst->step*i;
const uchar* sptr0 = src->data.ptr + src->step*y_idx->data.i[i]; const uchar* sptr0 = src->data.ptr + src->step*y_idx->data.i[i];
for( j = 0; j < dcols; j++, dptr += elem_size ) for( j = 0; j < dcols; j++, dptr += elem_size )
{ {
const uchar* sptr = sptr0 + x_tab[j]; const uchar* sptr = sptr0 + x_tab[j];
@ -394,7 +394,7 @@ static void test_remap( const Mat& src, Mat& dst, const Mat& mapx, const Mat& ma
xs -= ixs; xs -= ixs;
ys -= iys; ys -= iys;
switch( depth ) switch( depth )
{ {
case CV_8U: case CV_8U:
@ -508,7 +508,7 @@ int CV_WarpAffineTest::prepare_test_case( int test_case_idx )
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
int code = CV_ImgWarpBaseTest::prepare_test_case( test_case_idx ); int code = CV_ImgWarpBaseTest::prepare_test_case( test_case_idx );
const Mat& src = test_mat[INPUT][0]; const Mat& src = test_mat[INPUT][0];
const Mat& dst = test_mat[INPUT_OUTPUT][0]; const Mat& dst = test_mat[INPUT_OUTPUT][0];
Mat& mat = test_mat[INPUT][1]; Mat& mat = test_mat[INPUT][1];
CvPoint2D32f center; CvPoint2D32f center;
double scale, angle; double scale, angle;
@ -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);
@ -619,7 +619,7 @@ int CV_WarpPerspectiveTest::prepare_test_case( int test_case_idx )
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
int code = CV_ImgWarpBaseTest::prepare_test_case( test_case_idx ); int code = CV_ImgWarpBaseTest::prepare_test_case( test_case_idx );
const CvMat& src = test_mat[INPUT][0]; const CvMat& src = test_mat[INPUT][0];
const CvMat& dst = test_mat[INPUT_OUTPUT][0]; const CvMat& dst = test_mat[INPUT_OUTPUT][0];
Mat& mat = test_mat[INPUT][1]; Mat& mat = test_mat[INPUT][1];
Point2f s[4], d[4]; Point2f s[4], d[4];
int i; int i;
@ -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() );
@ -675,11 +675,11 @@ void CV_WarpPerspectiveTest::prepare_to_validation( int /*test_case_idx*/ )
double xs = x*m[0] + y*m[1] + m[2]; double xs = x*m[0] + y*m[1] + m[2];
double ys = x*m[3] + y*m[4] + m[5]; double ys = x*m[3] + y*m[4] + m[5];
double ds = x*m[6] + y*m[7] + m[8]; double ds = x*m[6] + y*m[7] + m[8];
ds = ds ? 1./ds : 0; ds = ds ? 1./ds : 0;
xs *= ds; xs *= ds;
ys *= ds; ys *= ds;
mapx.at<float>(y, x) = (float)xs; mapx.at<float>(y, x) = (float)xs;
mapy.at<float>(y, x) = (float)ys; mapy.at<float>(y, x) = (float)ys;
} }
@ -806,15 +806,15 @@ protected:
void fill_array( int test_case_idx, int i, int j, Mat& arr ); void fill_array( int test_case_idx, int i, int j, Mat& arr );
private: private:
bool useCPlus; bool useCPlus;
cv::Mat input0; cv::Mat input0;
cv::Mat input1; cv::Mat input1;
cv::Mat input2; cv::Mat input2;
cv::Mat input_new_cam; cv::Mat input_new_cam;
cv::Mat input_output; cv::Mat input_output;
bool zero_new_cam; bool zero_new_cam;
bool zero_distortion; bool zero_distortion;
}; };
@ -823,7 +823,7 @@ CV_UndistortTest::CV_UndistortTest() : CV_ImgWarpBaseTest( false )
//spatial_scale_zoom = spatial_scale_decimate; //spatial_scale_zoom = spatial_scale_decimate;
test_array[INPUT].push_back(NULL); test_array[INPUT].push_back(NULL);
test_array[INPUT].push_back(NULL); test_array[INPUT].push_back(NULL);
test_array[INPUT].push_back(NULL); test_array[INPUT].push_back(NULL);
spatial_scale_decimate = spatial_scale_zoom; spatial_scale_decimate = spatial_scale_zoom;
} }
@ -834,14 +834,14 @@ void CV_UndistortTest::get_test_array_types_and_sizes( int test_case_idx, vector
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
CV_ImgWarpBaseTest::get_test_array_types_and_sizes( test_case_idx, sizes, types ); CV_ImgWarpBaseTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
int type = types[INPUT][0]; int type = types[INPUT][0];
type = CV_MAKETYPE( CV_8U, CV_MAT_CN(type) ); type = CV_MAKETYPE( CV_8U, CV_MAT_CN(type) );
types[INPUT][0] = types[INPUT_OUTPUT][0] = types[REF_INPUT_OUTPUT][0] = type; types[INPUT][0] = types[INPUT_OUTPUT][0] = types[REF_INPUT_OUTPUT][0] = type;
types[INPUT][1] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F; types[INPUT][1] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F;
types[INPUT][2] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F; types[INPUT][2] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F;
sizes[INPUT][1] = cvSize(3,3); sizes[INPUT][1] = cvSize(3,3);
sizes[INPUT][2] = cvtest::randInt(rng)%2 ? cvSize(4,1) : cvSize(1,4); sizes[INPUT][2] = cvtest::randInt(rng)%2 ? cvSize(4,1) : cvSize(1,4);
types[INPUT][3] = types[INPUT][1]; types[INPUT][3] = types[INPUT][1];
sizes[INPUT][3] = sizes[INPUT][1]; sizes[INPUT][3] = sizes[INPUT][1];
interpolation = CV_INTER_LINEAR; interpolation = CV_INTER_LINEAR;
} }
@ -855,22 +855,22 @@ void CV_UndistortTest::fill_array( int test_case_idx, int i, int j, Mat& arr )
void CV_UndistortTest::run_func() void CV_UndistortTest::run_func()
{ {
if (!useCPlus) if (!useCPlus)
{ {
CvMat a = test_mat[INPUT][1], k = test_mat[INPUT][2]; CvMat a = test_mat[INPUT][1], k = test_mat[INPUT][2];
cvUndistort2( test_array[INPUT][0], test_array[INPUT_OUTPUT][0], &a, &k); cvUndistort2( test_array[INPUT][0], test_array[INPUT_OUTPUT][0], &a, &k);
} }
else else
{ {
if (zero_distortion) if (zero_distortion)
{ {
cv::undistort(input0,input_output,input1,cv::Mat()); cv::undistort(input0,input_output,input1,cv::Mat());
} }
else else
{ {
cv::undistort(input0,input_output,input1,input2); cv::undistort(input0,input_output,input1,input2);
} }
} }
} }
@ -888,10 +888,10 @@ int CV_UndistortTest::prepare_test_case( int test_case_idx )
const Mat& src = test_mat[INPUT][0]; const Mat& src = test_mat[INPUT][0];
double k[4], a[9] = {0,0,0,0,0,0,0,0,1}; double k[4], a[9] = {0,0,0,0,0,0,0,0,1};
double new_cam[9] = {0,0,0,0,0,0,0,0,1}; double new_cam[9] = {0,0,0,0,0,0,0,0,1};
double sz = MAX(src.rows, src.cols); double sz = MAX(src.rows, src.cols);
Mat& _new_cam0 = test_mat[INPUT][3]; Mat& _new_cam0 = test_mat[INPUT][3];
Mat _new_cam(test_mat[INPUT][3].rows,test_mat[INPUT][3].cols,CV_64F,new_cam); Mat _new_cam(test_mat[INPUT][3].rows,test_mat[INPUT][3].cols,CV_64F,new_cam);
Mat& _a0 = test_mat[INPUT][1]; Mat& _a0 = test_mat[INPUT][1];
Mat _a(3,3,CV_64F,a); Mat _a(3,3,CV_64F,a);
@ -925,21 +925,21 @@ int CV_UndistortTest::prepare_test_case( int test_case_idx )
_a.convertTo(_a0, _a0.depth()); _a.convertTo(_a0, _a0.depth());
zero_distortion = (cvtest::randInt(rng)%2) == 0 ? false : true; zero_distortion = (cvtest::randInt(rng)%2) == 0 ? false : true;
_k.convertTo(_k0, _k0.depth()); _k.convertTo(_k0, _k0.depth());
zero_new_cam = (cvtest::randInt(rng)%2) == 0 ? false : true; zero_new_cam = (cvtest::randInt(rng)%2) == 0 ? false : true;
_new_cam.convertTo(_new_cam0, _new_cam0.depth()); _new_cam.convertTo(_new_cam0, _new_cam0.depth());
//Testing C++ code //Testing C++ code
useCPlus = ((cvtest::randInt(rng) % 2)!=0); useCPlus = ((cvtest::randInt(rng) % 2)!=0);
if (useCPlus) if (useCPlus)
{ {
input0 = test_mat[INPUT][0]; input0 = test_mat[INPUT][0];
input1 = test_mat[INPUT][1]; input1 = test_mat[INPUT][1];
input2 = test_mat[INPUT][2]; input2 = test_mat[INPUT][2];
input_new_cam = test_mat[INPUT][3]; input_new_cam = test_mat[INPUT][3];
} }
return code; return code;
} }
@ -947,11 +947,11 @@ int CV_UndistortTest::prepare_test_case( int test_case_idx )
void CV_UndistortTest::prepare_to_validation( int /*test_case_idx*/ ) void CV_UndistortTest::prepare_to_validation( int /*test_case_idx*/ )
{ {
if (useCPlus) if (useCPlus)
{ {
Mat& output = test_mat[INPUT_OUTPUT][0]; Mat& output = test_mat[INPUT_OUTPUT][0];
input_output.convertTo(output, output.type()); input_output.convertTo(output, output.type());
} }
Mat& src = test_mat[INPUT][0]; Mat& src = test_mat[INPUT][0];
Mat& dst = test_mat[REF_INPUT_OUTPUT][0]; Mat& dst = test_mat[REF_INPUT_OUTPUT][0];
Mat& dst0 = test_mat[INPUT_OUTPUT][0]; Mat& dst0 = test_mat[INPUT_OUTPUT][0];
@ -978,7 +978,7 @@ protected:
void fill_array( int test_case_idx, int i, int j, Mat& arr ); void fill_array( int test_case_idx, int i, int j, Mat& arr );
private: private:
bool dualChannel; bool dualChannel;
}; };
@ -1003,8 +1003,8 @@ void CV_UndistortMapTest::get_test_array_types_and_sizes( int test_case_idx, vec
CvSize sz = sizes[OUTPUT][0]; CvSize sz = sizes[OUTPUT][0];
types[INPUT][0] = types[INPUT][1] = depth; types[INPUT][0] = types[INPUT][1] = depth;
dualChannel = cvtest::randInt(rng)%2 == 0; dualChannel = cvtest::randInt(rng)%2 == 0;
types[OUTPUT][0] = types[OUTPUT][1] = types[OUTPUT][0] = types[OUTPUT][1] =
types[REF_OUTPUT][0] = types[REF_OUTPUT][1] = dualChannel ? CV_32FC2 : CV_32F; types[REF_OUTPUT][0] = types[REF_OUTPUT][1] = dualChannel ? CV_32FC2 : CV_32F;
sizes[INPUT][0] = cvSize(3,3); sizes[INPUT][0] = cvSize(3,3);
sizes[INPUT][1] = cvtest::randInt(rng)%2 ? cvSize(4,1) : cvSize(1,4); sizes[INPUT][1] = cvtest::randInt(rng)%2 ? cvSize(4,1) : cvSize(1,4);
@ -1026,11 +1026,11 @@ void CV_UndistortMapTest::fill_array( int test_case_idx, int i, int j, Mat& arr
void CV_UndistortMapTest::run_func() void CV_UndistortMapTest::run_func()
{ {
CvMat a = test_mat[INPUT][0], k = test_mat[INPUT][1]; CvMat a = test_mat[INPUT][0], k = test_mat[INPUT][1];
if (!dualChannel ) if (!dualChannel )
cvInitUndistortMap( &a, &k, test_array[OUTPUT][0], test_array[OUTPUT][1] ); cvInitUndistortMap( &a, &k, test_array[OUTPUT][0], test_array[OUTPUT][1] );
else else
cvInitUndistortMap( &a, &k, test_array[OUTPUT][0], 0 ); cvInitUndistortMap( &a, &k, test_array[OUTPUT][0], 0 );
} }
@ -1069,11 +1069,11 @@ int CV_UndistortMapTest::prepare_test_case( int test_case_idx )
_a.convertTo(_a0, _a0.depth()); _a.convertTo(_a0, _a0.depth());
_k.convertTo(_k0, _k0.depth()); _k.convertTo(_k0, _k0.depth());
if (dualChannel) if (dualChannel)
{ {
test_mat[REF_OUTPUT][1] = Scalar::all(0); test_mat[REF_OUTPUT][1] = Scalar::all(0);
test_mat[OUTPUT][1] = Scalar::all(0); test_mat[OUTPUT][1] = Scalar::all(0);
} }
return code; return code;
} }
@ -1102,7 +1102,7 @@ test_getQuadrangeSubPix( const Mat& src, Mat& dst, double* a )
{ {
int sstep = (int)(src.step / sizeof(float)); int sstep = (int)(src.step / sizeof(float));
int scols = src.cols, srows = src.rows; int scols = src.cols, srows = src.rows;
CV_Assert( src.depth() == CV_32F && src.type() == dst.type() ); CV_Assert( src.depth() == CV_32F && src.type() == dst.type() );
int cn = dst.channels(); int cn = dst.channels();
@ -1167,11 +1167,11 @@ void CV_GetRectSubPixTest::get_test_array_types_and_sizes( int test_case_idx, ve
int src_depth = cvtest::randInt(rng) % 2, dst_depth; int src_depth = cvtest::randInt(rng) % 2, dst_depth;
int cn = cvtest::randInt(rng) % 2 ? 3 : 1; int cn = cvtest::randInt(rng) % 2 ? 3 : 1;
CvSize src_size, dst_size; CvSize src_size, dst_size;
dst_depth = src_depth = src_depth == 0 ? CV_8U : CV_32F; dst_depth = src_depth = src_depth == 0 ? CV_8U : CV_32F;
if( src_depth < CV_32F && cvtest::randInt(rng) % 2 ) if( src_depth < CV_32F && cvtest::randInt(rng) % 2 )
dst_depth = CV_32F; dst_depth = CV_32F;
types[INPUT][0] = CV_MAKETYPE(src_depth,cn); types[INPUT][0] = CV_MAKETYPE(src_depth,cn);
types[INPUT_OUTPUT][0] = types[REF_INPUT_OUTPUT][0] = CV_MAKETYPE(dst_depth,cn); types[INPUT_OUTPUT][0] = types[REF_INPUT_OUTPUT][0] = CV_MAKETYPE(dst_depth,cn);
@ -1181,11 +1181,11 @@ void CV_GetRectSubPixTest::get_test_array_types_and_sizes( int test_case_idx, ve
dst_size.width = MIN(dst_size.width,src_size.width); dst_size.width = MIN(dst_size.width,src_size.width);
dst_size.height = MIN(dst_size.width,src_size.height); dst_size.height = MIN(dst_size.width,src_size.height);
sizes[INPUT_OUTPUT][0] = sizes[REF_INPUT_OUTPUT][0] = dst_size; sizes[INPUT_OUTPUT][0] = sizes[REF_INPUT_OUTPUT][0] = dst_size;
center.x = (float)(cvtest::randReal(rng)*src_size.width); center.x = (float)(cvtest::randReal(rng)*src_size.width);
center.y = (float)(cvtest::randReal(rng)*src_size.height); center.y = (float)(cvtest::randReal(rng)*src_size.height);
interpolation = CV_INTER_LINEAR; interpolation = CV_INTER_LINEAR;
test_cpp = (cvtest::randInt(rng) & 256) == 0; test_cpp = (cvtest::randInt(rng) & 256) == 0;
} }
@ -1274,11 +1274,11 @@ void CV_GetQuadSubPixTest::get_test_array_types_and_sizes( int test_case_idx, ve
RNG& rng = ts->get_rng(); RNG& rng = ts->get_rng();
int msz, src_depth = cvtest::randInt(rng) % 2, dst_depth; int msz, src_depth = cvtest::randInt(rng) % 2, dst_depth;
int cn = cvtest::randInt(rng) % 2 ? 3 : 1; int cn = cvtest::randInt(rng) % 2 ? 3 : 1;
dst_depth = src_depth = src_depth == 0 ? CV_8U : CV_32F; dst_depth = src_depth = src_depth == 0 ? CV_8U : CV_32F;
if( src_depth < CV_32F && cvtest::randInt(rng) % 2 ) if( src_depth < CV_32F && cvtest::randInt(rng) % 2 )
dst_depth = CV_32F; dst_depth = CV_32F;
types[INPUT][0] = CV_MAKETYPE(src_depth,cn); types[INPUT][0] = CV_MAKETYPE(src_depth,cn);
types[INPUT_OUTPUT][0] = types[REF_INPUT_OUTPUT][0] = CV_MAKETYPE(dst_depth,cn); types[INPUT_OUTPUT][0] = types[REF_INPUT_OUTPUT][0] = CV_MAKETYPE(dst_depth,cn);
@ -1333,7 +1333,7 @@ int CV_GetQuadSubPixTest::prepare_test_case( int test_case_idx )
center.y = (float)((cvtest::randReal(rng)*1.2 - 0.1)*src.rows); center.y = (float)((cvtest::randReal(rng)*1.2 - 0.1)*src.rows);
angle = cvtest::randReal(rng)*360; angle = cvtest::randReal(rng)*360;
scale = cvtest::randReal(rng)*0.2 + 0.9; scale = cvtest::randReal(rng)*0.2 + 0.9;
// y = Ax + b -> x = A^-1(y - b) = A^-1*y - A^-1*b // y = Ax + b -> x = A^-1(y - b) = A^-1*y - A^-1*b
scale = 1./scale; scale = 1./scale;
angle = angle*(CV_PI/180.); angle = angle*(CV_PI/180.);
@ -1413,7 +1413,7 @@ TEST(Imgproc_fitLine_vector_2d, regression)
points_vector.push_back(p21); points_vector.push_back(p21);
points_vector.push_back(p22); points_vector.push_back(p22);
points_vector.push_back(p23); points_vector.push_back(p23);
std::vector<float> line; std::vector<float> line;

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);

232
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:
@ -192,10 +194,10 @@ public:
CvNormalBayesClassifier( const CvMat* trainData, const CvMat* responses, CvNormalBayesClassifier( const CvMat* trainData, const CvMat* responses,
const CvMat* varIdx=0, const CvMat* sampleIdx=0 ); const CvMat* varIdx=0, const CvMat* sampleIdx=0 );
virtual bool train( const CvMat* trainData, const CvMat* responses, virtual bool train( const CvMat* trainData, const CvMat* responses,
const CvMat* varIdx = 0, const CvMat* sampleIdx=0, bool update=false ); const CvMat* varIdx = 0, const CvMat* sampleIdx=0, bool update=false );
virtual float predict( const CvMat* samples, CV_OUT CvMat* results=0 ) const; virtual float predict( const CvMat* samples, CV_OUT CvMat* results=0 ) const;
CV_WRAP virtual void clear(); CV_WRAP virtual void clear();
@ -207,7 +209,7 @@ public:
bool update=false ); bool update=false );
CV_WRAP virtual float predict( const cv::Mat& samples, CV_OUT cv::Mat* results=0 ) const; CV_WRAP virtual float predict( const cv::Mat& samples, CV_OUT cv::Mat* results=0 ) const;
#endif #endif
virtual void write( CvFileStorage* storage, const char* name ) const; virtual void write( CvFileStorage* storage, const char* name ) const;
virtual void read( CvFileStorage* storage, CvFileNode* node ); virtual void read( CvFileStorage* storage, CvFileNode* node );
@ -243,31 +245,31 @@ public:
virtual bool train( const CvMat* trainData, const CvMat* responses, virtual bool train( const CvMat* trainData, const CvMat* responses,
const CvMat* sampleIdx=0, bool is_regression=false, const CvMat* sampleIdx=0, bool is_regression=false,
int maxK=32, bool updateBase=false ); int maxK=32, bool updateBase=false );
virtual float find_nearest( const CvMat* samples, int k, CV_OUT CvMat* results=0, virtual float find_nearest( const CvMat* samples, int k, CV_OUT CvMat* results=0,
const float** neighbors=0, CV_OUT CvMat* neighborResponses=0, CV_OUT CvMat* dist=0 ) const; const float** neighbors=0, CV_OUT CvMat* neighborResponses=0, CV_OUT CvMat* dist=0 ) const;
#ifndef SWIG #ifndef SWIG
CV_WRAP CvKNearest( const cv::Mat& trainData, const cv::Mat& responses, CV_WRAP CvKNearest( const cv::Mat& trainData, const cv::Mat& responses,
const cv::Mat& sampleIdx=cv::Mat(), bool isRegression=false, int max_k=32 ); const cv::Mat& sampleIdx=cv::Mat(), bool isRegression=false, int max_k=32 );
CV_WRAP virtual bool train( const cv::Mat& trainData, const cv::Mat& responses, CV_WRAP virtual bool train( const cv::Mat& trainData, const cv::Mat& responses,
const cv::Mat& sampleIdx=cv::Mat(), bool isRegression=false, const cv::Mat& sampleIdx=cv::Mat(), bool isRegression=false,
int maxK=32, bool updateBase=false ); int maxK=32, bool updateBase=false );
virtual float find_nearest( const cv::Mat& samples, int k, cv::Mat* results=0, virtual float find_nearest( const cv::Mat& samples, int k, cv::Mat* results=0,
const float** neighbors=0, cv::Mat* neighborResponses=0, const float** neighbors=0, cv::Mat* neighborResponses=0,
cv::Mat* dist=0 ) const; cv::Mat* dist=0 ) const;
CV_WRAP virtual float find_nearest( const cv::Mat& samples, int k, CV_OUT cv::Mat& results, CV_WRAP virtual float 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;
#endif #endif
virtual void clear(); virtual void clear();
int get_max_k() const; int get_max_k() const;
int get_var_count() const; int get_var_count() const;
int get_sample_count() const; int get_sample_count() const;
bool is_regression() const; bool is_regression() const;
virtual float write_results( int k, int k1, int start, int end, virtual float write_results( int k, int k1, int start, int end,
const float* neighbor_responses, const float* dist, CvMat* _results, const float* neighbor_responses, const float* dist, CvMat* _results,
CvMat* _neighbor_responses, CvMat* _dist, Cv32suf* sort_buf ) const; CvMat* _neighbor_responses, CvMat* _dist, Cv32suf* sort_buf ) const;
@ -473,7 +475,7 @@ public:
virtual bool train( const CvMat* trainData, const CvMat* responses, virtual bool train( const CvMat* trainData, const CvMat* responses,
const CvMat* varIdx=0, const CvMat* sampleIdx=0, const CvMat* varIdx=0, const CvMat* sampleIdx=0,
CvSVMParams params=CvSVMParams() ); CvSVMParams params=CvSVMParams() );
virtual bool train_auto( const CvMat* trainData, const CvMat* responses, virtual bool train_auto( const CvMat* trainData, const CvMat* responses,
const CvMat* varIdx, const CvMat* sampleIdx, CvSVMParams params, const CvMat* varIdx, const CvMat* sampleIdx, CvSVMParams params,
int kfold = 10, int kfold = 10,
@ -487,16 +489,16 @@ public:
virtual float predict( const CvMat* sample, bool returnDFVal=false ) const; virtual float predict( const CvMat* sample, bool returnDFVal=false ) const;
virtual float predict( const CvMat* samples, CvMat* results ) const; virtual float predict( const CvMat* samples, CvMat* results ) const;
#ifndef SWIG #ifndef SWIG
CV_WRAP CvSVM( const cv::Mat& trainData, const cv::Mat& responses, CV_WRAP CvSVM( const cv::Mat& trainData, const cv::Mat& responses,
const cv::Mat& varIdx=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varIdx=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(),
CvSVMParams params=CvSVMParams() ); CvSVMParams params=CvSVMParams() );
CV_WRAP virtual bool train( const cv::Mat& trainData, const cv::Mat& responses, CV_WRAP virtual bool train( const cv::Mat& trainData, const cv::Mat& responses,
const cv::Mat& varIdx=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varIdx=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(),
CvSVMParams params=CvSVMParams() ); CvSVMParams params=CvSVMParams() );
CV_WRAP virtual bool train_auto( const cv::Mat& trainData, const cv::Mat& responses, CV_WRAP virtual bool train_auto( const cv::Mat& trainData, const cv::Mat& responses,
const cv::Mat& varIdx, const cv::Mat& sampleIdx, CvSVMParams params, const cv::Mat& varIdx, const cv::Mat& sampleIdx, CvSVMParams params,
int k_fold = 10, int k_fold = 10,
@ -509,7 +511,7 @@ public:
bool balanced=false); bool balanced=false);
CV_WRAP virtual float predict( const cv::Mat& sample, bool returnDFVal=false ) const; CV_WRAP virtual float predict( const cv::Mat& sample, bool returnDFVal=false ) const;
#endif #endif
CV_WRAP virtual int get_support_vector_count() const; CV_WRAP virtual int get_support_vector_count() const;
virtual const float* get_support_vector(int i) const; virtual const float* get_support_vector(int i) const;
virtual CvSVMParams get_params() const { return params; }; virtual CvSVMParams get_params() const { return params; };
@ -564,14 +566,14 @@ public:
// Default parameters // Default parameters
enum {DEFAULT_NCLUSTERS=5, DEFAULT_MAX_ITERS=100}; enum {DEFAULT_NCLUSTERS=5, DEFAULT_MAX_ITERS=100};
// The initial step // The initial step
enum {START_E_STEP=1, START_M_STEP=2, START_AUTO_STEP=0}; enum {START_E_STEP=1, START_M_STEP=2, START_AUTO_STEP=0};
CV_WRAP EM(int nclusters=EM::DEFAULT_NCLUSTERS, int covMatType=EM::COV_MAT_DIAGONAL, CV_WRAP EM(int nclusters=EM::DEFAULT_NCLUSTERS, int covMatType=EM::COV_MAT_DIAGONAL,
const TermCriteria& termCrit=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, const TermCriteria& termCrit=TermCriteria(TermCriteria::COUNT+TermCriteria::EPS,
EM::DEFAULT_MAX_ITERS, FLT_EPSILON)); EM::DEFAULT_MAX_ITERS, FLT_EPSILON));
virtual ~EM(); virtual ~EM();
CV_WRAP virtual void clear(); CV_WRAP virtual void clear();
@ -579,7 +581,7 @@ public:
OutputArray logLikelihoods=noArray(), OutputArray logLikelihoods=noArray(),
OutputArray labels=noArray(), OutputArray labels=noArray(),
OutputArray probs=noArray()); OutputArray probs=noArray());
CV_WRAP virtual bool trainE(InputArray samples, CV_WRAP virtual bool trainE(InputArray samples,
InputArray means0, InputArray means0,
InputArray covs0=noArray(), InputArray covs0=noArray(),
@ -587,13 +589,13 @@ public:
OutputArray logLikelihoods=noArray(), OutputArray logLikelihoods=noArray(),
OutputArray labels=noArray(), OutputArray labels=noArray(),
OutputArray probs=noArray()); OutputArray probs=noArray());
CV_WRAP virtual bool trainM(InputArray samples, CV_WRAP virtual bool trainM(InputArray samples,
InputArray probs0, InputArray probs0,
OutputArray logLikelihoods=noArray(), OutputArray logLikelihoods=noArray(),
OutputArray labels=noArray(), OutputArray labels=noArray(),
OutputArray probs=noArray()); OutputArray probs=noArray());
CV_WRAP Vec2d predict(InputArray sample, CV_WRAP Vec2d predict(InputArray sample,
OutputArray probs=noArray()) const; OutputArray probs=noArray()) const;
@ -603,7 +605,7 @@ public:
virtual void read(const FileNode& fn); virtual void read(const FileNode& fn);
protected: protected:
virtual void setTrainData(int startStep, const Mat& samples, virtual void setTrainData(int startStep, const Mat& samples,
const Mat* probs0, const Mat* probs0,
const Mat* means0, const Mat* means0,
@ -802,7 +804,7 @@ struct CV_EXPORTS CvDTreeTrainData
int buf_count, buf_size; int buf_count, buf_size;
bool shared; bool shared;
int is_buf_16u; int is_buf_16u;
CvMat* cat_count; CvMat* cat_count;
CvMat* cat_ofs; CvMat* cat_ofs;
CvMat* cat_map; CvMat* cat_map;
@ -871,12 +873,12 @@ public:
const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
const cv::Mat& missingDataMask=cv::Mat(), const cv::Mat& missingDataMask=cv::Mat(),
CvDTreeParams params=CvDTreeParams() ); CvDTreeParams params=CvDTreeParams() );
CV_WRAP virtual CvDTreeNode* predict( const cv::Mat& sample, const cv::Mat& missingDataMask=cv::Mat(), CV_WRAP virtual CvDTreeNode* predict( const cv::Mat& sample, const cv::Mat& missingDataMask=cv::Mat(),
bool preprocessedInput=false ) const; bool preprocessedInput=false ) const;
CV_WRAP virtual cv::Mat getVarImportance(); CV_WRAP virtual cv::Mat getVarImportance();
#endif #endif
virtual const CvMat* get_var_importance(); virtual const CvMat* get_var_importance();
CV_WRAP virtual void clear(); CV_WRAP virtual void clear();
@ -900,13 +902,13 @@ protected:
virtual void try_split_node( CvDTreeNode* n ); virtual void try_split_node( CvDTreeNode* n );
virtual void split_node_data( CvDTreeNode* n ); virtual void split_node_data( CvDTreeNode* n );
virtual CvDTreeSplit* find_best_split( CvDTreeNode* n ); virtual CvDTreeSplit* find_best_split( CvDTreeNode* n );
virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi, virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi,
float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 ); float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi, virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi,
float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 ); float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi, virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi,
float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 ); float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi, virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi,
float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 ); float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
virtual CvDTreeSplit* find_surrogate_split_ord( CvDTreeNode* n, int vi, uchar* ext_buf = 0 ); virtual CvDTreeSplit* find_surrogate_split_ord( CvDTreeNode* n, int vi, uchar* ext_buf = 0 );
virtual CvDTreeSplit* find_surrogate_split_cat( CvDTreeNode* n, int vi, uchar* ext_buf = 0 ); virtual CvDTreeSplit* find_surrogate_split_cat( CvDTreeNode* n, int vi, uchar* ext_buf = 0 );
@ -1003,7 +1005,7 @@ public:
const CvMat* sampleIdx=0, const CvMat* varType=0, const CvMat* sampleIdx=0, const CvMat* varType=0,
const CvMat* missingDataMask=0, const CvMat* missingDataMask=0,
CvRTParams params=CvRTParams() ); CvRTParams params=CvRTParams() );
virtual bool train( CvMLData* data, CvRTParams params=CvRTParams() ); virtual bool train( CvMLData* data, CvRTParams params=CvRTParams() );
virtual float predict( const CvMat* sample, const CvMat* missing = 0 ) const; virtual float predict( const CvMat* sample, const CvMat* missing = 0 ) const;
virtual float predict_prob( const CvMat* sample, const CvMat* missing = 0 ) const; virtual float predict_prob( const CvMat* sample, const CvMat* missing = 0 ) const;
@ -1018,16 +1020,16 @@ public:
CV_WRAP virtual float predict_prob( const cv::Mat& sample, const cv::Mat& missing = cv::Mat() ) const; CV_WRAP virtual float predict_prob( const cv::Mat& sample, const cv::Mat& missing = cv::Mat() ) const;
CV_WRAP virtual cv::Mat getVarImportance(); CV_WRAP virtual cv::Mat getVarImportance();
#endif #endif
CV_WRAP virtual void clear(); CV_WRAP virtual void clear();
virtual const CvMat* get_var_importance(); virtual const CvMat* get_var_importance();
virtual float get_proximity( const CvMat* sample1, const CvMat* sample2, virtual float get_proximity( const CvMat* sample1, const CvMat* sample2,
const CvMat* missing1 = 0, const CvMat* missing2 = 0 ) const; const CvMat* missing1 = 0, const CvMat* missing2 = 0 ) const;
virtual float calc_error( CvMLData* data, int type , std::vector<float>* resp = 0 ); // type in {CV_TRAIN_ERROR, CV_TEST_ERROR} virtual float calc_error( CvMLData* data, int type , std::vector<float>* resp = 0 ); // type in {CV_TRAIN_ERROR, CV_TEST_ERROR}
virtual float get_train_error(); virtual float get_train_error();
virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void read( CvFileStorage* fs, CvFileNode* node );
virtual void write( CvFileStorage* fs, const char* name ) const; virtual void write( CvFileStorage* fs, const char* name ) const;
@ -1083,13 +1085,13 @@ class CV_EXPORTS CvForestERTree : public CvForestTree
{ {
protected: protected:
virtual double calc_node_dir( CvDTreeNode* node ); virtual double calc_node_dir( CvDTreeNode* node );
virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi, virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi,
float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 ); float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi, virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi,
float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 ); float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi, virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi,
float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 ); float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi, virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi,
float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 ); float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
virtual void split_node_data( CvDTreeNode* n ); virtual void split_node_data( CvDTreeNode* n );
}; };
@ -1169,13 +1171,13 @@ protected:
virtual void try_split_node( CvDTreeNode* n ); virtual void try_split_node( CvDTreeNode* n );
virtual CvDTreeSplit* find_surrogate_split_ord( CvDTreeNode* n, int vi, uchar* ext_buf = 0 ); virtual CvDTreeSplit* find_surrogate_split_ord( CvDTreeNode* n, int vi, uchar* ext_buf = 0 );
virtual CvDTreeSplit* find_surrogate_split_cat( CvDTreeNode* n, int vi, uchar* ext_buf = 0 ); virtual CvDTreeSplit* find_surrogate_split_cat( CvDTreeNode* n, int vi, uchar* ext_buf = 0 );
virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi, virtual CvDTreeSplit* find_split_ord_class( CvDTreeNode* n, int vi,
float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 ); float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi, virtual CvDTreeSplit* find_split_cat_class( CvDTreeNode* n, int vi,
float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 ); float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi, virtual CvDTreeSplit* find_split_ord_reg( CvDTreeNode* n, int vi,
float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 ); float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi, virtual CvDTreeSplit* find_split_cat_reg( CvDTreeNode* n, int vi,
float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 ); float init_quality = 0, CvDTreeSplit* _split = 0, uchar* ext_buf = 0 );
virtual void calc_node_value( CvDTreeNode* n ); virtual void calc_node_value( CvDTreeNode* n );
virtual double calc_node_dir( CvDTreeNode* n ); virtual double calc_node_dir( CvDTreeNode* n );
@ -1201,14 +1203,14 @@ public:
const CvMat* sampleIdx=0, const CvMat* varType=0, const CvMat* sampleIdx=0, const CvMat* varType=0,
const CvMat* missingDataMask=0, const CvMat* missingDataMask=0,
CvBoostParams params=CvBoostParams() ); CvBoostParams params=CvBoostParams() );
virtual bool train( const CvMat* trainData, int tflag, virtual bool train( const CvMat* trainData, int tflag,
const CvMat* responses, const CvMat* varIdx=0, const CvMat* responses, const CvMat* varIdx=0,
const CvMat* sampleIdx=0, const CvMat* varType=0, const CvMat* sampleIdx=0, const CvMat* varType=0,
const CvMat* missingDataMask=0, const CvMat* missingDataMask=0,
CvBoostParams params=CvBoostParams(), CvBoostParams params=CvBoostParams(),
bool update=false ); bool update=false );
virtual bool train( CvMLData* data, virtual bool train( CvMLData* data,
CvBoostParams params=CvBoostParams(), CvBoostParams params=CvBoostParams(),
bool update=false ); bool update=false );
@ -1223,19 +1225,19 @@ public:
const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
const cv::Mat& missingDataMask=cv::Mat(), const cv::Mat& missingDataMask=cv::Mat(),
CvBoostParams params=CvBoostParams() ); CvBoostParams params=CvBoostParams() );
CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag, CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag,
const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(), const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
const cv::Mat& missingDataMask=cv::Mat(), const cv::Mat& missingDataMask=cv::Mat(),
CvBoostParams params=CvBoostParams(), CvBoostParams params=CvBoostParams(),
bool update=false ); bool update=false );
CV_WRAP virtual float predict( const cv::Mat& sample, const cv::Mat& missing=cv::Mat(), CV_WRAP virtual float predict( const cv::Mat& sample, const cv::Mat& missing=cv::Mat(),
const cv::Range& slice=cv::Range::all(), bool rawMode=false, const cv::Range& slice=cv::Range::all(), bool rawMode=false,
bool returnSum=false ) const; bool returnSum=false ) const;
#endif #endif
virtual float calc_error( CvMLData* _data, int type , std::vector<float> *resp = 0 ); // type in {CV_TRAIN_ERROR, CV_TEST_ERROR} virtual float calc_error( CvMLData* _data, int type , std::vector<float> *resp = 0 ); // type in {CV_TRAIN_ERROR, CV_TEST_ERROR}
CV_WRAP virtual void prune( CvSlice slice ); CV_WRAP virtual void prune( CvSlice slice );
@ -1315,7 +1317,7 @@ struct CV_EXPORTS_W_MAP CvGBTreesParams : public CvDTreeParams
// DataType: CLASS CvGBTrees // DataType: CLASS CvGBTrees
// Gradient Boosting Trees (GBT) algorithm implementation. // Gradient Boosting Trees (GBT) algorithm implementation.
// //
// data - training dataset // data - training dataset
// params - parameters of the CvGBTrees // params - parameters of the CvGBTrees
// weak - array[0..(class_count-1)] of CvSeq // weak - array[0..(class_count-1)] of CvSeq
@ -1347,7 +1349,7 @@ struct CV_EXPORTS_W_MAP CvGBTreesParams : public CvDTreeParams
// missing - mask of the missing values in the training set. This // missing - mask of the missing values in the training set. This
// matrix has the same size as train_data. 1 - missing // matrix has the same size as train_data. 1 - missing
// value, 0 - not a missing value. // value, 0 - not a missing value.
// class_labels - output class labels map. // class_labels - output class labels map.
// rng - random number generator. Used for spliting the // rng - random number generator. Used for spliting the
// training set. // training set.
// class_count - count of output classes. // class_count - count of output classes.
@ -1368,15 +1370,15 @@ public:
/* /*
// DataType: ENUM // DataType: ENUM
// Loss functions implemented in CvGBTrees. // Loss functions implemented in CvGBTrees.
// //
// SQUARED_LOSS // SQUARED_LOSS
// problem: regression // problem: regression
// loss = (x - x')^2 // loss = (x - x')^2
// //
// ABSOLUTE_LOSS // ABSOLUTE_LOSS
// problem: regression // problem: regression
// loss = abs(x - x') // loss = abs(x - x')
// //
// HUBER_LOSS // HUBER_LOSS
// problem: regression // problem: regression
// loss = delta*( abs(x - x') - delta/2), if abs(x - x') > delta // loss = delta*( abs(x - x') - delta/2), if abs(x - x') > delta
@ -1386,18 +1388,18 @@ public:
// //
// DEVIANCE_LOSS // DEVIANCE_LOSS
// problem: classification // problem: classification
// //
*/ */
enum {SQUARED_LOSS=0, ABSOLUTE_LOSS, HUBER_LOSS=3, DEVIANCE_LOSS}; enum {SQUARED_LOSS=0, ABSOLUTE_LOSS, HUBER_LOSS=3, DEVIANCE_LOSS};
/* /*
// Default constructor. Creates a model only (without training). // Default constructor. Creates a model only (without training).
// Should be followed by one form of the train(...) function. // Should be followed by one form of the train(...) function.
// //
// API // API
// CvGBTrees(); // CvGBTrees();
// INPUT // INPUT
// OUTPUT // OUTPUT
// RESULT // RESULT
@ -1415,7 +1417,7 @@ public:
const CvMat* sampleIdx=0, const CvMat* varType=0, const CvMat* sampleIdx=0, const CvMat* varType=0,
const CvMat* missingDataMask=0, const CvMat* missingDataMask=0,
CvGBTreesParams params=CvGBTreesParams() ); CvGBTreesParams params=CvGBTreesParams() );
// INPUT // INPUT
// trainData - a set of input feature vectors. // trainData - a set of input feature vectors.
// size of matrix is // size of matrix is
@ -1448,13 +1450,13 @@ public:
const CvMat* missingDataMask=0, const CvMat* missingDataMask=0,
CvGBTreesParams params=CvGBTreesParams() ); CvGBTreesParams params=CvGBTreesParams() );
/* /*
// Destructor. // Destructor.
*/ */
virtual ~CvGBTrees(); virtual ~CvGBTrees();
/* /*
// Gradient tree boosting model training // Gradient tree boosting model training
// //
@ -1465,7 +1467,7 @@ public:
const CvMat* missingDataMask=0, const CvMat* missingDataMask=0,
CvGBTreesParams params=CvGBTreesParams(), CvGBTreesParams params=CvGBTreesParams(),
bool update=false ); bool update=false );
// INPUT // INPUT
// trainData - a set of input feature vectors. // trainData - a set of input feature vectors.
// size of matrix is // size of matrix is
@ -1500,8 +1502,8 @@ public:
const CvMat* missingDataMask=0, const CvMat* missingDataMask=0,
CvGBTreesParams params=CvGBTreesParams(), CvGBTreesParams params=CvGBTreesParams(),
bool update=false ); bool update=false );
/* /*
// Gradient tree boosting model training // Gradient tree boosting model training
// //
@ -1509,7 +1511,7 @@ public:
// virtual bool train( CvMLData* data, // virtual bool train( CvMLData* data,
CvGBTreesParams params=CvGBTreesParams(), CvGBTreesParams params=CvGBTreesParams(),
bool update=false ) {return false;}; bool update=false ) {return false;};
// INPUT // INPUT
// data - training set. // data - training set.
// params - parameters of GTB algorithm. // params - parameters of GTB algorithm.
@ -1522,7 +1524,7 @@ public:
CvGBTreesParams params=CvGBTreesParams(), CvGBTreesParams params=CvGBTreesParams(),
bool update=false ); bool update=false );
/* /*
// Response value prediction // Response value prediction
// //
@ -1530,7 +1532,7 @@ public:
// virtual float predict_serial( const CvMat* sample, const CvMat* missing=0, // virtual float predict_serial( const CvMat* sample, const CvMat* missing=0,
CvMat* weak_responses=0, CvSlice slice = CV_WHOLE_SEQ, CvMat* weak_responses=0, CvSlice slice = CV_WHOLE_SEQ,
int k=-1 ) const; int k=-1 ) const;
// INPUT // INPUT
// sample - input sample of the same type as in the training set. // sample - input sample of the same type as in the training set.
// missing - missing values mask. missing=0 if there are no // missing - missing values mask. missing=0 if there are no
@ -1541,7 +1543,7 @@ public:
// slice = CV_WHOLE_SEQ when all trees are used. // slice = CV_WHOLE_SEQ when all trees are used.
// k - number of ensemble used. // k - number of ensemble used.
// k is in {-1,0,1,..,<count of output classes-1>}. // k is in {-1,0,1,..,<count of output classes-1>}.
// in the case of classification problem // in the case of classification problem
// <count of output classes-1> ensembles are built. // <count of output classes-1> ensembles are built.
// If k = -1 ordinary prediction is the result, // If k = -1 ordinary prediction is the result,
// otherwise function gives the prediction of the // otherwise function gives the prediction of the
@ -1553,7 +1555,7 @@ public:
virtual float predict_serial( const CvMat* sample, const CvMat* missing=0, virtual float predict_serial( const CvMat* sample, const CvMat* missing=0,
CvMat* weakResponses=0, CvSlice slice = CV_WHOLE_SEQ, CvMat* weakResponses=0, CvSlice slice = CV_WHOLE_SEQ,
int k=-1 ) const; int k=-1 ) const;
/* /*
// Response value prediction. // Response value prediction.
// Parallel version (in the case of TBB existence) // Parallel version (in the case of TBB existence)
@ -1562,7 +1564,7 @@ public:
// virtual float predict( const CvMat* sample, const CvMat* missing=0, // virtual float predict( const CvMat* sample, const CvMat* missing=0,
CvMat* weak_responses=0, CvSlice slice = CV_WHOLE_SEQ, CvMat* weak_responses=0, CvSlice slice = CV_WHOLE_SEQ,
int k=-1 ) const; int k=-1 ) const;
// INPUT // INPUT
// sample - input sample of the same type as in the training set. // sample - input sample of the same type as in the training set.
// missing - missing values mask. missing=0 if there are no // missing - missing values mask. missing=0 if there are no
@ -1573,7 +1575,7 @@ public:
// slice = CV_WHOLE_SEQ when all trees are used. // slice = CV_WHOLE_SEQ when all trees are used.
// k - number of ensemble used. // k - number of ensemble used.
// k is in {-1,0,1,..,<count of output classes-1>}. // k is in {-1,0,1,..,<count of output classes-1>}.
// in the case of classification problem // in the case of classification problem
// <count of output classes-1> ensembles are built. // <count of output classes-1> ensembles are built.
// If k = -1 ordinary prediction is the result, // If k = -1 ordinary prediction is the result,
// otherwise function gives the prediction of the // otherwise function gives the prediction of the
@ -1581,7 +1583,7 @@ public:
// OUTPUT // OUTPUT
// RESULT // RESULT
// Predicted value. // Predicted value.
*/ */
virtual float predict( const CvMat* sample, const CvMat* missing=0, virtual float predict( const CvMat* sample, const CvMat* missing=0,
CvMat* weakResponses=0, CvSlice slice = CV_WHOLE_SEQ, CvMat* weakResponses=0, CvSlice slice = CV_WHOLE_SEQ,
int k=-1 ) const; int k=-1 ) const;
@ -1591,7 +1593,7 @@ public:
// //
// API // API
// virtual void clear(); // virtual void clear();
// INPUT // INPUT
// OUTPUT // OUTPUT
// delete data, weak, orig_response, sum_response, // delete data, weak, orig_response, sum_response,
@ -1622,7 +1624,7 @@ public:
std::vector<float> *resp = 0 ); std::vector<float> *resp = 0 );
/* /*
// //
// Write parameters of the gtb model and data. Write learned model. // Write parameters of the gtb model and data. Write learned model.
// //
// API // API
@ -1638,7 +1640,7 @@ public:
/* /*
// //
// Read parameters of the gtb model and data. Read learned model. // Read parameters of the gtb model and data. Read learned model.
// //
// API // API
@ -1652,14 +1654,14 @@ public:
*/ */
virtual void read( CvFileStorage* fs, CvFileNode* node ); virtual void read( CvFileStorage* fs, CvFileNode* node );
// new-style C++ interface // new-style C++ interface
CV_WRAP CvGBTrees( const cv::Mat& trainData, int tflag, CV_WRAP CvGBTrees( const cv::Mat& trainData, int tflag,
const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(), const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
const cv::Mat& missingDataMask=cv::Mat(), const cv::Mat& missingDataMask=cv::Mat(),
CvGBTreesParams params=CvGBTreesParams() ); CvGBTreesParams params=CvGBTreesParams() );
CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag, CV_WRAP virtual bool train( const cv::Mat& trainData, int tflag,
const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(), const cv::Mat& responses, const cv::Mat& varIdx=cv::Mat(),
const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(), const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& varType=cv::Mat(),
@ -1670,7 +1672,7 @@ public:
CV_WRAP virtual float predict( const cv::Mat& sample, const cv::Mat& missing=cv::Mat(), CV_WRAP virtual float predict( const cv::Mat& sample, const cv::Mat& missing=cv::Mat(),
const cv::Range& slice = cv::Range::all(), const cv::Range& slice = cv::Range::all(),
int k=-1 ) const; int k=-1 ) const;
protected: protected:
/* /*
@ -1678,7 +1680,7 @@ protected:
// //
// API // API
// virtual void find_gradient( const int k = 0); // virtual void find_gradient( const int k = 0);
// INPUT // INPUT
// k - used for classification problem, determining current // k - used for classification problem, determining current
// tree ensemble. // tree ensemble.
@ -1690,9 +1692,9 @@ protected:
*/ */
virtual void find_gradient( const int k = 0); virtual void find_gradient( const int k = 0);
/* /*
// //
// Change values in tree leaves according to the used loss function. // Change values in tree leaves according to the used loss function.
// //
// API // API
@ -1711,7 +1713,7 @@ protected:
/* /*
// //
// Find optimal constant prediction value according to the used loss // Find optimal constant prediction value according to the used loss
// function. // function.
// The goal is to find a constant which gives the minimal summary loss // The goal is to find a constant which gives the minimal summary loss
@ -1728,9 +1730,9 @@ protected:
*/ */
virtual float find_optimal_value( const CvMat* _Idx ); virtual float find_optimal_value( const CvMat* _Idx );
/* /*
// //
// Randomly split the whole training set in two parts according // Randomly split the whole training set in two parts according
// to params.portion. // to params.portion.
// //
@ -1747,7 +1749,7 @@ protected:
/* /*
// //
// Internal recursive function giving an array of subtree tree leaves. // Internal recursive function giving an array of subtree tree leaves.
// //
// API // API
@ -1761,10 +1763,10 @@ protected:
// RESULT // RESULT
*/ */
void leaves_get( CvDTreeNode** leaves, int& count, CvDTreeNode* node ); void leaves_get( CvDTreeNode** leaves, int& count, CvDTreeNode* node );
/* /*
// //
// Get leaves of the tree. // Get leaves of the tree.
// //
// API // API
@ -1779,9 +1781,9 @@ protected:
*/ */
CvDTreeNode** GetLeaves( const CvDTree* dtree, int& len ); CvDTreeNode** GetLeaves( const CvDTree* dtree, int& len );
/* /*
// //
// Is it a regression or a classification. // Is it a regression or a classification.
// //
// API // API
@ -1797,7 +1799,7 @@ protected:
/* /*
// //
// Write parameters of the gtb model. // Write parameters of the gtb model.
// //
// API // API
@ -1812,7 +1814,7 @@ protected:
/* /*
// //
// Read parameters of the gtb model and data. // Read parameters of the gtb model and data.
// //
// API // API
@ -1829,9 +1831,9 @@ protected:
// RESULT // RESULT
*/ */
virtual void read_params( CvFileStorage* fs, CvFileNode* fnode ); virtual void read_params( CvFileStorage* fs, CvFileNode* fnode );
int get_len(const CvMat* mat) const; int get_len(const CvMat* mat) const;
CvDTreeTrainData* data; CvDTreeTrainData* data;
CvGBTreesParams params; CvGBTreesParams params;
@ -1894,30 +1896,30 @@ public:
virtual void create( const CvMat* layerSizes, virtual void create( const CvMat* layerSizes,
int activateFunc=CvANN_MLP::SIGMOID_SYM, int activateFunc=CvANN_MLP::SIGMOID_SYM,
double fparam1=0, double fparam2=0 ); double fparam1=0, double fparam2=0 );
virtual int train( const CvMat* inputs, const CvMat* outputs, virtual int train( const CvMat* inputs, const CvMat* outputs,
const CvMat* sampleWeights, const CvMat* sampleIdx=0, const CvMat* sampleWeights, const CvMat* sampleIdx=0,
CvANN_MLP_TrainParams params = CvANN_MLP_TrainParams(), CvANN_MLP_TrainParams params = CvANN_MLP_TrainParams(),
int flags=0 ); int flags=0 );
virtual float predict( const CvMat* inputs, CV_OUT CvMat* outputs ) const; virtual float predict( const CvMat* inputs, CV_OUT CvMat* outputs ) const;
#ifndef SWIG #ifndef SWIG
CV_WRAP CvANN_MLP( const cv::Mat& layerSizes, CV_WRAP CvANN_MLP( const cv::Mat& layerSizes,
int activateFunc=CvANN_MLP::SIGMOID_SYM, int activateFunc=CvANN_MLP::SIGMOID_SYM,
double fparam1=0, double fparam2=0 ); double fparam1=0, double fparam2=0 );
CV_WRAP virtual void create( const cv::Mat& layerSizes, CV_WRAP virtual void create( const cv::Mat& layerSizes,
int activateFunc=CvANN_MLP::SIGMOID_SYM, int activateFunc=CvANN_MLP::SIGMOID_SYM,
double fparam1=0, double fparam2=0 ); double fparam1=0, double fparam2=0 );
CV_WRAP virtual int train( const cv::Mat& inputs, const cv::Mat& outputs, CV_WRAP virtual int train( const cv::Mat& inputs, const cv::Mat& outputs,
const cv::Mat& sampleWeights, const cv::Mat& sampleIdx=cv::Mat(), const cv::Mat& sampleWeights, const cv::Mat& sampleIdx=cv::Mat(),
CvANN_MLP_TrainParams params = CvANN_MLP_TrainParams(), CvANN_MLP_TrainParams params = CvANN_MLP_TrainParams(),
int flags=0 ); int flags=0 );
CV_WRAP virtual float predict( const cv::Mat& inputs, CV_OUT cv::Mat& outputs ) const; CV_WRAP virtual float predict( const cv::Mat& inputs, CV_OUT cv::Mat& outputs ) const;
#endif #endif
CV_WRAP virtual void clear(); CV_WRAP virtual void clear();
// possible activation functions // possible activation functions
@ -2031,7 +2033,7 @@ public:
virtual ~CvMLData(); virtual ~CvMLData();
// returns: // returns:
// 0 - OK // 0 - OK
// -1 - file can not be opened or is not correct // -1 - file can not be opened or is not correct
int read_csv( const char* filename ); int read_csv( const char* filename );
@ -2039,8 +2041,8 @@ public:
const CvMat* get_responses(); const CvMat* get_responses();
const CvMat* get_missing() const; const CvMat* get_missing() const;
void set_header_lines_number( int n ); void set_header_lines_number( int n );
int get_header_lines_number() const; int get_header_lines_number() const;
void set_response_idx( int idx ); // old response become predictors, new response_idx = idx void set_response_idx( int idx ); // old response become predictors, new response_idx = idx
// if idx < 0 there will be no response // if idx < 0 there will be no response
@ -2050,7 +2052,7 @@ public:
const CvMat* get_train_sample_idx() const; const CvMat* get_train_sample_idx() const;
const CvMat* get_test_sample_idx() const; const CvMat* get_test_sample_idx() const;
void mix_train_and_test_idx(); void mix_train_and_test_idx();
const CvMat* get_var_idx(); const CvMat* get_var_idx();
void chahge_var_idx( int vi, bool state ); // misspelled (saved for back compitability), void chahge_var_idx( int vi, bool state ); // misspelled (saved for back compitability),
// use change_var_idx // use change_var_idx
@ -2064,14 +2066,14 @@ public:
void set_var_types( const char* str ); // str examples: void set_var_types( const char* str ); // str examples:
// "ord[0-17],cat[18]", "ord[0,2,4,10-12], cat[1,3,5-9,13,14]", // "ord[0-17],cat[18]", "ord[0,2,4,10-12], cat[1,3,5-9,13,14]",
// "cat", "ord" (all vars are categorical/ordered) // "cat", "ord" (all vars are categorical/ordered)
void change_var_type( int var_idx, int type); // type in { CV_VAR_ORDERED, CV_VAR_CATEGORICAL } void change_var_type( int var_idx, int type); // type in { CV_VAR_ORDERED, CV_VAR_CATEGORICAL }
void set_delimiter( char ch ); void set_delimiter( char ch );
char get_delimiter() const; char get_delimiter() const;
void set_miss_ch( char ch ); void set_miss_ch( char ch );
char get_miss_ch() const; char get_miss_ch() const;
const std::map<std::string, int>& get_class_labels_map() const; const std::map<std::string, int>& get_class_labels_map() const;
protected: protected:
@ -2079,7 +2081,7 @@ protected:
void str_to_flt_elem( const char* token, float& flt_elem, int& type); void str_to_flt_elem( const char* token, float& flt_elem, int& type);
void free_train_test_idx(); void free_train_test_idx();
char delimiter; char delimiter;
char miss_ch; char miss_ch;
//char flt_separator; //char flt_separator;
@ -2093,13 +2095,13 @@ protected:
CvMat* var_idx_out; // mat CvMat* var_idx_out; // mat
CvMat* var_types_out; // mat CvMat* var_types_out; // mat
int header_lines_number; int header_lines_number;
int response_idx; int response_idx;
int train_sample_count; int train_sample_count;
bool mix; bool mix;
int total_class_count; int total_class_count;
std::map<std::string, int> class_map; std::map<std::string, int> class_map;
@ -2113,7 +2115,7 @@ protected:
namespace cv namespace cv
{ {
typedef CvStatModel StatModel; typedef CvStatModel StatModel;
typedef CvParamGrid ParamGrid; typedef CvParamGrid ParamGrid;
typedef CvNormalBayesClassifier NormalBayesClassifier; typedef CvNormalBayesClassifier NormalBayesClassifier;
@ -2142,7 +2144,7 @@ typedef CvGBTrees GradientBoostingTrees;
template<> CV_EXPORTS void Ptr<CvDTreeSplit>::delete_obj(); template<> CV_EXPORTS void Ptr<CvDTreeSplit>::delete_obj();
CV_EXPORTS bool initModule_ml(void); CV_EXPORTS bool initModule_ml(void);
} }
#endif // __cplusplus #endif // __cplusplus

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

@ -504,7 +504,7 @@ void CvANN_MLP::calc_activ_func_deriv( CvMat* _xf, CvMat* _df,
n *= cols; n *= cols;
xf -= n; df -= n; xf -= n; df -= n;
for( i = 0; i < n; i++ ) for( i = 0; i < n; i++ )
df[i] *= xf[i]; df[i] *= xf[i];
} }
@ -517,7 +517,7 @@ void CvANN_MLP::calc_activ_func_deriv( CvMat* _xf, CvMat* _df,
xf[j] = (xf[j] + bias[j])*scale; xf[j] = (xf[j] + bias[j])*scale;
df[j] = -fabs(xf[j]); df[j] = -fabs(xf[j]);
} }
cvExp( _df, _df ); cvExp( _df, _df );
n *= cols; n *= cols;
@ -1023,9 +1023,9 @@ int CvANN_MLP::train_backprop( CvVectors x0, CvVectors u, const double* sw )
} }
struct rprop_loop { struct rprop_loop {
rprop_loop(const CvANN_MLP* _point, double**& _weights, int& _count, int& _ivcount, CvVectors* _x0, rprop_loop(const CvANN_MLP* _point, double**& _weights, int& _count, int& _ivcount, CvVectors* _x0,
int& _l_count, CvMat*& _layer_sizes, int& _ovcount, int& _max_count, int& _l_count, CvMat*& _layer_sizes, int& _ovcount, int& _max_count,
CvVectors* _u, const double*& _sw, double& _inv_count, CvMat*& _dEdw, int& _dcount0, double* _E, int _buf_sz) CvVectors* _u, const double*& _sw, double& _inv_count, CvMat*& _dEdw, int& _dcount0, double* _E, int _buf_sz)
{ {
point = _point; point = _point;
weights = _weights; weights = _weights;
@ -1044,7 +1044,7 @@ struct rprop_loop {
E = _E; E = _E;
buf_sz = _buf_sz; buf_sz = _buf_sz;
} }
const CvANN_MLP* point; const CvANN_MLP* point;
double** weights; double** weights;
int count; int count;
@ -1062,14 +1062,14 @@ struct rprop_loop {
double* E; double* E;
int buf_sz; int buf_sz;
void operator()( const cv::BlockedRange& range ) const void operator()( const cv::BlockedRange& range ) const
{ {
double* buf_ptr; double* buf_ptr;
double** x = 0; double** x = 0;
double **df = 0; double **df = 0;
int total = 0; int total = 0;
for(int i = 0; i < l_count; i++ ) for(int i = 0; i < l_count; i++ )
total += layer_sizes->data.i[i]; total += layer_sizes->data.i[i];
CvMat* buf; CvMat* buf;
@ -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;
@ -1100,23 +1100,23 @@ struct rprop_loop {
// grab and preprocess input data // grab and preprocess input data
if( x0->type == CV_32F ) if( x0->type == CV_32F )
{ {
for(int i = 0; i < dcount; i++ ) for(int i = 0; i < dcount; i++ )
{ {
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];
} }
} }
else else
for(int i = 0; i < dcount; i++ ) for(int i = 0; i < dcount; i++ )
{ {
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] );
// forward pass, compute y[i]=w*x[i-1], x[i]=f(y[i]), df[i]=f'(y[i]) // forward pass, compute y[i]=w*x[i-1], x[i]=f(y[i]), df[i]=f'(y[i])
@ -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;
@ -1168,7 +1168,7 @@ struct rprop_loop {
} }
*E += sweight*E1; *E += sweight*E1;
} }
// backward pass, update dEdw // backward pass, update dEdw
#ifdef HAVE_TBB #ifdef HAVE_TBB
static tbb::spin_mutex mutex; static tbb::spin_mutex mutex;
@ -1191,10 +1191,10 @@ 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];
} }
if (i > 1) if (i > 1)
cvInitMatHeader( &_w, n1, n2, CV_64F, weights[i] ); cvInitMatHeader( &_w, n1, n2, CV_64F, weights[i] );
#ifdef HAVE_TBB #ifdef HAVE_TBB
@ -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;
@ -1297,8 +1297,8 @@ int CvANN_MLP::train_rprop( CvVectors x0, CvVectors u, const double* sw )
double E = 0; double E = 0;
// first, iterate through all the samples and compute dEdw // first, iterate through all the samples and compute dEdw
cv::parallel_for(cv::BlockedRange(0, count), cv::parallel_for(cv::BlockedRange(0, count),
rprop_loop(this, weights, count, ivcount, &x0, l_count, layer_sizes, rprop_loop(this, weights, count, ivcount, &x0, l_count, layer_sizes,
ovcount, max_count, &u, sw, inv_count, dEdw, dcount0, &E, buf_sz) ovcount, max_count, &u, sw, inv_count, dEdw, dcount0, &E, buf_sz)
); );
@ -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,
@ -1610,7 +1610,7 @@ int CvANN_MLP::train( const Mat& _inputs, const Mat& _outputs,
{ {
CvMat inputs = _inputs, outputs = _outputs, sweights = _sample_weights, sidx = _sample_idx; CvMat inputs = _inputs, outputs = _outputs, sweights = _sample_weights, sidx = _sample_idx;
return train(&inputs, &outputs, sweights.data.ptr ? &sweights : 0, return train(&inputs, &outputs, sweights.data.ptr ? &sweights : 0,
sidx.data.ptr ? &sidx : 0, _params, flags); sidx.data.ptr ? &sidx : 0, _params, flags);
} }
float CvANN_MLP::predict( const Mat& _inputs, Mat& _outputs ) const float CvANN_MLP::predict( const Mat& _inputs, Mat& _outputs ) const
@ -1618,8 +1618,8 @@ float CvANN_MLP::predict( const Mat& _inputs, Mat& _outputs ) const
CV_Assert(layer_sizes != 0); CV_Assert(layer_sizes != 0);
_outputs.create(_inputs.rows, layer_sizes->data.i[layer_sizes->cols-1], _inputs.type()); _outputs.create(_inputs.rows, layer_sizes->data.i[layer_sizes->cols-1], _inputs.type());
CvMat inputs = _inputs, outputs = _outputs; CvMat inputs = _inputs, outputs = _outputs;
return predict(&inputs, &outputs); return predict(&inputs, &outputs);
} }
/* End of file. */ /* End of file. */

56
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;
@ -501,7 +501,7 @@ CvBoostTree::find_split_ord_reg( CvDTreeNode* node, int vi, float init_quality,
int i, best_i = -1; int i, best_i = -1;
double L = 0, R = weights[n]; double L = 0, R = weights[n];
double best_val = init_quality, lsum = 0, rsum = node->value*R; double best_val = init_quality, lsum = 0, rsum = node->value*R;
// compensate for missing values // compensate for missing values
for( i = n1; i < n; i++ ) for( i = n1; i < n; i++ )
{ {
@ -590,7 +590,7 @@ CvBoostTree::find_split_cat_reg( CvDTreeNode* node, int vi, float init_quality,
{ {
R += counts[i]; R += counts[i];
rsum += sum[i]; rsum += sum[i];
sum[i] = fabs(counts[i]) > DBL_EPSILON ? sum[i]/counts[i] : 0; sum[i] = fabs(counts[i]) > DBL_EPSILON ? sum[i]/counts[i] : 0;
sum_ptr[i] = sum + i; sum_ptr[i] = sum + i;
} }
@ -1030,7 +1030,7 @@ CvBoost::train( const CvMat* _train_data, int _tflag,
__BEGIN__; __BEGIN__;
int i; int i;
set_params( _params ); set_params( _params );
cvReleaseMat( &active_vars ); cvReleaseMat( &active_vars );
@ -1057,7 +1057,7 @@ CvBoost::train( const CvMat* _train_data, int _tflag,
if ( (_params.boost_type == LOGIT) || (_params.boost_type == GENTLE) ) if ( (_params.boost_type == LOGIT) || (_params.boost_type == GENTLE) )
data->do_responses_copy(); data->do_responses_copy();
update_weights( 0 ); update_weights( 0 );
for( i = 0; i < params.weak_count; i++ ) for( i = 0; i < params.weak_count; i++ )
@ -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__;
@ -1258,7 +1258,7 @@ CvBoost::update_weights( CvBoostTree* tree )
// invert the subsample mask // invert the subsample mask
cvXorS( subsample_mask, cvScalar(1.), subsample_mask ); cvXorS( subsample_mask, cvScalar(1.), subsample_mask );
data->get_vectors( subsample_mask, values, missing, 0 ); data->get_vectors( subsample_mask, values, missing, 0 );
_sample = cvMat( 1, data->var_count, CV_32F ); _sample = cvMat( 1, data->var_count, CV_32F );
_mask = cvMat( 1, data->var_count, CV_8U ); _mask = cvMat( 1, data->var_count, CV_8U );
@ -1458,17 +1458,17 @@ CvBoost::trim_weights()
} }
const CvMat* const CvMat*
CvBoost::get_active_vars( bool absolute_idx ) CvBoost::get_active_vars( bool absolute_idx )
{ {
CvMat* mask = 0; CvMat* mask = 0;
CvMat* inv_map = 0; CvMat* inv_map = 0;
CvMat* result = 0; CvMat* result = 0;
CV_FUNCNAME( "CvBoost::get_active_vars" ); CV_FUNCNAME( "CvBoost::get_active_vars" );
__BEGIN__; __BEGIN__;
if( !weak ) if( !weak )
CV_ERROR( CV_StsError, "The boosted tree ensemble has not been trained yet" ); CV_ERROR( CV_StsError, "The boosted tree ensemble has not been trained yet" );
@ -1478,7 +1478,7 @@ CvBoost::get_active_vars( bool absolute_idx )
int i, j, nactive_vars; int i, j, nactive_vars;
CvBoostTree* wtree; CvBoostTree* wtree;
const CvDTreeNode* node; const CvDTreeNode* node;
assert(!active_vars && !active_vars_abs); assert(!active_vars && !active_vars_abs);
mask = cvCreateMat( 1, data->var_count, CV_8U ); mask = cvCreateMat( 1, data->var_count, CV_8U );
inv_map = cvCreateMat( 1, data->var_count, CV_32S ); inv_map = cvCreateMat( 1, data->var_count, CV_32S );
@ -1518,7 +1518,7 @@ CvBoost::get_active_vars( bool absolute_idx )
} }
nactive_vars = cvCountNonZero(mask); nactive_vars = cvCountNonZero(mask);
//if ( nactive_vars > 0 ) //if ( nactive_vars > 0 )
{ {
active_vars = cvCreateMat( 1, nactive_vars, CV_32S ); active_vars = cvCreateMat( 1, nactive_vars, CV_32S );
@ -1538,7 +1538,7 @@ CvBoost::get_active_vars( bool absolute_idx )
j++; j++;
} }
} }
// second pass: now compute the condensed indices // second pass: now compute the condensed indices
cvStartReadSeq( weak, &reader ); cvStartReadSeq( weak, &reader );
@ -1638,7 +1638,7 @@ CvBoost::predict( const CvMat* _sample, const CvMat* _missing,
"floating-point vector of the same number of components as the length of input slice" ); "floating-point vector of the same number of components as the length of input slice" );
wstep = CV_IS_MAT_CONT(weak_responses->type) ? 1 : weak_responses->step/sizeof(float); wstep = CV_IS_MAT_CONT(weak_responses->type) ? 1 : weak_responses->step/sizeof(float);
} }
int var_count = active_vars->cols; int var_count = active_vars->cols;
const int* vtype = data->var_type->data.i; const int* vtype = data->var_type->data.i;
const int* cmap = data->cat_map->data.i; const int* cmap = data->cat_map->data.i;
@ -1738,7 +1738,7 @@ CvBoost::predict( const CvMat* _sample, const CvMat* _missing,
CvBoostTree* wtree; CvBoostTree* wtree;
const CvDTreeNode* node; const CvDTreeNode* node;
CV_READ_SEQ_ELEM( wtree, reader ); CV_READ_SEQ_ELEM( wtree, reader );
node = wtree->get_root(); node = wtree->get_root();
while( node->left ) while( node->left )
{ {
@ -1757,14 +1757,14 @@ CvBoost::predict( const CvMat* _sample, const CvMat* _missing,
{ {
const int* avars = active_vars->data.i; const int* avars = active_vars->data.i;
const uchar* m = _missing ? _missing->data.ptr : 0; const uchar* m = _missing ? _missing->data.ptr : 0;
// full-featured version // full-featured version
for( i = 0; i < weak_count; i++ ) for( i = 0; i < weak_count; i++ )
{ {
CvBoostTree* wtree; CvBoostTree* wtree;
const CvDTreeNode* node; const CvDTreeNode* node;
CV_READ_SEQ_ELEM( wtree, reader ); CV_READ_SEQ_ELEM( wtree, reader );
node = wtree->get_root(); node = wtree->get_root();
while( node->left ) while( node->left )
{ {
@ -1841,9 +1841,9 @@ float CvBoost::calc_error( CvMLData* _data, int type, std::vector<float> *resp )
{ {
CvMat sample, miss; CvMat sample, miss;
int si = sidx ? sidx[i] : i; int si = sidx ? sidx[i] : i;
cvGetRow( values, &sample, si ); cvGetRow( values, &sample, si );
if( missing ) if( missing )
cvGetRow( missing, &miss, si ); cvGetRow( missing, &miss, si );
float r = (float)predict( &sample, missing ? &miss : 0 ); float r = (float)predict( &sample, missing ? &miss : 0 );
if( pred_resp ) if( pred_resp )
pred_resp[i] = r; pred_resp[i] = r;
@ -1859,15 +1859,15 @@ float CvBoost::calc_error( CvMLData* _data, int type, std::vector<float> *resp )
CvMat sample, miss; CvMat sample, miss;
int si = sidx ? sidx[i] : i; int si = sidx ? sidx[i] : i;
cvGetRow( values, &sample, si ); cvGetRow( values, &sample, si );
if( missing ) if( missing )
cvGetRow( missing, &miss, si ); cvGetRow( missing, &miss, si );
float r = (float)predict( &sample, missing ? &miss : 0 ); float r = (float)predict( &sample, missing ? &miss : 0 );
if( pred_resp ) if( pred_resp )
pred_resp[i] = r; pred_resp[i] = r;
float d = r - response->data.fl[si*r_step]; float d = r - response->data.fl[si*r_step];
err += d*d; err += d*d;
} }
err = sample_count ? err / (float)sample_count : -FLT_MAX; err = sample_count ? err / (float)sample_count : -FLT_MAX;
} }
return err; return err;
} }
@ -2097,10 +2097,10 @@ CvBoost::CvBoost( const Mat& _train_data, int _tflag,
default_model_name = "my_boost_tree"; default_model_name = "my_boost_tree";
active_vars = active_vars_abs = orig_response = sum_response = weak_eval = active_vars = active_vars_abs = orig_response = sum_response = weak_eval =
subsample_mask = weights = subtree_weights = 0; subsample_mask = weights = subtree_weights = 0;
train( _train_data, _tflag, _responses, _var_idx, _sample_idx, train( _train_data, _tflag, _responses, _var_idx, _sample_idx,
_var_type, _missing_mask, _params ); _var_type, _missing_mask, _params );
} }
bool bool
@ -2130,7 +2130,7 @@ CvBoost::predict( const Mat& _sample, const Mat& _missing,
weak_count = weak->total; weak_count = weak->total;
slice.start_index = 0; slice.start_index = 0;
} }
if( !(weak_responses->data && weak_responses->type() == CV_32FC1 && if( !(weak_responses->data && weak_responses->type() == CV_32FC1 &&
(weak_responses->cols == 1 || weak_responses->rows == 1) && (weak_responses->cols == 1 || weak_responses->rows == 1) &&
weak_responses->cols + weak_responses->rows - 1 == weak_count) ) weak_responses->cols + weak_responses->rows - 1 == weak_count) )

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

@ -71,7 +71,7 @@ void CvERTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
CV_FUNCNAME( "CvERTreeTrainData::set_data" ); CV_FUNCNAME( "CvERTreeTrainData::set_data" );
__BEGIN__; __BEGIN__;
int sample_all = 0, r_type, cv_n; int sample_all = 0, r_type, cv_n;
int total_c_count = 0; int total_c_count = 0;
int tree_block_size, temp_block_size, max_split_size, nv_size, cv_size = 0; int tree_block_size, temp_block_size, max_split_size, nv_size, cv_size = 0;
@ -79,10 +79,10 @@ void CvERTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
int vi, i, size; int vi, i, size;
char err[100]; char err[100];
const int *sidx = 0, *vidx = 0; const int *sidx = 0, *vidx = 0;
if ( _params.use_surrogates ) if ( _params.use_surrogates )
CV_ERROR(CV_StsBadArg, "CvERTrees do not support surrogate splits"); CV_ERROR(CV_StsBadArg, "CvERTrees do not support surrogate splits");
if( _update_data && data_root ) if( _update_data && data_root )
{ {
CV_ERROR(CV_StsBadArg, "CvERTrees do not support data update"); CV_ERROR(CV_StsBadArg, "CvERTrees do not support data update");
@ -143,17 +143,17 @@ void CvERTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
CV_ERROR( CV_StsBadArg, "The array of _responses must be an integer or " CV_ERROR( CV_StsBadArg, "The array of _responses must be an integer or "
"floating-point vector containing as many elements as " "floating-point vector containing as many elements as "
"the total number of samples in the training data matrix" ); "the total number of samples in the training data matrix" );
is_buf_16u = false; is_buf_16u = false;
if ( sample_count < 65536 ) if ( sample_count < 65536 )
is_buf_16u = true; is_buf_16u = true;
r_type = CV_VAR_CATEGORICAL; r_type = CV_VAR_CATEGORICAL;
if( _var_type ) if( _var_type )
CV_CALL( var_type0 = cvPreprocessVarType( _var_type, var_idx, var_count, &r_type )); CV_CALL( var_type0 = cvPreprocessVarType( _var_type, var_idx, var_count, &r_type ));
CV_CALL( var_type = cvCreateMat( 1, var_count+2, CV_32SC1 )); CV_CALL( var_type = cvCreateMat( 1, var_count+2, CV_32SC1 ));
cat_var_count = 0; cat_var_count = 0;
ord_var_count = -1; ord_var_count = -1;
@ -182,7 +182,7 @@ void CvERTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
buf_size = (work_var_count + 1)*sample_count; buf_size = (work_var_count + 1)*sample_count;
shared = _shared; shared = _shared;
buf_count = shared ? 2 : 1; buf_count = shared ? 2 : 1;
if ( is_buf_16u ) if ( is_buf_16u )
{ {
CV_CALL( buf = cvCreateMat( buf_count, buf_size, CV_16UC1 )); CV_CALL( buf = cvCreateMat( buf_count, buf_size, CV_16UC1 ));
@ -192,13 +192,13 @@ void CvERTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
{ {
CV_CALL( buf = cvCreateMat( buf_count, buf_size, CV_32SC1 )); CV_CALL( buf = cvCreateMat( buf_count, buf_size, CV_32SC1 ));
CV_CALL( int_ptr = (int**)cvAlloc( sample_count*sizeof(int_ptr[0]) )); CV_CALL( int_ptr = (int**)cvAlloc( sample_count*sizeof(int_ptr[0]) ));
} }
size = is_classifier ? cat_var_count+1 : cat_var_count; size = is_classifier ? cat_var_count+1 : cat_var_count;
size = !size ? 1 : size; size = !size ? 1 : size;
CV_CALL( cat_count = cvCreateMat( 1, size, CV_32SC1 )); CV_CALL( cat_count = cvCreateMat( 1, size, CV_32SC1 ));
CV_CALL( cat_ofs = cvCreateMat( 1, size, CV_32SC1 )); CV_CALL( cat_ofs = cvCreateMat( 1, size, CV_32SC1 ));
size = is_classifier ? (cat_var_count + 1)*params.max_categories : cat_var_count*params.max_categories; size = is_classifier ? (cat_var_count + 1)*params.max_categories : cat_var_count*params.max_categories;
size = !size ? 1 : size; size = !size ? 1 : size;
CV_CALL( cat_map = cvCreateMat( 1, size, CV_32SC1 )); CV_CALL( cat_map = cvCreateMat( 1, size, CV_32SC1 ));
@ -283,12 +283,12 @@ void CvERTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
{ {
int c_count, prev_label; int c_count, prev_label;
int* c_map; int* c_map;
if (is_buf_16u) if (is_buf_16u)
udst = (unsigned short*)(buf->data.s + ci*sample_count); udst = (unsigned short*)(buf->data.s + ci*sample_count);
else else
idst = buf->data.i + ci*sample_count; idst = buf->data.i + ci*sample_count;
// copy data // copy data
for( i = 0; i < sample_count; i++ ) for( i = 0; i < sample_count; i++ )
{ {
@ -322,7 +322,7 @@ void CvERTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
_idst[i] = val; _idst[i] = val;
pair16u32s_ptr[i].u = udst + i; pair16u32s_ptr[i].u = udst + i;
pair16u32s_ptr[i].i = _idst + i; pair16u32s_ptr[i].i = _idst + i;
} }
else else
{ {
idst[i] = val; idst[i] = val;
@ -397,7 +397,7 @@ void CvERTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
// replace labels for missing values with -1 // replace labels for missing values with -1
for( ; i < sample_count; i++ ) for( ; i < sample_count; i++ )
*int_ptr[i] = -1; *int_ptr[i] = -1;
} }
} }
else if( ci < 0 ) // process ordered variable else if( ci < 0 ) // process ordered variable
{ {
@ -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,12 +475,12 @@ 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 );
} }
} }
} }
if ( cat_map ) if ( cat_map )
cat_map->cols = MAX( total_c_count, 1 ); cat_map->cols = MAX( total_c_count, 1 );
max_split_size = cvAlign(sizeof(CvDTreeSplit) + max_split_size = cvAlign(sizeof(CvDTreeSplit) +
@ -532,7 +532,7 @@ void CvERTreeTrainData::get_ord_var_data( CvDTreeNode* n, int vi, float* ord_val
const float** ord_values, const int** missing, int* sample_indices_buf ) const float** ord_values, const int** missing, int* sample_indices_buf )
{ {
int vidx = var_idx ? var_idx->data.i[vi] : vi; int vidx = var_idx ? var_idx->data.i[vi] : vi;
int node_sample_count = n->sample_count; int node_sample_count = n->sample_count;
// may use missing_buf as buffer for sample indices! // may use missing_buf as buffer for sample indices!
const int* sample_indices = get_sample_indices(n, sample_indices_buf ? sample_indices_buf : missing_buf); const int* sample_indices = get_sample_indices(n, sample_indices_buf ? sample_indices_buf : missing_buf);
@ -580,7 +580,7 @@ const int* CvERTreeTrainData::get_cat_var_data( CvDTreeNode* n, int vi, int* cat
if( !is_buf_16u ) if( !is_buf_16u )
cat_values = buf->data.i + n->buf_idx*buf->cols + ci*sample_count + n->offset; cat_values = buf->data.i + n->buf_idx*buf->cols + ci*sample_count + n->offset;
else { else {
const unsigned short* short_values = (const unsigned short*)(buf->data.s + n->buf_idx*buf->cols + const unsigned short* short_values = (const unsigned short*)(buf->data.s + n->buf_idx*buf->cols +
ci*sample_count + n->offset); ci*sample_count + n->offset);
for( int i = 0; i < n->sample_count; i++ ) for( int i = 0; i < n->sample_count; i++ )
cat_values_buf[i] = short_values[i]; cat_values_buf[i] = short_values[i];
@ -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,10 +675,10 @@ 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
{ {
float* _values_buf = (float*)(uchar*)inn_buf; float* _values_buf = (float*)(uchar*)inn_buf;
int* sample_idx_buf = (int*)(_values_buf + sample_count); int* sample_idx_buf = (int*)(_values_buf + sample_count);
@ -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];
} }
} }
} }
@ -700,7 +700,7 @@ void CvERTreeTrainData::get_vectors( const CvMat* _subsample_idx,
CvDTreeNode* CvERTreeTrainData::subsample_data( const CvMat* _subsample_idx ) CvDTreeNode* CvERTreeTrainData::subsample_data( const CvMat* _subsample_idx )
{ {
CvDTreeNode* root = 0; CvDTreeNode* root = 0;
CV_FUNCNAME( "CvERTreeTrainData::subsample_data" ); CV_FUNCNAME( "CvERTreeTrainData::subsample_data" );
__BEGIN__; __BEGIN__;
@ -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)
@ -898,7 +898,7 @@ CvDTreeSplit* CvForestERTree::find_split_ord_class( CvDTreeNode* node, int vi, f
if (split_val - pmin <= FLT_EPSILON) if (split_val - pmin <= FLT_EPSILON)
split_val = pmin + split_delta; split_val = pmin + split_delta;
if (pmax - split_val <= FLT_EPSILON) if (pmax - split_val <= FLT_EPSILON)
split_val = pmax - split_delta; split_val = pmax - split_delta;
// calculate Gini index // calculate Gini index
if ( !priors ) if ( !priors )
@ -906,9 +906,9 @@ CvDTreeSplit* CvForestERTree::find_split_ord_class( CvDTreeNode* node, int vi, f
cv::AutoBuffer<int> lrc(m*2); cv::AutoBuffer<int> lrc(m*2);
int *lc = lrc, *rc = lc + m; int *lc = lrc, *rc = lc + m;
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]++;
@ -942,9 +942,9 @@ CvDTreeSplit* CvForestERTree::find_split_ord_class( CvDTreeNode* node, int vi, f
cv::AutoBuffer<double> lrc(m*2); cv::AutoBuffer<double> lrc(m*2);
double *lc = lrc, *rc = lc + m; double *lc = lrc, *rc = lc + m;
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;
@ -974,7 +974,7 @@ CvDTreeSplit* CvForestERTree::find_split_ord_class( CvDTreeNode* node, int vi, f
} }
best_val = (lbest_val*R + rbest_val*L) / (L*R); best_val = (lbest_val*R + rbest_val*L) / (L*R);
} }
} }
CvDTreeSplit* split = 0; CvDTreeSplit* split = 0;
@ -995,7 +995,7 @@ CvDTreeSplit* CvForestERTree::find_split_cat_class( CvDTreeNode* node, int vi, f
{ {
int ci = data->get_var_type(vi); int ci = data->get_var_type(vi);
int n = node->sample_count; int n = node->sample_count;
int cm = data->get_num_classes(); int cm = data->get_num_classes();
int vm = data->cat_count->data.i[ci]; int vm = data->cat_count->data.i[ci];
double best_val = init_quality; double best_val = init_quality;
CvDTreeSplit *split = 0; CvDTreeSplit *split = 0;
@ -1009,8 +1009,8 @@ CvDTreeSplit* CvForestERTree::find_split_cat_class( CvDTreeNode* node, int vi, f
const int* labels = data->get_cat_var_data( node, vi, ext_buf ); const int* labels = data->get_cat_var_data( node, vi, ext_buf );
const int* responses = data->get_class_labels( node, ext_buf + n ); const int* responses = data->get_class_labels( node, ext_buf + n );
const double* priors = data->have_priors ? data->priors_mult->data.db : 0; const double* priors = data->have_priors ? data->priors_mult->data.db : 0;
// create random class mask // create random class mask
cv::AutoBuffer<int> valid_cidx(vm); cv::AutoBuffer<int> valid_cidx(vm);
@ -1078,7 +1078,7 @@ CvDTreeSplit* CvForestERTree::find_split_cat_class( CvDTreeNode* node, int vi, f
if (var_class_mask->data.ptr[mask_class_idx]) if (var_class_mask->data.ptr[mask_class_idx])
{ {
lc[r]++; lc[r]++;
L++; L++;
split->subset[var_class_idx >> 5] |= 1 << (var_class_idx & 31); split->subset[var_class_idx >> 5] |= 1 << (var_class_idx & 31);
} }
else else
@ -1091,7 +1091,7 @@ CvDTreeSplit* CvForestERTree::find_split_cat_class( CvDTreeNode* node, int vi, f
{ {
lbest_val += lc[i]*lc[i]; lbest_val += lc[i]*lc[i];
rbest_val += rc[i]*rc[i]; rbest_val += rc[i]*rc[i];
} }
best_val = (lbest_val*R + rbest_val*L) / ((double)(L*R)); best_val = (lbest_val*R + rbest_val*L) / ((double)(L*R));
} }
else else
@ -1113,11 +1113,11 @@ CvDTreeSplit* CvForestERTree::find_split_cat_class( CvDTreeNode* node, int vi, f
continue; continue;
double p = priors[si]; double p = priors[si];
int mask_class_idx = valid_cidx[var_class_idx]; int mask_class_idx = valid_cidx[var_class_idx];
if (var_class_mask->data.ptr[mask_class_idx]) if (var_class_mask->data.ptr[mask_class_idx])
{ {
lc[r]+=(int)p; lc[r]+=(int)p;
L+=p; L+=p;
split->subset[var_class_idx >> 5] |= 1 << (var_class_idx & 31); split->subset[var_class_idx >> 5] |= 1 << (var_class_idx & 31);
} }
else else
@ -1136,8 +1136,8 @@ CvDTreeSplit* CvForestERTree::find_split_cat_class( CvDTreeNode* node, int vi, f
split->quality = (float)best_val; split->quality = (float)best_val;
cvReleaseMat(&var_class_mask); cvReleaseMat(&var_class_mask);
} }
} }
return split; return split;
} }
@ -1193,7 +1193,7 @@ CvDTreeSplit* CvForestERTree::find_split_ord_reg( CvDTreeNode* node, int vi, flo
if (split_val - pmin <= FLT_EPSILON) if (split_val - pmin <= FLT_EPSILON)
split_val = pmin + split_delta; split_val = pmin + split_delta;
if (pmax - split_val <= FLT_EPSILON) if (pmax - split_val <= FLT_EPSILON)
split_val = pmax - split_delta; split_val = pmax - split_delta;
for (int si = 0; si < n; si++) for (int si = 0; si < n; si++)
{ {
@ -1209,7 +1209,7 @@ CvDTreeSplit* CvForestERTree::find_split_ord_reg( CvDTreeNode* node, int vi, flo
else else
{ {
rsum += r; rsum += r;
R++; R++;
} }
} }
best_val = (lsum*lsum*R + rsum*rsum*L)/((double)L*R); best_val = (lsum*lsum*R + rsum*rsum*L)/((double)L*R);
@ -1306,7 +1306,7 @@ CvDTreeSplit* CvForestERTree::find_split_cat_reg( CvDTreeNode* node, int vi, flo
if (var_class_mask->data.ptr[mask_class_idx]) if (var_class_mask->data.ptr[mask_class_idx])
{ {
lsum += r; lsum += r;
L++; L++;
split->subset[var_class_idx >> 5] |= 1 << (var_class_idx & 31); split->subset[var_class_idx >> 5] |= 1 << (var_class_idx & 31);
} }
else else
@ -1320,8 +1320,8 @@ CvDTreeSplit* CvForestERTree::find_split_cat_reg( CvDTreeNode* node, int vi, flo
split->quality = (float)best_val; split->quality = (float)best_val;
cvReleaseMat(&var_class_mask); cvReleaseMat(&var_class_mask);
} }
} }
return split; return split;
} }
@ -1358,7 +1358,7 @@ void CvForestERTree::split_node_data( CvDTreeNode* node )
{ {
int ci = data->get_var_type(vi); int ci = data->get_var_type(vi);
if (ci >= 0) continue; if (ci >= 0) continue;
int n1 = node->get_num_valid(vi), nr1 = 0; int n1 = node->get_num_valid(vi), nr1 = 0;
float* values_buf = (float*)(uchar*)inn_buf; float* values_buf = (float*)(uchar*)inn_buf;
int* missing_buf = (int*)(values_buf + n); int* missing_buf = (int*)(values_buf + n);
@ -1369,7 +1369,7 @@ void CvForestERTree::split_node_data( CvDTreeNode* node )
for( i = 0; i < n; i++ ) for( i = 0; i < n; i++ )
nr1 += ((!missing[i]) & dir[i]); nr1 += ((!missing[i]) & dir[i]);
left->set_num_valid(vi, n1 - nr1); left->set_num_valid(vi, n1 - nr1);
right->set_num_valid(vi, nr1); right->set_num_valid(vi, nr1);
} }
// split categorical vars, responses and cv_labels using new_idx relocation table // split categorical vars, responses and cv_labels using new_idx relocation table
for( vi = 0; vi < data->get_work_var_count() + data->ord_var_count; vi++ ) for( vi = 0; vi < data->get_work_var_count() + data->ord_var_count; vi++ )
@ -1385,11 +1385,11 @@ void CvForestERTree::split_node_data( CvDTreeNode* node )
if (data->is_buf_16u) if (data->is_buf_16u)
{ {
unsigned short *ldst = (unsigned short *)(buf->data.s + left->buf_idx*buf->cols + unsigned short *ldst = (unsigned short *)(buf->data.s + left->buf_idx*buf->cols +
ci*scount + left->offset); ci*scount + left->offset);
unsigned short *rdst = (unsigned short *)(buf->data.s + right->buf_idx*buf->cols + unsigned short *rdst = (unsigned short *)(buf->data.s + right->buf_idx*buf->cols +
ci*scount + right->offset); ci*scount + right->offset);
for( i = 0; i < n; i++ ) for( i = 0; i < n; i++ )
{ {
int d = dir[i]; int d = dir[i];
@ -1415,11 +1415,11 @@ void CvForestERTree::split_node_data( CvDTreeNode* node )
} }
else else
{ {
int *ldst = buf->data.i + left->buf_idx*buf->cols + int *ldst = buf->data.i + left->buf_idx*buf->cols +
ci*scount + left->offset; ci*scount + left->offset;
int *rdst = buf->data.i + right->buf_idx*buf->cols + int *rdst = buf->data.i + right->buf_idx*buf->cols +
ci*scount + right->offset; ci*scount + right->offset;
for( i = 0; i < n; i++ ) for( i = 0; i < n; i++ )
{ {
int d = dir[i]; int d = dir[i];
@ -1435,7 +1435,7 @@ void CvForestERTree::split_node_data( CvDTreeNode* node )
*ldst = idx; *ldst = idx;
ldst++; ldst++;
} }
} }
if( vi < data->var_count ) if( vi < data->var_count )
@ -1443,7 +1443,7 @@ void CvForestERTree::split_node_data( CvDTreeNode* node )
left->set_num_valid(vi, n1 - nr1); left->set_num_valid(vi, n1 - nr1);
right->set_num_valid(vi, nr1); right->set_num_valid(vi, nr1);
} }
} }
} }
// split sample indices // split sample indices
@ -1457,14 +1457,14 @@ void CvForestERTree::split_node_data( CvDTreeNode* node )
temp_buf[i] = sample_idx_src[i]; temp_buf[i] = sample_idx_src[i];
int pos = data->get_work_var_count(); int pos = data->get_work_var_count();
if (data->is_buf_16u) if (data->is_buf_16u)
{ {
unsigned short* ldst = (unsigned short*)(buf->data.s + left->buf_idx*buf->cols + unsigned short* ldst = (unsigned short*)(buf->data.s + left->buf_idx*buf->cols +
pos*scount + left->offset); pos*scount + left->offset);
unsigned short* rdst = (unsigned short*)(buf->data.s + right->buf_idx*buf->cols + unsigned short* rdst = (unsigned short*)(buf->data.s + right->buf_idx*buf->cols +
pos*scount + right->offset); pos*scount + right->offset);
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
int d = dir[i]; int d = dir[i];
@ -1483,9 +1483,9 @@ void CvForestERTree::split_node_data( CvDTreeNode* node )
} }
else else
{ {
int* ldst = buf->data.i + left->buf_idx*buf->cols + int* ldst = buf->data.i + left->buf_idx*buf->cols +
pos*scount + left->offset; pos*scount + left->offset;
int* rdst = buf->data.i + right->buf_idx*buf->cols + int* rdst = buf->data.i + right->buf_idx*buf->cols +
pos*scount + right->offset; pos*scount + right->offset;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
@ -1504,9 +1504,9 @@ void CvForestERTree::split_node_data( CvDTreeNode* node )
} }
} }
} }
// deallocate the parent node data that is not needed anymore // deallocate the parent node data that is not needed anymore
data->free_node_data(node); data->free_node_data(node);
} }
CvERTrees::CvERTrees() CvERTrees::CvERTrees()
@ -1576,10 +1576,10 @@ bool CvERTrees::train( const CvMat* _train_data, int _tflag,
__END__ __END__
return result; return result;
} }
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__;
@ -1609,7 +1609,7 @@ bool CvERTrees::grow_forest( const CvTermCriteria term_crit )
const int dims = data->var_count; const int dims = data->var_count;
float maximal_response = 0; float maximal_response = 0;
CvMat* oob_sample_votes = 0; CvMat* oob_sample_votes = 0;
CvMat* oob_responses = 0; CvMat* oob_responses = 0;
float* oob_samples_perm_ptr= 0; float* oob_samples_perm_ptr= 0;
@ -1625,7 +1625,7 @@ bool CvERTrees::grow_forest( const CvTermCriteria term_crit )
// initialize these variable to avoid warning C4701 // initialize these variable to avoid warning C4701
CvMat oob_predictions_sum = cvMat( 1, 1, CV_32FC1 ); CvMat oob_predictions_sum = cvMat( 1, 1, CV_32FC1 );
CvMat oob_num_of_predictions = cvMat( 1, 1, CV_32FC1 ); CvMat oob_num_of_predictions = cvMat( 1, 1, CV_32FC1 );
nsamples = data->sample_count; nsamples = data->sample_count;
nclasses = data->get_num_classes(); nclasses = data->get_num_classes();
@ -1647,11 +1647,11 @@ bool CvERTrees::grow_forest( const CvTermCriteria term_crit )
cvGetRow( oob_responses, &oob_predictions_sum, 0 ); cvGetRow( oob_responses, &oob_predictions_sum, 0 );
cvGetRow( oob_responses, &oob_num_of_predictions, 1 ); cvGetRow( oob_responses, &oob_num_of_predictions, 1 );
} }
CV_CALL(oob_samples_perm_ptr = (float*)cvAlloc( sizeof(float)*nsamples*dims )); CV_CALL(oob_samples_perm_ptr = (float*)cvAlloc( sizeof(float)*nsamples*dims ));
CV_CALL(samples_ptr = (float*)cvAlloc( sizeof(float)*nsamples*dims )); CV_CALL(samples_ptr = (float*)cvAlloc( sizeof(float)*nsamples*dims ));
CV_CALL(missing_ptr = (uchar*)cvAlloc( sizeof(uchar)*nsamples*dims )); CV_CALL(missing_ptr = (uchar*)cvAlloc( sizeof(uchar)*nsamples*dims ));
CV_CALL(true_resp_ptr = (float*)cvAlloc( sizeof(float)*nsamples )); CV_CALL(true_resp_ptr = (float*)cvAlloc( sizeof(float)*nsamples ));
CV_CALL(data->get_vectors( 0, samples_ptr, missing_ptr, true_resp_ptr )); CV_CALL(data->get_vectors( 0, samples_ptr, missing_ptr, true_resp_ptr ));
{ {
@ -1661,7 +1661,7 @@ bool CvERTrees::grow_forest( const CvTermCriteria term_crit )
maximal_response = (float)MAX( MAX( fabs(minval), fabs(maxval) ), 0 ); maximal_response = (float)MAX( MAX( fabs(minval), fabs(maxval) ), 0 );
} }
} }
trees = (CvForestTree**)cvAlloc( sizeof(trees[0])*max_ntrees ); trees = (CvForestTree**)cvAlloc( sizeof(trees[0])*max_ntrees );
memset( trees, 0, sizeof(trees[0])*max_ntrees ); memset( trees, 0, sizeof(trees[0])*max_ntrees );
@ -1692,7 +1692,7 @@ bool CvERTrees::grow_forest( const CvTermCriteria term_crit )
sample.data.fl += dims, missing.data.ptr += dims ) sample.data.fl += dims, missing.data.ptr += dims )
{ {
CvDTreeNode* predicted_node = 0; CvDTreeNode* predicted_node = 0;
// predict oob samples // predict oob samples
if( !predicted_node ) if( !predicted_node )
CV_CALL(predicted_node = tree->predict(&sample, &missing, true)); CV_CALL(predicted_node = tree->predict(&sample, &missing, true));
@ -1796,12 +1796,12 @@ bool CvERTrees::grow_forest( const CvTermCriteria term_crit )
} }
result = true; result = true;
cvFree( &oob_samples_perm_ptr ); cvFree( &oob_samples_perm_ptr );
cvFree( &samples_ptr ); cvFree( &samples_ptr );
cvFree( &missing_ptr ); cvFree( &missing_ptr );
cvFree( &true_resp_ptr ); cvFree( &true_resp_ptr );
cvReleaseMat( &sample_idx_for_tree ); cvReleaseMat( &sample_idx_for_tree );
cvReleaseMat( &oob_sample_votes ); cvReleaseMat( &oob_sample_votes );

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);
} }

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

@ -141,7 +141,7 @@ bool CvKNearest::train( const CvMat* _train_data, const CvMat* _responses,
ok = true; ok = true;
__END__; __END__;
if( responses && responses->data.ptr != _responses->data.ptr ) if( responses && responses->data.ptr != _responses->data.ptr )
cvReleaseMat(&responses); cvReleaseMat(&responses);
@ -318,7 +318,7 @@ struct P1 {
result = _result; result = _result;
buf_sz = _buf_sz; buf_sz = _buf_sz;
} }
const CvKNearest* pointer; const CvKNearest* pointer;
int k; int k;
const CvMat* _samples; const CvMat* _samples;
@ -329,7 +329,7 @@ struct P1 {
CvMat* _dist; CvMat* _dist;
float* result; float* result;
int buf_sz; int buf_sz;
void operator()( const cv::BlockedRange& range ) const void operator()( const cv::BlockedRange& range ) const
{ {
cv::AutoBuffer<float> buf(buf_sz); cv::AutoBuffer<float> buf(buf_sz);
@ -429,7 +429,7 @@ bool CvKNearest::train( const Mat& _train_data, const Mat& _responses,
int _max_k, bool _update_base ) int _max_k, bool _update_base )
{ {
CvMat tdata = _train_data, responses = _responses, sidx = _sample_idx; CvMat tdata = _train_data, responses = _responses, sidx = _sample_idx;
return train(&tdata, &responses, sidx.data.ptr ? &sidx : 0, _is_regression, _max_k, _update_base ); return train(&tdata, &responses, sidx.data.ptr ? &sidx : 0, _is_regression, _max_k, _update_base );
} }
@ -439,7 +439,7 @@ float CvKNearest::find_nearest( const Mat& _samples, int k, Mat* _results,
Mat* _dist ) const Mat* _dist ) const
{ {
CvMat s = _samples, results, *presults = 0, nresponses, *pnresponses = 0, dist, *pdist = 0; CvMat s = _samples, results, *presults = 0, nresponses, *pnresponses = 0, dist, *pdist = 0;
if( _results ) if( _results )
{ {
if(!(_results->data && (_results->type() == CV_32F || if(!(_results->data && (_results->type() == CV_32F ||
@ -449,7 +449,7 @@ float CvKNearest::find_nearest( const Mat& _samples, int k, Mat* _results,
_results->create(_samples.rows, 1, CV_32F); _results->create(_samples.rows, 1, CV_32F);
presults = &(results = *_results); presults = &(results = *_results);
} }
if( _neighbor_responses ) if( _neighbor_responses )
{ {
if(!(_neighbor_responses->data && _neighbor_responses->type() == CV_32F && if(!(_neighbor_responses->data && _neighbor_responses->type() == CV_32F &&
@ -457,7 +457,7 @@ float CvKNearest::find_nearest( const Mat& _samples, int k, Mat* _results,
_neighbor_responses->create(_samples.rows, k, CV_32F); _neighbor_responses->create(_samples.rows, k, CV_32F);
pnresponses = &(nresponses = *_neighbor_responses); pnresponses = &(nresponses = *_neighbor_responses);
} }
if( _dist ) if( _dist )
{ {
if(!(_dist->data && _dist->type() == CV_32F && if(!(_dist->data && _dist->type() == CV_32F &&
@ -465,15 +465,15 @@ float CvKNearest::find_nearest( const Mat& _samples, int k, Mat* _results,
_dist->create(_samples.rows, k, CV_32F); _dist->create(_samples.rows, k, CV_32F);
pdist = &(dist = *_dist); pdist = &(dist = *_dist);
} }
return find_nearest(&s, k, presults, _neighbors, pnresponses, pdist ); return find_nearest(&s, k, presults, _neighbors, pnresponses, pdist );
} }
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 */

22
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;
} }
} }
@ -294,7 +294,7 @@ struct predict_body {
value = _value; value = _value;
var_count1 = _var_count1; var_count1 = _var_count1;
} }
CvMat* c; CvMat* c;
CvMat** cov_rotate_mats; CvMat** cov_rotate_mats;
CvMat** inv_eigen_values; CvMat** inv_eigen_values;
@ -306,15 +306,15 @@ struct predict_body {
CvMat* results; CvMat* results;
float* value; float* value;
int var_count1; int var_count1;
void operator()( const cv::BlockedRange& range ) const void operator()( const cv::BlockedRange& range ) const
{ {
int cls = -1; int cls = -1;
int rtype = 0, rstep = 0; int rtype = 0, rstep = 0;
int nclasses = cls_labels->cols; int nclasses = cls_labels->cols;
int _var_count = avg[0]->cols; int _var_count = avg[0]->cols;
if (results) if (results)
{ {
rtype = CV_MAT_TYPE(results->type); rtype = CV_MAT_TYPE(results->type);
@ -323,7 +323,7 @@ struct predict_body {
// allocate memory and initializing headers for calculating // allocate memory and initializing headers for calculating
cv::AutoBuffer<double> buffer(nclasses + var_count1); cv::AutoBuffer<double> buffer(nclasses + var_count1);
CvMat diff = cvMat( 1, var_count1, CV_64FC1, &buffer[0] ); CvMat diff = cvMat( 1, var_count1, CV_64FC1, &buffer[0] );
for(int k = range.begin(); k < range.end(); k += 1 ) for(int k = range.begin(); k < range.end(); k += 1 )
{ {
int ival; int ival;
@ -592,7 +592,7 @@ CvNormalBayesClassifier::CvNormalBayesClassifier( const Mat& _train_data, const
cov_rotate_mats = 0; cov_rotate_mats = 0;
c = 0; c = 0;
default_model_name = "my_nb"; default_model_name = "my_nb";
CvMat tdata = _train_data, responses = _responses, vidx = _var_idx, sidx = _sample_idx; CvMat tdata = _train_data, responses = _responses, vidx = _var_idx, sidx = _sample_idx;
train(&tdata, &responses, vidx.data.ptr ? &vidx : 0, train(&tdata, &responses, vidx.data.ptr ? &vidx : 0,
sidx.data.ptr ? &sidx : 0); sidx.data.ptr ? &sidx : 0);
@ -609,7 +609,7 @@ bool CvNormalBayesClassifier::train( const Mat& _train_data, const Mat& _respons
float CvNormalBayesClassifier::predict( const Mat& _samples, Mat* _results ) const float CvNormalBayesClassifier::predict( const Mat& _samples, Mat* _results ) const
{ {
CvMat samples = _samples, results, *presults = 0; CvMat samples = _samples, results, *presults = 0;
if( _results ) if( _results )
{ {
if( !(_results->data && _results->type() == CV_32F && if( !(_results->data && _results->type() == CV_32F &&
@ -618,7 +618,7 @@ float CvNormalBayesClassifier::predict( const Mat& _samples, Mat* _results ) con
_results->create(_samples.rows, 1, CV_32F); _results->create(_samples.rows, 1, CV_32F);
presults = &(results = *_results); presults = &(results = *_results);
} }
return predict(&samples, presults); return predict(&samples, presults);
} }

72
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 );
@ -331,7 +331,7 @@ bool CvRTrees::grow_forest( const CvTermCriteria term_crit )
const int dims = data->var_count; const int dims = data->var_count;
float maximal_response = 0; float maximal_response = 0;
CvMat* oob_sample_votes = 0; CvMat* oob_sample_votes = 0;
CvMat* oob_responses = 0; CvMat* oob_responses = 0;
float* oob_samples_perm_ptr= 0; float* oob_samples_perm_ptr= 0;
@ -347,7 +347,7 @@ bool CvRTrees::grow_forest( const CvTermCriteria term_crit )
// initialize these variable to avoid warning C4701 // initialize these variable to avoid warning C4701
CvMat oob_predictions_sum = cvMat( 1, 1, CV_32FC1 ); CvMat oob_predictions_sum = cvMat( 1, 1, CV_32FC1 );
CvMat oob_num_of_predictions = cvMat( 1, 1, CV_32FC1 ); CvMat oob_num_of_predictions = cvMat( 1, 1, CV_32FC1 );
nsamples = data->sample_count; nsamples = data->sample_count;
nclasses = data->get_num_classes(); nclasses = data->get_num_classes();
@ -369,14 +369,14 @@ bool CvRTrees::grow_forest( const CvTermCriteria term_crit )
cvGetRow( oob_responses, &oob_predictions_sum, 0 ); cvGetRow( oob_responses, &oob_predictions_sum, 0 );
cvGetRow( oob_responses, &oob_num_of_predictions, 1 ); cvGetRow( oob_responses, &oob_num_of_predictions, 1 );
} }
oob_samples_perm_ptr = (float*)cvAlloc( sizeof(float)*nsamples*dims ); oob_samples_perm_ptr = (float*)cvAlloc( sizeof(float)*nsamples*dims );
samples_ptr = (float*)cvAlloc( sizeof(float)*nsamples*dims ); samples_ptr = (float*)cvAlloc( sizeof(float)*nsamples*dims );
missing_ptr = (uchar*)cvAlloc( sizeof(uchar)*nsamples*dims ); missing_ptr = (uchar*)cvAlloc( sizeof(uchar)*nsamples*dims );
true_resp_ptr = (float*)cvAlloc( sizeof(float)*nsamples ); true_resp_ptr = (float*)cvAlloc( sizeof(float)*nsamples );
data->get_vectors( 0, samples_ptr, missing_ptr, true_resp_ptr ); data->get_vectors( 0, samples_ptr, missing_ptr, true_resp_ptr );
double minval, maxval; double minval, maxval;
CvMat responses = cvMat(1, nsamples, CV_32FC1, true_resp_ptr); CvMat responses = cvMat(1, nsamples, CV_32FC1, true_resp_ptr);
cvMinMaxLoc( &responses, &minval, &maxval ); cvMinMaxLoc( &responses, &minval, &maxval );
@ -536,7 +536,7 @@ bool CvRTrees::grow_forest( const CvTermCriteria term_crit )
cvFree( &samples_ptr ); cvFree( &samples_ptr );
cvFree( &missing_ptr ); cvFree( &missing_ptr );
cvFree( &true_resp_ptr ); cvFree( &true_resp_ptr );
cvReleaseMat( &sample_idx_mask_for_tree ); cvReleaseMat( &sample_idx_mask_for_tree );
cvReleaseMat( &sample_idx_for_tree ); cvReleaseMat( &sample_idx_for_tree );
@ -592,9 +592,9 @@ float CvRTrees::calc_error( CvMLData* _data, int type , std::vector<float> *resp
{ {
CvMat sample, miss; CvMat sample, miss;
int si = sidx ? sidx[i] : i; int si = sidx ? sidx[i] : i;
cvGetRow( values, &sample, si ); cvGetRow( values, &sample, si );
if( missing ) if( missing )
cvGetRow( missing, &miss, si ); cvGetRow( missing, &miss, si );
float r = (float)predict( &sample, missing ? &miss : 0 ); float r = (float)predict( &sample, missing ? &miss : 0 );
if( pred_resp ) if( pred_resp )
pred_resp[i] = r; pred_resp[i] = r;
@ -610,15 +610,15 @@ float CvRTrees::calc_error( CvMLData* _data, int type , std::vector<float> *resp
CvMat sample, miss; CvMat sample, miss;
int si = sidx ? sidx[i] : i; int si = sidx ? sidx[i] : i;
cvGetRow( values, &sample, si ); cvGetRow( values, &sample, si );
if( missing ) if( missing )
cvGetRow( missing, &miss, si ); cvGetRow( missing, &miss, si );
float r = (float)predict( &sample, missing ? &miss : 0 ); float r = (float)predict( &sample, missing ? &miss : 0 );
if( pred_resp ) if( pred_resp )
pred_resp[i] = r; pred_resp[i] = r;
float d = r - response->data.fl[si*r_step]; float d = r - response->data.fl[si*r_step];
err += d*d; err += d*d;
} }
err = sample_count ? err / (float)sample_count : -FLT_MAX; err = sample_count ? err / (float)sample_count : -FLT_MAX;
} }
return err; return err;
} }
@ -635,12 +635,12 @@ float CvRTrees::get_train_error()
float *responses_ptr = (float*)cvAlloc( sizeof(float)*sample_count ); float *responses_ptr = (float*)cvAlloc( sizeof(float)*sample_count );
data->get_vectors( 0, values_ptr, missing_ptr, responses_ptr); data->get_vectors( 0, values_ptr, missing_ptr, responses_ptr);
if (data->is_classifier) if (data->is_classifier)
{ {
int err_count = 0; int err_count = 0;
float *vp = values_ptr; float *vp = values_ptr;
uchar *mp = missing_ptr; uchar *mp = missing_ptr;
for (int si = 0; si < sample_count; si++, vp += var_count, mp += var_count) for (int si = 0; si < sample_count; si++, vp += var_count, mp += var_count)
{ {
CvMat sample = cvMat( 1, var_count, CV_32FC1, vp ); CvMat sample = cvMat( 1, var_count, CV_32FC1, vp );
@ -653,10 +653,10 @@ float CvRTrees::get_train_error()
} }
else else
CV_Error( CV_StsBadArg, "This method is not supported for regression problems" ); CV_Error( CV_StsBadArg, "This method is not supported for regression problems" );
cvFree( &values_ptr ); cvFree( &values_ptr );
cvFree( &missing_ptr ); cvFree( &missing_ptr );
cvFree( &responses_ptr ); cvFree( &responses_ptr );
return err; return err;
} }
@ -701,7 +701,7 @@ float CvRTrees::predict( const CvMat* sample, const CvMat* missing ) const
float CvRTrees::predict_prob( const CvMat* sample, const CvMat* missing) const float CvRTrees::predict_prob( const CvMat* sample, const CvMat* missing) const
{ {
if( nclasses == 2 ) //classification if( nclasses == 2 ) //classification
{ {
cv::AutoBuffer<int> _votes(nclasses); cv::AutoBuffer<int> _votes(nclasses);
int* votes = _votes; int* votes = _votes;
@ -711,15 +711,15 @@ float CvRTrees::predict_prob( const CvMat* sample, const CvMat* missing) const
CvDTreeNode* predicted_node = trees[k]->predict( sample, missing ); CvDTreeNode* predicted_node = trees[k]->predict( sample, missing );
int class_idx = predicted_node->class_idx; int class_idx = predicted_node->class_idx;
CV_Assert( 0 <= class_idx && class_idx < nclasses ); CV_Assert( 0 <= class_idx && class_idx < nclasses );
++votes[class_idx]; ++votes[class_idx];
} }
return float(votes[1])/ntrees; return float(votes[1])/ntrees;
} }
else // regression else // regression
CV_Error(CV_StsBadArg, "This function works for binary classification problems only..."); CV_Error(CV_StsBadArg, "This function works for binary classification problems only...");
return -1; return -1;
} }
@ -809,15 +809,15 @@ void CvRTrees::read( CvFileStorage* fs, CvFileNode* fnode )
{ {
// initialize active variables mask // initialize active variables mask
CvMat submask1; CvMat submask1;
cvGetCols( active_var_mask, &submask1, 0, nactive_vars ); cvGetCols( active_var_mask, &submask1, 0, nactive_vars );
cvSet( &submask1, cvScalar(1) ); cvSet( &submask1, cvScalar(1) );
if( nactive_vars < var_count ) if( nactive_vars < var_count )
{ {
CvMat submask2; CvMat submask2;
cvGetCols( active_var_mask, &submask2, nactive_vars, var_count ); cvGetCols( active_var_mask, &submask2, nactive_vars, var_count );
cvZero( &submask2 ); cvZero( &submask2 );
} }
} }
} }

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;

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

@ -156,7 +156,7 @@ void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
int vi, i, size; int vi, i, size;
char err[100]; char err[100];
const int *sidx = 0, *vidx = 0; const int *sidx = 0, *vidx = 0;
if( _update_data && data_root ) if( _update_data && data_root )
{ {
data = new CvDTreeTrainData( _train_data, _tflag, _responses, _var_idx, data = new CvDTreeTrainData( _train_data, _tflag, _responses, _var_idx,
@ -224,7 +224,7 @@ void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
sample_count = sample_all; sample_count = sample_all;
var_count = var_all; var_count = var_all;
if( _sample_idx ) if( _sample_idx )
{ {
CV_CALL( sample_indices = cvPreprocessIndexArray( _sample_idx, sample_all )); CV_CALL( sample_indices = cvPreprocessIndexArray( _sample_idx, sample_all ));
@ -239,10 +239,10 @@ void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
var_count = var_idx->rows + var_idx->cols - 1; var_count = var_idx->rows + var_idx->cols - 1;
} }
is_buf_16u = false; is_buf_16u = false;
if ( sample_count < 65536 ) if ( sample_count < 65536 )
is_buf_16u = true; is_buf_16u = true;
if( !CV_IS_MAT(_responses) || if( !CV_IS_MAT(_responses) ||
(CV_MAT_TYPE(_responses->type) != CV_32SC1 && (CV_MAT_TYPE(_responses->type) != CV_32SC1 &&
CV_MAT_TYPE(_responses->type) != CV_32FC1) || CV_MAT_TYPE(_responses->type) != CV_32FC1) ||
@ -251,13 +251,13 @@ void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
CV_ERROR( CV_StsBadArg, "The array of _responses must be an integer or " CV_ERROR( CV_StsBadArg, "The array of _responses must be an integer or "
"floating-point vector containing as many elements as " "floating-point vector containing as many elements as "
"the total number of samples in the training data matrix" ); "the total number of samples in the training data matrix" );
r_type = CV_VAR_CATEGORICAL; r_type = CV_VAR_CATEGORICAL;
if( _var_type ) if( _var_type )
CV_CALL( var_type0 = cvPreprocessVarType( _var_type, var_idx, var_count, &r_type )); CV_CALL( var_type0 = cvPreprocessVarType( _var_type, var_idx, var_count, &r_type ));
CV_CALL( var_type = cvCreateMat( 1, var_count+2, CV_32SC1 )); CV_CALL( var_type = cvCreateMat( 1, var_count+2, CV_32SC1 ));
cat_var_count = 0; cat_var_count = 0;
ord_var_count = -1; ord_var_count = -1;
@ -284,11 +284,11 @@ void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
work_var_count = var_count + (is_classifier ? 1 : 0) // for responses class_labels work_var_count = var_count + (is_classifier ? 1 : 0) // for responses class_labels
+ (have_labels ? 1 : 0); // for cv_labels + (have_labels ? 1 : 0); // for cv_labels
buf_size = (work_var_count + 1 /*for sample_indices*/) * sample_count; buf_size = (work_var_count + 1 /*for sample_indices*/) * sample_count;
shared = _shared; shared = _shared;
buf_count = shared ? 2 : 1; buf_count = shared ? 2 : 1;
if ( is_buf_16u ) if ( is_buf_16u )
{ {
CV_CALL( buf = cvCreateMat( buf_count, buf_size, CV_16UC1 )); CV_CALL( buf = cvCreateMat( buf_count, buf_size, CV_16UC1 ));
@ -298,13 +298,13 @@ void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
{ {
CV_CALL( buf = cvCreateMat( buf_count, buf_size, CV_32SC1 )); CV_CALL( buf = cvCreateMat( buf_count, buf_size, CV_32SC1 ));
CV_CALL( int_ptr = (int**)cvAlloc( sample_count*sizeof(int_ptr[0]) )); CV_CALL( int_ptr = (int**)cvAlloc( sample_count*sizeof(int_ptr[0]) ));
} }
size = is_classifier ? (cat_var_count+1) : cat_var_count; size = is_classifier ? (cat_var_count+1) : cat_var_count;
size = !size ? 1 : size; size = !size ? 1 : size;
CV_CALL( cat_count = cvCreateMat( 1, size, CV_32SC1 )); CV_CALL( cat_count = cvCreateMat( 1, size, CV_32SC1 ));
CV_CALL( cat_ofs = cvCreateMat( 1, size, CV_32SC1 )); CV_CALL( cat_ofs = cvCreateMat( 1, size, CV_32SC1 ));
size = is_classifier ? (cat_var_count + 1)*params.max_categories : cat_var_count*params.max_categories; size = is_classifier ? (cat_var_count + 1)*params.max_categories : cat_var_count*params.max_categories;
size = !size ? 1 : size; size = !size ? 1 : size;
CV_CALL( cat_map = cvCreateMat( 1, size, CV_32SC1 )); CV_CALL( cat_map = cvCreateMat( 1, size, CV_32SC1 ));
@ -389,12 +389,12 @@ void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
{ {
int c_count, prev_label; int c_count, prev_label;
int* c_map; int* c_map;
if (is_buf_16u) if (is_buf_16u)
udst = (unsigned short*)(buf->data.s + vi*sample_count); udst = (unsigned short*)(buf->data.s + vi*sample_count);
else else
idst = buf->data.i + vi*sample_count; idst = buf->data.i + vi*sample_count;
// copy data // copy data
for( i = 0; i < sample_count; i++ ) for( i = 0; i < sample_count; i++ )
{ {
@ -428,7 +428,7 @@ void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
_idst[i] = val; _idst[i] = val;
pair16u32s_ptr[i].u = udst + i; pair16u32s_ptr[i].u = udst + i;
pair16u32s_ptr[i].i = _idst + i; pair16u32s_ptr[i].i = _idst + i;
} }
else else
{ {
idst[i] = val; idst[i] = val;
@ -502,7 +502,7 @@ void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
// replace labels for missing values with -1 // replace labels for missing values with -1
for( ; i < sample_count; i++ ) for( ; i < sample_count; i++ )
*int_ptr[i] = -1; *int_ptr[i] = -1;
} }
} }
else if( ci < 0 ) // process ordered variable else if( ci < 0 ) // process ordered variable
{ {
@ -536,14 +536,14 @@ void CvDTreeTrainData::set_data( const CvMat* _train_data, int _tflag,
else else
idst[i] = i; idst[i] = i;
_fdst[i] = val; _fdst[i] = val;
} }
if (is_buf_16u) if (is_buf_16u)
icvSortUShAux( udst, sample_count, _fdst); icvSortUShAux( udst, sample_count, _fdst);
else else
icvSortIntAux( idst, sample_count, _fdst ); icvSortIntAux( idst, sample_count, _fdst );
} }
if( vi < var_count ) if( vi < var_count )
data_root->set_num_valid(vi, num_valid); data_root->set_num_valid(vi, num_valid);
} }
@ -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,12 +597,12 @@ 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 );
} }
} }
} }
if ( cat_map ) if ( cat_map )
cat_map->cols = MAX( total_c_count, 1 ); cat_map->cols = MAX( total_c_count, 1 );
max_split_size = cvAlign(sizeof(CvDTreeSplit) + max_split_size = cvAlign(sizeof(CvDTreeSplit) +
@ -751,7 +751,7 @@ CvDTreeNode* CvDTreeTrainData::subsample_data( const CvMat* _subsample_idx )
if (is_buf_16u) if (is_buf_16u)
{ {
unsigned short* udst = (unsigned short*)(buf->data.s + root->buf_idx*buf->cols + unsigned short* udst = (unsigned short*)(buf->data.s + root->buf_idx*buf->cols +
vi*sample_count + root->offset); vi*sample_count + root->offset);
for( i = 0; i < count; i++ ) for( i = 0; i < count; i++ )
{ {
@ -762,7 +762,7 @@ CvDTreeNode* CvDTreeTrainData::subsample_data( const CvMat* _subsample_idx )
} }
else else
{ {
int* idst = buf->data.i + root->buf_idx*buf->cols + int* idst = buf->data.i + root->buf_idx*buf->cols +
vi*sample_count + root->offset; vi*sample_count + root->offset;
for( i = 0; i < count; i++ ) for( i = 0; i < count; i++ )
{ {
@ -788,7 +788,7 @@ CvDTreeNode* CvDTreeTrainData::subsample_data( const CvMat* _subsample_idx )
if (is_buf_16u) if (is_buf_16u)
{ {
unsigned short* udst_idx = (unsigned short*)(buf->data.s + root->buf_idx*buf->cols + unsigned short* udst_idx = (unsigned short*)(buf->data.s + root->buf_idx*buf->cols +
vi*sample_count + data_root->offset); vi*sample_count + data_root->offset);
for( i = 0; i < num_valid; i++ ) for( i = 0; i < num_valid; i++ )
{ {
@ -812,7 +812,7 @@ CvDTreeNode* CvDTreeTrainData::subsample_data( const CvMat* _subsample_idx )
} }
else else
{ {
int* idst_idx = buf->data.i + root->buf_idx*buf->cols + int* idst_idx = buf->data.i + root->buf_idx*buf->cols +
vi*sample_count + root->offset; vi*sample_count + root->offset;
for( i = 0; i < num_valid; i++ ) for( i = 0; i < num_valid; i++ )
{ {
@ -840,14 +840,14 @@ CvDTreeNode* CvDTreeTrainData::subsample_data( const CvMat* _subsample_idx )
const int* sample_idx_src = get_sample_indices(data_root, (int*)(uchar*)inn_buf); const int* sample_idx_src = get_sample_indices(data_root, (int*)(uchar*)inn_buf);
if (is_buf_16u) if (is_buf_16u)
{ {
unsigned short* sample_idx_dst = (unsigned short*)(buf->data.s + root->buf_idx*buf->cols + unsigned short* sample_idx_dst = (unsigned short*)(buf->data.s + root->buf_idx*buf->cols +
workVarCount*sample_count + root->offset); workVarCount*sample_count + root->offset);
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
sample_idx_dst[i] = (unsigned short)sample_idx_src[sidx[i]]; sample_idx_dst[i] = (unsigned short)sample_idx_src[sidx[i]];
} }
else else
{ {
int* sample_idx_dst = buf->data.i + root->buf_idx*buf->cols + int* sample_idx_dst = buf->data.i + root->buf_idx*buf->cols +
workVarCount*sample_count + root->offset; workVarCount*sample_count + root->offset;
for (i = 0; i < count; i++) for (i = 0; i < count; i++)
sample_idx_dst[i] = sample_idx_src[sidx[i]]; sample_idx_dst[i] = sample_idx_src[sidx[i]];
@ -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];
} }
} }
} }
@ -1122,7 +1122,7 @@ void CvDTreeTrainData::clear()
cvReleaseMat( &cat_map ); cvReleaseMat( &cat_map );
cvReleaseMat( &priors ); cvReleaseMat( &priors );
cvReleaseMat( &priors_mult ); cvReleaseMat( &priors_mult );
node_heap = split_heap = 0; node_heap = split_heap = 0;
sample_count = var_all = var_count = max_c_count = ord_var_count = cat_var_count = 0; sample_count = var_all = var_count = max_c_count = ord_var_count = cat_var_count = 0;
@ -1130,7 +1130,7 @@ void CvDTreeTrainData::clear()
buf_count = buf_size = 0; buf_count = buf_size = 0;
shared = false; shared = false;
data_root = 0; data_root = 0;
rng = &cv::theRNG(); rng = &cv::theRNG();
@ -1152,7 +1152,7 @@ void CvDTreeTrainData::get_ord_var_data( CvDTreeNode* n, int vi, float* ord_valu
const float** ord_values, const int** sorted_indices, int* sample_indices_buf ) const float** ord_values, const int** sorted_indices, int* sample_indices_buf )
{ {
int vidx = var_idx ? var_idx->data.i[vi] : vi; int vidx = var_idx ? var_idx->data.i[vi] : vi;
int node_sample_count = n->sample_count; int node_sample_count = n->sample_count;
int td_step = train_data->step/CV_ELEM_SIZE(train_data->type); int td_step = train_data->step/CV_ELEM_SIZE(train_data->type);
const int* sample_indices = get_sample_indices(n, sample_indices_buf); const int* sample_indices = get_sample_indices(n, sample_indices_buf);
@ -1161,16 +1161,16 @@ void CvDTreeTrainData::get_ord_var_data( CvDTreeNode* n, int vi, float* ord_valu
*sorted_indices = buf->data.i + n->buf_idx*buf->cols + *sorted_indices = buf->data.i + n->buf_idx*buf->cols +
vi*sample_count + n->offset; vi*sample_count + n->offset;
else { else {
const unsigned short* short_indices = (const unsigned short*)(buf->data.s + n->buf_idx*buf->cols + const unsigned short* short_indices = (const unsigned short*)(buf->data.s + n->buf_idx*buf->cols +
vi*sample_count + n->offset ); vi*sample_count + n->offset );
for( int i = 0; i < node_sample_count; i++ ) for( int i = 0; i < node_sample_count; i++ )
sorted_indices_buf[i] = short_indices[i]; sorted_indices_buf[i] = short_indices[i];
*sorted_indices = sorted_indices_buf; *sorted_indices = sorted_indices_buf;
} }
if( tflag == CV_ROW_SAMPLE ) if( tflag == CV_ROW_SAMPLE )
{ {
for( int i = 0; i < node_sample_count && for( int i = 0; i < node_sample_count &&
((((*sorted_indices)[i] >= 0) && !is_buf_16u) || (((*sorted_indices)[i] != 65535) && is_buf_16u)); i++ ) ((((*sorted_indices)[i] >= 0) && !is_buf_16u) || (((*sorted_indices)[i] != 65535) && is_buf_16u)); i++ )
{ {
int idx = (*sorted_indices)[i]; int idx = (*sorted_indices)[i];
@ -1179,14 +1179,14 @@ void CvDTreeTrainData::get_ord_var_data( CvDTreeNode* n, int vi, float* ord_valu
} }
} }
else else
for( int i = 0; i < node_sample_count && for( int i = 0; i < node_sample_count &&
((((*sorted_indices)[i] >= 0) && !is_buf_16u) || (((*sorted_indices)[i] != 65535) && is_buf_16u)); i++ ) ((((*sorted_indices)[i] >= 0) && !is_buf_16u) || (((*sorted_indices)[i] != 65535) && is_buf_16u)); i++ )
{ {
int idx = (*sorted_indices)[i]; int idx = (*sorted_indices)[i];
idx = sample_indices[idx]; idx = sample_indices[idx];
ord_values_buf[i] = *(train_data->data.fl + vidx* td_step + idx); ord_values_buf[i] = *(train_data->data.fl + vidx* td_step + idx);
} }
*ord_values = ord_values_buf; *ord_values = ord_values_buf;
} }
@ -1205,17 +1205,17 @@ 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];
values_buf[i] = *(responses->data.fl + idx * r_step); values_buf[i] = *(responses->data.fl + idx * r_step);
} }
return values_buf; return values_buf;
} }
@ -1235,7 +1235,7 @@ const int* CvDTreeTrainData::get_cat_var_data( CvDTreeNode* n, int vi, int* cat_
cat_values = buf->data.i + n->buf_idx*buf->cols + cat_values = buf->data.i + n->buf_idx*buf->cols +
vi*sample_count + n->offset; vi*sample_count + n->offset;
else { else {
const unsigned short* short_values = (const unsigned short*)(buf->data.s + n->buf_idx*buf->cols + const unsigned short* short_values = (const unsigned short*)(buf->data.s + n->buf_idx*buf->cols +
vi*sample_count + n->offset); vi*sample_count + n->offset);
for( int i = 0; i < n->sample_count; i++ ) for( int i = 0; i < n->sample_count; i++ )
cat_values_buf[i] = short_values[i]; cat_values_buf[i] = short_values[i];
@ -1562,7 +1562,7 @@ bool CvDTree::train( const Mat& _train_data, int _tflag,
const Mat& _missing_mask, CvDTreeParams _params ) const Mat& _missing_mask, CvDTreeParams _params )
{ {
CvMat tdata = _train_data, responses = _responses, vidx=_var_idx, CvMat tdata = _train_data, responses = _responses, vidx=_var_idx,
sidx=_sample_idx, vtype=_var_type, mmask=_missing_mask; sidx=_sample_idx, vtype=_var_type, mmask=_missing_mask;
return train(&tdata, _tflag, &responses, vidx.data.ptr ? &vidx : 0, sidx.data.ptr ? &sidx : 0, return train(&tdata, _tflag, &responses, vidx.data.ptr ? &vidx : 0, sidx.data.ptr ? &sidx : 0,
vtype.data.ptr ? &vtype : 0, mmask.data.ptr ? &mmask : 0, _params); vtype.data.ptr ? &vtype : 0, mmask.data.ptr ? &mmask : 0, _params);
} }
@ -1794,7 +1794,7 @@ double CvDTree::calc_node_dir( CvDTreeNode* node )
const float* val = 0; const float* val = 0;
const int* sorted = 0; const int* sorted = 0;
data->get_ord_var_data( node, vi, val_buf, sorted_buf, &val, &sorted, sample_idx_buf); data->get_ord_var_data( node, vi, val_buf, sorted_buf, &val, &sorted, sample_idx_buf);
assert( 0 <= split_point && split_point < n1-1 ); assert( 0 <= split_point && split_point < n1-1 );
if( !data->have_priors ) if( !data->have_priors )
@ -1848,7 +1848,7 @@ template<> CV_EXPORTS void Ptr<CvDTreeSplit>::delete_obj()
{ {
fastFree(obj); fastFree(obj);
} }
DTreeBestSplitFinder::DTreeBestSplitFinder( CvDTree* _tree, CvDTreeNode* _node) DTreeBestSplitFinder::DTreeBestSplitFinder( CvDTree* _tree, CvDTreeNode* _node)
{ {
tree = _tree; tree = _tree;
@ -2310,7 +2310,7 @@ CvDTreeSplit* CvDTree::find_split_cat_class( CvDTreeNode* node, int vi, float in
} }
CvDTreeSplit* split = 0; CvDTreeSplit* split = 0;
if( best_subset >= 0 ) if( best_subset >= 0 )
{ {
split = _split ? _split : data->new_split_cat( 0, -1.0f ); split = _split ? _split : data->new_split_cat( 0, -1.0f );
split->var_idx = vi; split->var_idx = vi;
@ -2933,7 +2933,7 @@ void CvDTree::complete_node_dir( CvDTreeNode* node )
{ {
int idx = labels[i]; int idx = labels[i];
if( !dir[i] && ( ((idx >= 0)&&(!data->is_buf_16u)) || ((idx != 65535)&&(data->is_buf_16u)) )) if( !dir[i] && ( ((idx >= 0)&&(!data->is_buf_16u)) || ((idx != 65535)&&(data->is_buf_16u)) ))
{ {
int d = CV_DTREE_CAT_DIR(idx,subset); int d = CV_DTREE_CAT_DIR(idx,subset);
dir[i] = (char)((d ^ inversed_mask) - inversed_mask); dir[i] = (char)((d ^ inversed_mask) - inversed_mask);
@ -3049,7 +3049,7 @@ void CvDTree::split_node_data( CvDTreeNode* node )
{ {
unsigned short *ldst, *rdst, *ldst0, *rdst0; unsigned short *ldst, *rdst, *ldst0, *rdst0;
//unsigned short tl, tr; //unsigned short tl, tr;
ldst0 = ldst = (unsigned short*)(buf->data.s + left->buf_idx*buf->cols + ldst0 = ldst = (unsigned short*)(buf->data.s + left->buf_idx*buf->cols +
vi*scount + left->offset); vi*scount + left->offset);
rdst0 = rdst = (unsigned short*)(ldst + nl); rdst0 = rdst = (unsigned short*)(ldst + nl);
@ -3095,9 +3095,9 @@ void CvDTree::split_node_data( CvDTreeNode* node )
else else
{ {
int *ldst0, *ldst, *rdst0, *rdst; int *ldst0, *ldst, *rdst0, *rdst;
ldst0 = ldst = buf->data.i + left->buf_idx*buf->cols + ldst0 = ldst = buf->data.i + left->buf_idx*buf->cols +
vi*scount + left->offset; vi*scount + left->offset;
rdst0 = rdst = buf->data.i + right->buf_idx*buf->cols + rdst0 = rdst = buf->data.i + right->buf_idx*buf->cols +
vi*scount + right->offset; vi*scount + right->offset;
// split sorted // split sorted
@ -3146,7 +3146,7 @@ void CvDTree::split_node_data( CvDTreeNode* node )
{ {
int ci = data->get_var_type(vi); int ci = data->get_var_type(vi);
int n1 = node->get_num_valid(vi), nr1 = 0; int n1 = node->get_num_valid(vi), nr1 = 0;
if( ci < 0 || (vi < data->var_count && !split_input_data) ) if( ci < 0 || (vi < data->var_count && !split_input_data) )
continue; continue;
@ -3158,11 +3158,11 @@ void CvDTree::split_node_data( CvDTreeNode* node )
if (data->is_buf_16u) if (data->is_buf_16u)
{ {
unsigned short *ldst = (unsigned short *)(buf->data.s + left->buf_idx*buf->cols + unsigned short *ldst = (unsigned short *)(buf->data.s + left->buf_idx*buf->cols +
vi*scount + left->offset); vi*scount + left->offset);
unsigned short *rdst = (unsigned short *)(buf->data.s + right->buf_idx*buf->cols + unsigned short *rdst = (unsigned short *)(buf->data.s + right->buf_idx*buf->cols +
vi*scount + right->offset); vi*scount + right->offset);
for( i = 0; i < n; i++ ) for( i = 0; i < n; i++ )
{ {
int d = dir[i]; int d = dir[i];
@ -3188,11 +3188,11 @@ void CvDTree::split_node_data( CvDTreeNode* node )
} }
else else
{ {
int *ldst = buf->data.i + left->buf_idx*buf->cols + int *ldst = buf->data.i + left->buf_idx*buf->cols +
vi*scount + left->offset; vi*scount + left->offset;
int *rdst = buf->data.i + right->buf_idx*buf->cols + int *rdst = buf->data.i + right->buf_idx*buf->cols +
vi*scount + right->offset; vi*scount + right->offset;
for( i = 0; i < n; i++ ) for( i = 0; i < n; i++ )
{ {
int d = dir[i]; int d = dir[i];
@ -3208,7 +3208,7 @@ void CvDTree::split_node_data( CvDTreeNode* node )
*ldst = idx; *ldst = idx;
ldst++; ldst++;
} }
} }
if( vi < data->var_count ) if( vi < data->var_count )
@ -3216,7 +3216,7 @@ void CvDTree::split_node_data( CvDTreeNode* node )
left->set_num_valid(vi, n1 - nr1); left->set_num_valid(vi, n1 - nr1);
right->set_num_valid(vi, nr1); right->set_num_valid(vi, nr1);
} }
} }
} }
@ -3230,9 +3230,9 @@ void CvDTree::split_node_data( CvDTreeNode* node )
int pos = data->get_work_var_count(); int pos = data->get_work_var_count();
if (data->is_buf_16u) if (data->is_buf_16u)
{ {
unsigned short* ldst = (unsigned short*)(buf->data.s + left->buf_idx*buf->cols + unsigned short* ldst = (unsigned short*)(buf->data.s + left->buf_idx*buf->cols +
pos*scount + left->offset); pos*scount + left->offset);
unsigned short* rdst = (unsigned short*)(buf->data.s + right->buf_idx*buf->cols + unsigned short* rdst = (unsigned short*)(buf->data.s + right->buf_idx*buf->cols +
pos*scount + right->offset); pos*scount + right->offset);
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
@ -3252,9 +3252,9 @@ void CvDTree::split_node_data( CvDTreeNode* node )
} }
else else
{ {
int* ldst = buf->data.i + left->buf_idx*buf->cols + int* ldst = buf->data.i + left->buf_idx*buf->cols +
pos*scount + left->offset; pos*scount + left->offset;
int* rdst = buf->data.i + right->buf_idx*buf->cols + int* rdst = buf->data.i + right->buf_idx*buf->cols +
pos*scount + right->offset; pos*scount + right->offset;
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
{ {
@ -3272,9 +3272,9 @@ void CvDTree::split_node_data( CvDTreeNode* node )
} }
} }
} }
// deallocate the parent node data that is not needed anymore // deallocate the parent node data that is not needed anymore
data->free_node_data(node); data->free_node_data(node);
} }
float CvDTree::calc_error( CvMLData* _data, int type, vector<float> *resp ) float CvDTree::calc_error( CvMLData* _data, int type, vector<float> *resp )
@ -3304,9 +3304,9 @@ float CvDTree::calc_error( CvMLData* _data, int type, vector<float> *resp )
{ {
CvMat sample, miss; CvMat sample, miss;
int si = sidx ? sidx[i] : i; int si = sidx ? sidx[i] : i;
cvGetRow( values, &sample, si ); cvGetRow( values, &sample, si );
if( missing ) if( missing )
cvGetRow( missing, &miss, si ); cvGetRow( missing, &miss, si );
float r = (float)predict( &sample, missing ? &miss : 0 )->value; float r = (float)predict( &sample, missing ? &miss : 0 )->value;
if( pred_resp ) if( pred_resp )
pred_resp[i] = r; pred_resp[i] = r;
@ -3321,16 +3321,16 @@ float CvDTree::calc_error( CvMLData* _data, int type, vector<float> *resp )
{ {
CvMat sample, miss; CvMat sample, miss;
int si = sidx ? sidx[i] : i; int si = sidx ? sidx[i] : i;
cvGetRow( values, &sample, si ); cvGetRow( values, &sample, si );
if( missing ) if( missing )
cvGetRow( missing, &miss, si ); cvGetRow( missing, &miss, si );
float r = (float)predict( &sample, missing ? &miss : 0 )->value; float r = (float)predict( &sample, missing ? &miss : 0 )->value;
if( pred_resp ) if( pred_resp )
pred_resp[i] = r; pred_resp[i] = r;
float d = r - response->data.fl[si*r_step]; float d = r - response->data.fl[si*r_step];
err += d*d; err += d*d;
} }
err = sample_count ? err / (float)sample_count : -FLT_MAX; err = sample_count ? err / (float)sample_count : -FLT_MAX;
} }
return err; return err;
} }
@ -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 );
@ -3650,12 +3650,12 @@ CvDTreeNode* CvDTree::predict( const CvMat* _sample,
{ {
int a = c = cofs[ci]; int a = c = cofs[ci];
int b = (ci+1 >= data->cat_ofs->cols) ? data->cat_map->cols : cofs[ci+1]; int b = (ci+1 >= data->cat_ofs->cols) ? data->cat_map->cols : cofs[ci+1];
int ival = cvRound(val); int ival = cvRound(val);
if( ival != val ) if( ival != val )
CV_Error( CV_StsBadArg, CV_Error( CV_StsBadArg,
"one of input categorical variable is not an integer" ); "one of input categorical variable is not an integer" );
int sh = 0; int sh = 0;
while( a < b ) while( a < b )
{ {

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