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


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

Subversion Repositories seema-scanner

(root)/src/SMCaptureWorker.cpp – Rev 121 → 123