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


#include "SMCaptureWorker.h"
 
#include "AlgorithmGrayCode.h"
#include "AlgorithmGrayCodeHorzVert.h"
#include "AlgorithmPhaseShift.h"
 
#include <QCoreApplication>
#include <QTime>
#include <QSettings>
#include <QtTest/QTest>
 
void SMCaptureWorker::setup(){
 
    QSettings settings;
 
    // Create cameras
    int iNum0 = settings.value("camera0/interfaceNumber", 0).toInt();
    int cNum0 = settings.value("camera0/cameraNumber", 0).toInt();
    if(iNum0 != -1)
        camera0 = Camera::NewCamera(iNum0,cNum0,triggerModeSoftware);
 
    int iNum1 = settings.value("camera1/interfaceNumber", 0).toInt();
    int cNum1 = settings.value("camera1/cameraNumber", 1).toInt();
    if(iNum1 != -1)
        camera1 = Camera::NewCamera(iNum1,cNum1,triggerModeSoftware);
 
    // Set camera settings
    CameraSettings cameraSettings;
    cameraSettings.shutter = settings.value("camera/shutter", 16.666).toFloat();
    cameraSettings.gain = 0.0;
 
    camera0->setCameraSettings(cameraSettings);
    camera1->setCameraSettings(cameraSettings);
 
    // Start capturing
    camera0->startCapture();
    camera1->startCapture();
 
    // Create projector
    int screenNum = settings.value("projector/screenNumber", 1).toInt();
    if(screenNum != -1)
        projector = new ProjectorOpenGL(screenNum);
 
    unsigned int screenCols, screenRows;
    projector->getScreenRes(&screenCols, &screenRows);
 
    // Create rotation stage
    rotationStage = new RotationStage();
 
    // Create Algorithm
    codec = settings.value("algorithm", "GrayCode").toString();
    if(codec == "GrayCode")
        algorithm = new AlgorithmGrayCode(screenCols, screenRows);
    else if(codec == "GrayCodeHQ")
        algorithm = new AlgorithmGrayCodeHorzVert(screenCols, screenRows);
    else if(codec == "PhaseShift")
        algorithm = new AlgorithmPhaseShift(screenCols, screenRows);
    else
        std::cerr << "SMCaptureWorker: invalid codec " << codec.toStdString() << std::endl;
 
 
    // Upload patterns to projector/GPU
    for(unsigned int i=0; i<algorithm->getNPatterns(); i++){
        cv::Mat pattern = algorithm->getEncodingPattern(i);
        projector->setPattern(i, pattern.ptr(), pattern.cols, pattern.rows);
    }
 
    delay = settings.value("trigger/delay", 50).toInt();
}
 
 
void SMCaptureWorker::doWork(){
 
    working = true;
 
    // Processing loop
    QTime time;
    time.start();
    while(working){
 
        projector->displayWhite();
 
        std::vector<cv::Mat> frameSet;
 
        CameraFrame frame;
 
        // trigger cameras
        camera0->trigger();
        camera1->trigger();
 
        // retrieve frames
        frame = camera0->getFrame();
        cv::Mat frameCV;
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);
        frameCV = frameCV.clone();
        frameSet.push_back(frameCV);
 
        emit newFrame(0, frameCV);
 
        frame = camera1->getFrame();
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);
        frameCV = frameCV.clone();
        frameSet.push_back(frameCV);
 
        emit newFrame(1, frameCV);
 
        //std::cout << "SMCaptureWorker idle " << time.restart() << "ms" << std::endl;
 
        // Process events e.g. perform a task
        QCoreApplication::processEvents();
    }
 
    emit finished();
}
 
void SMCaptureWorker::rotateTo(float angle){
 
    rotationStage->moveAbsolute(angle);
 
    while(rotationStage->isMoving()){
 
        // trigger cameras
        camera0->trigger();
        camera1->trigger();
 
        // retrieve frames
        CameraFrame frame;
        frame = camera0->getFrame();
        cv::Mat frameCV;
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);
        frameCV = frameCV.clone();
        emit newFrame(0, frameCV);
        frame = camera1->getFrame();
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);
        frameCV = frameCV.clone();
        emit newFrame(1, frameCV);
    }
 
    emit rotatedTo(angle);
}
 
void SMCaptureWorker::acquireCalibrationSet(float angle){
 
    if(angle != -1.0)
        rotateTo(angle);
 
    CameraFrame frame;
    SMCalibrationSet calibrationSet;
 
    // trigger cameras
    camera0->trigger();
    camera1->trigger();
 
    // retrieve frames
    frame = camera0->getFrame();
    cv::Mat frameCV;
    frameCV  = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);
    frameCV = frameCV.clone();
 
    emit newFrame(0, frameCV);
    calibrationSet.frame0 = frameCV;
 
    frame = camera1->getFrame();
    frameCV  = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);
    frameCV = frameCV.clone();
 
    emit newFrame(1, frameCV);
    calibrationSet.frame1 = frameCV;
 
    calibrationSet.rotationAngle = rotationStage->getAngle();
 
    emit newCalibrationSet(calibrationSet);
}
 
void SMCaptureWorker::acquireCalibrationSets(std::vector<float> angles){
 
    for(int i=0; i<angles.size(); i++)
        acquireCalibrationSet(angles[i]);
}
 
void SMCaptureWorker::acquireFrameSequence(float angle){
 
    if(angle != -1.0)
        rotateTo(angle);
 
    CameraFrame frame;
 
    SMFrameSequence frameSequence;
 
    for(unsigned int i=0; i<algorithm->getNPatterns(); i++){
 
        // display pattern
        projector->displayPattern(i);
 
        QTest::qSleep(delay);
 
        // trigger cameras
        camera0->trigger();
        camera1->trigger();
 
        cv::Mat frameCV;
        std::vector<char> compressedFrameCV;
 
        // retrieve frames
        frame = camera0->getFrame();
 
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);
        frameCV = frameCV.clone();
        cv::imencode("png", frameCV, compressedFrameCV);
 
        emit newFrame(0, frameCV);
        frameSequence.compressedFrames0.push_back(compressedFrameCV);
 
        frame = camera1->getFrame();
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);
        frameCV = frameCV.clone();
        cv::imencode("png", frameCV, compressedFrameCV);
 
        emit newFrame(1, frameCV);
        frameSequence.compressedFrames1.push_back(compressedFrameCV);
 
    }
 
    frameSequence.rotationAngle = rotationStage->getAngle();
    frameSequence.codec = codec;
 
    emit newFrameSequence(frameSequence);
 
    projector->displayWhite();
}
 
 
void SMCaptureWorker::acquireFrameSequences(std::vector<float> angles){
 
    for(int i=0; i<angles.size(); i++)
        acquireFrameSequence(angles[i]);
}
 
void SMCaptureWorker::abort(){}
 
void SMCaptureWorker::stopWork(){
    working = false;
}
 
SMCaptureWorker::~SMCaptureWorker(){
    delete projector;
//    delete camera0;
//    delete camera1;
    delete rotationStage;
}
 

Rev 97	Rev 99
1	`#include "SMCaptureWorker.h"`	1	`#include "SMCaptureWorker.h"`
2		2
3	`#include "AlgorithmGrayCode.h"`	3	`#include "AlgorithmGrayCode.h"`
4	`#include "AlgorithmGrayCodeHQ.h"`	4	`#include "AlgorithmGrayCodeHorzVert.h"`
5	`#include "AlgorithmPhaseShift.h"`	5	`#include "AlgorithmPhaseShift.h"`
6		6
7	`#include <QCoreApplication>`	7	`#include <QCoreApplication>`
8	`#include <QTime>`	8	`#include <QTime>`
9	`#include <QSettings>`	9	`#include <QSettings>`
10	`#include <QtTest/QTest>`	10	`#include <QtTest/QTest>`
11		11
12	`void SMCaptureWorker::setup(){`	12	`void SMCaptureWorker::setup(){`
13		13
14	`QSettings settings;`	14	`QSettings settings;`
15		15
16	`// Create cameras`	16	`// Create cameras`
17	`int iNum0 = settings.value("camera0/interfaceNumber", 0).toInt();`	17	`int iNum0 = settings.value("camera0/interfaceNumber", 0).toInt();`
18	`int cNum0 = settings.value("camera0/cameraNumber", 0).toInt();`	18	`int cNum0 = settings.value("camera0/cameraNumber", 0).toInt();`
19	`if(iNum0 != -1)`	19	`if(iNum0 != -1)`
20	`camera0 = Camera::NewCamera(iNum0,cNum0,triggerModeSoftware);`	20	`camera0 = Camera::NewCamera(iNum0,cNum0,triggerModeSoftware);`
21		21
22	`int iNum1 = settings.value("camera1/interfaceNumber", 0).toInt();`	22	`int iNum1 = settings.value("camera1/interfaceNumber", 0).toInt();`
23	`int cNum1 = settings.value("camera1/cameraNumber", 1).toInt();`	23	`int cNum1 = settings.value("camera1/cameraNumber", 1).toInt();`
24	`if(iNum1 != -1)`	24	`if(iNum1 != -1)`
25	`camera1 = Camera::NewCamera(iNum1,cNum1,triggerModeSoftware);`	25	`camera1 = Camera::NewCamera(iNum1,cNum1,triggerModeSoftware);`
26		26
27	`// Set camera settings`	27	`// Set camera settings`
28	`CameraSettings cameraSettings;`	28	`CameraSettings cameraSettings;`
29	`cameraSettings.shutter = settings.value("camera/shutter", 16.666).toFloat();`	29	`cameraSettings.shutter = settings.value("camera/shutter", 16.666).toFloat();`
30	`cameraSettings.gain = 0.0;`	30	`cameraSettings.gain = 0.0;`
31		31
32	`camera0->setCameraSettings(cameraSettings);`	32	`camera0->setCameraSettings(cameraSettings);`
33	`camera1->setCameraSettings(cameraSettings);`	33	`camera1->setCameraSettings(cameraSettings);`
34		34
35	`// Start capturing`	35	`// Start capturing`
36	`camera0->startCapture();`	36	`camera0->startCapture();`
37	`camera1->startCapture();`	37	`camera1->startCapture();`
38		38
39	`// Create projector`	39	`// Create projector`
40	`int screenNum = settings.value("projector/screenNumber", 1).toInt();`	40	`int screenNum = settings.value("projector/screenNumber", 1).toInt();`
41	`if(screenNum != -1)`	41	`if(screenNum != -1)`
42	`projector = new ProjectorOpenGL(screenNum);`	42	`projector = new ProjectorOpenGL(screenNum);`
43		43
44	`unsigned int screenCols, screenRows;`	44	`unsigned int screenCols, screenRows;`
45	`projector->getScreenRes(&screenCols, &screenRows);`	45	`projector->getScreenRes(&screenCols, &screenRows);`
46		46
47	`// Create rotation stage`	47	`// Create rotation stage`
48	`rotationStage = new RotationStage();`	48	`rotationStage = new RotationStage();`
49		49
50	`// Create Algorithm`	50	`// Create Algorithm`
51	`codec = settings.value("algorithm", "GrayCode").toString();`	51	`codec = settings.value("algorithm", "GrayCode").toString();`
52	`if(codec == "GrayCode")`	52	`if(codec == "GrayCode")`
53	`algorithm = new AlgorithmGrayCode(screenCols, screenRows);`	53	`algorithm = new AlgorithmGrayCode(screenCols, screenRows);`
54	`else if(codec == "GrayCodeHQ")`	54	`else if(codec == "GrayCodeHQ")`
55	`algorithm = new AlgorithmGrayCodeHQ(screenCols, screenRows);`	55	`algorithm = new AlgorithmGrayCodeHorzVert(screenCols, screenRows);`
56	`else if(codec == "PhaseShift")`	56	`else if(codec == "PhaseShift")`
57	`algorithm = new AlgorithmPhaseShift(screenCols, screenRows);`	57	`algorithm = new AlgorithmPhaseShift(screenCols, screenRows);`
58	`else`	58	`else`
59	`std::cerr << "SMCaptureWorker: invalid codec " << codec.toStdString() << std::endl;`	59	`std::cerr << "SMCaptureWorker: invalid codec " << codec.toStdString() << std::endl;`
60		60
61		61
62	`// Upload patterns to projector/GPU`	62	`// Upload patterns to projector/GPU`
63	`for(unsigned int i=0; i<algorithm->getNPatterns(); i++){`	63	`for(unsigned int i=0; i<algorithm->getNPatterns(); i++){`
64	`cv::Mat pattern = algorithm->getEncodingPattern(i);`	64	`cv::Mat pattern = algorithm->getEncodingPattern(i);`
65	`projector->setPattern(i, pattern.ptr(), pattern.cols, pattern.rows);`	65	`projector->setPattern(i, pattern.ptr(), pattern.cols, pattern.rows);`
66	`}`	66	`}`
67		67
68	`delay = settings.value("trigger/delay", 50).toInt();`	68	`delay = settings.value("trigger/delay", 50).toInt();`
69	`}`	69	`}`
70		70
71		71
72	`void SMCaptureWorker::doWork(){`	72	`void SMCaptureWorker::doWork(){`
73		73
74	`working = true;`	74	`working = true;`
75		75
76	`// Processing loop`	76	`// Processing loop`
77	`QTime time;`	77	`QTime time;`
78	`time.start();`	78	`time.start();`
79	`while(working){`	79	`while(working){`
80		80
81	`projector->displayWhite();`	81	`projector->displayWhite();`
82		82
83	`std::vector<cv::Mat> frameSet;`	83	`std::vector<cv::Mat> frameSet;`
84		84
85	`CameraFrame frame;`	85	`CameraFrame frame;`
86		86
87	`// trigger cameras`	87	`// trigger cameras`
88	`camera0->trigger();`	88	`camera0->trigger();`
89	`camera1->trigger();`	89	`camera1->trigger();`
90		90
91	`// retrieve frames`	91	`// retrieve frames`
92	`frame = camera0->getFrame();`	92	`frame = camera0->getFrame();`
93	`cv::Mat frameCV;`	93	`cv::Mat frameCV;`
94	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`	94	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`
95	`frameCV = frameCV.clone();`	95	`frameCV = frameCV.clone();`
96	`frameSet.push_back(frameCV);`	96	`frameSet.push_back(frameCV);`
97		97
98	`emit newFrame(0, frameCV);`	98	`emit newFrame(0, frameCV);`
99		99
100	`frame = camera1->getFrame();`	100	`frame = camera1->getFrame();`
101	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`	101	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`
102	`frameCV = frameCV.clone();`	102	`frameCV = frameCV.clone();`
103	`frameSet.push_back(frameCV);`	103	`frameSet.push_back(frameCV);`
104		104
105	`emit newFrame(1, frameCV);`	105	`emit newFrame(1, frameCV);`
106		106
107	`//std::cout << "SMCaptureWorker idle " << time.restart() << "ms" << std::endl;`	107	`//std::cout << "SMCaptureWorker idle " << time.restart() << "ms" << std::endl;`
108		108
109	`// Process events e.g. perform a task`	109	`// Process events e.g. perform a task`
110	`QCoreApplication::processEvents();`	110	`QCoreApplication::processEvents();`
111	`}`	111	`}`
112		112
113	`emit finished();`	113	`emit finished();`
114	`}`	114	`}`
115		115
116	`void SMCaptureWorker::rotateTo(float angle){`	116	`void SMCaptureWorker::rotateTo(float angle){`
117		117
118	`rotationStage->moveAbsolute(angle);`	118	`rotationStage->moveAbsolute(angle);`
119		119
120	`while(rotationStage->isMoving()){`	120	`while(rotationStage->isMoving()){`
121		121
122	`// trigger cameras`	122	`// trigger cameras`
123	`camera0->trigger();`	123	`camera0->trigger();`
124	`camera1->trigger();`	124	`camera1->trigger();`
125		125
126	`// retrieve frames`	126	`// retrieve frames`
127	`CameraFrame frame;`	127	`CameraFrame frame;`
128	`frame = camera0->getFrame();`	128	`frame = camera0->getFrame();`
129	`cv::Mat frameCV;`	129	`cv::Mat frameCV;`
130	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`	130	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`
131	`frameCV = frameCV.clone();`	131	`frameCV = frameCV.clone();`
132	`emit newFrame(0, frameCV);`	132	`emit newFrame(0, frameCV);`
133	`frame = camera1->getFrame();`	133	`frame = camera1->getFrame();`
134	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`	134	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`
135	`frameCV = frameCV.clone();`	135	`frameCV = frameCV.clone();`
136	`emit newFrame(1, frameCV);`	136	`emit newFrame(1, frameCV);`
137	`}`	137	`}`
138		138
139	`emit rotatedTo(angle);`	139	`emit rotatedTo(angle);`
140	`}`	140	`}`
141		141
142	`void SMCaptureWorker::acquireCalibrationSet(float angle){`	142	`void SMCaptureWorker::acquireCalibrationSet(float angle){`
143		143
144	`if(angle != -1.0)`	144	`if(angle != -1.0)`
145	`rotateTo(angle);`	145	`rotateTo(angle);`
146		146
147	`CameraFrame frame;`	147	`CameraFrame frame;`
148	`SMCalibrationSet calibrationSet;`	148	`SMCalibrationSet calibrationSet;`
149		149
150	`// trigger cameras`	150	`// trigger cameras`
151	`camera0->trigger();`	151	`camera0->trigger();`
152	`camera1->trigger();`	152	`camera1->trigger();`
153		153
154	`// retrieve frames`	154	`// retrieve frames`
155	`frame = camera0->getFrame();`	155	`frame = camera0->getFrame();`
156	`cv::Mat frameCV;`	156	`cv::Mat frameCV;`
157	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`	157	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`
158	`frameCV = frameCV.clone();`	158	`frameCV = frameCV.clone();`
159		159
160	`emit newFrame(0, frameCV);`	160	`emit newFrame(0, frameCV);`
161	`calibrationSet.frame0 = frameCV;`	161	`calibrationSet.frame0 = frameCV;`
162		162
163	`frame = camera1->getFrame();`	163	`frame = camera1->getFrame();`
164	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`	164	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`
165	`frameCV = frameCV.clone();`	165	`frameCV = frameCV.clone();`
166		166
167	`emit newFrame(1, frameCV);`	167	`emit newFrame(1, frameCV);`
168	`calibrationSet.frame1 = frameCV;`	168	`calibrationSet.frame1 = frameCV;`
169		169
170	`calibrationSet.rotationAngle = rotationStage->getAngle();`	170	`calibrationSet.rotationAngle = rotationStage->getAngle();`
171		171
172	`emit newCalibrationSet(calibrationSet);`	172	`emit newCalibrationSet(calibrationSet);`
173	`}`	173	`}`
174		174
175	`void SMCaptureWorker::acquireCalibrationSets(std::vector<float> angles){`	175	`void SMCaptureWorker::acquireCalibrationSets(std::vector<float> angles){`
176		176
177	`for(int i=0; i<angles.size(); i++)`	177	`for(int i=0; i<angles.size(); i++)`
178	`acquireCalibrationSet(angles[i]);`	178	`acquireCalibrationSet(angles[i]);`
179	`}`	179	`}`
180		180
181	`void SMCaptureWorker::acquireFrameSequence(float angle){`	181	`void SMCaptureWorker::acquireFrameSequence(float angle){`
182		182
183	`if(angle != -1.0)`	183	`if(angle != -1.0)`
184	`rotateTo(angle);`	184	`rotateTo(angle);`
185		185
186	`CameraFrame frame;`	186	`CameraFrame frame;`
187		187
188	`SMFrameSequence frameSequence;`	188	`SMFrameSequence frameSequence;`
189		189
190	`for(unsigned int i=0; i<algorithm->getNPatterns(); i++){`	190	`for(unsigned int i=0; i<algorithm->getNPatterns(); i++){`
191		191
192	`// display pattern`	192	`// display pattern`
193	`projector->displayPattern(i);`	193	`projector->displayPattern(i);`
194		194
195	`QTest::qSleep(delay);`	195	`QTest::qSleep(delay);`
196		196
197	`// trigger cameras`	197	`// trigger cameras`
198	`camera0->trigger();`	198	`camera0->trigger();`
199	`camera1->trigger();`	199	`camera1->trigger();`
200		200
-		201	`cv::Mat frameCV;`
-		202	`std::vector<char> compressedFrameCV;`
-		203
201	`// retrieve frames`	204	`// retrieve frames`
202	`frame = camera0->getFrame();`	205	`frame = camera0->getFrame();`
203	`cv::Mat frameCV;`	-
204	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`	206	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`
205	`frameCV = frameCV.clone();`	207	`frameCV = frameCV.clone();`
-		208	`cv::imencode("png", frameCV, compressedFrameCV);`
206		209
207	`emit newFrame(0, frameCV);`	210	`emit newFrame(0, frameCV);`
208	`frameSequence.frames0.push_back(frameCV);`	211	`frameSequence.compressedFrames0.push_back(compressedFrameCV);`
209		212
210	`frame = camera1->getFrame();`	213	`frame = camera1->getFrame();`
211	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`	214	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC3, frame.memory);`
212	`frameCV = frameCV.clone();`	215	`frameCV = frameCV.clone();`
-		216	`cv::imencode("png", frameCV, compressedFrameCV);`
213		217
214	`emit newFrame(1, frameCV);`	218	`emit newFrame(1, frameCV);`
215	`frameSequence.frames1.push_back(frameCV);`	219	`frameSequence.compressedFrames1.push_back(compressedFrameCV);`
216		220
217	`}`	221	`}`
218		222
219	`frameSequence.rotationAngle = rotationStage->getAngle();`	223	`frameSequence.rotationAngle = rotationStage->getAngle();`
220	`frameSequence.codec = codec;`	224	`frameSequence.codec = codec;`
221		225
222	`emit newFrameSequence(frameSequence);`	226	`emit newFrameSequence(frameSequence);`
223		227
224	`projector->displayWhite();`	228	`projector->displayWhite();`
225	`}`	229	`}`
226		230
227		231
228	`void SMCaptureWorker::acquireFrameSequences(std::vector<float> angles){`	232	`void SMCaptureWorker::acquireFrameSequences(std::vector<float> angles){`
229		233
230	`for(int i=0; i<angles.size(); i++)`	234	`for(int i=0; i<angles.size(); i++)`
231	`acquireFrameSequence(angles[i]);`	235	`acquireFrameSequence(angles[i]);`
232	`}`	236	`}`
233		237
234	`void SMCaptureWorker::abort(){}`	238	`void SMCaptureWorker::abort(){}`
235		239
236	`void SMCaptureWorker::stopWork(){`	240	`void SMCaptureWorker::stopWork(){`
237	`working = false;`	241	`working = false;`
238	`}`	242	`}`
239		243
240	`SMCaptureWorker::~SMCaptureWorker(){`	244	`SMCaptureWorker::~SMCaptureWorker(){`
241	`delete projector;`	245	`delete projector;`
242	`// delete camera0;`	246	`// delete camera0;`
243	`// delete camera1;`	247	`// delete camera1;`
244	`delete rotationStage;`	248	`delete rotationStage;`
245	`}`	249	`}`
246		250

Subversion Repositories seema-scanner

(root)/src/SMCaptureWorker.cpp – Rev 97 → 99