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


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

Subversion Repositories seema-scanner

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