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


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

Subversion Repositories seema-scanner

(root)/src/SMCaptureWorker.cpp – Rev 162 → 164