WebSVN – seema-scanner – Diff – /src/SMReconstructionWorker.cpp


#include "SMReconstructionWorker.h"
 
#include "AlgorithmGrayCode.h"
#include "AlgorithmGrayCodeHorzVert.h"
#include "AlgorithmPhaseShiftTwoFreq.h"
#include "AlgorithmPhaseShiftTwoFreqHorzVert.h"
#include "AlgorithmPhaseShiftThreeFreq.h"
#include "AlgorithmPhaseShiftEmbedded.h"
#include "AlgorithmLineShift.h"
 
#include <QCoreApplication>
#include <QSettings>
 
#include <iostream>
#include <opencv2/opencv.hpp>
 
#include "cvtools.h"
#include <opencv2/core/eigen.hpp>
 
#include <pcl/filters/statistical_outlier_removal.h>
#include <pcl/io/pcd_io.h>
#include <pcl/features/normal_3d.h>
#include <pcl/features/normal_3d_omp.h>
#include <pcl/common/transforms.h>
 
 
void SMReconstructionWorker::reconstructPointCloud(const SMFrameSequence &frameSequence){
 
    QSettings settings;
 
    // Get current calibration
    calibration = settings.value("calibration/parameters").value<SMCalibrationParameters>();
 
    // Create Algorithm
    QString codec = frameSequence.codec;
    unsigned int resX = settings.value("projector/resX").toInt();
    unsigned int resY = settings.value("projector/resY").toInt();
 
    if(codec == "GrayCode")
        algorithm = new AlgorithmGrayCode(resX, resY);
    else if(codec == "GrayCodeHorzVert")
        algorithm = new AlgorithmGrayCodeHorzVert(resX, resY);
    else if(codec == "PhaseShiftTwoFreq")
        algorithm = new AlgorithmPhaseShiftTwoFreq(resX, resY);
    else if(codec == "PhaseShiftTwoFreqHorzVert")
        algorithm = new AlgorithmPhaseShiftTwoFreqHorzVert(resX, resY);
    else if(codec == "PhaseShiftThreeFreq")
        algorithm = new AlgorithmPhaseShiftThreeFreq(resX, resY);
    else if(codec == "PhaseShiftEmbedded")
        algorithm = new AlgorithmPhaseShiftEmbedded(resX, resY);
    else if(codec == "LineShift")
        algorithm = new AlgorithmLineShift(resX, resY);
    else{
        std::cerr << "SLScanWorker: invalid codec (Please set codec in preferences): " << codec.toStdString() << std::endl;
        return; // otherwise segfault TODO no default?
    }
 
    assert(frameSequence.frames0.size() == algorithm->getNPatterns());
    assert(frameSequence.frames1.size() == algorithm->getNPatterns());
 
    // Print OpenCV build information
    cv::setUseOptimized(true);
    std::cout << cv::getBuildInformation();
 
    time.start();
 
    // Get 3D Points
    std::vector<cv::Point3f> Q;
    std::vector<cv::Vec3b> color;
    algorithm->get3DPoints(calibration, frameSequence.frames0, frameSequence.frames1, Q, color);
 
    // Convert point cloud to PCL format
    pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr pointCloudPCL(new pcl::PointCloud<pcl::PointXYZRGBNormal>);
 
    pointCloudPCL->width = Q.size();
    pointCloudPCL->height = 1;
    pointCloudPCL->is_dense = true;
 
    pointCloudPCL->points.resize(Q.size());
 
    for(unsigned int i=0; i<Q.size(); i++){
        pcl::PointXYZRGBNormal point;
        point.x = Q[i].x; point.y = Q[i].y; point.z = Q[i].z;
        point.r = color[i][0]; point.g = color[i][1]; point.b = color[i][2];
        pointCloudPCL->points[i] = point;
    }
 
    // Transform point cloud to rotation axis coordinate system
    /*cv::Mat TRCV(3, 4, CV_32F);
    cv::Mat(calibration.Rr).copyTo(TRCV.colRange(0, 3));
    cv::Mat(calibration.Tr).copyTo(TRCV.col(3));
    Eigen::Affine3f TR;
    cv::cv2eigen(TRCV, TR.matrix());
    pcl::transformPointCloud(*pointCloudPCL, *pointCloudPCL, TR);
 
    // Estimate surface normals (does not produce proper normals...)
    std::cout << "Estimating normals..." << std::endl;
    pcl::PointCloud<pcl::PointXYZ>::Ptr points(new pcl::PointCloud<pcl::PointXYZ>);
    pcl::copyPointCloud(*pointCloudPCL, *points);
    pcl::PointCloud<pcl::Normal>::Ptr normals(new pcl::PointCloud<pcl::Normal>);
    pcl::NormalEstimationOMP<pcl::PointXYZ, pcl::Normal> ne;
    pcl::search::KdTree<pcl::PointXYZ>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZ>());
    tree->setInputCloud(points);
    ne.setSearchMethod(tree);
    ne.setRadiusSearch(1.0);
    //ne.setKSearch(50);
    ne.setViewPoint(0.0, 0.0, 0.0);
    ne.setInputCloud(points);
    ne.compute(*normals);
    pcl::copyPointCloud(*normals, *pointCloudPCL);*/
 
    // Assemble SMPointCloud data structure
    SMPointCloud smPointCloud;
    smPointCloud.id = frameSequence.id;
    smPointCloud.pointCloud = pointCloudPCL;
    smPointCloud.rotationAngle = frameSequence.rotationAngle;
 
    // Determine transform in world (camera0) coordinate system
    float angleRadians = frameSequence.rotationAngle/180.0*M_PI;
    cv::Vec3f rot_rvec(0.0, -angleRadians, 0.0);
    cv::Mat R;
    cv::Rodrigues(rot_rvec, R);
    smPointCloud.R = calibration.Rr.t()*cv::Matx33f(R)*calibration.Rr;
    smPointCloud.T = calibration.Rr.t()*cv::Matx33f(R)*calibration.Tr - calibration.Rr.t()*calibration.Tr;
 
 
    // Determine transform in world (camera0) coordinate system
    /*float angleRadians = frameSequence.rotationAngle/180.0*M_PI;
    cv::Vec3f rot_rvec(0.0, -angleRadians, 0.0);
    cv::Mat R;
    cv::Rodrigues(rot_rvec, R);
    smPointCloud.R = cv::Matx33f(R);
    smPointCloud.T = cv::Vec3f(0.0,0.0,0.0);*/
 
    // Emit result
    emit newPointCloud(smPointCloud);
    std::cout << "SMReconstructionWorker: " << time.elapsed() << "ms" << std::endl;
    std::cout << "SMReconstructionWorker: " << smPointCloud.pointCloud->size() << " Points" << std::endl;
 
}
 
void SMReconstructionWorker::reconstructPointClouds(const std::vector<SMFrameSequence> &frameSequences){
 
    // Process sequentially
    #pragma omp parallel for
    for(unsigned int i=0; i<frameSequences.size(); i++){
        if(!frameSequences[i].reconstructed) reconstructPointCloud(frameSequences[i]);
    }
}
 
void SMReconstructionWorker::triangulate(const std::vector<cv::Point2f>& q0, const std::vector<cv::Point2f>& q1, std::vector<cv::Point3f> &Q){
    cv::Mat P0(3,4,CV_32F,cv::Scalar(0.0));
    cv::Mat(calibration.K0).copyTo(P0(cv::Range(0,3), cv::Range(0,3)));
 
    cv::Mat temp(3,4,CV_32F);
    cv::Mat(calibration.R1).copyTo(temp(cv::Range(0,3), cv::Range(0,3)));
    cv::Mat(calibration.T1).copyTo(temp(cv::Range(0,3), cv::Range(3,4)));
    cv::Mat P1 = cv::Mat(calibration.K1) * temp;
 
    cv::Mat QMatHomogenous, QMat;
    cv::triangulatePoints(P0, P1, q0, q1, QMatHomogenous);
    cvtools::convertMatFromHomogeneous(QMatHomogenous, QMat);
    cvtools::matToPoints3f(QMat, Q);
}
 

Subversion Repositories seema-scanner

(root)/src/SMReconstructionWorker.cpp – Rev 231 → 236

Rev 231		Rev 236
1	`#include "SMReconstructionWorker.h"`	1	`#include "SMReconstructionWorker.h"`
2		2
3	`#include "AlgorithmGrayCode.h"`	3	`#include "AlgorithmGrayCode.h"`
4	`#include "AlgorithmGrayCodeHorzVert.h"`	4	`#include "AlgorithmGrayCodeHorzVert.h"`
5	`#include "AlgorithmPhaseShiftTwoFreq.h"`	5	`#include "AlgorithmPhaseShiftTwoFreq.h"`
6	`#include "AlgorithmPhaseShiftTwoFreqHorzVert.h"`	6	`#include "AlgorithmPhaseShiftTwoFreqHorzVert.h"`
7	`#include "AlgorithmPhaseShiftThreeFreq.h"`	7	`#include "AlgorithmPhaseShiftThreeFreq.h"`
8	`#include "AlgorithmPhaseShiftEmbedded.h"`	8	`#include "AlgorithmPhaseShiftEmbedded.h"`
9	`#include "AlgorithmLineShift.h"`	9	`#include "AlgorithmLineShift.h"`
10		10
11	`#include <QCoreApplication>`	11	`#include <QCoreApplication>`
12	`#include <QSettings>`	12	`#include <QSettings>`
13		13
14	`#include <iostream>`	14	`#include <iostream>`
15	`#include <opencv2/opencv.hpp>`	15	`#include <opencv2/opencv.hpp>`
16		16
17	`#include "cvtools.h"`	17	`#include "cvtools.h"`
18	`#include <opencv2/core/eigen.hpp>`	18	`#include <opencv2/core/eigen.hpp>`
19		19
20	`#include <pcl/filters/statistical_outlier_removal.h>`	20	`#include <pcl/filters/statistical_outlier_removal.h>`
21	`#include <pcl/io/pcd_io.h>`	21	`#include <pcl/io/pcd_io.h>`
22	`#include <pcl/features/normal_3d.h>`	22	`#include <pcl/features/normal_3d.h>`
23	`#include <pcl/features/normal_3d_omp.h>`	23	`#include <pcl/features/normal_3d_omp.h>`
24	`#include <pcl/common/transforms.h>`	24	`#include <pcl/common/transforms.h>`
25		25
26		26
27	`void SMReconstructionWorker::reconstructPointCloud(const SMFrameSequence &frameSequence){`	27	`void SMReconstructionWorker::reconstructPointCloud(const SMFrameSequence &frameSequence){`
28		28
29	`QSettings settings;`	29	`QSettings settings;`
30		30
31	`// Get current calibration`	31	`// Get current calibration`
32	`calibration = settings.value("calibration/parameters").value<SMCalibrationParameters>();`	32	`calibration = settings.value("calibration/parameters").value<SMCalibrationParameters>();`
33		33
34	`// Create Algorithm`	34	`// Create Algorithm`
35	`QString codec = frameSequence.codec;`	35	`QString codec = frameSequence.codec;`
36	`unsigned int resX = settings.value("projector/resX").toInt();`	36	`unsigned int resX = settings.value("projector/resX").toInt();`
37	`unsigned int resY = settings.value("projector/resY").toInt();`	37	`unsigned int resY = settings.value("projector/resY").toInt();`
38		38
39	`if(codec == "GrayCode")`	39	`if(codec == "GrayCode")`
40	`algorithm = new AlgorithmGrayCode(resX, resY);`	40	`algorithm = new AlgorithmGrayCode(resX, resY);`
41	`else if(codec == "GrayCodeHorzVert")`	41	`else if(codec == "GrayCodeHorzVert")`
42	`algorithm = new AlgorithmGrayCodeHorzVert(resX, resY);`	42	`algorithm = new AlgorithmGrayCodeHorzVert(resX, resY);`
43	`else if(codec == "PhaseShiftTwoFreq")`	43	`else if(codec == "PhaseShiftTwoFreq")`
44	`algorithm = new AlgorithmPhaseShiftTwoFreq(resX, resY);`	44	`algorithm = new AlgorithmPhaseShiftTwoFreq(resX, resY);`
45	`else if(codec == "PhaseShiftTwoFreqHorzVert")`	45	`else if(codec == "PhaseShiftTwoFreqHorzVert")`
46	`algorithm = new AlgorithmPhaseShiftTwoFreqHorzVert(resX, resY);`	46	`algorithm = new AlgorithmPhaseShiftTwoFreqHorzVert(resX, resY);`
47	`else if(codec == "PhaseShiftThreeFreq")`	47	`else if(codec == "PhaseShiftThreeFreq")`
48	`algorithm = new AlgorithmPhaseShiftThreeFreq(resX, resY);`	48	`algorithm = new AlgorithmPhaseShiftThreeFreq(resX, resY);`
49	`else if(codec == "PhaseShiftEmbedded")`	49	`else if(codec == "PhaseShiftEmbedded")`
50	`algorithm = new AlgorithmPhaseShiftEmbedded(resX, resY);`	50	`algorithm = new AlgorithmPhaseShiftEmbedded(resX, resY);`
51	`else if(codec == "LineShift")`	51	`else if(codec == "LineShift")`
52	`algorithm = new AlgorithmLineShift(resX, resY);`	52	`algorithm = new AlgorithmLineShift(resX, resY);`
53	`else{`	53	`else{`
54	`std::cerr << "SLScanWorker: invalid codec (Please set codec in preferences): " << codec.toStdString() << std::endl;`	54	`std::cerr << "SLScanWorker: invalid codec (Please set codec in preferences): " << codec.toStdString() << std::endl;`
55	`return; // otherwise segfault TODO no default?`	55	`return; // otherwise segfault TODO no default?`
56	`}`	56	`}`
57		57
58	`assert(frameSequence.frames0.size() == algorithm->getNPatterns());`	58	`assert(frameSequence.frames0.size() == algorithm->getNPatterns());`
59	`assert(frameSequence.frames1.size() == algorithm->getNPatterns());`	59	`assert(frameSequence.frames1.size() == algorithm->getNPatterns());`
60		60
61	`// Print OpenCV build information`	61	`// Print OpenCV build information`
62	`cv::setUseOptimized(true);`	62	`cv::setUseOptimized(true);`
63	`//std::cout << cv::getBuildInformation();`	63	`std::cout << cv::getBuildInformation();`
64		64
65	`time.start();`	65	`time.start();`
66		66
67	`// Get 3D Points`	67	`// Get 3D Points`
68	`std::vector<cv::Point3f> Q;`	68	`std::vector<cv::Point3f> Q;`
69	`std::vector<cv::Vec3b> color;`	69	`std::vector<cv::Vec3b> color;`
70	`algorithm->get3DPoints(calibration, frameSequence.frames0, frameSequence.frames1, Q, color);`	70	`algorithm->get3DPoints(calibration, frameSequence.frames0, frameSequence.frames1, Q, color);`
71		71
72	`// Convert point cloud to PCL format`	72	`// Convert point cloud to PCL format`
73	`pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr pointCloudPCL(new pcl::PointCloud<pcl::PointXYZRGBNormal>);`	73	`pcl::PointCloud<pcl::PointXYZRGBNormal>::Ptr pointCloudPCL(new pcl::PointCloud<pcl::PointXYZRGBNormal>);`
74		74
75	`pointCloudPCL->width = Q.size();`	75	`pointCloudPCL->width = Q.size();`
76	`pointCloudPCL->height = 1;`	76	`pointCloudPCL->height = 1;`
77	`pointCloudPCL->is_dense = true;`	77	`pointCloudPCL->is_dense = true;`
78		78
79	`pointCloudPCL->points.resize(Q.size());`	79	`pointCloudPCL->points.resize(Q.size());`
80		80
81	`for(unsigned int i=0; i<Q.size(); i++){`	81	`for(unsigned int i=0; i<Q.size(); i++){`
82	`pcl::PointXYZRGBNormal point;`	82	`pcl::PointXYZRGBNormal point;`
83	`point.x = Q[i].x; point.y = Q[i].y; point.z = Q[i].z;`	83	`point.x = Q[i].x; point.y = Q[i].y; point.z = Q[i].z;`
84	`point.r = color[i][0]; point.g = color[i][1]; point.b = color[i][2];`	84	`point.r = color[i][0]; point.g = color[i][1]; point.b = color[i][2];`
85	`pointCloudPCL->points[i] = point;`	85	`pointCloudPCL->points[i] = point;`
86	`}`	86	`}`
87		87
88	`// Transform point cloud to rotation axis coordinate system`	88	`// Transform point cloud to rotation axis coordinate system`
89	`/*cv::Mat TRCV(3, 4, CV_32F);`	89	`/*cv::Mat TRCV(3, 4, CV_32F);`
90	`cv::Mat(calibration.Rr).copyTo(TRCV.colRange(0, 3));`	90	`cv::Mat(calibration.Rr).copyTo(TRCV.colRange(0, 3));`
91	`cv::Mat(calibration.Tr).copyTo(TRCV.col(3));`	91	`cv::Mat(calibration.Tr).copyTo(TRCV.col(3));`
92	`Eigen::Affine3f TR;`	92	`Eigen::Affine3f TR;`
93	`cv::cv2eigen(TRCV, TR.matrix());`	93	`cv::cv2eigen(TRCV, TR.matrix());`
94	`pcl::transformPointCloud(pointCloudPCL, pointCloudPCL, TR);`	94	`pcl::transformPointCloud(pointCloudPCL, pointCloudPCL, TR);`
95		95
96	`// Estimate surface normals (does not produce proper normals...)`	96	`// Estimate surface normals (does not produce proper normals...)`
97	`std::cout << "Estimating normals..." << std::endl;`	97	`std::cout << "Estimating normals..." << std::endl;`
98	`pcl::PointCloud<pcl::PointXYZ>::Ptr points(new pcl::PointCloud<pcl::PointXYZ>);`	98	`pcl::PointCloud<pcl::PointXYZ>::Ptr points(new pcl::PointCloud<pcl::PointXYZ>);`
99	`pcl::copyPointCloud(pointCloudPCL, points);`	99	`pcl::copyPointCloud(pointCloudPCL, points);`
100	`pcl::PointCloud<pcl::Normal>::Ptr normals(new pcl::PointCloud<pcl::Normal>);`	100	`pcl::PointCloud<pcl::Normal>::Ptr normals(new pcl::PointCloud<pcl::Normal>);`
101	`pcl::NormalEstimationOMP<pcl::PointXYZ, pcl::Normal> ne;`	101	`pcl::NormalEstimationOMP<pcl::PointXYZ, pcl::Normal> ne;`
102	`pcl::search::KdTree<pcl::PointXYZ>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZ>());`	102	`pcl::search::KdTree<pcl::PointXYZ>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZ>());`
103	`tree->setInputCloud(points);`	103	`tree->setInputCloud(points);`
104	`ne.setSearchMethod(tree);`	104	`ne.setSearchMethod(tree);`
105	`ne.setRadiusSearch(1.0);`	105	`ne.setRadiusSearch(1.0);`
106	`//ne.setKSearch(50);`	106	`//ne.setKSearch(50);`
107	`ne.setViewPoint(0.0, 0.0, 0.0);`	107	`ne.setViewPoint(0.0, 0.0, 0.0);`
108	`ne.setInputCloud(points);`	108	`ne.setInputCloud(points);`
109	`ne.compute(*normals);`	109	`ne.compute(*normals);`
110	`pcl::copyPointCloud(normals, pointCloudPCL);*/`	110	`pcl::copyPointCloud(normals, pointCloudPCL);*/`
111		111
112	`// Assemble SMPointCloud data structure`	112	`// Assemble SMPointCloud data structure`
113	`SMPointCloud smPointCloud;`	113	`SMPointCloud smPointCloud;`
114	`smPointCloud.id = frameSequence.id;`	114	`smPointCloud.id = frameSequence.id;`
115	`smPointCloud.pointCloud = pointCloudPCL;`	115	`smPointCloud.pointCloud = pointCloudPCL;`
116	`smPointCloud.rotationAngle = frameSequence.rotationAngle;`	116	`smPointCloud.rotationAngle = frameSequence.rotationAngle;`
117		117
118	`// Determine transform in world (camera0) coordinate system`	118	`// Determine transform in world (camera0) coordinate system`
119	`float angleRadians = frameSequence.rotationAngle/180.0*M_PI;`	119	`float angleRadians = frameSequence.rotationAngle/180.0*M_PI;`
120	`cv::Vec3f rot_rvec(0.0, -angleRadians, 0.0);`	120	`cv::Vec3f rot_rvec(0.0, -angleRadians, 0.0);`
121	`cv::Mat R;`	121	`cv::Mat R;`
122	`cv::Rodrigues(rot_rvec, R);`	122	`cv::Rodrigues(rot_rvec, R);`
123	`smPointCloud.R = calibration.Rr.t()cv::Matx33f(R)calibration.Rr;`	123	`smPointCloud.R = calibration.Rr.t()cv::Matx33f(R)calibration.Rr;`
124	`smPointCloud.T = calibration.Rr.t()cv::Matx33f(R)calibration.Tr - calibration.Rr.t()*calibration.Tr;`	124	`smPointCloud.T = calibration.Rr.t()cv::Matx33f(R)calibration.Tr - calibration.Rr.t()*calibration.Tr;`
125		125
126		126
127	`// Determine transform in world (camera0) coordinate system`	127	`// Determine transform in world (camera0) coordinate system`
128	`/float angleRadians = frameSequence.rotationAngle/180.0M_PI;`	128	`/float angleRadians = frameSequence.rotationAngle/180.0M_PI;`
129	`cv::Vec3f rot_rvec(0.0, -angleRadians, 0.0);`	129	`cv::Vec3f rot_rvec(0.0, -angleRadians, 0.0);`
130	`cv::Mat R;`	130	`cv::Mat R;`
131	`cv::Rodrigues(rot_rvec, R);`	131	`cv::Rodrigues(rot_rvec, R);`
132	`smPointCloud.R = cv::Matx33f(R);`	132	`smPointCloud.R = cv::Matx33f(R);`
133	`smPointCloud.T = cv::Vec3f(0.0,0.0,0.0);*/`	133	`smPointCloud.T = cv::Vec3f(0.0,0.0,0.0);*/`
134		134
135	`// Emit result`	135	`// Emit result`
136	`emit newPointCloud(smPointCloud);`	136	`emit newPointCloud(smPointCloud);`
137	`std::cout << "SMReconstructionWorker: " << time.elapsed() << "ms" << std::endl;`	137	`std::cout << "SMReconstructionWorker: " << time.elapsed() << "ms" << std::endl;`
138	`std::cout << "SMReconstructionWorker: " << smPointCloud.pointCloud->size() << " Points" << std::endl;`	138	`std::cout << "SMReconstructionWorker: " << smPointCloud.pointCloud->size() << " Points" << std::endl;`
139		139
140	`}`	140	`}`
141		141
142	`void SMReconstructionWorker::reconstructPointClouds(const std::vector<SMFrameSequence> &frameSequences){`	142	`void SMReconstructionWorker::reconstructPointClouds(const std::vector<SMFrameSequence> &frameSequences){`
143		143
144	`// Process sequentially`	144	`// Process sequentially`
145	`#pragma omp parallel for`	145	`#pragma omp parallel for`
146	`for(unsigned int i=0; i<frameSequences.size(); i++){`	146	`for(unsigned int i=0; i<frameSequences.size(); i++){`
147	`if(!frameSequences[i].reconstructed) reconstructPointCloud(frameSequences[i]);`	147	`if(!frameSequences[i].reconstructed) reconstructPointCloud(frameSequences[i]);`
148	`}`	148	`}`
149	`}`	149	`}`
150		150
151	`void SMReconstructionWorker::triangulate(const std::vector<cv::Point2f>& q0, const std::vector<cv::Point2f>& q1, std::vector<cv::Point3f> &Q){`	151	`void SMReconstructionWorker::triangulate(const std::vector<cv::Point2f>& q0, const std::vector<cv::Point2f>& q1, std::vector<cv::Point3f> &Q){`
152	`cv::Mat P0(3,4,CV_32F,cv::Scalar(0.0));`	152	`cv::Mat P0(3,4,CV_32F,cv::Scalar(0.0));`
153	`cv::Mat(calibration.K0).copyTo(P0(cv::Range(0,3), cv::Range(0,3)));`	153	`cv::Mat(calibration.K0).copyTo(P0(cv::Range(0,3), cv::Range(0,3)));`
154		154
155	`cv::Mat temp(3,4,CV_32F);`	155	`cv::Mat temp(3,4,CV_32F);`
156	`cv::Mat(calibration.R1).copyTo(temp(cv::Range(0,3), cv::Range(0,3)));`	156	`cv::Mat(calibration.R1).copyTo(temp(cv::Range(0,3), cv::Range(0,3)));`
157	`cv::Mat(calibration.T1).copyTo(temp(cv::Range(0,3), cv::Range(3,4)));`	157	`cv::Mat(calibration.T1).copyTo(temp(cv::Range(0,3), cv::Range(3,4)));`
158	`cv::Mat P1 = cv::Mat(calibration.K1) * temp;`	158	`cv::Mat P1 = cv::Mat(calibration.K1) * temp;`
159		159
160	`cv::Mat QMatHomogenous, QMat;`	160	`cv::Mat QMatHomogenous, QMat;`
161	`cv::triangulatePoints(P0, P1, q0, q1, QMatHomogenous);`	161	`cv::triangulatePoints(P0, P1, q0, q1, QMatHomogenous);`
162	`cvtools::convertMatFromHomogeneous(QMatHomogenous, QMat);`	162	`cvtools::convertMatFromHomogeneous(QMatHomogenous, QMat);`
163	`cvtools::matToPoints3f(QMat, Q);`	163	`cvtools::matToPoints3f(QMat, Q);`
164	`}`	164	`}`
165		165