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

Subversion Repositories seema-scanner

(root)/src/SMCaptureWorker.cpp – Rev 134 → 137