|
|
|
|
@ -1,8 +1,28 @@ |
|
|
|
|
#include "cv.h" // include standard OpenCV headers, same as before |
|
|
|
|
#include "highgui.h" |
|
|
|
|
#include "ml.h" |
|
|
|
|
#include <stdio.h> |
|
|
|
|
#include <iostream> |
|
|
|
|
#include <opencv2/flann/flann.hpp> |
|
|
|
|
|
|
|
|
|
using namespace cv; // all the new API is put into "cv" namespace. Export its content
|
|
|
|
|
using namespace std; |
|
|
|
|
using namespace cv::flann; |
|
|
|
|
|
|
|
|
|
#define RAD2DEG 57.295779513082321 |
|
|
|
|
void print32FMat(const CvMat&mat) |
|
|
|
|
{ |
|
|
|
|
float *data = mat.data.fl; |
|
|
|
|
|
|
|
|
|
for (int r = 0; r < mat.rows; ++r) |
|
|
|
|
{ |
|
|
|
|
for (int c = 0; c < mat.cols; ++c) |
|
|
|
|
{ |
|
|
|
|
printf("%+1.9f\t", data[r*mat.cols+c]); |
|
|
|
|
} |
|
|
|
|
printf("\n"); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#if 0 |
|
|
|
|
|
|
|
|
|
@ -114,26 +134,610 @@ int main( int argc, char** argv ) |
|
|
|
|
|
|
|
|
|
int main(int argc, char *argv[]) |
|
|
|
|
{ |
|
|
|
|
Mat im(160, 160, CV_32F); |
|
|
|
|
randu(im, Scalar(0.0), Scalar(1.0)); |
|
|
|
|
Mat dd = Mat::zeros(17,1,CV_32F); |
|
|
|
|
Mat lp = Mat::zeros(17,1,CV_32F); |
|
|
|
|
dd.at<float>(0) = 0.5; |
|
|
|
|
dd.at<float>(16) = -0.5; |
|
|
|
|
lp.at<float>(0) = 0.5; |
|
|
|
|
lp.at<float>(16) = 0.5; |
|
|
|
|
int p = 16; |
|
|
|
|
Mat H = dd*lp.t(); |
|
|
|
|
Mat imcrop(im, Rect(17, 17, im.cols-2*p, im.rows-2*p)); |
|
|
|
|
Mat out1, out2; |
|
|
|
|
filter2D(imcrop, out1, CV_32F, H, Point(-1,-1)); |
|
|
|
|
sepFilter2D(imcrop, out2, CV_32F, lp, dd, Point(-1,-1)); |
|
|
|
|
Mat temp; |
|
|
|
|
out1.convertTo(temp, CV_16U, 65535.0, 32768.0); |
|
|
|
|
imshow("filtered1.png", temp); |
|
|
|
|
out2.convertTo(temp, CV_16U, 65535.0, 32768.0); |
|
|
|
|
imshow("filtered2.png", temp); |
|
|
|
|
waitKey(); |
|
|
|
|
/*double a = 56004.409155979447;
|
|
|
|
|
double b = -15158.994132169822; |
|
|
|
|
double c = 215540.83745481662; |
|
|
|
|
|
|
|
|
|
{ |
|
|
|
|
double A[4]; |
|
|
|
|
double InvA[4]; |
|
|
|
|
CvMat matA, matInvA; |
|
|
|
|
|
|
|
|
|
A[0] = a; |
|
|
|
|
A[1] = A[2] = b; |
|
|
|
|
A[3] = c; |
|
|
|
|
|
|
|
|
|
cvInitMatHeader( &matA, 2, 2, CV_64F, A ); |
|
|
|
|
cvInitMatHeader( &matInvA, 2, 2, CV_64FC1, InvA ); |
|
|
|
|
|
|
|
|
|
cvInvert( &matA, &matInvA, CV_SVD ); |
|
|
|
|
|
|
|
|
|
printf("%g\t%g\n%g\t%g\n", InvA[0], InvA[1], InvA[2], InvA[3]); |
|
|
|
|
}*/ |
|
|
|
|
|
|
|
|
|
//Mat img = imread("/Users/vp/work/ocv/opencv/samples/c/left04.jpg", 1);
|
|
|
|
|
//Vec<string, 4> v;
|
|
|
|
|
|
|
|
|
|
/*Mat img = Mat::zeros(20, 20, CV_8U);
|
|
|
|
|
img(Range(0,10),Range(0,10)) = Scalar(255); |
|
|
|
|
img.at<uchar>(10,10)=255; |
|
|
|
|
img(Range(11,20),Range(11,20)) = Scalar(255); |
|
|
|
|
vector<Point2f> corner(1, Point2f(9.5,9.5)); |
|
|
|
|
cornerSubPix(img, corner, Size(5,5), Size(-1,-1), TermCriteria(3, 30, 0.001)); |
|
|
|
|
printf("Corner at (%g, %g)", corner[0].x, corner[0].y);*/ |
|
|
|
|
|
|
|
|
|
/*Mat large, large2, gray;
|
|
|
|
|
resize(img, large, img.size()*3, 0, 0, CV_INTER_LANCZOS4); |
|
|
|
|
cvtColor(large, gray, CV_BGR2GRAY); |
|
|
|
|
vector<Point2f> corners; |
|
|
|
|
bool found = findChessboardCorners(gray, Size(9,6), corners); |
|
|
|
|
cornerSubPix(gray, corners, Size(11,11), Size(-1,-1), |
|
|
|
|
TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, 0.01)); |
|
|
|
|
|
|
|
|
|
drawChessboardCorners(large, Size(9,6), Mat(corners), false); |
|
|
|
|
//rectangle(img, Point(150,100), Point(250,200), Scalar(0,255,0), 1);
|
|
|
|
|
resize(large(Rect(150*3,100*3,100*3,100*3)), large2, Size(), 4, 4, CV_INTER_CUBIC); |
|
|
|
|
imshow("test", large2); |
|
|
|
|
waitKey(0);*/ |
|
|
|
|
|
|
|
|
|
/*int N=4;
|
|
|
|
|
CvEM em_model; |
|
|
|
|
CvEMParams params; |
|
|
|
|
int nsamples=500; |
|
|
|
|
for (int D=2; D < 15; D++) |
|
|
|
|
{ |
|
|
|
|
CvMat* samples = cvCreateMat( nsamples, D, CV_32FC1 ); |
|
|
|
|
for (int s=0; s < nsamples;s++) |
|
|
|
|
for (int d=0; d <D;d++) |
|
|
|
|
cvmSet(samples, s, d, (double)s+d); |
|
|
|
|
// initialize model's parameters
|
|
|
|
|
params.covs = NULL; |
|
|
|
|
params.means = NULL; |
|
|
|
|
params.weights = NULL; |
|
|
|
|
params.probs = NULL; |
|
|
|
|
params.nclusters = N; |
|
|
|
|
params.cov_mat_type = CvEM::COV_MAT_DIAGONAL; |
|
|
|
|
params.start_step = CvEM::START_AUTO_STEP; |
|
|
|
|
params.term_crit.max_iter = 100; |
|
|
|
|
params.term_crit.epsilon = 0.01; |
|
|
|
|
params.term_crit.type = CV_TERMCRIT_ITER|CV_TERMCRIT_EPS; |
|
|
|
|
em_model.train( samples, 0, params); |
|
|
|
|
const CvMat* w = em_model.get_weights(); |
|
|
|
|
double sum=0; |
|
|
|
|
for (int i=0; i < N; i++) |
|
|
|
|
sum+=cvmGet(w, 0, i); |
|
|
|
|
printf("D = %d, sum = %f\n", D, sum); |
|
|
|
|
cvReleaseMat( &samples ); |
|
|
|
|
}*/ |
|
|
|
|
/*Mat a(1, 0, CV_32F);
|
|
|
|
|
cout << " empty=" << a.empty() << " data=" << (size_t)a.data << endl;*/ |
|
|
|
|
|
|
|
|
|
//XOR input
|
|
|
|
|
/*double in[]={ 0 ,0,
|
|
|
|
|
1, 0, |
|
|
|
|
0, 1, |
|
|
|
|
1, 1}; |
|
|
|
|
double out[]={ 0, |
|
|
|
|
1, |
|
|
|
|
1, |
|
|
|
|
0}; |
|
|
|
|
|
|
|
|
|
const int IVS = 2; // Input Vector Size
|
|
|
|
|
const int OVS = 1; // Output Vector Size
|
|
|
|
|
const int HN = 10; // Number of Hidden nodes
|
|
|
|
|
const int NV= 4; //Number of Training Vector
|
|
|
|
|
|
|
|
|
|
int layer[] = { IVS, HN, OVS}; |
|
|
|
|
|
|
|
|
|
CvMat *input =cvCreateMat( NV, IVS, CV_64FC1); |
|
|
|
|
CvMat *output =cvCreateMat( NV, OVS, CV_64FC1); |
|
|
|
|
CvMat *p_output =cvCreateMat( NV, OVS, CV_64FC1); |
|
|
|
|
CvMat *layersize =cvCreateMat( 1 , 3 , CV_32SC1); |
|
|
|
|
|
|
|
|
|
cvInitMatHeader(input, NV, IVS, CV_64FC1, in); |
|
|
|
|
cvInitMatHeader(output, NV, OVS, CV_64FC1, out); |
|
|
|
|
cvInitMatHeader(layersize, 1, 3, CV_32SC1, layer); |
|
|
|
|
|
|
|
|
|
CvANN_MLP train_model(layersize, CvANN_MLP::SIGMOID_SYM,1,1); |
|
|
|
|
std::cout<< " =========== =========== =========== =========== ==========="<<std::endl; |
|
|
|
|
std::cout<< " * First Iteration with initialzation of weights"<<std::endl; |
|
|
|
|
std::cout<< " =========== =========== =========== =========== ==========="<<std::endl; |
|
|
|
|
int iter = train_model.train( input, |
|
|
|
|
output,
|
|
|
|
|
NULL,
|
|
|
|
|
0, |
|
|
|
|
CvANN_MLP_TrainParams( cvTermCriteria ( CV_TERMCRIT_ITER | |
|
|
|
|
CV_TERMCRIT_EPS, |
|
|
|
|
5000,0.000001), |
|
|
|
|
CvANN_MLP_TrainParams::BACKPROP, |
|
|
|
|
0.1,0.1), |
|
|
|
|
0 |
|
|
|
|
//+ CvANN_MLP::NO_OUTPUT_SCALE
|
|
|
|
|
); |
|
|
|
|
|
|
|
|
|
std::cout << " * iteration :"<<iter<<std::endl; |
|
|
|
|
train_model.predict( input, p_output ); |
|
|
|
|
for(int i=0; i<NV;i++){ |
|
|
|
|
std::cout<< CV_MAT_ELEM(*input,double,i,0) << " ," << CV_MAT_ELEM(*input,double,i,1) |
|
|
|
|
<< " : " << CV_MAT_ELEM(*p_output,double,i,0) <<std::endl; |
|
|
|
|
|
|
|
|
|
} |
|
|
|
|
train_model.save( "firstModel.xml"); |
|
|
|
|
std::cout<< " =========== =========== =========== =========== ==========="<<std::endl; |
|
|
|
|
std::cout<< " * Second Iteration without initialzation of weights"<<std::endl; |
|
|
|
|
std::cout<< " =========== =========== =========== =========== ==========="<<std::endl; |
|
|
|
|
|
|
|
|
|
int iter2; |
|
|
|
|
for(int i=0;i<5;i++) |
|
|
|
|
{ |
|
|
|
|
iter2 = train_model.train( input, |
|
|
|
|
output,
|
|
|
|
|
NULL,
|
|
|
|
|
0, |
|
|
|
|
CvANN_MLP_TrainParams( cvTermCriteria ( CV_TERMCRIT_ITER | |
|
|
|
|
CV_TERMCRIT_EPS, |
|
|
|
|
5000,0.0000001), |
|
|
|
|
CvANN_MLP_TrainParams::BACKPROP, |
|
|
|
|
0.1,0.1), |
|
|
|
|
0 |
|
|
|
|
+CvANN_MLP::UPDATE_WEIGHTS |
|
|
|
|
//+ CvANN_MLP::NO_OUTPUT_SCALE
|
|
|
|
|
); |
|
|
|
|
} |
|
|
|
|
std::cout << " * iteration :"<<iter2<<std::endl; |
|
|
|
|
train_model.save( "secondModel.xml"); |
|
|
|
|
|
|
|
|
|
train_model.predict( input, p_output ); |
|
|
|
|
for(int i=0; i<NV;i++){ |
|
|
|
|
std::cout<< CV_MAT_ELEM(*input,double,i,0) << " ," << CV_MAT_ELEM(*input,double,i,1) |
|
|
|
|
<< " : " << CV_MAT_ELEM(*p_output,double,i,0) <<std::endl; |
|
|
|
|
|
|
|
|
|
}*/ |
|
|
|
|
|
|
|
|
|
/*cv::Size imageSize;
|
|
|
|
|
int Nimg, Npts; |
|
|
|
|
vector<vector<cv::Point3f> > objectPoints; |
|
|
|
|
vector<vector<cv::Point2f> >imagePoints; |
|
|
|
|
cv::FileStorage f("/Users/vp/Downloads/calib_debug.2.yml",cv::FileStorage::READ); |
|
|
|
|
cv::FileNodeIterator it = f["img_sz"].begin(); it >> imageSize.width >> imageSize.height; |
|
|
|
|
Nimg = (int) f ["NofImages"]; |
|
|
|
|
Npts = (int) f["NofPoints"]; |
|
|
|
|
for (int i=0; i<Nimg;i++) { |
|
|
|
|
std::stringstream imagename; imagename << "image" << i; |
|
|
|
|
cv::FileNode img = f[imagename.str()]; |
|
|
|
|
vector <cv::Point3f> ov; |
|
|
|
|
vector <cv::Point2f> iv; |
|
|
|
|
for (int j=0; j<Npts; j++) { |
|
|
|
|
std::stringstream nodename; nodename << "node" << j; |
|
|
|
|
cv::FileNode pnt = img[nodename.str()]; |
|
|
|
|
cv::Point3f op; |
|
|
|
|
cv::Point2f ip; |
|
|
|
|
cv::FileNodeIterator ot = pnt["objPnt"].begin(); ot >> op.x >> op.y >> op.z; |
|
|
|
|
cv::FileNodeIterator it = pnt["imgPnt"].begin(); it >> ip.x >> ip.y; |
|
|
|
|
iv.push_back(ip); |
|
|
|
|
ov.push_back(op); |
|
|
|
|
} |
|
|
|
|
imagePoints.push_back(iv); |
|
|
|
|
objectPoints.push_back(ov); |
|
|
|
|
} |
|
|
|
|
cv::Mat M,D; |
|
|
|
|
vector<cv::Mat> R,T; |
|
|
|
|
cv::calibrateCamera(objectPoints, imagePoints, imageSize, M, D,R,T, |
|
|
|
|
CV_CALIB_FIX_ASPECT_RATIO + 1*CV_CALIB_FIX_K3 + 1*CV_CALIB_ZERO_TANGENT_DIST); |
|
|
|
|
cv::FileStorage fo("calib_output.yml",cv::FileStorage::WRITE); |
|
|
|
|
//fo << "M" << M;
|
|
|
|
|
cout << "M: " << M;*/ |
|
|
|
|
|
|
|
|
|
/*Mat img = imread("/Users/vp/Downloads/test5.tif", CV_LOAD_IMAGE_ANYDEPTH|CV_LOAD_IMAGE_COLOR), img16;
|
|
|
|
|
cout << "img.depth()=" << img.depth() << endl; |
|
|
|
|
if(img.depth() == CV_16U) |
|
|
|
|
img16 = img; |
|
|
|
|
else |
|
|
|
|
img.convertTo(img16, CV_16U, 256, 0); |
|
|
|
|
imshow("test", img16); |
|
|
|
|
imwrite("/Users/vp/tmp/test16_2.png", img16); |
|
|
|
|
waitKey();*/ |
|
|
|
|
|
|
|
|
|
/*Mat img(600,800,CV_8UC3);
|
|
|
|
|
img = Scalar::all(0); |
|
|
|
|
IplImage _img = img; |
|
|
|
|
|
|
|
|
|
CvFont font = cvFont(2,1); |
|
|
|
|
cvPutText(&_img, "Test", cvPoint(100, 100), &font, cvScalar(0,0,255)); |
|
|
|
|
|
|
|
|
|
imshow("test", img); |
|
|
|
|
waitKey();*/ |
|
|
|
|
|
|
|
|
|
/*IplImage* img = cvCreateImage(cvSize(800,600), 8, 3);
|
|
|
|
|
cvZero(img); |
|
|
|
|
CvFont font = cvFont(2,1); |
|
|
|
|
cvPutText(img, "Test", cvPoint(100, 100), &font, cvScalar(0,0,255));
|
|
|
|
|
cvNamedWindow("test", 1); |
|
|
|
|
cvShowImage("test", img); |
|
|
|
|
cvWaitKey(0);*/ |
|
|
|
|
/*int sz[] = {1, 5, 5};
|
|
|
|
|
CvMatND* src = cvCreateMatND(3, sz, CV_64F); |
|
|
|
|
CvMatND* dst = cvCreateMatND(3, sz, CV_64F); |
|
|
|
|
CvRNG rng = cvRNG(-1); |
|
|
|
|
cvRandArr(&rng, src, CV_RAND_UNI, cvScalarAll(-100), cvScalarAll(100)); |
|
|
|
|
cvAddS(src, cvScalar(100), dst, 0); |
|
|
|
|
cvSave("_input.xml", src); |
|
|
|
|
cvSave("_output.xml", dst);*/ |
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
/// random data generation :
|
|
|
|
|
Mat data(100,10,CV_32FC1); |
|
|
|
|
randn(data, 0.0, 1.0); |
|
|
|
|
/// Creating the ANN engine
|
|
|
|
|
AutotunedIndexParams autoParams(0.9,0.5,0.2,1); |
|
|
|
|
Index index(data,autoParams); |
|
|
|
|
/// Creating a query
|
|
|
|
|
SearchParams searchParams(5); |
|
|
|
|
vector<float> query, dist; |
|
|
|
|
vector<int> foundIndice; |
|
|
|
|
foundIndice.push_back(0); |
|
|
|
|
dist.push_back(0); |
|
|
|
|
for(int i = 0 ; i < 10 ; i++) |
|
|
|
|
{ |
|
|
|
|
query.push_back(data.at<float>(2,i)); |
|
|
|
|
} |
|
|
|
|
/// Do a reaserch : result must be equal to 2.
|
|
|
|
|
index.knnSearch(query, foundIndice, dist, 1, searchParams); |
|
|
|
|
cout << "Found indice (must be 2) : " << foundIndice[0] << endl; |
|
|
|
|
/// save params
|
|
|
|
|
index.save(string("test")); |
|
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
/*namedWindow("orig", CV_WINDOW_AUTOSIZE);
|
|
|
|
|
namedWindow("canny", CV_WINDOW_AUTOSIZE); |
|
|
|
|
namedWindow("hough", CV_WINDOW_AUTOSIZE); |
|
|
|
|
|
|
|
|
|
Mat orig = cv::imread("/Users/vp/Downloads/1.jpg", 0); |
|
|
|
|
//equalizeHist(orig, orig);
|
|
|
|
|
Mat hough; |
|
|
|
|
cvtColor(orig, hough, CV_GRAY2BGR); |
|
|
|
|
|
|
|
|
|
Mat canny; |
|
|
|
|
Canny(orig, canny, 100, 50); // reproduce Canny-Filtering as in Hough-Circles
|
|
|
|
|
|
|
|
|
|
int bestRad = 20; |
|
|
|
|
int minRad = bestRad / 1.3; |
|
|
|
|
int maxRad = bestRad * 1.3; |
|
|
|
|
|
|
|
|
|
vector<Vec3f> circles; // detect circles
|
|
|
|
|
HoughCircles(orig, circles, CV_HOUGH_GRADIENT, |
|
|
|
|
1, // accu-scaling
|
|
|
|
|
20, // minDist
|
|
|
|
|
100, // CannyParam
|
|
|
|
|
10, // minAccuCount
|
|
|
|
|
minRad, |
|
|
|
|
maxRad); |
|
|
|
|
// Draw Circles into image in gray
|
|
|
|
|
for( size_t i = 0; i < circles.size(); i++ ) |
|
|
|
|
{ |
|
|
|
|
Point center(cvRound(circles[i][0]), cvRound(circles[i][1])); |
|
|
|
|
int radius = cvRound(circles[i][2]); |
|
|
|
|
// draw the circle center
|
|
|
|
|
circle( hough, center, 3, Scalar(0,0,255), -1, 8, 0 ); |
|
|
|
|
// draw the circle outline
|
|
|
|
|
circle( hough, center, radius, Scalar(0,255,255), 1, 8, 0 ); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
// Draw reference circles
|
|
|
|
|
Point c(bestRad * 3, bestRad * 3); |
|
|
|
|
circle(hough, c, bestRad, 255); |
|
|
|
|
circle(hough, c, minRad, 255); |
|
|
|
|
circle(hough, c, maxRad, 255); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
cv::imshow("orig", orig); |
|
|
|
|
cv::imshow("canny", canny); |
|
|
|
|
cv::imshow("hough", hough); |
|
|
|
|
|
|
|
|
|
cv::waitKey();*/ |
|
|
|
|
|
|
|
|
|
/*int npoints = 4;
|
|
|
|
|
CvMat *OP = cvCreateMat(1, npoints, CV_32FC3); |
|
|
|
|
CvPoint3D32f *op = (CvPoint3D32f *)OP->data.fl; |
|
|
|
|
|
|
|
|
|
CvMat *OP2 = cvCreateMat(1, npoints, CV_32FC3); |
|
|
|
|
CvPoint3D32f *op2 = (CvPoint3D32f *)OP2->data.fl; |
|
|
|
|
|
|
|
|
|
CvMat *IP = cvCreateMat(1, npoints, CV_32FC2); |
|
|
|
|
CvPoint2D32f *ip = (CvPoint2D32f *)IP->data.fl; |
|
|
|
|
|
|
|
|
|
CvMat *IP2 = cvCreateMat(1, npoints, CV_32FC2); |
|
|
|
|
CvPoint2D32f *ip2 = (CvPoint2D32f *)IP2->data.fl; |
|
|
|
|
|
|
|
|
|
CvMat *IP0 = cvCreateMat(1, npoints, CV_32FC2); |
|
|
|
|
|
|
|
|
|
float rv[3], rv2[3]; |
|
|
|
|
float rotMat[9]; |
|
|
|
|
float t[3], t2[3]; |
|
|
|
|
float tRotMat[16]; |
|
|
|
|
|
|
|
|
|
double kMat[9]; |
|
|
|
|
|
|
|
|
|
CvMat K = cvMat(3, 3, CV_64F, kMat); |
|
|
|
|
CvMat T = cvMat(3, 1, CV_32F, t); |
|
|
|
|
CvMat RV = cvMat(3, 1, CV_32F, rv); |
|
|
|
|
CvMat T2 = cvMat(3, 1, CV_32F, t2); |
|
|
|
|
CvMat RV2 = cvMat(3, 1, CV_32F, rv2); |
|
|
|
|
CvMat R = cvMat(3, 3, CV_32F, rotMat); |
|
|
|
|
|
|
|
|
|
float r0, r1, r2; |
|
|
|
|
|
|
|
|
|
kMat[0] = 659.88; |
|
|
|
|
kMat[1] = 0.00;
|
|
|
|
|
kMat[2] = 320.40;
|
|
|
|
|
kMat[3] = 0.00;
|
|
|
|
|
kMat[4] = 657.53;
|
|
|
|
|
kMat[5] = 240.98;
|
|
|
|
|
kMat[6] = 0.00;
|
|
|
|
|
kMat[7] = 0.00; |
|
|
|
|
kMat[8] = 1.00; |
|
|
|
|
|
|
|
|
|
ip[0].x = 277.56; ip[0].y = 184.03;
|
|
|
|
|
ip[1].x = 329.00; ip[1].y = 199.04;
|
|
|
|
|
ip[2].x = 405.96; ip[2].y = 205.96;
|
|
|
|
|
ip[3].x = 364.00; ip[3].y = 187.97; |
|
|
|
|
|
|
|
|
|
op[0].x = -189.00; op[0].y = 171.00;
|
|
|
|
|
op[1].x = -280.00; op[1].y = 265.00;
|
|
|
|
|
op[2].x = -436.00; op[2].y = 316.00;
|
|
|
|
|
op[3].x = -376.00; op[3].y = 209.00; |
|
|
|
|
|
|
|
|
|
ip2[0].x = 277.56; ip2[0].y = 184.03;
|
|
|
|
|
ip2[1].x = 328.00; ip2[1].y = 199.11;
|
|
|
|
|
ip2[2].x = 405.89; ip2[2].y = 206.89;
|
|
|
|
|
ip2[3].x = 366.00; ip2[3].y = 187.93; |
|
|
|
|
|
|
|
|
|
op2[0].x = -194.00; op2[0].y = 168.00;
|
|
|
|
|
op2[1].x = -281.00; op2[1].y = 267.00;
|
|
|
|
|
op2[2].x = -433.00; op2[2].y = 321.00;
|
|
|
|
|
op2[3].x = -372.00; op2[3].y = 208.00; |
|
|
|
|
|
|
|
|
|
//ip[4].x = 405.89; ip[4].y = 206.89;
|
|
|
|
|
//op[4].x = -433.00; op[4].y = 321.00;
|
|
|
|
|
//ip2[4].x = 364.00; ip2[4].y = 187.97;
|
|
|
|
|
//op2[4].x = -376.00; op2[4].y = 209.00;
|
|
|
|
|
|
|
|
|
|
cvFindExtrinsicCameraParams2(OP, IP, &K,
|
|
|
|
|
NULL, //&D,
|
|
|
|
|
&RV, &T, 0); |
|
|
|
|
|
|
|
|
|
cvRodrigues2(&RV, &R, 0); |
|
|
|
|
|
|
|
|
|
printf("--first--\n"); |
|
|
|
|
print32FMat(R); |
|
|
|
|
|
|
|
|
|
cvFindExtrinsicCameraParams2(OP2, IP2, &K,
|
|
|
|
|
NULL, //&D,
|
|
|
|
|
&RV2, &T2, 0); |
|
|
|
|
|
|
|
|
|
cvRodrigues2(&RV2, &R, 0); |
|
|
|
|
printf("---second---\n"); |
|
|
|
|
print32FMat(R); |
|
|
|
|
|
|
|
|
|
double err; |
|
|
|
|
cvProjectPoints2(OP, &RV, &T, &K, NULL, IP0); |
|
|
|
|
err = cvNorm(IP, IP0, CV_L2); |
|
|
|
|
printf("\n\nfirst avg reprojection error = %g\n", sqrt(err*err/npoints)); |
|
|
|
|
|
|
|
|
|
cvProjectPoints2(OP2, &RV2, &T2, &K, NULL, IP0); |
|
|
|
|
err = cvNorm(IP2, IP0, CV_L2); |
|
|
|
|
printf("second avg reprojection error = %g\n", sqrt(err*err/npoints)); |
|
|
|
|
|
|
|
|
|
cvProjectPoints2(OP, &RV2, &T2, &K, NULL, IP0); |
|
|
|
|
err = cvNorm(IP, IP0, CV_L2); |
|
|
|
|
printf("\n\nsecond->first cross reprojection error = %g\n", sqrt(err*err/npoints)); |
|
|
|
|
|
|
|
|
|
cvProjectPoints2(OP2, &RV, &T, &K, NULL, IP0); |
|
|
|
|
err = cvNorm(IP2, IP0, CV_L2); |
|
|
|
|
printf("first->second cross reprojection error = %g\n", sqrt(err*err/npoints)); |
|
|
|
|
*/ |
|
|
|
|
/*Mat img = imread("/Users/vp/work/ocv/opencv/samples/c/baboon.jpg", 1);
|
|
|
|
|
vector<Point2f> corners; |
|
|
|
|
double t0 = 0, t; |
|
|
|
|
|
|
|
|
|
for( size_t i = 0; i < 50; i++ ) |
|
|
|
|
{ |
|
|
|
|
corners.clear(); |
|
|
|
|
t = (double)getTickCount(); |
|
|
|
|
goodFeaturesToTrack(img, corners, 1000, 0.01, 10); |
|
|
|
|
t = (double)getTickCount() - t; |
|
|
|
|
if( i == 0 || t0 > t ) |
|
|
|
|
t0 = t; |
|
|
|
|
} |
|
|
|
|
printf("minimum running time = %gms\n", t0*1000./getTickFrequency()); |
|
|
|
|
|
|
|
|
|
Mat imgc; |
|
|
|
|
cvtColor(img, imgc, CV_GRAY2BGR); |
|
|
|
|
|
|
|
|
|
for( size_t i = 0; i < corners.size(); i++ ) |
|
|
|
|
{ |
|
|
|
|
circle(imgc, corners[i], 3, Scalar(0,255,0), -1); |
|
|
|
|
} |
|
|
|
|
imshow("corners", imgc);*/ |
|
|
|
|
/*Mat imgf, imgf2, img2;
|
|
|
|
|
img.convertTo(imgf, CV_64F, 1./255); |
|
|
|
|
resize(imgf, imgf2, Size(), 0.7, 0.7, CV_INTER_LANCZOS4); |
|
|
|
|
imgf2.convertTo(img2, CV_8U, 255); |
|
|
|
|
imshow("test", img2); |
|
|
|
|
|
|
|
|
|
waitKey();*/ |
|
|
|
|
|
|
|
|
|
/*Mat src = imread("/Users/vp/work/ocv/opencv/samples/c/fruits.jpg", 1);
|
|
|
|
|
//if( argc != 2 || !(src=imread(argv[1], 1)).data )
|
|
|
|
|
// return -1;
|
|
|
|
|
|
|
|
|
|
Mat hsv; |
|
|
|
|
cvtColor(src, hsv, CV_BGR2HSV); |
|
|
|
|
|
|
|
|
|
// let's quantize the hue to 30 levels
|
|
|
|
|
// and the saturation to 32 levels
|
|
|
|
|
int hbins = 30, sbins = 32; |
|
|
|
|
int histSize[] = {hbins, sbins}; |
|
|
|
|
// hue varies from 0 to 179, see cvtColor
|
|
|
|
|
float hranges[] = { 0, 180 }; |
|
|
|
|
// saturation varies from 0 (black-gray-white) to
|
|
|
|
|
// 255 (pure spectrum color)
|
|
|
|
|
float sranges[] = { 0, 256 }; |
|
|
|
|
const float* ranges[] = { hranges, sranges }; |
|
|
|
|
MatND hist; |
|
|
|
|
// we compute the histogram from the 0-th and 1-st channels
|
|
|
|
|
int channels[] = {0, 1}; |
|
|
|
|
|
|
|
|
|
calcHist( &hsv, 1, channels, Mat(), // do not use mask
|
|
|
|
|
hist, 2, histSize, ranges, |
|
|
|
|
true, // the histogram is uniform
|
|
|
|
|
false ); |
|
|
|
|
double maxVal=0; |
|
|
|
|
minMaxLoc(hist, 0, &maxVal, 0, 0); |
|
|
|
|
|
|
|
|
|
int scale = 10; |
|
|
|
|
Mat histImg = Mat::zeros(sbins*scale, hbins*10, CV_8UC3); |
|
|
|
|
|
|
|
|
|
for( int h = 0; h < hbins; h++ ) |
|
|
|
|
for( int s = 0; s < sbins; s++ ) |
|
|
|
|
{ |
|
|
|
|
float binVal = hist.at<float>(h, s); |
|
|
|
|
int intensity = cvRound(binVal*255/maxVal); |
|
|
|
|
rectangle( histImg, Point(h*scale, s*scale), |
|
|
|
|
Point( (h+1)*scale - 1, (s+1)*scale - 1), |
|
|
|
|
Scalar::all(intensity), |
|
|
|
|
CV_FILLED ); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
namedWindow( "Source", 1 ); |
|
|
|
|
imshow( "Source", src ); |
|
|
|
|
|
|
|
|
|
namedWindow( "H-S Histogram", 1 ); |
|
|
|
|
imshow( "H-S Histogram", histImg ); |
|
|
|
|
waitKey();*/ |
|
|
|
|
|
|
|
|
|
/*Mat_<double> a(3, 3);
|
|
|
|
|
a << 1, 0, 0, 0, 1, 0, 0, 0, 1; |
|
|
|
|
Mat_<double> b(3, 1); |
|
|
|
|
b << 1, 2, 3; |
|
|
|
|
Mat c; |
|
|
|
|
hconcat(a, b, c); |
|
|
|
|
cout << c;*/ |
|
|
|
|
|
|
|
|
|
/*Mat img = imread("/Users/vp/work/ocv/opencv/samples/c/lena.jpg", 1), img2;
|
|
|
|
|
cv::imshow( "Original Image D", img ); |
|
|
|
|
|
|
|
|
|
if( img.channels()==3 ) |
|
|
|
|
{ |
|
|
|
|
Mat L,u,v; |
|
|
|
|
Mat luv; |
|
|
|
|
vector<Mat> splitted; |
|
|
|
|
Mat img_float0, img_float; |
|
|
|
|
|
|
|
|
|
img.convertTo( img_float0, CV_32F, 1./255, 0 ); |
|
|
|
|
cvtColor( img_float0, luv, CV_BGR2Luv); |
|
|
|
|
|
|
|
|
|
cv::split( luv, splitted ); |
|
|
|
|
|
|
|
|
|
L = (Mat)splitted[0]; |
|
|
|
|
u = (Mat)splitted[1]; |
|
|
|
|
v = (Mat)splitted[2];
|
|
|
|
|
|
|
|
|
|
vector<Mat> res; |
|
|
|
|
|
|
|
|
|
res.push_back( L ); |
|
|
|
|
res.push_back( u ); |
|
|
|
|
res.push_back( v ); |
|
|
|
|
|
|
|
|
|
cv::merge( res, luv ); |
|
|
|
|
|
|
|
|
|
cvtColor( luv, img_float, CV_Luv2BGR ); |
|
|
|
|
|
|
|
|
|
printf("diff = %g\n", cv::norm(img_float0, img_float, CV_C)); |
|
|
|
|
|
|
|
|
|
img_float.convertTo( img2, CV_8U, 255. ); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
cv::imshow( "After Darken", img2 ); |
|
|
|
|
cv::absdiff(img, img2, img2); |
|
|
|
|
img2 *= 255; |
|
|
|
|
cv::imshow("Magnified difference", img2); |
|
|
|
|
|
|
|
|
|
waitKey();*/ |
|
|
|
|
|
|
|
|
|
/*const char* imgFilename = "/Users/vp/Downloads/tsukuba.png";
|
|
|
|
|
|
|
|
|
|
Mat bgr = imread( imgFilename ); |
|
|
|
|
Mat gray = imread( imgFilename, 0 ), gray_; |
|
|
|
|
cvtColor( bgr, gray_, CV_BGR2GRAY ); |
|
|
|
|
|
|
|
|
|
int N = countNonZero( gray != gray_ ); |
|
|
|
|
printf( "Count non zero = %d / %d\n", N, gray.cols * gray.rows ); |
|
|
|
|
|
|
|
|
|
Mat diff = abs( gray-gray_ ); |
|
|
|
|
double maxVal = 0; |
|
|
|
|
minMaxLoc( diff, 0, &maxVal, 0, 0); |
|
|
|
|
printf( "Max abs diff = %f\n", maxVal);*/ |
|
|
|
|
/*Mat img = imread("/Users/vp/Downloads/r_forearm_cam_rect_crop.png", 1);
|
|
|
|
|
vector<Point2f> corners; |
|
|
|
|
Mat big; |
|
|
|
|
resize(img, big, Size(), 1, 1); |
|
|
|
|
bool found = findChessboardCorners(big, Size(5,4), corners); |
|
|
|
|
drawChessboardCorners(big, Size(5,4), Mat(corners), found); |
|
|
|
|
imshow("test", big); |
|
|
|
|
waitKey();*/ |
|
|
|
|
|
|
|
|
|
/*float x[] = {0, 1};
|
|
|
|
|
float y[] = {0, 1}; |
|
|
|
|
CvMat mx = cvMat(2, 1, CV_32F, x); |
|
|
|
|
CvMat my = cvMat(2, 1, CV_32F, y); |
|
|
|
|
CvNormalBayesClassifier b; |
|
|
|
|
bool s = b.train(&mx, &my, 0, 0, false);*/ |
|
|
|
|
|
|
|
|
|
/*float responseData[] = {1, 1, 1, 0, 0, 0};
|
|
|
|
|
float intdata[] = { 1, 0, 0, 1, |
|
|
|
|
1, 0, 1, 0, |
|
|
|
|
|
|
|
|
|
1, 1, 0, 0, |
|
|
|
|
|
|
|
|
|
0, 0, 0, 1, |
|
|
|
|
|
|
|
|
|
0, 0, 1, 0, |
|
|
|
|
|
|
|
|
|
0, 1, 0, 0}; |
|
|
|
|
|
|
|
|
|
CvMat data = cvMat(6, 4, CV_32FC1, intdata); |
|
|
|
|
|
|
|
|
|
CvMat responses = cvMat(6, 1, CV_32FC1, responseData); |
|
|
|
|
|
|
|
|
|
CvNormalBayesClassifier bc; |
|
|
|
|
|
|
|
|
|
bool succ = bc.train(&data, &responses, 0, 0, false); |
|
|
|
|
float testData[] = {1.0, 1, 0, 0}; |
|
|
|
|
float dummy[] = {0}; |
|
|
|
|
CvMat test = cvMat(1, 4, CV_32FC1, testData); |
|
|
|
|
|
|
|
|
|
CvMat testResults = cvMat(1, 6, CV_32FC1, 0); |
|
|
|
|
|
|
|
|
|
float whatsthis = bc.predict(&test, &testResults);*/ |
|
|
|
|
|
|
|
|
|
int sz[] = {10, 20, 30}; |
|
|
|
|
Mat m(3, sz, CV_32F); |
|
|
|
|
randu(m, Scalar::all(-10), Scalar::all(10)); |
|
|
|
|
double maxVal0, maxVal = -FLT_MAX; |
|
|
|
|
minMaxIdx(m, 0, &maxVal0, 0, 0); |
|
|
|
|
|
|
|
|
|
MatConstIterator_<float> it = m.begin<float>(), it_end = m.end<float>(); |
|
|
|
|
|
|
|
|
|
for( ; it != it_end; ++it ) |
|
|
|
|
{ |
|
|
|
|
if( maxVal < *it ) |
|
|
|
|
maxVal = *it; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
printf("maxval(minmaxloc) = %g, maxval(iterator) = %g\n", maxVal0, maxVal); |
|
|
|
|
return 0; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
#endif |
|
|
|
|
|
Vadim Pisarevsky
14 years ago