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 == "GrayCodeHorzVert")
        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();
    stacking = settings.value("stacking", 1).toInt();
}
 
 
void SMCaptureWorker::doWork(){
 
    working = true;
 
    // Processing loop
//    QTime time;
//    time.start();
    while(working){
 
        projector->displayWhite();
 
        CameraFrame frame;
 
        // trigger cameras
        camera0->trigger();
        camera1->trigger();
 
        // retrieve raw frames
        frame = camera0->getFrame();
        cv::Mat frameCV;
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);
        frameCV = frameCV.clone();
        emit newFrame(0, frameCV);
 
        frame = camera1->getFrame();
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);
        frameCV = frameCV.clone();
        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_8UC1, frame.memory);
        frameCV = frameCV.clone();
        emit newFrame(0, frameCV);
        frame = camera1->getFrame();
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, 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;
    cv::Mat frameCVStacked0(camera0->getFrameHeight(), camera0->getFrameWidth(), CV_16UC1, cv::Scalar(0));
    cv::Mat frameCVStacked1(camera1->getFrameHeight(), camera1->getFrameWidth(), CV_16UC1, cv::Scalar(0));
 
    for(int i=0; i<stacking; i++){
        // trigger cameras
        camera0->trigger();
        camera1->trigger();
 
        // retrieve frames
        frame = camera0->getFrame();
        cv::Mat frameCV;
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);
        frameCV = frameCV.clone();
        cv::add(frameCV, frameCVStacked0, frameCVStacked0, cv::noArray(), CV_16UC1);
 
        emit newFrame(0, frameCV);
 
        frame = camera1->getFrame();
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);
        frameCV = frameCV.clone();
        cv::add(frameCV, frameCVStacked1, frameCVStacked1, cv::noArray(), CV_16UC1);
 
        emit newFrame(1, frameCV);
 
    }
 
    frameCVStacked0.convertTo(frameCVStacked0, CV_8UC1, 1.0/stacking);
    frameCVStacked1.convertTo(frameCVStacked1, CV_8UC1, 1.0/stacking);
 
    calibrationSet.frame0 = frameCVStacked0;
    calibrationSet.frame1 = frameCVStacked1;
 
    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);
 
        cv::Mat frameCVStacked0(camera0->getFrameHeight(), camera0->getFrameWidth(), CV_16UC1, cv::Scalar(0));
        cv::Mat frameCVStacked1(camera1->getFrameHeight(), camera1->getFrameWidth(), CV_16UC1, cv::Scalar(0));
        for(int i=0; i<stacking; i++){
            // trigger cameras
            camera0->trigger();
            camera1->trigger();
 
            // retrieve frames
            frame = camera0->getFrame();
            cv::Mat frameCV;
            frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);
            frameCV = frameCV.clone();
            cv::add(frameCV, frameCVStacked0, frameCVStacked0, cv::noArray(), CV_16UC1);
 
            emit newFrame(0, frameCV);
 
            frame = camera1->getFrame();
            frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);
            frameCV = frameCV.clone();
            cv::add(frameCV, frameCVStacked1, frameCVStacked1, cv::noArray(), CV_16UC1);
 
            emit newFrame(1, frameCV);
 
        }
 
        frameCVStacked0.convertTo(frameCVStacked0, CV_8UC1, 1.0/stacking);
        frameCVStacked1.convertTo(frameCVStacked1, CV_8UC1, 1.0/stacking);
 
        frameSequence.frames0.push_back(frameCVStacked0);
        frameSequence.frames1.push_back(frameCVStacked1);
 
    }
 
    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 113	Rev 114
1	`#include "SMCaptureWorker.h"`	1	`#include "SMCaptureWorker.h"`
2		2
3	`#include "AlgorithmGrayCode.h"`	3	`#include "AlgorithmGrayCode.h"`
4	`#include "AlgorithmGrayCodeHorzVert.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 == "GrayCodeHorzVert")`	54	`else if(codec == "GrayCodeHorzVert")`
55	`algorithm = new AlgorithmGrayCodeHorzVert(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	`stacking = settings.value("stacking", 1).toInt();`	69	`stacking = settings.value("stacking", 1).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	`CameraFrame frame;`	84	`CameraFrame frame;`
85		85
86	`// trigger cameras`	86	`// trigger cameras`
87	`camera0->trigger();`	87	`camera0->trigger();`
88	`camera1->trigger();`	88	`camera1->trigger();`
89		89
90	`// retrieve raw frames`	90	`// retrieve raw frames`
91	`frame = camera0->getFrame();`	91	`frame = camera0->getFrame();`
92	`cv::Mat frameCV;`	92	`cv::Mat frameCV;`
93	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	93	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
94	`frameCV = frameCV.clone();`	94	`frameCV = frameCV.clone();`
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_8UC1, frame.memory);`	98	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
99	`frameCV = frameCV.clone();`	99	`frameCV = frameCV.clone();`
100	`emit newFrame(1, frameCV);`	100	`emit newFrame(1, frameCV);`
101		101
102	`//std::cout << "SMCaptureWorker idle " << time.restart() << "ms" << std::endl;`	102	`//std::cout << "SMCaptureWorker idle " << time.restart() << "ms" << std::endl;`
103		103
104	`// Process events e.g. perform a task`	104	`// Process events e.g. perform a task`
105	`QCoreApplication::processEvents();`	105	`QCoreApplication::processEvents();`
106	`}`	106	`}`
107		107
108	`emit finished();`	108	`emit finished();`
109	`}`	109	`}`
110		110
111	`void SMCaptureWorker::rotateTo(float angle){`	111	`void SMCaptureWorker::rotateTo(float angle){`
112		112
113	`rotationStage->moveAbsolute(angle);`	113	`rotationStage->moveAbsolute(angle);`
114		114
115	`while(rotationStage->isMoving()){`	115	`while(rotationStage->isMoving()){`
116		116
117	`// trigger cameras`	117	`// trigger cameras`
118	`camera0->trigger();`	118	`camera0->trigger();`
119	`camera1->trigger();`	119	`camera1->trigger();`
120		120
121	`// retrieve frames`	121	`// retrieve frames`
122	`CameraFrame frame;`	122	`CameraFrame frame;`
123	`frame = camera0->getFrame();`	123	`frame = camera0->getFrame();`
124	`cv::Mat frameCV;`	124	`cv::Mat frameCV;`
125	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	125	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
126	`frameCV = frameCV.clone();`	126	`frameCV = frameCV.clone();`
127	`emit newFrame(0, frameCV);`	127	`emit newFrame(0, frameCV);`
128	`frame = camera1->getFrame();`	128	`frame = camera1->getFrame();`
129	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	129	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
130	`frameCV = frameCV.clone();`	130	`frameCV = frameCV.clone();`
131	`emit newFrame(1, frameCV);`	131	`emit newFrame(1, frameCV);`
132	`}`	132	`}`
133		133
134	`emit rotatedTo(angle);`	134	`emit rotatedTo(angle);`
135	`}`	135	`}`
136		136
137	`void SMCaptureWorker::acquireCalibrationSet(float angle){`	137	`void SMCaptureWorker::acquireCalibrationSet(float angle){`
138		138
139	`if(angle != -1.0)`	139	`if(angle != -1.0)`
140	`rotateTo(angle);`	140	`rotateTo(angle);`
141		141
142	`CameraFrame frame;`	142	`CameraFrame frame;`
143	`SMCalibrationSet calibrationSet;`	143	`SMCalibrationSet calibrationSet;`
144	`cv::Mat frameCVStacked0, frameCVStacked1;`	144	`cv::Mat frameCVStacked0(camera0->getFrameHeight(), camera0->getFrameWidth(), CV_16UC1, cv::Scalar(0));`
-		145	`cv::Mat frameCVStacked1(camera1->getFrameHeight(), camera1->getFrameWidth(), CV_16UC1, cv::Scalar(0));`
145		146
146	`for(int i=0; i<stacking; i++){`	147	`for(int i=0; i<stacking; i++){`
147	`// trigger cameras`	148	`// trigger cameras`
148	`camera0->trigger();`	149	`camera0->trigger();`
149	`camera1->trigger();`	150	`camera1->trigger();`
150		151
151	`// retrieve frames`	152	`// retrieve frames`
152	`frame = camera0->getFrame();`	153	`frame = camera0->getFrame();`
153	`cv::Mat frameCV;`	154	`cv::Mat frameCV;`
154	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	155	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
155	`frameCV = frameCV.clone();`	156	`frameCV = frameCV.clone();`
156	`cv::add(frameCV, frameCVStacked0, frameCVStacked0, cv::noArray(), CV_16UC1);`	157	`cv::add(frameCV, frameCVStacked0, frameCVStacked0, cv::noArray(), CV_16UC1);`
157		158
158	`emit newFrame(0, frameCV);`	159	`emit newFrame(0, frameCV);`
159		160
160	`frame = camera1->getFrame();`	161	`frame = camera1->getFrame();`
161	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	162	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
162	`frameCV = frameCV.clone();`	163	`frameCV = frameCV.clone();`
163	`cv::add(frameCV, frameCVStacked1, frameCVStacked1, cv::noArray(), CV_16UC1);`	164	`cv::add(frameCV, frameCVStacked1, frameCVStacked1, cv::noArray(), CV_16UC1);`
164		165
165	`emit newFrame(1, frameCV);`	166	`emit newFrame(1, frameCV);`
166		167
167	`}`	168	`}`
168		169
169	`frameCVStacked0.convertTo(frameCVStacked0, CV_8UC1, 1.0/stacking);`	170	`frameCVStacked0.convertTo(frameCVStacked0, CV_8UC1, 1.0/stacking);`
170	`frameCVStacked1.convertTo(frameCVStacked1, CV_8UC1, 1.0/stacking);`	171	`frameCVStacked1.convertTo(frameCVStacked1, CV_8UC1, 1.0/stacking);`
171		172
172	`calibrationSet.frame0 = frameCVStacked0;`	173	`calibrationSet.frame0 = frameCVStacked0;`
173	`calibrationSet.frame1 = frameCVStacked1;`	174	`calibrationSet.frame1 = frameCVStacked1;`
174		175
175	`calibrationSet.rotationAngle = rotationStage->getAngle();`	176	`calibrationSet.rotationAngle = rotationStage->getAngle();`
176		177
177	`emit newCalibrationSet(calibrationSet);`	178	`emit newCalibrationSet(calibrationSet);`
178	`}`	179	`}`
179		180
180	`void SMCaptureWorker::acquireCalibrationSets(std::vector<float> angles){`	181	`void SMCaptureWorker::acquireCalibrationSets(std::vector<float> angles){`
181		182
182	`for(int i=0; i<angles.size(); i++)`	183	`for(int i=0; i<angles.size(); i++)`
183	`acquireCalibrationSet(angles[i]);`	184	`acquireCalibrationSet(angles[i]);`
184	`}`	185	`}`
185		186
186	`void SMCaptureWorker::acquireFrameSequence(float angle){`	187	`void SMCaptureWorker::acquireFrameSequence(float angle){`
187		188
188	`if(angle != -1.0)`	189	`if(angle != -1.0)`
189	`rotateTo(angle);`	190	`rotateTo(angle);`
190		191
191	`CameraFrame frame;`	192	`CameraFrame frame;`
192	`SMFrameSequence frameSequence;`	193	`SMFrameSequence frameSequence;`
193		194
194	`for(unsigned int i=0; i<algorithm->getNPatterns(); i++){`	195	`for(unsigned int i=0; i<algorithm->getNPatterns(); i++){`
195		196
196	`// display pattern`	197	`// display pattern`
197	`projector->displayPattern(i);`	198	`projector->displayPattern(i);`
198		199
199	`QTest::qSleep(delay);`	200	`QTest::qSleep(delay);`
200		201
201	`cv::Mat frameCVStacked0, frameCVStacked1;`	202	`cv::Mat frameCVStacked0(camera0->getFrameHeight(), camera0->getFrameWidth(), CV_16UC1, cv::Scalar(0));`
-		203	`cv::Mat frameCVStacked1(camera1->getFrameHeight(), camera1->getFrameWidth(), CV_16UC1, cv::Scalar(0));`
202	`for(int i=0; i<stacking; i++){`	204	`for(int i=0; i<stacking; i++){`
203	`// trigger cameras`	205	`// trigger cameras`
204	`camera0->trigger();`	206	`camera0->trigger();`
205	`camera1->trigger();`	207	`camera1->trigger();`
206		208
207	`// retrieve frames`	209	`// retrieve frames`
208	`frame = camera0->getFrame();`	210	`frame = camera0->getFrame();`
209	`cv::Mat frameCV;`	211	`cv::Mat frameCV;`
210	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	212	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
211	`frameCV = frameCV.clone();`	213	`frameCV = frameCV.clone();`
212	`cv::add(frameCV, frameCVStacked0, frameCVStacked0, cv::noArray(), CV_16UC1);`	214	`cv::add(frameCV, frameCVStacked0, frameCVStacked0, cv::noArray(), CV_16UC1);`
213		215
214	`emit newFrame(0, frameCV);`	216	`emit newFrame(0, frameCV);`
215		217
216	`frame = camera1->getFrame();`	218	`frame = camera1->getFrame();`
217	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	219	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
218	`frameCV = frameCV.clone();`	220	`frameCV = frameCV.clone();`
219	`cv::add(frameCV, frameCVStacked1, frameCVStacked1, cv::noArray(), CV_16UC1);`	221	`cv::add(frameCV, frameCVStacked1, frameCVStacked1, cv::noArray(), CV_16UC1);`
220		222
221	`emit newFrame(1, frameCV);`	223	`emit newFrame(1, frameCV);`
222		224
223	`}`	225	`}`
224		226
225	`frameCVStacked0.convertTo(frameCVStacked0, CV_8UC1, 1.0/stacking);`	227	`frameCVStacked0.convertTo(frameCVStacked0, CV_8UC1, 1.0/stacking);`
226	`frameCVStacked1.convertTo(frameCVStacked1, CV_8UC1, 1.0/stacking);`	228	`frameCVStacked1.convertTo(frameCVStacked1, CV_8UC1, 1.0/stacking);`
227		229
228	`frameSequence.frames0.push_back(frameCVStacked0);`	230	`frameSequence.frames0.push_back(frameCVStacked0);`
229	`frameSequence.frames1.push_back(frameCVStacked1);`	231	`frameSequence.frames1.push_back(frameCVStacked1);`
230		232
231	`}`	233	`}`
232		234
233	`frameSequence.rotationAngle = rotationStage->getAngle();`	235	`frameSequence.rotationAngle = rotationStage->getAngle();`
234	`frameSequence.codec = codec;`	236	`frameSequence.codec = codec;`
235		237
236	`emit newFrameSequence(frameSequence);`	238	`emit newFrameSequence(frameSequence);`
237		239
238	`projector->displayWhite();`	240	`projector->displayWhite();`
239	`}`	241	`}`
240		242
241		243
242	`void SMCaptureWorker::acquireFrameSequences(std::vector<float> angles){`	244	`void SMCaptureWorker::acquireFrameSequences(std::vector<float> angles){`
243		245
244	`for(int i=0; i<angles.size(); i++)`	246	`for(int i=0; i<angles.size(); i++)`
245	`acquireFrameSequence(angles[i]);`	247	`acquireFrameSequence(angles[i]);`
246	`}`	248	`}`
247		249
248	`void SMCaptureWorker::abort(){}`	250	`void SMCaptureWorker::abort(){}`
249		251
250	`void SMCaptureWorker::stopWork(){`	252	`void SMCaptureWorker::stopWork(){`
251	`working = false;`	253	`working = false;`
252	`}`	254	`}`
253		255
254	`SMCaptureWorker::~SMCaptureWorker(){`	256	`SMCaptureWorker::~SMCaptureWorker(){`
255	`delete projector;`	257	`delete projector;`
256	`// delete camera0;`	258	`// delete camera0;`
257	`// delete camera1;`	259	`// delete camera1;`
258	`delete rotationStage;`	260	`delete rotationStage;`
259	`}`	261	`}`
260		262

Subversion Repositories seema-scanner

(root)/src/SMCaptureWorker.cpp – Rev 113 → 114