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.reset(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.reset(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.reset(new ProjectorOpenGL(screenNum));
 
    // Create rotation stage
    for(int i = 0; i<10; i++){
        try{
            delete rotationStage.get();
            rotationStage = std::make_shared<RotationStage>();
            break;
        }
        catch (...){
            std::cerr << "trying to setup rotation stage" << std::endl;
        }
    }
 
    // Create Algorithm
    unsigned int screenCols, screenRows;
    projector->getScreenRes(&screenCols, &screenRows);
    codec = settings.value("algorithm", "GrayCode").toString();
    if(codec == "GrayCode")
        algorithm.reset(new AlgorithmGrayCode(screenCols, screenRows));
    else if(codec == "GrayCodeHorzVert")
        algorithm.reset(new AlgorithmGrayCodeHorzVert(screenCols, screenRows));
    else if(codec == "PhaseShiftTwoFreq")
        algorithm.reset(new AlgorithmPhaseShiftTwoFreq(screenCols, screenRows));
    else if(codec == "PhaseShiftThreeFreq")
        algorithm.reset(new AlgorithmPhaseShiftThreeFreq(screenCols, screenRows));
    else if(codec == "PhaseShiftTwoFreqHorzVert")
        algorithm.reset(new AlgorithmPhaseShiftTwoFreqHorzVert(screenCols, screenRows));
    else if(codec == "PhaseShiftEmbedded")
        algorithm.reset(new AlgorithmPhaseShiftEmbedded(screenCols, screenRows));
    else if(codec == "LineShift")
        algorithm.reset(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(100);
 
        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){
 
    // TODO is this the right check
    if(!setupSuccessful || !rotationStage || !rotationStage->Handle)
        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 || !rotationStage || !rotationStage->Handle)
        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);
 
    }
 
    if(rotationStage && rotationStage->Handle)// TODO is this the right check
        frameSequence.rotationAngle = rotationStage->getAngle();
    else
        frameSequence.rotationAngle = 0;
 
    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;
}
 
 

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

Subversion Repositories seema-scanner

(root)/src/SMCaptureWorker.cpp – Rev 208 → 223