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

M_PI changed to CV_PI (#12645)

Browse Source 
* M_PI changed to CV_PI

* M_PI changed to CV_PI

* M_PI changed to CV_PI
This commit is contained in:
Menghui Xie 2018-09-26 21:05:02 +08:00 committed by Vadim Pisarevsky
parent d8d025c33b
commit f0d277e452
3 changed files with 33 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
modules/calib3d/src/chessboard.cpp
View File

@ -22,11 +22,11 @@ namespace details {
// magic numbers used for chessboard corner detection
/////////////////////////////////////////////////////////////////////////////
const float CORNERS_SEARCH = 0.5F; // percentage of the edge length to the next corner used to find new corners
const float MAX_ANGLE = float(48.0/180.0*M_PI); // max angle between line segments supposed to be straight
const float MIN_COS_ANGLE = float(cos(35.0/180*M_PI)); // min cos angle between board edges
const float MAX_ANGLE = float(48.0/180.0*CV_PI); // max angle between line segments supposed to be straight
const float MIN_COS_ANGLE = float(cos(35.0/180*CV_PI)); // min cos angle between board edges
const float MIN_RESPONSE_RATIO = 0.1F;
const float ELLIPSE_WIDTH = 0.35F; // width of the search ellipse in percentage of its length
const float RAD2DEG = float(180.0/M_PI);
const float RAD2DEG = float(180.0/CV_PI);
const int MAX_SYMMETRY_ERRORS = 5; // maximal number of failures during point symmetry test (filtering out lines)
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
@ -214,7 +214,7 @@ int testPointSymmetry(cv::Mat mat,cv::Point2f pt,float dist,float max_error)
int count = 0;
cv::Mat patch1,patch2;
cv::Point2f center1,center2;
for(double angle=0;angle <= M_PI;angle+=M_PI*0.1)
for(double angle=0;angle <= CV_PI;angle+=CV_PI*0.1)
{
cv::Point2f n(float(cos(angle)),float(-sin(angle)));
center1 = pt+dist*n;
@ -284,7 +284,7 @@ void FastX::rotate(float angle,const cv::Mat &img,cv::Size size,cv::Mat &out)con
}
else
{
cv::Mat m = cv::getRotationMatrix2D(cv::Point2f(float(img.cols*0.5),float(img.rows*0.5)),float(angle/M_PI*180),1);
cv::Mat m = cv::getRotationMatrix2D(cv::Point2f(float(img.cols*0.5),float(img.rows*0.5)),float(angle/CV_PI*180),1);
CV_Assert(m.type() == CV_64FC1);
m.at<double>(0,2) += 0.5*(size.width-img.cols);
m.at<double>(1,2) += 0.5*(size.height-img.rows);
@ -390,7 +390,7 @@ std::vector<std::vector<float> > FastX::calcAngles(const std::vector<cv::Mat> &r
// assuming all elements of the same channel
const int channels = rotated_images.front().channels();
int channels_1 = channels-1;
float resolution = float(M_PI/channels);
float resolution = float(CV_PI/channels);
float angle;
float val1,val2,val3,wrap_around;
@ -436,9 +436,9 @@ std::vector<std::vector<float> > FastX::calcAngles(const std::vector<cv::Mat> &r
{
angle = float((calcSubPos(val1,val2,val3)+i)*resolution);
if(angle < 0)
angle += float(M_PI);
else if(angle > M_PI)
angle -= float(M_PI);
angle += float(CV_PI);
else if(angle > CV_PI)
angle -= float(CV_PI);
angles_i.push_back(angle);
pt_iter->angle = 360.0F-angle*RAD2DEG;
}
@ -447,9 +447,9 @@ std::vector<std::vector<float> > FastX::calcAngles(const std::vector<cv::Mat> &r
{
angle = float((calcSubPos(val1,val2,val3)+i)*resolution);
if(angle < 0)
angle += float(M_PI);
else if(angle > M_PI)
angle -= float(M_PI);
angle += float(CV_PI);
else if(angle > CV_PI)
angle -= float(CV_PI);
angles_i.push_back(-angle);
pt_iter->angle = 360.0F-angle*RAD2DEG;
}
@ -463,9 +463,9 @@ std::vector<std::vector<float> > FastX::calcAngles(const std::vector<cv::Mat> &r
{
angle = float((calcSubPos(val1,val2,wrap_around)+channels-1)*resolution);
if(angle < 0)
angle += float(M_PI);
else if(angle > M_PI)
angle -= float(M_PI);
angle += float(CV_PI);
else if(angle > CV_PI)
angle -= float(CV_PI);
angles_i.push_back(angle);
pt_iter->angle = 360.0F-angle*RAD2DEG;
}
@ -474,9 +474,9 @@ std::vector<std::vector<float> > FastX::calcAngles(const std::vector<cv::Mat> &r
{
angle = float((calcSubPos(val1,val2,wrap_around)+channels-1)*resolution);
if(angle < 0)
angle += float(M_PI);
else if(angle > M_PI)
angle -= float(M_PI);
angle += float(CV_PI);
else if(angle > CV_PI)
angle -= float(CV_PI);
angles_i.push_back(-angle);
pt_iter->angle = 360.0F-angle*RAD2DEG;
}
@ -632,7 +632,7 @@ void FastX::detectImpl(const cv::Mat& _gray_image,
cv::Mat rotated,filtered_h,filtered_v;
int diag = int(sqrt(gray_image.rows*gray_image.rows+gray_image.cols*gray_image.cols));
cv::Size size(diag,diag);
int num = int(0.5001*M_PI/parameters.resolution);
int num = int(0.5001*CV_PI/parameters.resolution);
std::vector<cv::Mat> images;
images.resize(2*num);
int scale_size = int(1+pow(2.0,scale+1+super_res));
@ -722,7 +722,7 @@ cv::Point2f Ellipse::getCenter()const
void Ellipse::draw(cv::InputOutputArray img,const cv::Scalar &color)const
{
cv::ellipse(img,center,axes,360-angle/M_PI*180,0,360,color);
cv::ellipse(img,center,axes,360-angle/CV_PI*180,0,360,color);
}
bool Ellipse::contains(const cv::Point2f &pt)const
@ -1542,10 +1542,10 @@ float Chessboard::Board::findMaxPoint(cv::flann::Index &index,const cv::Mat &dat
const float &a0 = *(val+2);
float a1 = fabs(a0-white_angle);
float a2 = fabs(a0-black_angle);
if(a1 > M_PI*0.5)
a1= float(fabs(a1-M_PI));
if(a2> M_PI*0.5)
a2= float(fabs(a2-M_PI));
if(a1 > CV_PI*0.5)
a1= float(fabs(a1-CV_PI));
if(a2> CV_PI*0.5)
a2= float(fabs(a2-CV_PI));
if(a1 < MAX_ANGLE || a2 < MAX_ANGLE )
{
cv::Point2f pt(*val,*(val+1));
@ -1788,7 +1788,7 @@ bool Chessboard::Board::estimateSearchArea(const cv::Point2f &p1,const cv::Point
n = n/norm;
float angle = acos(n.x);
if(n.y > 0)
angle = float(2.0F*M_PI-angle);
angle = float(2.0F*CV_PI-angle);
n = p4-p3;
norm = float(cv::norm(n));
double delta = std::max(3.0F,p*norm);
@ -2795,7 +2795,7 @@ void Chessboard::findKeyPoints(const cv::Mat& image, std::vector<KeyPoint>& keyp
para.branches = 2; // this is always the case for checssboard corners
para.strength = 10; // minimal threshold
para.resolution = float(M_PI*0.25); // this gives the best results taking interpolation into account
para.resolution = float(CV_PI*0.25); // this gives the best results taking interpolation into account
para.filter = 1;
para.super_resolution = parameters.super_resolution;
para.min_scale = parameters.min_scale;
@ -2846,7 +2846,7 @@ cv::Mat Chessboard::buildData(const std::vector<KeyPoint>& keypoints)const
{
(*val++) = iter->pt.x;
(*val++) = iter->pt.y;
(*val++) = float(2.0*M_PI-iter->angle/180.0*M_PI);
(*val++) = float(2.0*CV_PI-iter->angle/180.0*CV_PI);
(*val++) = iter->response;
}
return data;
@ -2876,13 +2876,13 @@ std::vector<cv::KeyPoint> Chessboard::getInitialPoints(cv::flann::Index &flann_i
continue;
const float &angle = data.at<float>(*ids_iter,2);
float angle_temp = fabs(angle-white_angle);
if(angle_temp > M_PI*0.5)
angle_temp = float(fabs(angle_temp-M_PI));
if(angle_temp > CV_PI*0.5)
angle_temp = float(fabs(angle_temp-CV_PI));
if(angle_temp > MAX_ANGLE)
{
angle_temp = fabs(angle-black_angle);
if(angle_temp > M_PI*0.5)
angle_temp = float(fabs(angle_temp-M_PI));
if(angle_temp > CV_PI*0.5)
angle_temp = float(fabs(angle_temp-CV_PI));
if(angle_temp >MAX_ANGLE)
continue;
}

2
modules/calib3d/src/chessboard.hpp
View File

@ -32,7 +32,7 @@ class FastX : public cv::Feature2D
Parameters()
{
strength = 40;
resolution = float(M_PI*0.25);
resolution = float(CV_PI*0.25);
branches = 2;
min_scale = 2;
max_scale = 5;

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

@ -566,7 +566,7 @@ bool CV_ChessboardDetectorTest::checkByGeneratorHighAccuracy()
for(int i=15;i<90;i=i+15)
{
// project 3d points to new camera
Vec3f rvec(0.0F,0.05F,float(float(i)/180.0*M_PI));
Vec3f rvec(0.0F,0.05F,float(float(i)/180.0*CV_PI));
Vec3f tvec(0,0,0);
cv::Mat k = (cv::Mat_<double>(3,3) << fx/2,0,center.x*2, 0,fy/2,center.y, 0,0,1);
cv::projectPoints(pts3d,rvec,tvec,k,cv::Mat(),pts2_all);