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;
//        }
//    }
    rotationStage.reset();
    rotationStage.reset(new RotationStage());
 
    // 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::acquireFrameSequenceLDR(SMFrameSequence &frameSequence){
 
    CameraFrame frame;
 
    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);
 
    }
 
 
}
 
void SMCaptureWorker::acquireFrameSequenceHDR(SMFrameSequence &frameSequence){
 
    QSettings settings;
    QString shuttersString = settings.value("camera/shuttersHDR").toString();
    QStringList list = shuttersString.split("/");
    std::vector<float> shutters(list.size());
    for(int i=0; i<list.size(); i++)
        shutters[i] = list[i].toFloat();
    if(shutters.empty()){
        std::cerr << "Could not read HDR shutter times" << std::endl;
        return;
    }
 
    int nShutters = shutters.size();
 
    std::vector<SMFrameSequence> frameSequences(nShutters);
 
    CameraSettings cameraSettings;
 
    for(int i=0; i<nShutters; i++){
 
        // Set camera shutter
        cameraSettings.shutter = shutters[i];
 
        // assert that shutter is given in ms
        assert(cameraSettings.shutter < 2000.0);
 
        camera0->setCameraSettings(cameraSettings);
        camera1->setCameraSettings(cameraSettings);
 
        // Project/acquire sequence
        acquireFrameSequenceLDR(frameSequences[i]);
 
    }
 
    unsigned int nFrames = frameSequences[0].frames0.size();
    int nRows = frameSequences[0].frames0[0].rows;
    int nCols = frameSequences[0].frames0[0].cols;
 
    // Debayer images, since cvtColor cannot debayer floating point images
    for(int j=0; j<nShutters; j++){
        for(unsigned int i=0; i<nFrames; i++){
            cv::cvtColor(frameSequences[j].frames0[i], frameSequences[j].frames0[i], CV_BayerBG2GRAY);
            cv::cvtColor(frameSequences[j].frames1[i], frameSequences[j].frames1[i], CV_BayerBG2GRAY);
        }
    }
 
    // Merge into HDR
    frameSequence.frames0.resize(nFrames);
    frameSequence.frames1.resize(nFrames);
 
    float shutterMean = 0.0;
    for(unsigned int i=0; i<shutters.size(); i++)
        shutterMean += shutters[i]/shutters.size();
 
    for(unsigned int i=0; i<nFrames; i++){
        frameSequence.frames0[i].create(nRows, nCols, CV_32F);
        frameSequence.frames1[i].create(nRows, nCols, CV_32F);
 
    }
 
 
    frameSequence.frames0[0].setTo(0.0);
    frameSequence.frames1[0].setTo(0.0);
 
 
 
 
 
 
 
 
 
    #pragma omp parallel for
 
 
 
    for(int j=nShutters-1; j>=0; j--){
 
        cv::Mat mask0 = (frameSequences[j].frames0[0] < 250) & (frameSequence.frames0[0] == 0);
        cv::Mat mask1 = (frameSequences[j].frames1[0] < 250) & (frameSequence.frames1[0] == 0);
 
 
        for(unsigned int i=0; i<nFrames; i++){
            cv::add((shutterMean/shutters[j]) * frameSequences[j].frames0[i], frameSequence.frames0[i], frameSequence.frames0[i], mask0);
            cv::add((shutterMean/shutters[j]) * frameSequences[j].frames1[i], frameSequence.frames1[i], frameSequence.frames1[i], mask1);
 
 
 
 
        }
 
    }
 
    // Set camera shutter back to default
    cameraSettings.shutter = settings.value("shutter", 66.666).toFloat();
 
    camera0->setCameraSettings(cameraSettings);
    camera1->setCameraSettings(cameraSettings);
 
    // TODO: we need to somehow make the debayer function cvtColor accept floating point images...
}
 
 
void SMCaptureWorker::acquireFrameSequence(float angle){
 
    if(!setupSuccessful)
        return;
 
    if(int(angle) != -1.0)
        rotateTo(angle);
 
    SMFrameSequence frameSequence;
 
    QSettings settings;
    if(settings.contains("camera/shuttersHDR"))
        acquireFrameSequenceHDR(frameSequence);
    else
        acquireFrameSequenceLDR(frameSequence);
 
 
    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 242	Rev 244
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	`camera1->setCameraSettings(cameraSettings);`	43	`camera1->setCameraSettings(cameraSettings);`
44		44
45	`// Start capturing`	45	`// Start capturing`
46	`camera0->startCapture();`	46	`camera0->startCapture();`
47	`camera1->startCapture();`	47	`camera1->startCapture();`
48		48
49	`// Create projector`	49	`// Create projector`
50	`//int screenNum = settings.value("projector/screenNumber", -1).toInt();`	50	`//int screenNum = settings.value("projector/screenNumber", -1).toInt();`
51	`int screenNum = settings.value("projector/screenNumber", 1).toInt();`	51	`int screenNum = settings.value("projector/screenNumber", 1).toInt();`
52	`if(screenNum != -1)`	52	`if(screenNum != -1)`
53	`projector.reset(new ProjectorOpenGL(screenNum));`	53	`projector.reset(new ProjectorOpenGL(screenNum));`
54		54
55	`// // Create rotation stage`	55	`// // Create rotation stage`
56	`// for(int i = 0; i<10; i++){`	56	`// for(int i = 0; i<10; i++){`
57	`// try{`	57	`// try{`
58	`// delete rotationStage.get();`	58	`// delete rotationStage.get();`
59	`// rotationStage = std::make_shared<RotationStage>();`	59	`// rotationStage = std::make_shared<RotationStage>();`
60	`// break;`	60	`// break;`
61	`// }`	61	`// }`
62	`// catch (...){`	62	`// catch (...){`
63	`// std::cerr << "trying to setup rotation stage" << std::endl;`	63	`// std::cerr << "trying to setup rotation stage" << std::endl;`
64	`// }`	64	`// }`
65	`// }`	65	`// }`
66	`rotationStage.reset();`	66	`rotationStage.reset();`
67	`rotationStage.reset(new RotationStage());`	67	`rotationStage.reset(new RotationStage());`
68		68
69	`// Create Algorithm`	69	`// Create Algorithm`
70	`unsigned int screenCols, screenRows;`	70	`unsigned int screenCols, screenRows;`
71	`projector->getScreenRes(&screenCols, &screenRows);`	71	`projector->getScreenRes(&screenCols, &screenRows);`
72	`codec = settings.value("algorithm", "GrayCode").toString();`	72	`codec = settings.value("algorithm", "GrayCode").toString();`
73	`if(codec == "GrayCode")`	73	`if(codec == "GrayCode")`
74	`algorithm.reset(new AlgorithmGrayCode(screenCols, screenRows));`	74	`algorithm.reset(new AlgorithmGrayCode(screenCols, screenRows));`
75	`else if(codec == "GrayCodeHorzVert")`	75	`else if(codec == "GrayCodeHorzVert")`
76	`algorithm.reset(new AlgorithmGrayCodeHorzVert(screenCols, screenRows));`	76	`algorithm.reset(new AlgorithmGrayCodeHorzVert(screenCols, screenRows));`
77	`else if(codec == "PhaseShiftTwoFreq")`	77	`else if(codec == "PhaseShiftTwoFreq")`
78	`algorithm.reset(new AlgorithmPhaseShiftTwoFreq(screenCols, screenRows));`	78	`algorithm.reset(new AlgorithmPhaseShiftTwoFreq(screenCols, screenRows));`
79	`else if(codec == "PhaseShiftThreeFreq")`	79	`else if(codec == "PhaseShiftThreeFreq")`
80	`algorithm.reset(new AlgorithmPhaseShiftThreeFreq(screenCols, screenRows));`	80	`algorithm.reset(new AlgorithmPhaseShiftThreeFreq(screenCols, screenRows));`
81	`else if(codec == "PhaseShiftTwoFreqHorzVert")`	81	`else if(codec == "PhaseShiftTwoFreqHorzVert")`
82	`algorithm.reset(new AlgorithmPhaseShiftTwoFreqHorzVert(screenCols, screenRows));`	82	`algorithm.reset(new AlgorithmPhaseShiftTwoFreqHorzVert(screenCols, screenRows));`
83	`else if(codec == "PhaseShiftEmbedded")`	83	`else if(codec == "PhaseShiftEmbedded")`
84	`algorithm.reset(new AlgorithmPhaseShiftEmbedded(screenCols, screenRows));`	84	`algorithm.reset(new AlgorithmPhaseShiftEmbedded(screenCols, screenRows));`
85	`else if(codec == "LineShift")`	85	`else if(codec == "LineShift")`
86	`algorithm.reset(new AlgorithmLineShift(screenCols, screenRows));`	86	`algorithm.reset(new AlgorithmLineShift(screenCols, screenRows));`
87	`else`	87	`else`
88	`std::cerr << "SMCaptureWorker: invalid codec " << codec.toStdString() << std::endl;`	88	`std::cerr << "SMCaptureWorker: invalid codec " << codec.toStdString() << std::endl;`
89		89
90	`// Upload patterns to projector/GPU`	90	`// Upload patterns to projector/GPU`
91	`for(unsigned int i=0; i<algorithm->getNPatterns(); i++){`	91	`for(unsigned int i=0; i<algorithm->getNPatterns(); i++){`
92	`cv::Mat pattern = algorithm->getEncodingPattern(i);`	92	`cv::Mat pattern = algorithm->getEncodingPattern(i);`
93	`projector->setPattern(i, pattern.ptr(), pattern.cols, pattern.rows);`	93	`projector->setPattern(i, pattern.ptr(), pattern.cols, pattern.rows);`
94	`}`	94	`}`
95		95
96	`delay = settings.value("trigger/delay", 50).toInt();`	96	`delay = settings.value("trigger/delay", 50).toInt();`
97	`stackingCalibration = settings.value("stacking/calibration", 1).toInt();`	97	`stackingCalibration = settings.value("stacking/calibration", 1).toInt();`
98	`stackingAcquisition= settings.value("stacking/acquisition", 1).toInt();`	98	`stackingAcquisition= settings.value("stacking/acquisition", 1).toInt();`
99		99
100	`setupSuccessful = true;`	100	`setupSuccessful = true;`
101	`}`	101	`}`
102		102
103		103
104	`void SMCaptureWorker::doWork(){`	104	`void SMCaptureWorker::doWork(){`
105		105
106	`if(!setupSuccessful)`	106	`if(!setupSuccessful)`
107	`return;`	107	`return;`
108		108
109	`working = true;`	109	`working = true;`
110		110
111	`cv::Mat checkerboard(8, 8, CV_8UC3);`	111	`cv::Mat checkerboard(8, 8, CV_8UC3);`
112	`checkerboard.setTo(0);`	112	`checkerboard.setTo(0);`
113	`checkerboard.rowRange(0, 4).colRange(0, 4).setTo(cv::Vec3b(255,255,255));`	113	`checkerboard.rowRange(0, 4).colRange(0, 4).setTo(cv::Vec3b(255,255,255));`
114	`checkerboard.rowRange(4, 8).colRange(4, 8).setTo(cv::Vec3b(255,255,255));`	114	`checkerboard.rowRange(4, 8).colRange(4, 8).setTo(cv::Vec3b(255,255,255));`
115		115
116	`// Processing loop`	116	`// Processing loop`
117	`// QTime time;`	117	`// QTime time;`
118	`// time.start();`	118	`// time.start();`
119	`while(working){`	119	`while(working){`
120		120
121	`if(focusingPattern)`	121	`if(focusingPattern)`
122	`projector->displayTexture(checkerboard.ptr(), checkerboard.cols, checkerboard.rows);`	122	`projector->displayTexture(checkerboard.ptr(), checkerboard.cols, checkerboard.rows);`
123	`else`	123	`else`
124	`projector->displayWhite();`	124	`projector->displayWhite();`
125		125
126		126
127	`// prevent image acquisition timeout`	127	`// prevent image acquisition timeout`
128	`QTest::qSleep(100);`	128	`QTest::qSleep(100);`
129		129
130	`CameraFrame frame;`	130	`CameraFrame frame;`
131		131
132	`// trigger cameras`	132	`// trigger cameras`
133	`camera0->trigger();`	133	`camera0->trigger();`
134	`camera1->trigger();`	134	`camera1->trigger();`
135		135
136	`// retrieve raw frames`	136	`// retrieve raw frames`
137	`frame = camera0->getFrame();`	137	`frame = camera0->getFrame();`
138	`cv::Mat frameCV;`	138	`cv::Mat frameCV;`
139	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	139	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
140	`frameCV = frameCV.clone();`	140	`frameCV = frameCV.clone();`
141	`// cvtools::rshift(frameCV, 8);`	141	`// cvtools::rshift(frameCV, 8);`
142	`// frameCV.convertTo(frameCV, CV_8UC1);`	142	`// frameCV.convertTo(frameCV, CV_8UC1);`
143	`emit newFrame(0, frameCV);`	143	`emit newFrame(0, frameCV);`
144		144
145	`frame = camera1->getFrame();`	145	`frame = camera1->getFrame();`
146	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	146	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
147	`frameCV = frameCV.clone();`	147	`frameCV = frameCV.clone();`
148	`// cvtools::rshift(frameCV, 8);`	148	`// cvtools::rshift(frameCV, 8);`
149	`// frameCV.convertTo(frameCV, CV_8UC1);`	149	`// frameCV.convertTo(frameCV, CV_8UC1);`
150	`emit newFrame(1, frameCV);`	150	`emit newFrame(1, frameCV);`
151		151
152	`//std::cout << "SMCaptureWorker idle " << time.restart() << "ms" << std::endl;`	152	`//std::cout << "SMCaptureWorker idle " << time.restart() << "ms" << std::endl;`
153		153
154	`// Process events e.g. perform a task`	154	`// Process events e.g. perform a task`
155	`QCoreApplication::processEvents();`	155	`QCoreApplication::processEvents();`
156	`}`	156	`}`
157		157
158	`emit finished();`	158	`emit finished();`
159	`}`	159	`}`
160		160
161	`void SMCaptureWorker::rotateTo(float angle){`	161	`void SMCaptureWorker::rotateTo(float angle){`
162	`// TODO is this the right check`	162	`// TODO is this the right check`
163	`if(!setupSuccessful \|\| !rotationStage \|\| !rotationStage->Handle)`	163	`if(!setupSuccessful \|\| !rotationStage \|\| !rotationStage->Handle)`
164	`return;`	164	`return;`
165		165
166	`rotationStage->moveAbsolute(angle);`	166	`rotationStage->moveAbsolute(angle);`
167	`while(rotationStage->isMoving()){`	167	`while(rotationStage->isMoving()){`
168		168
169	`// prevent grab timeout in flycapture`	169	`// prevent grab timeout in flycapture`
170	`QTest::qSleep(10);`	170	`QTest::qSleep(10);`
171		171
172	`// trigger cameras`	172	`// trigger cameras`
173	`camera0->trigger();`	173	`camera0->trigger();`
174	`camera1->trigger();`	174	`camera1->trigger();`
175		175
176	`// retrieve frames`	176	`// retrieve frames`
177	`CameraFrame frame;`	177	`CameraFrame frame;`
178	`frame = camera0->getFrame();`	178	`frame = camera0->getFrame();`
179	`cv::Mat frameCV;`	179	`cv::Mat frameCV;`
180	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	180	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
181	`frameCV = frameCV.clone();`	181	`frameCV = frameCV.clone();`
182	`emit newFrame(0, frameCV);`	182	`emit newFrame(0, frameCV);`
183	`frame = camera1->getFrame();`	183	`frame = camera1->getFrame();`
184	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	184	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
185	`frameCV = frameCV.clone();`	185	`frameCV = frameCV.clone();`
186	`emit newFrame(1, frameCV);`	186	`emit newFrame(1, frameCV);`
187	`}`	187	`}`
188		188
189	`emit rotatedTo(angle);`	189	`emit rotatedTo(angle);`
190	`}`	190	`}`
191		191
192	`void SMCaptureWorker::acquireCalibrationSet(float angle){`	192	`void SMCaptureWorker::acquireCalibrationSet(float angle){`
193	`if(!setupSuccessful \|\| !rotationStage \|\| !rotationStage->Handle)`	193	`if(!setupSuccessful \|\| !rotationStage \|\| !rotationStage->Handle)`
194	`return;`	194	`return;`
195		195
196	`if(angle != -1.0)`	196	`if(angle != -1.0)`
197	`rotateTo(angle);`	197	`rotateTo(angle);`
198		198
199	`projector->displayWhite();`	199	`projector->displayWhite();`
200		200
201	`// just for safe measures`	201	`// just for safe measures`
202	`QTest::qSleep(500);`	202	`QTest::qSleep(500);`
203		203
204	`CameraFrame frame;`	204	`CameraFrame frame;`
205	`SMCalibrationSet calibrationSet;`	205	`SMCalibrationSet calibrationSet;`
206	`cv::Mat frameCVStacked0(camera0->getFrameHeight(), camera0->getFrameWidth(), CV_32SC1, cv::Scalar(0));`	206	`cv::Mat frameCVStacked0(camera0->getFrameHeight(), camera0->getFrameWidth(), CV_32SC1, cv::Scalar(0));`
207	`cv::Mat frameCVStacked1(camera1->getFrameHeight(), camera1->getFrameWidth(), CV_32SC1, cv::Scalar(0));`	207	`cv::Mat frameCVStacked1(camera1->getFrameHeight(), camera1->getFrameWidth(), CV_32SC1, cv::Scalar(0));`
208		208
209	`for(int i=0; i<stackingCalibration; i++){`	209	`for(int i=0; i<stackingCalibration; i++){`
210	`// trigger cameras`	210	`// trigger cameras`
211	`camera0->trigger();`	211	`camera0->trigger();`
212	`camera1->trigger();`	212	`camera1->trigger();`
213		213
214	`// retrieve frames`	214	`// retrieve frames`
215	`frame = camera0->getFrame();`	215	`frame = camera0->getFrame();`
216	`cv::Mat frameCV;`	216	`cv::Mat frameCV;`
217	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	217	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
218	`frameCV = frameCV.clone();`	218	`frameCV = frameCV.clone();`
219	`cv::add(frameCV, frameCVStacked0, frameCVStacked0, cv::noArray(), CV_32SC1);`	219	`cv::add(frameCV, frameCVStacked0, frameCVStacked0, cv::noArray(), CV_32SC1);`
220	`//cvtools::writeMat(frameCV, "frameCV.mat", "frameCV");`	220	`//cvtools::writeMat(frameCV, "frameCV.mat", "frameCV");`
221	`//cvtools::writeMat(frameCVStacked0, "frameCVStacked0.mat", "frameCVStacked0");`	221	`//cvtools::writeMat(frameCVStacked0, "frameCVStacked0.mat", "frameCVStacked0");`
222	`emit newFrame(0, frameCV);`	222	`emit newFrame(0, frameCV);`
223		223
224	`frame = camera1->getFrame();`	224	`frame = camera1->getFrame();`
225	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	225	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
226	`frameCV = frameCV.clone();`	226	`frameCV = frameCV.clone();`
227	`cv::add(frameCV, frameCVStacked1, frameCVStacked1, cv::noArray(), CV_32SC1);`	227	`cv::add(frameCV, frameCVStacked1, frameCVStacked1, cv::noArray(), CV_32SC1);`
228		228
229	`emit newFrame(1, frameCV);`	229	`emit newFrame(1, frameCV);`
230		230
231	`}`	231	`}`
232		232
233	`frameCVStacked0.convertTo(frameCVStacked0, CV_8UC1, 1.0/stackingCalibration);`	233	`frameCVStacked0.convertTo(frameCVStacked0, CV_8UC1, 1.0/stackingCalibration);`
234	`//cvtools::writeMat(frameCVStacked0, "frameCVStacked0a.mat", "frameCVStacked0a");`	234	`//cvtools::writeMat(frameCVStacked0, "frameCVStacked0a.mat", "frameCVStacked0a");`
235	`frameCVStacked1.convertTo(frameCVStacked1, CV_8UC1, 1.0/stackingCalibration);`	235	`frameCVStacked1.convertTo(frameCVStacked1, CV_8UC1, 1.0/stackingCalibration);`
236		236
237	`calibrationSet.frame0 = frameCVStacked0;`	237	`calibrationSet.frame0 = frameCVStacked0;`
238	`calibrationSet.frame1 = frameCVStacked1;`	238	`calibrationSet.frame1 = frameCVStacked1;`
239		239
240	`calibrationSet.rotationAngle = rotationStage->getAngle();`	240	`calibrationSet.rotationAngle = rotationStage->getAngle();`
241		241
242	`emit newCalibrationSet(calibrationSet);`	242	`emit newCalibrationSet(calibrationSet);`
243	`}`	243	`}`
244		244
245	`void SMCaptureWorker::acquireCalibrationSets(std::vector<float> angles){`	245	`void SMCaptureWorker::acquireCalibrationSets(std::vector<float> angles){`
246		246
247	`if(!setupSuccessful)`	247	`if(!setupSuccessful)`
248	`return;`	248	`return;`
249		249
250	`for(unsigned int i=0; i<angles.size(); i++)`	250	`for(unsigned int i=0; i<angles.size(); i++)`
251	`acquireCalibrationSet(angles[i]);`	251	`acquireCalibrationSet(angles[i]);`
252	`}`	252	`}`
253		253
254	`void SMCaptureWorker::acquireFrameSequenceLDR(SMFrameSequence &frameSequence){`	254	`void SMCaptureWorker::acquireFrameSequenceLDR(SMFrameSequence &frameSequence){`
255		255
256	`CameraFrame frame;`	256	`CameraFrame frame;`
257		257
258	`for(unsigned int i=0; i<algorithm->getNPatterns(); i++){`	258	`for(unsigned int i=0; i<algorithm->getNPatterns(); i++){`
259		259
260	`// display pattern`	260	`// display pattern`
261	`projector->displayPattern(i);`	261	`projector->displayPattern(i);`
262		262
263	`QTest::qSleep(delay);`	263	`QTest::qSleep(delay);`
264		264
265	`cv::Mat frameCVStacked0(camera0->getFrameHeight(), camera0->getFrameWidth(), CV_32SC1, cv::Scalar(0));`	265	`cv::Mat frameCVStacked0(camera0->getFrameHeight(), camera0->getFrameWidth(), CV_32SC1, cv::Scalar(0));`
266	`cv::Mat frameCVStacked1(camera1->getFrameHeight(), camera1->getFrameWidth(), CV_32SC1, cv::Scalar(0));`	266	`cv::Mat frameCVStacked1(camera1->getFrameHeight(), camera1->getFrameWidth(), CV_32SC1, cv::Scalar(0));`
267	`for(int i=0; i<stackingAcquisition; i++){`	267	`for(int i=0; i<stackingAcquisition; i++){`
268	`// trigger cameras`	268	`// trigger cameras`
269	`camera0->trigger();`	269	`camera0->trigger();`
270	`camera1->trigger();`	270	`camera1->trigger();`
271		271
272	`// retrieve frames`	272	`// retrieve frames`
273	`frame = camera0->getFrame();`	273	`frame = camera0->getFrame();`
274	`cv::Mat frameCV;`	274	`cv::Mat frameCV;`
275	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	275	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
276	`frameCV = frameCV.clone();`	276	`frameCV = frameCV.clone();`
277	`cv::add(frameCV, frameCVStacked0, frameCVStacked0, cv::noArray(), CV_32SC1);`	277	`cv::add(frameCV, frameCVStacked0, frameCVStacked0, cv::noArray(), CV_32SC1);`
278		278
279	`emit newFrame(0, frameCV);`	279	`emit newFrame(0, frameCV);`
280		280
281	`frame = camera1->getFrame();`	281	`frame = camera1->getFrame();`
282	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`	282	`frameCV = cv::Mat(frame.height, frame.width, CV_8UC1, frame.memory);`
283	`frameCV = frameCV.clone();`	283	`frameCV = frameCV.clone();`
284	`cv::add(frameCV, frameCVStacked1, frameCVStacked1, cv::noArray(), CV_32SC1);`	284	`cv::add(frameCV, frameCVStacked1, frameCVStacked1, cv::noArray(), CV_32SC1);`
285		285
286	`emit newFrame(1, frameCV);`	286	`emit newFrame(1, frameCV);`
287		287
288	`}`	288	`}`
289		289
290	`frameCVStacked0.convertTo(frameCVStacked0, CV_8UC1, 1.0/stackingAcquisition);`	290	`frameCVStacked0.convertTo(frameCVStacked0, CV_8UC1, 1.0/stackingAcquisition);`
291	`frameCVStacked1.convertTo(frameCVStacked1, CV_8UC1, 1.0/stackingAcquisition);`	291	`frameCVStacked1.convertTo(frameCVStacked1, CV_8UC1, 1.0/stackingAcquisition);`
292		292
293	`frameSequence.frames0.push_back(frameCVStacked0);`	293	`frameSequence.frames0.push_back(frameCVStacked0);`
294	`frameSequence.frames1.push_back(frameCVStacked1);`	294	`frameSequence.frames1.push_back(frameCVStacked1);`
295		295
296	`}`	296	`}`
297		297
298		298
299	`}`	299	`}`
300		300
301	`void SMCaptureWorker::acquireFrameSequenceHDR(SMFrameSequence &frameSequence){`	301	`void SMCaptureWorker::acquireFrameSequenceHDR(SMFrameSequence &frameSequence){`
302		302
303	`QSettings settings;`	303	`QSettings settings;`
304	`QString shuttersString = settings.value("camera/shuttersHDR").toString();`	304	`QString shuttersString = settings.value("camera/shuttersHDR").toString();`
305	`QStringList list = shuttersString.split("/");`	305	`QStringList list = shuttersString.split("/");`
306	`std::vector<float> shutters(list.size());`	306	`std::vector<float> shutters(list.size());`
307	`for(int i=0; i<list.size(); i++)`	307	`for(int i=0; i<list.size(); i++)`
308	`shutters[i] = list[i].toFloat();`	308	`shutters[i] = list[i].toFloat();`
309	`if(shutters.empty()){`	309	`if(shutters.empty()){`
310	`std::cerr << "Could not read HDR shutter times" << std::endl;`	310	`std::cerr << "Could not read HDR shutter times" << std::endl;`
311	`return;`	311	`return;`
312	`}`	312	`}`
313		313
314	`int nShutters = shutters.size();`	314	`int nShutters = shutters.size();`
315		315
316	`std::vector<SMFrameSequence> frameSequences(nShutters);`	316	`std::vector<SMFrameSequence> frameSequences(nShutters);`
317		317
318	`CameraSettings cameraSettings;`	318	`CameraSettings cameraSettings;`
319		319
320	`for(int i=0; i<nShutters; i++){`	320	`for(int i=0; i<nShutters; i++){`
321		321
322	`// Set camera shutter`	322	`// Set camera shutter`
323	`cameraSettings.shutter = shutters[i];`	323	`cameraSettings.shutter = shutters[i];`
324		324
325	`// assert that shutter is given in ms`	325	`// assert that shutter is given in ms`
326	`assert(cameraSettings.shutter < 2000.0);`	326	`assert(cameraSettings.shutter < 2000.0);`
327		327
328	`camera0->setCameraSettings(cameraSettings);`	328	`camera0->setCameraSettings(cameraSettings);`
329	`camera1->setCameraSettings(cameraSettings);`	329	`camera1->setCameraSettings(cameraSettings);`
330		330
331	`// Project/acquire sequence`	331	`// Project/acquire sequence`
332	`acquireFrameSequenceLDR(frameSequences[i]);`	332	`acquireFrameSequenceLDR(frameSequences[i]);`
333		333
334	`}`	334	`}`
335		335
336	`unsigned int nFrames = frameSequences[0].frames0.size();`	336	`unsigned int nFrames = frameSequences[0].frames0.size();`
337	`int nRows = frameSequences[0].frames0[0].rows;`	337	`int nRows = frameSequences[0].frames0[0].rows;`
338	`int nCols = frameSequences[0].frames0[0].cols;`	338	`int nCols = frameSequences[0].frames0[0].cols;`
339		339
-		340	`// Debayer images, since cvtColor cannot debayer floating point images`
-		341	`for(int j=0; j<nShutters; j++){`
-		342	`for(unsigned int i=0; i<nFrames; i++){`
-		343	`cv::cvtColor(frameSequences[j].frames0[i], frameSequences[j].frames0[i], CV_BayerBG2GRAY);`
-		344	`cv::cvtColor(frameSequences[j].frames1[i], frameSequences[j].frames1[i], CV_BayerBG2GRAY);`
-		345	`}`
-		346	`}`
-		347
340	`// Merge into HDR`	348	`// Merge into HDR`
341	`frameSequence.frames0.resize(nFrames);`	349	`frameSequence.frames0.resize(nFrames);`
342	`frameSequence.frames1.resize(nFrames);`	350	`frameSequence.frames1.resize(nFrames);`
343		351
344	`float shutterMean = 0.0;`	352	`float shutterMean = 0.0;`
345	`for(unsigned int i=0; i<shutters.size(); i++)`	353	`for(unsigned int i=0; i<shutters.size(); i++)`
346	`shutterMean += shutters[i]/shutters.size();`	354	`shutterMean += shutters[i]/shutters.size();`
347		355
348	`for(unsigned int i=0; i<nFrames; i++){`	356	`for(unsigned int i=0; i<nFrames; i++){`
349	`frameSequence.frames0[i].create(nRows, nCols, CV_32F);`	357	`frameSequence.frames0[i].create(nRows, nCols, CV_32F);`
350	`frameSequence.frames1[i].create(nRows, nCols, CV_32F);`	358	`frameSequence.frames1[i].create(nRows, nCols, CV_32F);`
351		359
352	`}`	360	`}`
353		361
354	`#pragma omp parallel for`	-
355	`for(int r=0; r<nRows; r++){`	362	`frameSequence.frames0[0].setTo(0.0);`
356	`for(int c=0; c<nCols; c++){`	363	`frameSequence.frames1[0].setTo(0.0);`
357		-
358	`for(int j=nShutters-1; j>=0; j--){`	-
359		364
360	`uchar s0 = frameSequences[j].frames0[0].at<uchar>(r,c);`	-
361		-
362	`if(s0 < 250){`	-
363	`for(unsigned int i=0; i<nFrames; i++)`	-
364	`frameSequence.frames0[i].at<float>(r,c) = (shutterMean/shutters[j]) * frameSequences[j].frames0[i].at<uchar>(r,c);`	-
365		-
366	`break;`	365	`#pragma omp parallel for`
367	`}`	-
368	`}`	-
369		-
370	`for(int j=nShutters-1; j>=0; j--){`	366	`for(int j=nShutters-1; j>=0; j--){`
371		367
-		368	`cv::Mat mask0 = (frameSequences[j].frames0[0] < 250) & (frameSequence.frames0[0] == 0);`
372	`uchar s1 = frameSequences[j].frames1[0].at<uchar>(r,c);`	369	`cv::Mat mask1 = (frameSequences[j].frames1[0] < 250) & (frameSequence.frames1[0] == 0);`
373		370
374	`if(s1 < 250){`	-
375	`for(unsigned int i=0; i<nFrames; i++)`	371	`for(unsigned int i=0; i<nFrames; i++){`
-		372	`cv::add((shutterMean/shutters[j]) * frameSequences[j].frames0[i], frameSequence.frames0[i], frameSequence.frames0[i], mask0);`
376	`frameSequence.frames1[i].at<float>(r,c) = (shutterMean/shutters[j]) * frameSequences[j].frames1[i].at<uchar>(r,c);`	373	`cv::add((shutterMean/shutters[j]) * frameSequences[j].frames1[i], frameSequence.frames1[i], frameSequence.frames1[i], mask1);`
377		374
378	`break;`	-
379	`}`	-
380	`}`	-
381	`}`	375	`}`
382	`//cvtools::writeMat(frame0i, QString("frame0_%1.mat").arg(i).toLatin1(), QString("frame0_%1").arg(i).toLatin1());`	-
383	`}`	376	`}`
384		377
385	`// Set camera shutter back to default`	378	`// Set camera shutter back to default`
386	`cameraSettings.shutter = settings.value("shutter", 66.666).toFloat();`	379	`cameraSettings.shutter = settings.value("shutter", 66.666).toFloat();`
387		380
388	`camera0->setCameraSettings(cameraSettings);`	381	`camera0->setCameraSettings(cameraSettings);`
389	`camera1->setCameraSettings(cameraSettings);`	382	`camera1->setCameraSettings(cameraSettings);`
390		383
391	`// TODO: we need to somehow make the debayer function cvtColor accept floating point images...`	384	`// TODO: we need to somehow make the debayer function cvtColor accept floating point images...`
392	`}`	385	`}`
393		386
394		387
395	`void SMCaptureWorker::acquireFrameSequence(float angle){`	388	`void SMCaptureWorker::acquireFrameSequence(float angle){`
396		389
397	`if(!setupSuccessful)`	390	`if(!setupSuccessful)`
398	`return;`	391	`return;`
399		392
400	`if(int(angle) != -1.0)`	393	`if(int(angle) != -1.0)`
401	`rotateTo(angle);`	394	`rotateTo(angle);`
402		395
403	`SMFrameSequence frameSequence;`	396	`SMFrameSequence frameSequence;`
404		397
405	`QSettings settings;`	398	`QSettings settings;`
406	`if(settings.contains("camera/shuttersHDR"))`	399	`if(settings.contains("camera/shuttersHDR"))`
407	`acquireFrameSequenceHDR(frameSequence);`	400	`acquireFrameSequenceHDR(frameSequence);`
408	`else`	401	`else`
409	`acquireFrameSequenceLDR(frameSequence);`	402	`acquireFrameSequenceLDR(frameSequence);`
410		403
411		404
412	`if(rotationStage && rotationStage->Handle)// TODO is this the right check`	405	`if(rotationStage && rotationStage->Handle)// TODO is this the right check`
413	`frameSequence.rotationAngle = rotationStage->getAngle();`	406	`frameSequence.rotationAngle = rotationStage->getAngle();`
414	`else`	407	`else`
415	`frameSequence.rotationAngle = 0;`	408	`frameSequence.rotationAngle = 0;`
416		409
417	`frameSequence.codec = codec;`	410	`frameSequence.codec = codec;`
418		411
419	`emit newFrameSequence(frameSequence);`	412	`emit newFrameSequence(frameSequence);`
420		413
421	`projector->displayWhite();`	414	`projector->displayWhite();`
422	`}`	415	`}`
423		416
424		417
425	`void SMCaptureWorker::acquireFrameSequences(std::vector<float> angles){`	418	`void SMCaptureWorker::acquireFrameSequences(std::vector<float> angles){`
426		419
427	`if(!setupSuccessful)`	420	`if(!setupSuccessful)`
428	`return;`	421	`return;`
429		422
430	`for(unsigned int i=0; i<angles.size(); i++)`	423	`for(unsigned int i=0; i<angles.size(); i++)`
431	`acquireFrameSequence(angles[i]);`	424	`acquireFrameSequence(angles[i]);`
432	`}`	425	`}`
433		426
434	`void SMCaptureWorker::abort(){}`	427	`void SMCaptureWorker::abort(){}`
435		428
436	`void SMCaptureWorker::stopWork(){`	429	`void SMCaptureWorker::stopWork(){`
437	`working = false;`	430	`working = false;`
438	`}`	431	`}`
439		432
440		433

Subversion Repositories seema-scanner

(root)/src/SMCaptureWorker.cpp – Rev 242 → 244