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

Subversion Repositories seema-scanner

(root)/src/SMCaptureWorker.cpp – Rev 36 → 41