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


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

Subversion Repositories seema-scanner

(root)/src/SMCaptureWorker.cpp – Rev 182 → 192