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


#include "SMCaptureWorker.h"
 
#include "AlgorithmGrayCode.h"
#include "AlgorithmGrayCodeHorzVert.h"
#include "AlgorithmPhaseShiftTwoFreq.h"
#include "AlgorithmPhaseShiftThreeFreq.h"
#include "AlgorithmPhaseShiftEmbedded.h"
#include "AlgorithmLineShift.h"
 
#include <QCoreApplication>
#include <QTime>
#include <QSettings>
#include <QtTest/QTest>
 
#include "cvtools.h"
 
void SMCaptureWorker::setup(){
 
    QSettings settings;
 
    // Create cameras
    int iNum0 = settings.value("camera0/interfaceNumber", -1).toInt();
    int cNum0 = settings.value("camera0/cameraNumber", -1).toInt();
    camera0 = CameraFactory::NewCamera(iNum0,cNum0,triggerModeSoftware);
 
    if(!camera0)
        return;
 
    int iNum1 = settings.value("camera1/interfaceNumber", -1).toInt();
    int cNum1 = settings.value("camera1/cameraNumber", -1).toInt();
    camera1 = CameraFactory::NewCamera(iNum1,cNum1,triggerModeSoftware);
 
    if(!camera1)
        return;
 
    // Set camera settings
    CameraSettings cameraSettings;
    cameraSettings.shutter = settings.value("camera/shutter", 16.666).toFloat();
    cameraSettings.gain = 0.0;
 
    camera0->setCameraSettings(cameraSettings);
 
    camera1->setCameraSettings(cameraSettings);
 
    // Start capturing
    camera0->startCapture();
    camera1->startCapture();
 
    // Create projector
    //int screenNum = settings.value("projector/screenNumber", -1).toInt();
    int screenNum = settings.value("projector/screenNumber", 1).toInt();
    if(screenNum != -1)
        projector = new ProjectorOpenGL(screenNum);
 
    // Create rotation stage
    rotationStage = new RotationStage();
 
    // Create Algorithm
    unsigned int screenCols, screenRows;
    projector->getScreenRes(&screenCols, &screenRows);
    codec = settings.value("algorithm", "GrayCode").toString();
    if(codec == "GrayCode")
        algorithm = new AlgorithmGrayCode(screenCols, screenRows);
    else if(codec == "GrayCodeHorzVert")
        algorithm = new AlgorithmGrayCodeHorzVert(screenCols, screenRows);
    else if(codec == "PhaseShiftTwoFreq")
        algorithm = new AlgorithmPhaseShiftTwoFreq(screenCols, screenRows);
    else if(codec == "PhaseShiftThreeFreq")
        algorithm = new AlgorithmPhaseShiftThreeFreq(screenCols, screenRows);
    else if(codec == "PhaseShiftEmbedded")
        algorithm = new AlgorithmPhaseShiftEmbedded(screenCols, screenRows);
    else if(codec == "LineShift")
        algorithm = new AlgorithmLineShift(screenCols, screenRows);
    else
        std::cerr << "SMCaptureWorker: invalid codec " << codec.toStdString() << std::endl;
 
    // Upload patterns to projector/GPU
    for(unsigned int i=0; i<algorithm->getNPatterns(); i++){
        cv::Mat pattern = algorithm->getEncodingPattern(i);
        projector->setPattern(i, pattern.ptr(), pattern.cols, pattern.rows);
    }
 
    delay = settings.value("trigger/delay", 50).toInt();
    stackingCalibration = settings.value("stacking/calibration", 1).toInt();
    stackingAcquisition= settings.value("stacking/acquisition", 1).toInt();
 
    setupSuccessful = true;
}
 
 
void SMCaptureWorker::doWork(){
 
    if(!setupSuccessful)
        return;
 
    working = true;
 
    cv::Mat checkerboard(8, 8, CV_8UC3);
    checkerboard.setTo(0);
    checkerboard.rowRange(0, 4).colRange(0, 4).setTo(cv::Vec3b(255,255,255));
    checkerboard.rowRange(4, 8).colRange(4, 8).setTo(cv::Vec3b(255,255,255));
 
    // Processing loop
//    QTime time;
//    time.start();
    while(working){
 
        if(focusingPattern)
            projector->displayTexture(checkerboard.ptr(), checkerboard.cols, checkerboard.rows);
        else
            projector->displayWhite();
 
 
        // prevent image acquisition timeout
        QTest::qSleep(10);
 
        CameraFrame frame;
 
        // trigger cameras
        camera0->trigger();
        camera1->trigger();
 
        // retrieve raw frames
        frame = camera0->getFrame();
        cv::Mat frameCV;
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);
        frameCV = frameCV.clone();
//        cvtools::rshift(frameCV, 8);
//        frameCV.convertTo(frameCV, CV_8UC1);
        emit newFrame(0, frameCV);
 
        frame = camera1->getFrame();
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);
        frameCV = frameCV.clone();
//        cvtools::rshift(frameCV, 8);
//        frameCV.convertTo(frameCV, CV_8UC1);
        emit newFrame(1, frameCV);
 
        //std::cout << "SMCaptureWorker idle " << time.restart() << "ms" << std::endl;
 
        // Process events e.g. perform a task
        QCoreApplication::processEvents();
    }
 
    emit finished();
}
 
void SMCaptureWorker::rotateTo(float angle){
 
    if(!setupSuccessful)
        return;
 
    rotationStage->moveAbsolute(angle);
 
    while(rotationStage->isMoving()){
 
        // prevent grab timeout in flycapture
        QTest::qSleep(10);
 
        // trigger cameras
        camera0->trigger();
        camera1->trigger();
 
        // retrieve frames
        CameraFrame frame;
        frame = camera0->getFrame();
        cv::Mat frameCV;
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);
        frameCV = frameCV.clone();
        emit newFrame(0, frameCV);
        frame = camera1->getFrame();
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);
        frameCV = frameCV.clone();
        emit newFrame(1, frameCV);
    }
 
    emit rotatedTo(angle);
}
 
void SMCaptureWorker::acquireCalibrationSet(float angle){
 
    if(!setupSuccessful)
        return;
 
    if(angle != -1.0)
        rotateTo(angle);
 
    projector->displayWhite();
 
    // just for safe measures
    QTest::qSleep(500);
 
    CameraFrame frame;
    SMCalibrationSet calibrationSet;
    cv::Mat frameCVStacked0(camera0->getFrameHeight(), camera0->getFrameWidth(), CV_32SC1, cv::Scalar(0));
    cv::Mat frameCVStacked1(camera1->getFrameHeight(), camera1->getFrameWidth(), CV_32SC1, cv::Scalar(0));
 
    for(int i=0; i<stackingCalibration; i++){
        // trigger cameras
        camera0->trigger();
        camera1->trigger();
 
        // retrieve frames
        frame = camera0->getFrame();
        cv::Mat frameCV;
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);
        frameCV = frameCV.clone();
        cv::add(frameCV, frameCVStacked0, frameCVStacked0, cv::noArray(), CV_32SC1);
//cvtools::writeMat(frameCV, "frameCV.mat", "frameCV");
//cvtools::writeMat(frameCVStacked0, "frameCVStacked0.mat", "frameCVStacked0");
        emit newFrame(0, frameCV);
 
        frame = camera1->getFrame();
        frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);
        frameCV = frameCV.clone();
        cv::add(frameCV, frameCVStacked1, frameCVStacked1, cv::noArray(), CV_32SC1);
 
        emit newFrame(1, frameCV);
 
    }
 
    frameCVStacked0.convertTo(frameCVStacked0, CV_8UC1, 1.0/stackingCalibration);
//cvtools::writeMat(frameCVStacked0, "frameCVStacked0a.mat", "frameCVStacked0a");
    frameCVStacked1.convertTo(frameCVStacked1, CV_8UC1, 1.0/stackingCalibration);
 
    calibrationSet.frame0 = frameCVStacked0;
    calibrationSet.frame1 = frameCVStacked1;
 
    calibrationSet.rotationAngle = rotationStage->getAngle();
 
    emit newCalibrationSet(calibrationSet);
}
 
void SMCaptureWorker::acquireCalibrationSets(std::vector<float> angles){
 
    if(!setupSuccessful)
        return;
 
    for(unsigned int i=0; i<angles.size(); i++)
        acquireCalibrationSet(angles[i]);
}
 
void SMCaptureWorker::acquireFrameSequence(float angle){
 
    if(!setupSuccessful)
        return;
 
    if(angle != -1.0)
        rotateTo(angle);
 
    CameraFrame frame;
    SMFrameSequence frameSequence;
 
    for(unsigned int i=0; i<algorithm->getNPatterns(); i++){
 
        // display pattern
        projector->displayPattern(i);
 
        QTest::qSleep(delay);
 
        cv::Mat frameCVStacked0(camera0->getFrameHeight(), camera0->getFrameWidth(), CV_32SC1, cv::Scalar(0));
        cv::Mat frameCVStacked1(camera1->getFrameHeight(), camera1->getFrameWidth(), CV_32SC1, cv::Scalar(0));
        for(int i=0; i<stackingAcquisition; i++){
            // trigger cameras
            camera0->trigger();
            camera1->trigger();
 
            // retrieve frames
            frame = camera0->getFrame();
            cv::Mat frameCV;
            frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);
            frameCV = frameCV.clone();
            cv::add(frameCV, frameCVStacked0, frameCVStacked0, cv::noArray(), CV_32SC1);
 
            emit newFrame(0, frameCV);
 
            frame = camera1->getFrame();
            frameCV  = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);
            frameCV = frameCV.clone();
            cv::add(frameCV, frameCVStacked1, frameCVStacked1, cv::noArray(), CV_32SC1);
 
            emit newFrame(1, frameCV);
 
        }
 
        frameCVStacked0.convertTo(frameCVStacked0, CV_8UC1, 1.0/stackingAcquisition);
        frameCVStacked1.convertTo(frameCVStacked1, CV_8UC1, 1.0/stackingAcquisition);
 
        frameSequence.frames0.push_back(frameCVStacked0);
        frameSequence.frames1.push_back(frameCVStacked1);
 
    }
 
    frameSequence.rotationAngle = rotationStage->getAngle();
    frameSequence.codec = codec;
 
    emit newFrameSequence(frameSequence);
 
    projector->displayWhite();
}
 
 
void SMCaptureWorker::acquireFrameSequences(std::vector<float> angles){
 
    if(!setupSuccessful)
        return;
 
    for(unsigned int i=0; i<angles.size(); i++)
        acquireFrameSequence(angles[i]);
}
 
void SMCaptureWorker::abort(){}
 
void SMCaptureWorker::stopWork(){
    working = false;
}
 
SMCaptureWorker::~SMCaptureWorker(){
    delete projector;
    delete camera0;
    delete camera1;
    delete rotationStage;
}
 

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

Subversion Repositories seema-scanner

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