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


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

Subversion Repositories seema-scanner

(root)/src/SMCaptureWorker.cpp – Rev 139 → 159