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


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

Subversion Repositories seema-scanner

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