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


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

Subversion Repositories seema-scanner

(root)/src/SMCaptureWorker.cpp – Rev 74 → 92