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

Subversion Repositories seema-scanner

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