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


#include "SMPointCloudWidget.h"
 
#include <opencv2/opencv.hpp>
#include <opencv2/core/eigen.hpp>
 
#include <vtkWindowToImageFilter.h>
#include <vtkPNGWriter.h>
#include <vtkRenderWindow.h>
 
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>
#include <pcl/common/io.h>
#include <pcl/visualization/point_cloud_color_handlers.h>
#include <pcl/geometry/quad_mesh.h>
 
#include <pcl/io/pcd_io.h>
#include <pcl/io/ascii_io.h>
#include <pcl/io/ply_io.h>
#include <pcl/io/png_io.h>
#include <pcl/io/vtk_io.h>
#include <vtkPolyDataWriter.h>
#include <pcl/conversions.h>
 
#include <fstream>
 
 
#include <QFileDialog>
#include <QSettings>
 
#include "SMCalibrationParameters.h"
 
SMPointCloudWidget::SMPointCloudWidget(QWidget *parent) : QVTKWidget(parent) {
 
    visualizer = new pcl::visualization::PCLVisualizer("PCLVisualizer", false);
    this->SetRenderWindow(visualizer->getRenderWindow());
 
    visualizer->setShowFPS(false);
 
    // Create point cloud viewport
    visualizer->setBackgroundColor(0, 0, 0);
    visualizer->addCoordinateSystem(100, 0);
#ifndef __APPLE__
    // this leads to a segfault on OS X
    visualizer->setCameraPosition(0,0,-50,0,0,0,0,-1,0);
#endif
 
    // Initialize point cloud color handler
    colorHandler = new pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB>();
 
    updateCalibrationParameters();
    //time.start();
}
 
void SMPointCloudWidget::addPointCloud(PointCloudPtr _pointCloudPCL, int id){
 
 
 
    pointCloudPCL = _pointCloudPCL;
 
    // Note: using the color handler makes a copy of the rgb fields
    colorHandler->setInputCloud(_pointCloudPCL);
 
    visualizer->addPointCloud(pointCloudPCL, *colorHandler, QString::number(id).toStdString());
    visualizer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2.0, QString::number(id).toStdString());
 
    this->update();
    emit newPointCloudDisplayed();
 
 
}
 
void SMPointCloudWidget::updatePointCloud(PointCloudPtr _pointCloudPCL, int id){
 
 
 
    pointCloudPCL = _pointCloudPCL;
 
    // Note: using the color handler makes a copy of the rgb fields
    colorHandler->setInputCloud(_pointCloudPCL);
 
    if(!visualizer->updatePointCloud(pointCloudPCL, *colorHandler, QString::number(id).toStdString())){
        visualizer->addPointCloud(pointCloudPCL, *colorHandler, QString::number(id).toStdString());
        visualizer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2.0, QString::number(id).toStdString());
     }
 
    this->update();
    emit newPointCloudDisplayed();
 
 
}
 
void SMPointCloudWidget::savePointCloud(){
 
    QString selectedFilter;
    QString fileName = QFileDialog::getSaveFileName(this, "Save Point Cloud", QString(), "*.pcd;;*.ply;;*.vtk;;*.png;;*.txt", &selectedFilter);
    QFileInfo info(fileName);
    QString type = info.suffix();
    if(type == ""){
        fileName.append(selectedFilter.remove(0,1));
        type = selectedFilter.remove(0,1);
    }
 
    if(type == "pcd"){
        pcl::io::savePCDFileASCII(fileName.toStdString(), *pointCloudPCL);
    } else if(type == "ply"){
        //pcl::io::savePLYFileBinary(fileName.toStdString(), *pointCloudPCL);
        pcl::PLYWriter w;
        // Write to ply in binary without camera
        w.write<pcl::PointXYZRGB> (fileName.toStdString(), *pointCloudPCL, true, false);
    } else if(type == "vtk"){
        pcl::PCLPointCloud2 pointCloud2;
        pcl::toPCLPointCloud2(*pointCloudPCL, pointCloud2);
        pcl::io::saveVTKFile(fileName.toStdString(), pointCloud2);
 
//        vtkPolyData polyData;
//        pcl::io::pointCloudTovtkPolyData(*pointCloudPCL, polyData);
//        vtkPolyDataWriter::Pointer writer = vtkPolyDataWriter::New();
//        writer->SetInput(polyData);
//        writer->SetFileName(fileName.toStdString());
//        writer->Update();
    } else if(type == "png"){
        pcl::io::savePNGFile(fileName.toStdString(), *pointCloudPCL, "rgb");
    } else if(type == "txt"){
        std::ofstream s(fileName.toLocal8Bit());
        for(unsigned int r=0; r<pointCloudPCL->height; r++){
            for(unsigned int c=0; c<pointCloudPCL->width; c++){
                pcl::PointXYZRGB p = pointCloudPCL->at(c, r);
                if(p.x == p.x)
                    s << p.x << " " << p.y << " " << p.z << "\r\n";
            }
        }
        std::flush(s);
        s.close();
    }
 
}
 
void SMPointCloudWidget::saveScreenShot(){
 
    vtkWindowToImageFilter* filter = vtkWindowToImageFilter::New();
    //filter->SetInput(visualizer->getRenderWindow());
    filter->Modified();
 
    QString fileName = QFileDialog::getSaveFileName(this, "Save Screen Shot", QString(), "*.png");
    QFileInfo info(fileName);
    QString type = info.suffix();
    if(type == "")
        fileName.append(".png");
 
    vtkPNGWriter* writer = vtkPNGWriter::New();
    writer->SetInput(filter->GetOutput());
    writer->SetFileName(qPrintable(fileName));
    writer->Write();
    writer->Delete();
}
 
void SMPointCloudWidget::updateCalibrationParameters(){
 
    QSettings settings;
    SMCalibrationParameters calibration = settings.value("calibration/parameters").value<SMCalibrationParameters>();
 
    // camera 0 coordinate system
    visualizer->removeCoordinateSystem(0);
    visualizer->addCoordinateSystem(100, 0);
 
    // camera 1 coordinate system
    cv::Mat Transform1CV(3, 4, CV_32F);
    cv::Mat(calibration.R1).copyTo(Transform1CV.colRange(0, 3));
    cv::Mat(calibration.T1).copyTo(Transform1CV.col(3));
    Eigen::Affine3f Transform1;
    cv::cv2eigen(Transform1CV, Transform1.matrix());
 
    visualizer->addCoordinateSystem(100, Transform1.inverse());
 
    // rotation axis coordinate system
//    cv::Mat TransformRCV(3, 4, CV_32F);
//    cv::Mat(calibration.Rr).copyTo(TransformRCV.colRange(0, 3));
//    cv::Mat(calibration.Tr).copyTo(TransformRCV.col(3));
//    Eigen::Affine3f TransformR;
//    cv::cv2eigen(TransformRCV, TransformR.matrix());
 
//    visualizer->addCoordinateSystem(100, TransformR);
 
    // rotation axis at (0,0,0) pointing (0,1,0) in rotation stage frame
    cv::Vec3f O(0.0, -100.0, 0.0);
    cv::Vec3f v(0.0, 300.0, 0.0);
 
    // determine coefficients in camera 0 frame
    O = calibration.Rr.t()*O + -calibration.Rr.t()*calibration.Tr;
    v = calibration.Rr.t()*v + -calibration.Rr.t()*calibration.Tr - O;
 
    pcl::ModelCoefficients lineCoefficients;
    lineCoefficients.values.resize(6);
    lineCoefficients.values[0] = O[0];
    lineCoefficients.values[1] = O[1];
    lineCoefficients.values[2] = O[2];
    lineCoefficients.values[3] = v[0];
    lineCoefficients.values[4] = v[1];
    lineCoefficients.values[5] = v[2];
    visualizer->removeShape("line");
    visualizer->addLine(lineCoefficients);
 
 
}
 
SMPointCloudWidget::~SMPointCloudWidget(){
 
    //delete visualizer;
 
}
 

Subversion Repositories seema-scanner

(root)/src/SMPointCloudWidget.cpp – Rev 42 → 43

Rev 42		Rev 43
1	`#include "SMPointCloudWidget.h"`	1	`#include "SMPointCloudWidget.h"`
2		2
3	`#include <opencv2/opencv.hpp>`	3	`#include <opencv2/opencv.hpp>`
4	`#include <opencv2/core/eigen.hpp>`	4	`#include <opencv2/core/eigen.hpp>`
5		5
6	`#include <vtkWindowToImageFilter.h>`	6	`#include <vtkWindowToImageFilter.h>`
7	`#include <vtkPNGWriter.h>`	7	`#include <vtkPNGWriter.h>`
8	`#include <vtkRenderWindow.h>`	8	`#include <vtkRenderWindow.h>`
9		9
10	`#include <pcl/point_cloud.h>`	10	`#include <pcl/point_cloud.h>`
11	`#include <pcl/point_types.h>`	11	`#include <pcl/point_types.h>`
12	`#include <pcl/common/io.h>`	12	`#include <pcl/common/io.h>`
13	`#include <pcl/visualization/point_cloud_color_handlers.h>`	13	`#include <pcl/visualization/point_cloud_color_handlers.h>`
14	`#include <pcl/geometry/quad_mesh.h>`	14	`#include <pcl/geometry/quad_mesh.h>`
15		15
16	`#include <pcl/io/pcd_io.h>`	16	`#include <pcl/io/pcd_io.h>`
17	`#include <pcl/io/ascii_io.h>`	17	`#include <pcl/io/ascii_io.h>`
18	`#include <pcl/io/ply_io.h>`	18	`#include <pcl/io/ply_io.h>`
19	`#include <pcl/io/png_io.h>`	19	`#include <pcl/io/png_io.h>`
20	`#include <pcl/io/vtk_io.h>`	20	`#include <pcl/io/vtk_io.h>`
21	`#include <vtkPolyDataWriter.h>`	21	`#include <vtkPolyDataWriter.h>`
22	`#include <pcl/conversions.h>`	22	`#include <pcl/conversions.h>`
23		23
24	`#include <fstream>`	24	`#include <fstream>`
25		25
-		26
26	`#include <QFileDialog>`	27	`#include <QFileDialog>`
27	`#include <QSettings>`	28	`#include <QSettings>`
28		29
29	`#include "SMCalibrationParameters.h"`	30	`#include "SMCalibrationParameters.h"`
30		31
31	`SMPointCloudWidget::SMPointCloudWidget(QWidget *parent) : QVTKWidget(parent) {`	32	`SMPointCloudWidget::SMPointCloudWidget(QWidget *parent) : QVTKWidget(parent) {`
32		33
33	`visualizer = new pcl::visualization::PCLVisualizer("PCLVisualizer", false);`	34	`visualizer = new pcl::visualization::PCLVisualizer("PCLVisualizer", false);`
34	`this->SetRenderWindow(visualizer->getRenderWindow());`	35	`this->SetRenderWindow(visualizer->getRenderWindow());`
35		36
36	`visualizer->setShowFPS(false);`	37	`visualizer->setShowFPS(false);`
37		38
38	`// Create point cloud viewport`	39	`// Create point cloud viewport`
39	`visualizer->setBackgroundColor(0, 0, 0);`	40	`visualizer->setBackgroundColor(0, 0, 0);`
40	`visualizer->addCoordinateSystem(100, 0);`	41	`visualizer->addCoordinateSystem(100, 0);`
41	`#ifndef __APPLE__`	42	`#ifndef __APPLE__`
42	`// this leads to a segfault on OS X`	43	`// this leads to a segfault on OS X`
43	`visualizer->setCameraPosition(0,0,-50,0,0,0,0,-1,0);`	44	`visualizer->setCameraPosition(0,0,-50,0,0,0,0,-1,0);`
44	`#endif`	45	`#endif`
45		46
46	`// Initialize point cloud color handler`	47	`// Initialize point cloud color handler`
47	`colorHandler = new pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB>();`	48	`colorHandler = new pcl::visualization::PointCloudColorHandlerRGBField<pcl::PointXYZRGB>();`
48		49
49	`updateCalibrationParameters();`	50	`updateCalibrationParameters();`
50	`//time.start();`	51	`//time.start();`
51	`}`	52	`}`
52		53
53	`void SMPointCloudWidget::addPointCloud(PointCloudPtr _pointCloudPCL){`	54	`void SMPointCloudWidget::addPointCloud(PointCloudPtr _pointCloudPCL, int id){`
54		-
55	`// time.restart();`	-
56		55
57	`pointCloudPCL = _pointCloudPCL;`	56	`pointCloudPCL = _pointCloudPCL;`
58		57
59	`// Note: using the color handler makes a copy of the rgb fields`	58	`// Note: using the color handler makes a copy of the rgb fields`
60	`colorHandler->setInputCloud(_pointCloudPCL);`	59	`colorHandler->setInputCloud(_pointCloudPCL);`
61		60
62	`visualizer->addPointCloud(pointCloudPCL, *colorHandler, "pointCloudPCL");`	61	`visualizer->addPointCloud(pointCloudPCL, *colorHandler, QString::number(id).toStdString());`
63	`visualizer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2.0, "pointCloudPCL");`	62	`visualizer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2.0, QString::number(id).toStdString());`
64		63
65	`this->update();`	64	`this->update();`
66	`emit newPointCloudDisplayed();`	65	`emit newPointCloudDisplayed();`
67		66
68	`// std::cout << "PCL Widget: " << time.restart() << "ms" << std::endl;`	-
69	`}`	67	`}`
70		68
71	`void SMPointCloudWidget::updatePointCloud(PointCloudPtr _pointCloudPCL){`	69	`void SMPointCloudWidget::updatePointCloud(PointCloudPtr _pointCloudPCL, int id){`
72		-
73	`// time.restart();`	-
74		70
75	`pointCloudPCL = _pointCloudPCL;`	71	`pointCloudPCL = _pointCloudPCL;`
76		72
77	`// Note: using the color handler makes a copy of the rgb fields`	73	`// Note: using the color handler makes a copy of the rgb fields`
78	`colorHandler->setInputCloud(_pointCloudPCL);`	74	`colorHandler->setInputCloud(_pointCloudPCL);`
79		75
80	`if(!visualizer->updatePointCloud(pointCloudPCL, *colorHandler, "pointCloudPCL")){`	76	`if(!visualizer->updatePointCloud(pointCloudPCL, *colorHandler, QString::number(id).toStdString())){`
81	`visualizer->addPointCloud(pointCloudPCL, *colorHandler, "pointCloudPCL");`	77	`visualizer->addPointCloud(pointCloudPCL, *colorHandler, QString::number(id).toStdString());`
82	`visualizer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2.0, "pointCloudPCL");`	78	`visualizer->setPointCloudRenderingProperties(pcl::visualization::PCL_VISUALIZER_POINT_SIZE, 2.0, QString::number(id).toStdString());`
83	`}`	79	`}`
84		80
85	`this->update();`	81	`this->update();`
86	`emit newPointCloudDisplayed();`	82	`emit newPointCloudDisplayed();`
87		83
88	`// std::cout << "PCL Widget: " << time.restart() << "ms" << std::endl;`	-
89	`}`	84	`}`
90		85
91	`void SMPointCloudWidget::savePointCloud(){`	86	`void SMPointCloudWidget::savePointCloud(){`
92		87
93	`QString selectedFilter;`	88	`QString selectedFilter;`
94	`QString fileName = QFileDialog::getSaveFileName(this, "Save Point Cloud", QString(), ".pcd;;.ply;;.vtk;;.png;;*.txt", &selectedFilter);`	89	`QString fileName = QFileDialog::getSaveFileName(this, "Save Point Cloud", QString(), ".pcd;;.ply;;.vtk;;.png;;*.txt", &selectedFilter);`
95	`QFileInfo info(fileName);`	90	`QFileInfo info(fileName);`
96	`QString type = info.suffix();`	91	`QString type = info.suffix();`
97	`if(type == ""){`	92	`if(type == ""){`
98	`fileName.append(selectedFilter.remove(0,1));`	93	`fileName.append(selectedFilter.remove(0,1));`
99	`type = selectedFilter.remove(0,1);`	94	`type = selectedFilter.remove(0,1);`
100	`}`	95	`}`
101		96
102	`if(type == "pcd"){`	97	`if(type == "pcd"){`
103	`pcl::io::savePCDFileASCII(fileName.toStdString(), *pointCloudPCL);`	98	`pcl::io::savePCDFileASCII(fileName.toStdString(), *pointCloudPCL);`
104	`} else if(type == "ply"){`	99	`} else if(type == "ply"){`
105	`//pcl::io::savePLYFileBinary(fileName.toStdString(), *pointCloudPCL);`	100	`//pcl::io::savePLYFileBinary(fileName.toStdString(), *pointCloudPCL);`
106	`pcl::PLYWriter w;`	101	`pcl::PLYWriter w;`
107	`// Write to ply in binary without camera`	102	`// Write to ply in binary without camera`
108	`w.write<pcl::PointXYZRGB> (fileName.toStdString(), *pointCloudPCL, true, false);`	103	`w.write<pcl::PointXYZRGB> (fileName.toStdString(), *pointCloudPCL, true, false);`
109	`} else if(type == "vtk"){`	104	`} else if(type == "vtk"){`
110	`pcl::PCLPointCloud2 pointCloud2;`	105	`pcl::PCLPointCloud2 pointCloud2;`
111	`pcl::toPCLPointCloud2(*pointCloudPCL, pointCloud2);`	106	`pcl::toPCLPointCloud2(*pointCloudPCL, pointCloud2);`
112	`pcl::io::saveVTKFile(fileName.toStdString(), pointCloud2);`	107	`pcl::io::saveVTKFile(fileName.toStdString(), pointCloud2);`
113		108
114	`// vtkPolyData polyData;`	109	`// vtkPolyData polyData;`
115	`// pcl::io::pointCloudTovtkPolyData(*pointCloudPCL, polyData);`	110	`// pcl::io::pointCloudTovtkPolyData(*pointCloudPCL, polyData);`
116	`// vtkPolyDataWriter::Pointer writer = vtkPolyDataWriter::New();`	111	`// vtkPolyDataWriter::Pointer writer = vtkPolyDataWriter::New();`
117	`// writer->SetInput(polyData);`	112	`// writer->SetInput(polyData);`
118	`// writer->SetFileName(fileName.toStdString());`	113	`// writer->SetFileName(fileName.toStdString());`
119	`// writer->Update();`	114	`// writer->Update();`
120	`} else if(type == "png"){`	115	`} else if(type == "png"){`
121	`pcl::io::savePNGFile(fileName.toStdString(), *pointCloudPCL, "rgb");`	116	`pcl::io::savePNGFile(fileName.toStdString(), *pointCloudPCL, "rgb");`
122	`} else if(type == "txt"){`	117	`} else if(type == "txt"){`
123	`std::ofstream s(fileName.toLocal8Bit());`	118	`std::ofstream s(fileName.toLocal8Bit());`
124	`for(unsigned int r=0; r<pointCloudPCL->height; r++){`	119	`for(unsigned int r=0; r<pointCloudPCL->height; r++){`
125	`for(unsigned int c=0; c<pointCloudPCL->width; c++){`	120	`for(unsigned int c=0; c<pointCloudPCL->width; c++){`
126	`pcl::PointXYZRGB p = pointCloudPCL->at(c, r);`	121	`pcl::PointXYZRGB p = pointCloudPCL->at(c, r);`
127	`if(p.x == p.x)`	122	`if(p.x == p.x)`
128	`s << p.x << " " << p.y << " " << p.z << "\r\n";`	123	`s << p.x << " " << p.y << " " << p.z << "\r\n";`
129	`}`	124	`}`
130	`}`	125	`}`
131	`std::flush(s);`	126	`std::flush(s);`
132	`s.close();`	127	`s.close();`
133	`}`	128	`}`
134		129
135	`}`	130	`}`
136		131
137	`void SMPointCloudWidget::saveScreenShot(){`	132	`void SMPointCloudWidget::saveScreenShot(){`
138		133
139	`vtkWindowToImageFilter* filter = vtkWindowToImageFilter::New();`	134	`vtkWindowToImageFilter* filter = vtkWindowToImageFilter::New();`
140	`//filter->SetInput(visualizer->getRenderWindow());`	135	`//filter->SetInput(visualizer->getRenderWindow());`
141	`filter->Modified();`	136	`filter->Modified();`
142		137
143	`QString fileName = QFileDialog::getSaveFileName(this, "Save Screen Shot", QString(), "*.png");`	138	`QString fileName = QFileDialog::getSaveFileName(this, "Save Screen Shot", QString(), "*.png");`
144	`QFileInfo info(fileName);`	139	`QFileInfo info(fileName);`
145	`QString type = info.suffix();`	140	`QString type = info.suffix();`
146	`if(type == "")`	141	`if(type == "")`
147	`fileName.append(".png");`	142	`fileName.append(".png");`
148		143
149	`vtkPNGWriter* writer = vtkPNGWriter::New();`	144	`vtkPNGWriter* writer = vtkPNGWriter::New();`
150	`writer->SetInput(filter->GetOutput());`	145	`writer->SetInput(filter->GetOutput());`
151	`writer->SetFileName(qPrintable(fileName));`	146	`writer->SetFileName(qPrintable(fileName));`
152	`writer->Write();`	147	`writer->Write();`
153	`writer->Delete();`	148	`writer->Delete();`
154	`}`	149	`}`
155		150
156	`void SMPointCloudWidget::updateCalibrationParameters(){`	151	`void SMPointCloudWidget::updateCalibrationParameters(){`
157		152
158	`QSettings settings;`	153	`QSettings settings;`
159	`SMCalibrationParameters calibration = settings.value("calibration/parameters").value<SMCalibrationParameters>();`	154	`SMCalibrationParameters calibration = settings.value("calibration/parameters").value<SMCalibrationParameters>();`
160		155
161	`// camera 0 coordinate system`	156	`// camera 0 coordinate system`
162	`visualizer->removeCoordinateSystem(0);`	157	`visualizer->removeCoordinateSystem(0);`
163	`visualizer->addCoordinateSystem(100, 0);`	158	`visualizer->addCoordinateSystem(100, 0);`
164		159
165	`// camera 1 coordinate system`	160	`// camera 1 coordinate system`
166	`cv::Mat Transform1CV(3, 4, CV_32F);`	161	`cv::Mat Transform1CV(3, 4, CV_32F);`
167	`cv::Mat(calibration.R1).copyTo(Transform1CV.colRange(0, 3));`	162	`cv::Mat(calibration.R1).copyTo(Transform1CV.colRange(0, 3));`
168	`cv::Mat(calibration.T1).copyTo(Transform1CV.col(3));`	163	`cv::Mat(calibration.T1).copyTo(Transform1CV.col(3));`
169	`Eigen::Affine3f Transform1;`	164	`Eigen::Affine3f Transform1;`
170	`cv::cv2eigen(Transform1CV, Transform1.matrix());`	165	`cv::cv2eigen(Transform1CV, Transform1.matrix());`
171		166
172	`visualizer->addCoordinateSystem(100, Transform1.inverse());`	167	`visualizer->addCoordinateSystem(100, Transform1.inverse());`
173		168
174	`// rotation axis coordinate system`	169	`// rotation axis coordinate system`
175	`// cv::Mat TransformRCV(3, 4, CV_32F);`	170	`// cv::Mat TransformRCV(3, 4, CV_32F);`
176	`// cv::Mat(calibration.Rr).copyTo(TransformRCV.colRange(0, 3));`	171	`// cv::Mat(calibration.Rr).copyTo(TransformRCV.colRange(0, 3));`
177	`// cv::Mat(calibration.Tr).copyTo(TransformRCV.col(3));`	172	`// cv::Mat(calibration.Tr).copyTo(TransformRCV.col(3));`
178	`// Eigen::Affine3f TransformR;`	173	`// Eigen::Affine3f TransformR;`
179	`// cv::cv2eigen(TransformRCV, TransformR.matrix());`	174	`// cv::cv2eigen(TransformRCV, TransformR.matrix());`
180		175
181	`// visualizer->addCoordinateSystem(100, TransformR);`	176	`// visualizer->addCoordinateSystem(100, TransformR);`
182		177
183	`// rotation axis at (0,0,0) pointing (0,1,0) in rotation stage frame`	178	`// rotation axis at (0,0,0) pointing (0,1,0) in rotation stage frame`
184	`cv::Vec3f O(0.0, -100.0, 0.0);`	179	`cv::Vec3f O(0.0, -100.0, 0.0);`
185	`cv::Vec3f v(0.0, 300.0, 0.0);`	180	`cv::Vec3f v(0.0, 300.0, 0.0);`
186		181
187	`// determine coefficients in camera 0 frame`	182	`// determine coefficients in camera 0 frame`
188	`O = calibration.Rr.t()O + -calibration.Rr.t()calibration.Tr;`	183	`O = calibration.Rr.t()O + -calibration.Rr.t()calibration.Tr;`
189	`v = calibration.Rr.t()v + -calibration.Rr.t()calibration.Tr - O;`	184	`v = calibration.Rr.t()v + -calibration.Rr.t()calibration.Tr - O;`
190		185
191	`pcl::ModelCoefficients lineCoefficients;`	186	`pcl::ModelCoefficients lineCoefficients;`
192	`lineCoefficients.values.resize(6);`	187	`lineCoefficients.values.resize(6);`
193	`lineCoefficients.values[0] = O[0];`	188	`lineCoefficients.values[0] = O[0];`
194	`lineCoefficients.values[1] = O[1];`	189	`lineCoefficients.values[1] = O[1];`
195	`lineCoefficients.values[2] = O[2];`	190	`lineCoefficients.values[2] = O[2];`
196	`lineCoefficients.values[3] = v[0];`	191	`lineCoefficients.values[3] = v[0];`
197	`lineCoefficients.values[4] = v[1];`	192	`lineCoefficients.values[4] = v[1];`
198	`lineCoefficients.values[5] = v[2];`	193	`lineCoefficients.values[5] = v[2];`
199	`visualizer->removeShape("line");`	194	`visualizer->removeShape("line");`
200	`visualizer->addLine(lineCoefficients);`	195	`visualizer->addLine(lineCoefficients);`
201		196
202		197
203	`}`	198	`}`
204		199
205	`SMPointCloudWidget::~SMPointCloudWidget(){`	200	`SMPointCloudWidget::~SMPointCloudWidget(){`
206		201
207	`//delete visualizer;`	202	`//delete visualizer;`
208		203
209	`}`	204	`}`
210		205