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

code clean up

Browse Source
This commit is contained in:
Suleyman TURKMEN 2019-01-11 20:31:55 +03:00
parent 78bd55c8df
commit 794c14b29a
8 changed files with 33 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -160,7 +160,7 @@ void CirclesGridClusterFinder::findGrid(const std::vector<cv::Point2f> &points,
#endif #endif
std::vector<Point2f> hull2f; std::vector<Point2f> hull2f;
convexHull(Mat(patternPoints), hull2f, false); convexHull(patternPoints, hull2f, false);
const size_t cornersCount = isAsymmetricGrid ? 6 : 4; const size_t cornersCount = isAsymmetricGrid ? 6 : 4;
if(hull2f.size() < cornersCount) if(hull2f.size() < cornersCount)
return; return;
@ -411,7 +411,7 @@ void CirclesGridClusterFinder::rectifyPatternPoints(const std::vector<cv::Point2
} }
} }
Mat homography = findHomography(Mat(sortedCorners), Mat(idealPoints), 0); Mat homography = findHomography(sortedCorners, idealPoints, 0);
Mat rectifiedPointsMat; Mat rectifiedPointsMat;
transform(patternPoints, rectifiedPointsMat, homography); transform(patternPoints, rectifiedPointsMat, homography);
rectifiedPatternPoints.clear(); rectifiedPatternPoints.clear();
@ -871,8 +871,8 @@ Mat CirclesGridFinder::rectifyGrid(Size detectedGridSize, const std::vector<Poin
} }
} }
Mat H = findHomography(Mat(centers), Mat(dstPoints), RANSAC); Mat H = findHomography(centers, dstPoints, RANSAC);
//Mat H = findHomography( Mat( corners ), Mat( dstPoints ) ); //Mat H = findHomography(corners, dstPoints);
if (H.empty()) if (H.empty())
{ {
@ -888,7 +888,7 @@ Mat CirclesGridFinder::rectifyGrid(Size detectedGridSize, const std::vector<Poin
} }
Mat dstKeypointsMat; Mat dstKeypointsMat;
transform(Mat(srcKeypoints), dstKeypointsMat, H); transform(srcKeypoints, dstKeypointsMat, H);
std::vector<Point2f> dstKeypoints; std::vector<Point2f> dstKeypoints;
convertPointsFromHomogeneous(dstKeypointsMat, dstKeypoints); convertPointsFromHomogeneous(dstKeypointsMat, dstKeypoints);
@ -1176,7 +1176,7 @@ void CirclesGridFinder::findBasis(const std::vector<Point2f> &samples, std::vect
} }
for (size_t i = 0; i < basis.size(); i++) for (size_t i = 0; i < basis.size(); i++)
{ {
convexHull(Mat(clusters[i]), hulls[i]); convexHull(clusters[i], hulls[i]);
} }
basisGraphs.resize(basis.size(), Graph(keypoints.size())); basisGraphs.resize(basis.size(), Graph(keypoints.size()));
@ -1191,7 +1191,7 @@ void CirclesGridFinder::findBasis(const std::vector<Point2f> &samples, std::vect
for (size_t k = 0; k < hulls.size(); k++) for (size_t k = 0; k < hulls.size(); k++)
{ {
if (pointPolygonTest(Mat(hulls[k]), vec, false) >= 0) if (pointPolygonTest(hulls[k], vec, false) >= 0)
{ {
basisGraphs[k].addEdge(i, j); basisGraphs[k].addEdge(i, j);
} }
@ -1422,7 +1422,6 @@ void CirclesGridFinder::drawHoles(const Mat &srcImage, Mat &drawImage) const
if (i != holes.size() - 1) if (i != holes.size() - 1)
line(drawImage, keypoints[holes[i][j]], keypoints[holes[i + 1][j]], Scalar(255, 0, 0), 2); line(drawImage, keypoints[holes[i][j]], keypoints[holes[i + 1][j]], Scalar(255, 0, 0), 2);
//circle(drawImage, keypoints[holes[i][j]], holeRadius, holeColor, holeThickness);
circle(drawImage, keypoints[holes[i][j]], holeRadius, holeColor, holeThickness); circle(drawImage, keypoints[holes[i][j]], holeRadius, holeColor, holeThickness);
} }
} }

5
modules/calib3d/src/quadsubpix.cpp
View File

@ -194,9 +194,8 @@ bool cv::find4QuadCornerSubpix(InputArray _img, InputOutputArray _corners, Size
erode(white_comp, white_comp, Mat(), Point(-1, -1), erode_count); erode(white_comp, white_comp, Mat(), Point(-1, -1), erode_count);
std::vector<std::vector<Point> > white_contours, black_contours; std::vector<std::vector<Point> > white_contours, black_contours;
std::vector<Vec4i> white_hierarchy, black_hierarchy; findContours(black_comp, black_contours, RETR_LIST, CHAIN_APPROX_SIMPLE);
findContours(black_comp, black_contours, black_hierarchy, RETR_LIST, CHAIN_APPROX_SIMPLE); findContours(white_comp, white_contours, RETR_LIST, CHAIN_APPROX_SIMPLE);
findContours(white_comp, white_contours, white_hierarchy, RETR_LIST, CHAIN_APPROX_SIMPLE);
if(black_contours.size() < 5 || white_contours.size() < 5) continue; if(black_contours.size() < 5 || white_contours.size() < 5) continue;

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

@ -1514,7 +1514,7 @@ bool CV_StereoCalibrationTest::checkPandROI( int test_case_idx, const Mat& M, co
for( x = 0; x < N; x++ ) for( x = 0; x < N; x++ )
pts.push_back(Point2f((float)x*imgsize.width/(N-1), (float)y*imgsize.height/(N-1))); pts.push_back(Point2f((float)x*imgsize.width/(N-1), (float)y*imgsize.height/(N-1)));
undistortPoints(Mat(pts), upts, M, D, R, P ); undistortPoints(pts, upts, M, D, R, P );
for( k = 0; k < N*N; k++ ) for( k = 0; k < N*N; k++ )
if( upts[k].x < -imgsize.width*eps || upts[k].x > imgsize.width*(1+eps) || if( upts[k].x < -imgsize.width*eps || upts[k].x > imgsize.width*(1+eps) ||
upts[k].y < -imgsize.height*eps || upts[k].y > imgsize.height*(1+eps) ) upts[k].y < -imgsize.height*eps || upts[k].y > imgsize.height*(1+eps) )
@ -1823,8 +1823,8 @@ void CV_StereoCalibrationTest::run( int )
for( int i = 0, k = 0; i < nframes; i++ ) for( int i = 0, k = 0; i < nframes; i++ )
{ {
vector<Point2f> temp[2]; vector<Point2f> temp[2];
undistortPoints(Mat(imgpt1[i]), temp[0], M1, D1, R1, P1); undistortPoints(imgpt1[i], temp[0], M1, D1, R1, P1);
undistortPoints(Mat(imgpt2[i]), temp[1], M2, D2, R2, P2); undistortPoints(imgpt2[i], temp[1], M2, D2, R2, P2);
for( int j = 0; j < npoints; j++, k++ ) for( int j = 0; j < npoints; j++, k++ )
{ {

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

@ -353,7 +353,7 @@ protected:
rvecs_spnp.resize(brdsNum); rvecs_spnp.resize(brdsNum);
tvecs_spnp.resize(brdsNum); tvecs_spnp.resize(brdsNum);
for(size_t i = 0; i < brdsNum; ++i) for(size_t i = 0; i < brdsNum; ++i)
solvePnP(Mat(objectPoints[i]), Mat(imagePoints[i]), camMat, distCoeffs, rvecs_spnp[i], tvecs_spnp[i]); solvePnP(objectPoints[i], 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);

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

@ -126,10 +126,10 @@ Mat ChessBoardGenerator::generateChessBoard(const Mat& bg, const Mat& camMat, co
generateEdge(p3, p4, pts_square3d); generateEdge(p3, p4, pts_square3d);
generateEdge(p4, p1, pts_square3d); generateEdge(p4, p1, pts_square3d);
projectPoints(Mat(pts_square3d), rvec, tvec, camMat, distCoeffs, pts_square2d); projectPoints(pts_square3d, rvec, tvec, camMat, distCoeffs, pts_square2d);
squares_black.resize(squares_black.size() + 1); squares_black.resize(squares_black.size() + 1);
vector<Point2f> temp; vector<Point2f> temp;
approxPolyDP(Mat(pts_square2d), temp, 1.0, true); approxPolyDP(pts_square2d, temp, 1.0, true);
transform(temp.begin(), temp.end(), back_inserter(squares_black.back()), Mult(rendererResolutionMultiplier)); transform(temp.begin(), temp.end(), back_inserter(squares_black.back()), Mult(rendererResolutionMultiplier));
} }
@ -139,7 +139,7 @@ Mat ChessBoardGenerator::generateChessBoard(const Mat& bg, const Mat& camMat, co
for(int i = 0; i < patternSize.width - 1; ++i) for(int i = 0; i < patternSize.width - 1; ++i)
corners3d.push_back(zero + (i + 1) * sqWidth * pb1 + (j + 1) * sqHeight * pb2); corners3d.push_back(zero + (i + 1) * sqWidth * pb1 + (j + 1) * sqHeight * pb2);
corners.clear(); corners.clear();
projectPoints(Mat(corners3d), rvec, tvec, camMat, distCoeffs, corners); projectPoints(corners3d, rvec, tvec, camMat, distCoeffs, corners);
vector<Point3f> whole3d; vector<Point3f> whole3d;
vector<Point2f> whole2d; vector<Point2f> whole2d;
@ -147,9 +147,9 @@ Mat ChessBoardGenerator::generateChessBoard(const Mat& bg, const Mat& camMat, co
generateEdge(whole[1], whole[2], whole3d); generateEdge(whole[1], whole[2], whole3d);
generateEdge(whole[2], whole[3], whole3d); generateEdge(whole[2], whole[3], whole3d);
generateEdge(whole[3], whole[0], whole3d); generateEdge(whole[3], whole[0], whole3d);
projectPoints(Mat(whole3d), rvec, tvec, camMat, distCoeffs, whole2d); projectPoints(whole3d, rvec, tvec, camMat, distCoeffs, whole2d);
vector<Point2f> temp_whole2d; vector<Point2f> temp_whole2d;
approxPolyDP(Mat(whole2d), temp_whole2d, 1.0, true); approxPolyDP(whole2d, temp_whole2d, 1.0, true);
vector< vector<Point > > whole_contour(1); vector< vector<Point > > whole_contour(1);
transform(temp_whole2d.begin(), temp_whole2d.end(), transform(temp_whole2d.begin(), temp_whole2d.end(),
@ -213,7 +213,7 @@ Mat ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const Mat
pts3d[3] = p - pb1 * cbHalfWidthEx + cbHalfHeightEx * pb2; pts3d[3] = p - pb1 * cbHalfWidthEx + cbHalfHeightEx * pb2;
/* can remake with better perf */ /* can remake with better perf */
projectPoints(Mat(pts3d), rvec, tvec, camMat, distCoeffs, pts2d); projectPoints(pts3d, rvec, tvec, camMat, distCoeffs, pts2d);
bool inrect1 = pts2d[0].x < bg.cols && pts2d[0].y < bg.rows && pts2d[0].x > 0 && pts2d[0].y > 0; bool inrect1 = pts2d[0].x < bg.cols && pts2d[0].y < bg.rows && pts2d[0].x > 0 && pts2d[0].y > 0;
bool inrect2 = pts2d[1].x < bg.cols && pts2d[1].y < bg.rows && pts2d[1].x > 0 && pts2d[1].y > 0; bool inrect2 = pts2d[1].x < bg.cols && pts2d[1].y < bg.rows && pts2d[1].x > 0 && pts2d[1].y > 0;
@ -278,7 +278,7 @@ Mat ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const Mat
pts3d[3] = p - pb1 * cbHalfWidthEx + cbHalfHeightEx * pb2; pts3d[3] = p - pb1 * cbHalfWidthEx + cbHalfHeightEx * pb2;
/* can remake with better perf */ /* can remake with better perf */
projectPoints(Mat(pts3d), rvec, tvec, camMat, distCoeffs, pts2d); projectPoints(pts3d, rvec, tvec, camMat, distCoeffs, pts2d);
bool inrect1 = pts2d[0].x < bg.cols && pts2d[0].y < bg.rows && pts2d[0].x > 0 && pts2d[0].y > 0; bool inrect1 = pts2d[0].x < bg.cols && pts2d[0].y < bg.rows && pts2d[0].x > 0 && pts2d[0].y > 0;
bool inrect2 = pts2d[1].x < bg.cols && pts2d[1].y < bg.rows && pts2d[1].x > 0 && pts2d[1].y > 0; bool inrect2 = pts2d[1].x < bg.cols && pts2d[1].y < bg.rows && pts2d[1].x > 0 && pts2d[1].y > 0;
@ -320,7 +320,7 @@ Mat ChessBoardGenerator::operator ()(const Mat& bg, const Mat& camMat, const Mat
pts3d[3] = p - pb1 * cbHalfWidthEx + cbHalfHeightEx * pb2; pts3d[3] = p - pb1 * cbHalfWidthEx + cbHalfHeightEx * pb2;
/* can remake with better perf */ /* can remake with better perf */
projectPoints(Mat(pts3d), rvec, tvec, camMat, distCoeffs, pts2d); projectPoints(pts3d, rvec, tvec, camMat, distCoeffs, pts2d);
Point3f zero = p - pb1 * cbHalfWidth - cbHalfHeight * pb2; Point3f zero = p - pb1 * cbHalfWidth - cbHalfHeight * pb2;

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

@ -124,7 +124,7 @@ protected:
vector<Point2f> projectedPoints; vector<Point2f> projectedPoints;
projectedPoints.resize(points.size()); projectedPoints.resize(points.size());
projectPoints(Mat(points), trueRvec, trueTvec, intrinsics, distCoeffs, projectedPoints); projectPoints(points, trueRvec, trueTvec, intrinsics, distCoeffs, projectedPoints);
for (size_t i = 0; i < projectedPoints.size(); i++) for (size_t i = 0; i < projectedPoints.size(); i++)
{ {
if (i % 20 == 0) if (i % 20 == 0)
@ -241,7 +241,7 @@ protected:
vector<Point2f> projectedPoints; vector<Point2f> projectedPoints;
projectedPoints.resize(opoints.size()); projectedPoints.resize(opoints.size());
projectPoints(Mat(opoints), trueRvec, trueTvec, intrinsics, distCoeffs, projectedPoints); projectPoints(opoints, trueRvec, trueTvec, intrinsics, distCoeffs, projectedPoints);
bool isEstimateSuccess = solvePnP(opoints, projectedPoints, intrinsics, distCoeffs, rvec, tvec, false, method); bool isEstimateSuccess = solvePnP(opoints, projectedPoints, intrinsics, distCoeffs, rvec, tvec, false, method);
if (isEstimateSuccess == false) if (isEstimateSuccess == false)
@ -291,7 +291,7 @@ class CV_solveP3P_Test : public CV_solvePnPRansac_Test
vector<Point2f> projectedPoints; vector<Point2f> projectedPoints;
projectedPoints.resize(opoints.size()); projectedPoints.resize(opoints.size());
projectPoints(Mat(opoints), trueRvec, trueTvec, intrinsics, distCoeffs, projectedPoints); projectPoints(opoints, trueRvec, trueTvec, intrinsics, distCoeffs, projectedPoints);
int num_of_solutions = solveP3P(opoints, projectedPoints, intrinsics, distCoeffs, rvecs, tvecs, method); int num_of_solutions = solveP3P(opoints, projectedPoints, intrinsics, distCoeffs, rvecs, tvecs, method);
if (num_of_solutions != (int) rvecs.size() || num_of_solutions != (int) tvecs.size() || num_of_solutions == 0) if (num_of_solutions != (int) rvecs.size() || num_of_solutions != (int) tvecs.size() || num_of_solutions == 0)

13
modules/features2d/src/blobdetector.cpp
View File

@ -197,8 +197,7 @@ void SimpleBlobDetectorImpl::findBlobs(InputArray _image, InputArray _binaryImag
centers.clear(); centers.clear();
std::vector < std::vector<Point> > contours; std::vector < std::vector<Point> > contours;
Mat tmpBinaryImage = binaryImage.clone(); findContours(binaryImage, contours, RETR_LIST, CHAIN_APPROX_NONE);
findContours(tmpBinaryImage, contours, RETR_LIST, CHAIN_APPROX_NONE);
#ifdef DEBUG_BLOB_DETECTOR #ifdef DEBUG_BLOB_DETECTOR
// Mat keypointsImage; // Mat keypointsImage;
@ -214,7 +213,7 @@ void SimpleBlobDetectorImpl::findBlobs(InputArray _image, InputArray _binaryImag
{ {
Center center; Center center;
center.confidence = 1; center.confidence = 1;
Moments moms = moments(Mat(contours[contourIdx])); Moments moms = moments(contours[contourIdx]);
if (params.filterByArea) if (params.filterByArea)
{ {
double area = moms.m00; double area = moms.m00;
@ -225,7 +224,7 @@ void SimpleBlobDetectorImpl::findBlobs(InputArray _image, InputArray _binaryImag
if (params.filterByCircularity) if (params.filterByCircularity)
{ {
double area = moms.m00; double area = moms.m00;
double perimeter = arcLength(Mat(contours[contourIdx]), true); double perimeter = arcLength(contours[contourIdx], true);
double ratio = 4 * CV_PI * area / (perimeter * perimeter); double ratio = 4 * CV_PI * area / (perimeter * perimeter);
if (ratio < params.minCircularity || ratio >= params.maxCircularity) if (ratio < params.minCircularity || ratio >= params.maxCircularity)
continue; continue;
@ -261,9 +260,9 @@ void SimpleBlobDetectorImpl::findBlobs(InputArray _image, InputArray _binaryImag
if (params.filterByConvexity) if (params.filterByConvexity)
{ {
std::vector < Point > hull; std::vector < Point > hull;
convexHull(Mat(contours[contourIdx]), hull); convexHull(contours[contourIdx], hull);
double area = contourArea(Mat(contours[contourIdx])); double area = contourArea(contours[contourIdx]);
double hullArea = contourArea(Mat(hull)); double hullArea = contourArea(hull);
if (fabs(hullArea) < DBL_EPSILON) if (fabs(hullArea) < DBL_EPSILON)
continue; continue;
double ratio = area / hullArea; double ratio = area / hullArea;

6
modules/objdetect/src/qrcode.cpp
View File

@ -387,7 +387,7 @@ bool QRDetect::computeTransformationPoints()
findNonZero(mask_roi, non_zero_elem[i]); findNonZero(mask_roi, non_zero_elem[i]);
newHull.insert(newHull.end(), non_zero_elem[i].begin(), non_zero_elem[i].end()); newHull.insert(newHull.end(), non_zero_elem[i].begin(), non_zero_elem[i].end());
} }
convexHull(Mat(newHull), locations); convexHull(newHull, locations);
for (size_t i = 0; i < locations.size(); i++) for (size_t i = 0; i < locations.size(); i++)
{ {
for (size_t j = 0; j < 3; j++) for (size_t j = 0; j < 3; j++)
@ -556,7 +556,7 @@ vector<Point2f> QRDetect::getQuadrilateral(vector<Point2f> angle_list)
} }
vector<Point> integer_hull; vector<Point> integer_hull;
convexHull(Mat(locations), integer_hull); convexHull(locations, integer_hull);
int hull_size = (int)integer_hull.size(); int hull_size = (int)integer_hull.size();
vector<Point2f> hull(hull_size); vector<Point2f> hull(hull_size);
for (int i = 0; i < hull_size; i++) for (int i = 0; i < hull_size; i++)
@ -910,7 +910,7 @@ bool QRDecode::versionDefinition()
vector<Point> locations, non_zero_elem; vector<Point> locations, non_zero_elem;
Mat mask_roi = mask(Range(1, intermediate.rows - 1), Range(1, intermediate.cols - 1)); Mat mask_roi = mask(Range(1, intermediate.rows - 1), Range(1, intermediate.cols - 1));
findNonZero(mask_roi, non_zero_elem); findNonZero(mask_roi, non_zero_elem);
convexHull(Mat(non_zero_elem), locations); convexHull(non_zero_elem, locations);
Point offset = computeOffset(locations); Point offset = computeOffset(locations);
Point temp_remote = locations[0], remote_point; Point temp_remote = locations[0], remote_point;