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

Subversion Repositories seema-scanner

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