WebSVN – seema-scanner – Diff – /src/algorithm/AlgorithmPhaseShift.cpp


#include "AlgorithmPhaseShift.h"
#include <math.h>
 
#include "cvtools.h"
 
#ifndef M_PI
    #define M_PI 3.14159265358979323846
#endif
 
static unsigned int nStepsPrimary = 24; // number of shifts/steps in primary
static unsigned int nStepsSecondary = 12; // number of shifts/steps in secondary
static float periodPrimary = 24; // primary period
 
// Algorithm
static cv::Mat computePhaseVector(unsigned int length, float phase, float pitch){
 
    cv::Mat phaseVector(length, 1, CV_8UC3);
    //phaseVector.setTo(0);
 
    const float pi = M_PI;
 
    // Loop through vector
    for(int i=0; i<phaseVector.rows; i++){
        // Amplitude of channels
        float amp = 0.5*(1+cos(2*pi*i/pitch - phase));
        phaseVector.at<cv::Vec3b>(i, 0) = cv::Vec3b(255.0*amp,255.0*amp,255.0*amp);
    }
 
    return phaseVector;
}
 
AlgorithmPhaseShift::AlgorithmPhaseShift(unsigned int _screenCols, unsigned int _screenRows) : Algorithm(_screenCols, _screenRows){
 
    // Set N
    N = 2+nStepsPrimary+nStepsSecondary;
 
    // Determine the secondary (wider) period
    float pSecondary = (screenCols*periodPrimary)/(screenCols-periodPrimary);
 
    // all on pattern
    cv::Mat allOn(1, screenCols, CV_8UC3, cv::Scalar::all(255));
    patterns.push_back(allOn);
 
    // all off pattern
    cv::Mat allOff(1, screenCols, CV_8UC3, cv::Scalar::all(0));
    patterns.push_back(allOff);
 
    // Precompute encoded patterns
    const float pi = M_PI;
 
    // Primary encoding patterns
    for(unsigned int i=0; i<nStepsPrimary; i++){
        float phase = 2.0*pi/nStepsPrimary * i;
        float pitch = periodPrimary;
        cv::Mat patternI(1,1,CV_8U);
        patternI = computePhaseVector(screenCols, phase, pitch);
        patterns.push_back(patternI.t());
    }
 
    // Secondary encoding patterns
    for(unsigned int i=0; i<nStepsSecondary; i++){
        float phase = 2.0*pi/nStepsSecondary * i;
        float pitch = pSecondary;
        cv::Mat patternI(1,1,CV_8U);
        patternI = computePhaseVector(screenCols, phase, pitch);
        patterns.push_back(patternI.t());
    }
 
 
}
 
cv::Mat AlgorithmPhaseShift::getEncodingPattern(unsigned int depth){
    return patterns[depth];
}
 
 
// Absolute phase from 3 frames
cv::Mat getPhase(const cv::Mat I1, const cv::Mat I2, const cv::Mat I3){
 
    cv::Mat_<float> I1_(I1);
    cv::Mat_<float> I2_(I2);
    cv::Mat_<float> I3_(I3);
 
    cv::Mat phase;
 
    // One call approach
    cv::phase(2.0*I1_-I3_-I2_, sqrt(3.0)*(I2_-I3_), phase);
    return phase;
 
}
 
// Phase unwrapping by means of a phase cue
cv::Mat unwrapWithCue(const cv::Mat up, const cv::Mat upCue, float nPhases){
 
    const float pi = M_PI;
 
    // Determine number of jumps
    cv::Mat P = (upCue*nPhases-up)/(2*pi);
 
    // Round to integers
    P.convertTo(P, CV_8U);
    P.convertTo(P, CV_32F);
 
    // Add to phase
    cv::Mat upUnwrapped = up + P*2*pi;
 
    // Scale to range [0; 2pi]
    upUnwrapped *= 1.0/nPhases;
 
    return upUnwrapped;
}
 
// Absolute phase and magnitude from N frames
std::vector<cv::Mat> getDFTComponents(const std::vector<cv::Mat> frames){
 
    unsigned int N = frames.size();
 
//    std::vector<cv::Mat> framesReverse = frames;
//    std::reverse(framesReverse.begin(), framesReverse.end());
 
    // DFT approach
    cv::Mat I;
    cv::merge(frames, I);
    unsigned int w = I.cols;
    unsigned int h = I.rows;
    I = I.reshape(1, h*w);
    I.convertTo(I, CV_32F);
    cv::Mat fI;
    cv::dft(I, fI, cv::DFT_ROWS + cv::DFT_COMPLEX_OUTPUT);
    fI = fI.reshape(N*2, h);
 
    std::vector<cv::Mat> fIcomp;
    cv::split(fI, fIcomp);
 
    return fIcomp;
 
}
 
void AlgorithmPhaseShift::get3DPoints(SMCalibrationParameters calibration, const std::vector<cv::Mat>& frames0, const std::vector<cv::Mat>& frames1, std::vector<cv::Point3f>& Q, std::vector<cv::Vec3b>& color){
 
    const float pi = M_PI;
 
    assert(frames0.size() == N);
    assert(frames1.size() == N);
 
    int frameRows = frames0[0].rows;
    int frameCols = frames0[0].cols;
 
    // Gray-scale everything
    std::vector<cv::Mat> frames0Gray(N);
    std::vector<cv::Mat> frames1Gray(N);
    for(int i=0; i<N; i++){
        cv::cvtColor(frames0[i], frames0Gray[i], CV_BayerBG2GRAY);
        cv::cvtColor(frames1[i], frames1Gray[i], CV_BayerBG2GRAY);
    }
 
    // Decode camera0
    std::vector<cv::Mat> frames0Primary(frames0Gray.begin()+2, frames0Gray.begin()+2+nStepsPrimary);
    std::vector<cv::Mat> frames0Secondary(frames0Gray.begin()+2+nStepsPrimary, frames0Gray.end());
    std::vector<cv::Mat> F0Primary = getDFTComponents(frames0Primary);
    cv::Mat up0Primary;
    cv::phase(F0Primary[2], -F0Primary[3], up0Primary);
    //cv::Mat up0Secondary = getPhase(frames0Secondary[0], frames0Secondary[1], frames0Secondary[2]);
    std::vector<cv::Mat> F0Secondary = getDFTComponents(frames0Secondary);
    cv::Mat up0Secondary;
    cv::phase(F0Secondary[2], -F0Secondary[3], up0Secondary);
    cv::Mat up0Equivalent = up0Primary - up0Secondary;
    up0Equivalent = cvtools::modulo(up0Equivalent, 2*pi);
    cv::Mat up0 = unwrapWithCue(up0Primary, up0Equivalent, (float)screenCols/periodPrimary);
    up0 *= screenCols/(2*pi);
 
    // Decode camera1
    std::vector<cv::Mat> frames1Primary(frames1Gray.begin()+2, frames1Gray.begin()+2+nStepsPrimary);
    std::vector<cv::Mat> frames1Secondary(frames1Gray.begin()+2+nStepsPrimary, frames1Gray.end());
    std::vector<cv::Mat> F1Primary = getDFTComponents(frames1Primary);
    cv::Mat up1Primary;
    cv::phase(F1Primary[2], -F1Primary[3], up1Primary);
    //cv::Mat up1Secondary = getPhase(frames1Secondary[0], frames1Secondary[1], frames1Secondary[2]);
    std::vector<cv::Mat> F1Secondary = getDFTComponents(frames1Secondary);
    cv::Mat up1Secondary;
    cv::phase(F1Secondary[2], -F1Secondary[3], up1Secondary);
    cv::Mat up1Equivalent = up1Primary - up1Secondary;
    up1Equivalent = cvtools::modulo(up1Equivalent, 2*pi);
    cv::Mat up1 = unwrapWithCue(up1Primary, up1Equivalent, (float)screenCols/periodPrimary);
    up1 *= screenCols/(2*pi);
 
 
    // Rectifying homographies (rotation+projections)
    cv::Size frameSize(frameCols, frameRows);
    cv::Mat R, T;
    // stereoRectify segfaults unless R is double precision
    cv::Mat(calibration.R1).convertTo(R, CV_64F);
    cv::Mat(calibration.T1).convertTo(T, CV_64F);
    cv::Mat R0, R1, P0, P1, QRect;
    cv::stereoRectify(calibration.K0, calibration.k0, calibration.K1, calibration.k1, frameSize, R, T, R0, R1, P0, P1, QRect, 0);
 
    // Interpolation maps (lens distortion and rectification)
    cv::Mat map0X, map0Y, map1X, map1Y;
    cv::initUndistortRectifyMap(calibration.K0, calibration.k0, R0, P0, frameSize, CV_32F, map0X, map0Y);
    cv::initUndistortRectifyMap(calibration.K1, calibration.k1, R1, P1, frameSize, CV_32F, map1X, map1Y);
 
    // Phase remaps
    cv::Mat up0Rect, up1Rect;
    cv::remap(up0, up0Rect, map0X, map0Y, CV_INTER_LINEAR);
    cv::remap(up1, up1Rect, map1X, map1Y, CV_INTER_LINEAR);
 
//cvtools::writeMat(up0Rect, "up0Rect.mat", "up0Rect");
//cvtools::writeMat(up1Rect, "up1Rect.mat", "up1Rect");
 
    // color debayer and remap
 
    cv::Mat color0Rect, color1Rect;
    frames0[0].convertTo(color0Rect, CV_8UC1, 1.0/256.0);
    cv::cvtColor(color0Rect, color0Rect, CV_BayerBG2RGB);
    cv::remap(color0Rect, color0Rect, map0X, map0Y, CV_INTER_LINEAR);
 
    frames1[0].convertTo(color1Rect, CV_8UC1, 1.0/256.0);
    cv::cvtColor(color1Rect, color1Rect, CV_BayerBG2RGB);
    cv::remap(color1Rect, color1Rect, map1X, map1Y, CV_INTER_LINEAR);
 
//cvtools::writeMat(frames0Rect[18], "frames0Rect_18.mat", "frames0Rect_18");
//cvtools::writeMat(frames0Rect[19], "frames0Rect_19.mat", "frames0Rect_19");
 
//cvtools::writeMat(color0Rect, "color0Rect.mat", "color0Rect");
//cvtools::writeMat(color1Rect, "color1Rect.mat", "color1Rect");
 
    // On/off remaps
    cv::Mat frames0OnRect, frames0OffRect;
    cv::remap(frames0Gray[0], frames0OnRect, map0X, map0Y, CV_INTER_LINEAR);
    cv::remap(frames0Gray[1], frames0OffRect, map0X, map0Y, CV_INTER_LINEAR);
 
    cv::Mat frames1OnRect, frames1OffRect;
    cv::remap(frames1Gray[0], frames1OnRect, map1X, map1Y, CV_INTER_LINEAR);
    cv::remap(frames1Gray[1], frames1OffRect, map1X, map1Y, CV_INTER_LINEAR);
 
    // Occlusion masks
    cv::Mat occlusion0Rect, occlusion1Rect;
    cv::subtract(frames0OnRect, frames0OffRect, occlusion0Rect);
    occlusion0Rect = (occlusion0Rect > 6400) & (occlusion0Rect < 50000);
    cv::subtract(frames1OnRect, frames1OffRect, occlusion1Rect);
    occlusion1Rect = (occlusion1Rect > 6400) & (occlusion1Rect < 50000);
 
//cvtools::writeMat(occlusion0Rect, "occlusion0Rect.mat", "occlusion0Rect");
//cvtools::writeMat(occlusion1Rect, "occlusion1Rect.mat", "occlusion1Rect");
 
    // Erode occlusion masks
    cv::Mat strel = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(5,5));
    cv::erode(occlusion0Rect, occlusion0Rect, strel);
    cv::erode(occlusion1Rect, occlusion1Rect, strel);
 
    // Threshold on gradient of phase
    cv::Mat edges0;
    cv::Sobel(up0Rect, edges0, -1, 1, 0, 5);
    occlusion0Rect = occlusion0Rect & (abs(edges0) < 150);
 
    cv::Mat edges1;
    cv::Sobel(up1Rect, edges1, -1, 1, 0, 5);
    occlusion1Rect = occlusion1Rect & (abs(edges1) < 150);
 
//cvtools::writeMat(edges0, "edges0.mat", "edges0");
//cvtools::writeMat(edges1, "edges1.mat", "edges1");
 
    // Match phase maps
    int frameRectRows = map0X.rows;
    int frameRectCols = map0X.cols;
 
    // camera0 against camera1
    std::vector<cv::Vec2f> q0Rect, q1Rect;
    for(int row=0; row<frameRectRows; row++){
        for(int col=0; col<frameRectCols; col++){
 
            if(!occlusion0Rect.at<char>(row,col))
                continue;
 
            float up0i = up0Rect.at<float>(row,col);
            for(int col1=0; col1<up1Rect.cols-1; col1++){
 
                if(!occlusion1Rect.at<char>(row,col1) || !occlusion1Rect.at<char>(row,col1+1))
                    continue;
 
                float up1Left = up1Rect.at<float>(row,col1);
                float up1Right = up1Rect.at<float>(row,col1+1);
 
                if((up1Left <= up0i) && (up0i <= up1Right) && (up0i-up1Left < 1) && (up1Right-up0i < 1)){
 
                    float col1i = col1 + (up0i-up1Left)/(up1Right-up1Left);
 
                    q0Rect.push_back(cv::Point2f(col, row));
                    q1Rect.push_back(cv::Point2f(col1i, row));
 
                    break;
                }
            }
        }
    }
 
//    // camera1 against camera0
//    for(int row=0; row<frameRectRows; row++){
//        for(int col=0; col<frameRectCols; col++){
 
//            if(!occlusion1Rect.at<char>(row,col))
//                continue;
 
//            float up1i = up1Rect.at<float>(row,col);
//            for(int col0=0; col0<up0Rect.cols-1; col0++){
 
//                if(!occlusion0Rect.at<char>(row,col0) || !occlusion0Rect.at<char>(row,col0+1))
//                    continue;
 
//                float up0Left = up0Rect.at<float>(row,col0);
//                float up0Right = up0Rect.at<float>(row,col0+1);
 
//                if((up0Left <= up1i) && (up1i <= up0Right) && (up1i-up0Left < 1) && (up0Right-up1i < 1)){
 
//                    float col0i = col0 + (up1i-up0Left)/(up0Right-up0Left);
 
//                    q1Rect.push_back(cv::Point2f(col, row));
//                    q0Rect.push_back(cv::Point2f(col0i, row));
 
//                    break;
//                }
//            }
//        }
//    }
 
    int nMatches = q0Rect.size();
 
    if(nMatches < 1){
        Q.resize(0);
        color.resize(0);
 
        return;
    }
 
    // Retrieve color information
    color.resize(nMatches);
    for(int i=0; i<nMatches; i++){
 
        cv::Vec3b c0 = color0Rect.at<cv::Vec3b>(q0Rect[i][1], q0Rect[i][0]);
        cv::Vec3b c1 = color1Rect.at<cv::Vec3b>(q1Rect[i][1], q1Rect[i][0]);
 
        color[i] = 0.5*c0 + 0.5*c1;
    }
 
    // Triangulate points
    cv::Mat QMatHomogenous, QMat;
    cv::triangulatePoints(P0, P1, q0Rect, q1Rect, QMatHomogenous);
    cvtools::convertMatFromHomogeneous(QMatHomogenous, QMat);
 
    // Undo rectification
    cv::Mat R0Inv;
    cv::Mat(R0.t()).convertTo(R0Inv, CV_32F);
    QMat = R0Inv*QMat;
 
    cvtools::matToPoints3f(QMat, Q);
 
}
 

Rev 113	Rev 118
1	`#include "AlgorithmPhaseShift.h"`	1	`#include "AlgorithmPhaseShift.h"`
2	`#include <math.h>`	2	`#include <math.h>`
3		3
4	`#include "cvtools.h"`	4	`#include "cvtools.h"`
5		5
6	`#ifndef M_PI`	6	`#ifndef M_PI`
7	`#define M_PI 3.14159265358979323846`	7	`#define M_PI 3.14159265358979323846`
8	`#endif`	8	`#endif`
9		9
10	`static unsigned int nSteps = 20; // number of shifts/steps in primary`	10	`static unsigned int nStepsPrimary = 24; // number of shifts/steps in primary`
-		11	`static unsigned int nStepsSecondary = 12; // number of shifts/steps in secondary`
11	`static float pPrimary = 64; // primary period`	12	`static float periodPrimary = 24; // primary period`
12		13
13	`// Algorithm`	14	`// Algorithm`
14	`static cv::Mat computePhaseVector(unsigned int length, float phase, float pitch){`	15	`static cv::Mat computePhaseVector(unsigned int length, float phase, float pitch){`
15		16
16	`cv::Mat phaseVector(length, 1, CV_8UC3);`	17	`cv::Mat phaseVector(length, 1, CV_8UC3);`
17	`//phaseVector.setTo(0);`	18	`//phaseVector.setTo(0);`
18		19
19	`const float pi = M_PI;`	20	`const float pi = M_PI;`
20		21
21	`// Loop through vector`	22	`// Loop through vector`
22	`for(int i=0; i<phaseVector.rows; i++){`	23	`for(int i=0; i<phaseVector.rows; i++){`
23	`// Amplitude of channels`	24	`// Amplitude of channels`
24	`float amp = 0.5(1+cos(2pi*i/pitch - phase));`	25	`float amp = 0.5(1+cos(2pi*i/pitch - phase));`
25	`phaseVector.at<cv::Vec3b>(i, 0) = cv::Vec3b(255.0amp,255.0amp,255.0*amp);`	26	`phaseVector.at<cv::Vec3b>(i, 0) = cv::Vec3b(255.0amp,255.0amp,255.0*amp);`
26	`}`	27	`}`
27		28
28	`return phaseVector;`	29	`return phaseVector;`
29	`}`	30	`}`
30		31
31	`AlgorithmPhaseShift::AlgorithmPhaseShift(unsigned int _screenCols, unsigned int _screenRows) : Algorithm(_screenCols, _screenRows){`	32	`AlgorithmPhaseShift::AlgorithmPhaseShift(unsigned int _screenCols, unsigned int _screenRows) : Algorithm(_screenCols, _screenRows){`
32		33
33	`// Set N`	34	`// Set N`
34	`N = 2+2*nSteps;`	35	`N = 2+nStepsPrimary+nStepsSecondary;`
35		36
36	`// Determine the secondary (wider) period`	37	`// Determine the secondary (wider) period`
37	`float pSecondary = (screenCols*pPrimary)/(screenCols-pPrimary);`	38	`float pSecondary = (screenCols*periodPrimary)/(screenCols-periodPrimary);`
38		39
39	`// all on pattern`	40	`// all on pattern`
40	`cv::Mat allOn(1, screenCols, CV_8UC3, cv::Scalar::all(255));`	41	`cv::Mat allOn(1, screenCols, CV_8UC3, cv::Scalar::all(255));`
41	`patterns.push_back(allOn);`	42	`patterns.push_back(allOn);`
42		43
43	`// all off pattern`	44	`// all off pattern`
44	`cv::Mat allOff(1, screenCols, CV_8UC3, cv::Scalar::all(0));`	45	`cv::Mat allOff(1, screenCols, CV_8UC3, cv::Scalar::all(0));`
45	`patterns.push_back(allOff);`	46	`patterns.push_back(allOff);`
46		47
47	`// Precompute encoded patterns`	48	`// Precompute encoded patterns`
48	`const float pi = M_PI;`	49	`const float pi = M_PI;`
49		50
50	`// Primary encoding patterns`	51	`// Primary encoding patterns`
51	`for(unsigned int i=0; i<nSteps; i++){`	52	`for(unsigned int i=0; i<nStepsPrimary; i++){`
52	`float phase = 2.0pi/nSteps i;`	53	`float phase = 2.0pi/nStepsPrimary i;`
53	`float pitch = pPrimary;`	54	`float pitch = periodPrimary;`
54	`cv::Mat patternI(1,1,CV_8U);`	55	`cv::Mat patternI(1,1,CV_8U);`
55	`patternI = computePhaseVector(screenCols, phase, pitch);`	56	`patternI = computePhaseVector(screenCols, phase, pitch);`
56	`patterns.push_back(patternI.t());`	57	`patterns.push_back(patternI.t());`
57	`}`	58	`}`
58		59
59	`// Secondary encoding patterns`	60	`// Secondary encoding patterns`
60	`for(unsigned int i=0; i<nSteps; i++){`	61	`for(unsigned int i=0; i<nStepsSecondary; i++){`
61	`float phase = 2.0pi/nSteps i;`	62	`float phase = 2.0pi/nStepsSecondary i;`
62	`float pitch = pSecondary;`	63	`float pitch = pSecondary;`
63	`cv::Mat patternI(1,1,CV_8U);`	64	`cv::Mat patternI(1,1,CV_8U);`
64	`patternI = computePhaseVector(screenCols, phase, pitch);`	65	`patternI = computePhaseVector(screenCols, phase, pitch);`
65	`patterns.push_back(patternI.t());`	66	`patterns.push_back(patternI.t());`
66	`}`	67	`}`
67		68
68		69
69	`}`	70	`}`
70		71
71	`cv::Mat AlgorithmPhaseShift::getEncodingPattern(unsigned int depth){`	72	`cv::Mat AlgorithmPhaseShift::getEncodingPattern(unsigned int depth){`
72	`return patterns[depth];`	73	`return patterns[depth];`
73	`}`	74	`}`
74		75
75		76
76	`// Absolute phase from 3 frames`	77	`// Absolute phase from 3 frames`
77	`cv::Mat getPhase(const cv::Mat I1, const cv::Mat I2, const cv::Mat I3){`	78	`cv::Mat getPhase(const cv::Mat I1, const cv::Mat I2, const cv::Mat I3){`
78		79
79	`cv::Mat_<float> I1_(I1);`	80	`cv::Mat_<float> I1_(I1);`
80	`cv::Mat_<float> I2_(I2);`	81	`cv::Mat_<float> I2_(I2);`
81	`cv::Mat_<float> I3_(I3);`	82	`cv::Mat_<float> I3_(I3);`
82		83
83	`cv::Mat phase;`	84	`cv::Mat phase;`
84		85
85	`// One call approach`	86	`// One call approach`
86	`cv::phase(2.0I1_-I3_-I2_, sqrt(3.0)(I2_-I3_), phase);`	87	`cv::phase(2.0I1_-I3_-I2_, sqrt(3.0)(I2_-I3_), phase);`
87	`return phase;`	88	`return phase;`
88		89
89	`}`	90	`}`
90		91
91	`// Phase unwrapping by means of a phase cue`	92	`// Phase unwrapping by means of a phase cue`
92	`cv::Mat unwrapWithCue(const cv::Mat up, const cv::Mat upCue, float nPhases){`	93	`cv::Mat unwrapWithCue(const cv::Mat up, const cv::Mat upCue, float nPhases){`
93		94
94	`const float pi = M_PI;`	95	`const float pi = M_PI;`
95		96
96	`// Determine number of jumps`	97	`// Determine number of jumps`
97	`cv::Mat P = (upCuenPhases-up)/(2pi);`	98	`cv::Mat P = (upCuenPhases-up)/(2pi);`
98		99
99	`// Round to integers`	100	`// Round to integers`
100	`P.convertTo(P, CV_8U);`	101	`P.convertTo(P, CV_8U);`
101	`P.convertTo(P, CV_32F);`	102	`P.convertTo(P, CV_32F);`
102		103
103	`// Add to phase`	104	`// Add to phase`
104	`cv::Mat upUnwrapped = up + P2pi;`	105	`cv::Mat upUnwrapped = up + P2pi;`
105		106
106	`// Scale to range [0; 2pi]`	107	`// Scale to range [0; 2pi]`
107	`upUnwrapped *= 1.0/nPhases;`	108	`upUnwrapped *= 1.0/nPhases;`
108		109
109	`return upUnwrapped;`	110	`return upUnwrapped;`
110	`}`	111	`}`
111		112
112	`// Absolute phase and magnitude from N frames`	113	`// Absolute phase and magnitude from N frames`
113	`std::vector<cv::Mat> getDFTComponents(const std::vector<cv::Mat> frames){`	114	`std::vector<cv::Mat> getDFTComponents(const std::vector<cv::Mat> frames){`
114		115
115	`unsigned int N = frames.size();`	116	`unsigned int N = frames.size();`
116		117
117	`// std::vector<cv::Mat> framesReverse = frames;`	118	`// std::vector<cv::Mat> framesReverse = frames;`
118	`// std::reverse(framesReverse.begin(), framesReverse.end());`	119	`// std::reverse(framesReverse.begin(), framesReverse.end());`
119		120
120	`// DFT approach`	121	`// DFT approach`
121	`cv::Mat I;`	122	`cv::Mat I;`
122	`cv::merge(frames, I);`	123	`cv::merge(frames, I);`
123	`unsigned int w = I.cols;`	124	`unsigned int w = I.cols;`
124	`unsigned int h = I.rows;`	125	`unsigned int h = I.rows;`
125	`I = I.reshape(1, h*w);`	126	`I = I.reshape(1, h*w);`
126	`I.convertTo(I, CV_32F);`	127	`I.convertTo(I, CV_32F);`
127	`cv::Mat fI;`	128	`cv::Mat fI;`
128	`cv::dft(I, fI, cv::DFT_ROWS + cv::DFT_COMPLEX_OUTPUT);`	129	`cv::dft(I, fI, cv::DFT_ROWS + cv::DFT_COMPLEX_OUTPUT);`
129	`fI = fI.reshape(N*2, h);`	130	`fI = fI.reshape(N*2, h);`
130		131
131	`std::vector<cv::Mat> fIcomp;`	132	`std::vector<cv::Mat> fIcomp;`
132	`cv::split(fI, fIcomp);`	133	`cv::split(fI, fIcomp);`
133		134
134	`return fIcomp;`	135	`return fIcomp;`
135		136
136	`}`	137	`}`
137		138
138	`void AlgorithmPhaseShift::get3DPoints(SMCalibrationParameters calibration, const std::vector<cv::Mat>& frames0, const std::vector<cv::Mat>& frames1, std::vector<cv::Point3f>& Q, std::vector<cv::Vec3b>& color){`	139	`void AlgorithmPhaseShift::get3DPoints(SMCalibrationParameters calibration, const std::vector<cv::Mat>& frames0, const std::vector<cv::Mat>& frames1, std::vector<cv::Point3f>& Q, std::vector<cv::Vec3b>& color){`
139		140
140	`const float pi = M_PI;`	141	`const float pi = M_PI;`
141		142
142	`assert(frames0.size() == N);`	143	`assert(frames0.size() == N);`
143	`assert(frames1.size() == N);`	144	`assert(frames1.size() == N);`
144		145
145	`int frameRows = frames0[0].rows;`	146	`int frameRows = frames0[0].rows;`
146	`int frameCols = frames0[0].cols;`	147	`int frameCols = frames0[0].cols;`
147		148
148	`// Gray-scale everything`	149	`// Gray-scale everything`
149	`std::vector<cv::Mat> frames0Gray(N);`	150	`std::vector<cv::Mat> frames0Gray(N);`
150	`std::vector<cv::Mat> frames1Gray(N);`	151	`std::vector<cv::Mat> frames1Gray(N);`
151	`for(int i=0; i<N; i++){`	152	`for(int i=0; i<N; i++){`
152	`cv::cvtColor(frames0[i], frames0Gray[i], CV_BayerBG2GRAY);`	153	`cv::cvtColor(frames0[i], frames0Gray[i], CV_BayerBG2GRAY);`
153	`cv::cvtColor(frames1[i], frames1Gray[i], CV_BayerBG2GRAY);`	154	`cv::cvtColor(frames1[i], frames1Gray[i], CV_BayerBG2GRAY);`
154	`}`	155	`}`
155		156
156	`// Decode camera0`	157	`// Decode camera0`
157	`std::vector<cv::Mat> frames0Primary(frames0Gray.begin()+2, frames0Gray.begin()+2+nSteps);`	158	`std::vector<cv::Mat> frames0Primary(frames0Gray.begin()+2, frames0Gray.begin()+2+nStepsPrimary);`
158	`std::vector<cv::Mat> frames0Secondary(frames0Gray.begin()+2+nSteps, frames0Gray.begin()+2+2*nSteps);`	159	`std::vector<cv::Mat> frames0Secondary(frames0Gray.begin()+2+nStepsPrimary, frames0Gray.end());`
159	`std::vector<cv::Mat> F0Primary = getDFTComponents(frames0Primary);`	160	`std::vector<cv::Mat> F0Primary = getDFTComponents(frames0Primary);`
160	`cv::Mat up0Primary;`	161	`cv::Mat up0Primary;`
161	`cv::phase(F0Primary[2], -F0Primary[3], up0Primary);`	162	`cv::phase(F0Primary[2], -F0Primary[3], up0Primary);`
162	`//cv::Mat up0Secondary = getPhase(frames0Secondary[0], frames0Secondary[1], frames0Secondary[2]);`	163	`//cv::Mat up0Secondary = getPhase(frames0Secondary[0], frames0Secondary[1], frames0Secondary[2]);`
163	`std::vector<cv::Mat> F0Secondary = getDFTComponents(frames0Secondary);`	164	`std::vector<cv::Mat> F0Secondary = getDFTComponents(frames0Secondary);`
164	`cv::Mat up0Secondary;`	165	`cv::Mat up0Secondary;`
165	`cv::phase(F0Secondary[2], -F0Secondary[3], up0Secondary);`	166	`cv::phase(F0Secondary[2], -F0Secondary[3], up0Secondary);`
166	`cv::Mat up0Equivalent = up0Primary - up0Secondary;`	167	`cv::Mat up0Equivalent = up0Primary - up0Secondary;`
167	`up0Equivalent = cvtools::modulo(up0Equivalent, 2*pi);`	168	`up0Equivalent = cvtools::modulo(up0Equivalent, 2*pi);`
168	`cv::Mat up0 = unwrapWithCue(up0Primary, up0Equivalent, (float)screenCols/pPrimary);`	169	`cv::Mat up0 = unwrapWithCue(up0Primary, up0Equivalent, (float)screenCols/periodPrimary);`
169	`up0 = screenCols/(2pi);`	170	`up0 = screenCols/(2pi);`
170		171
171	`// Decode camera1`	172	`// Decode camera1`
172	`std::vector<cv::Mat> frames1Primary(frames1Gray.begin()+2, frames1Gray.begin()+2+nSteps);`	173	`std::vector<cv::Mat> frames1Primary(frames1Gray.begin()+2, frames1Gray.begin()+2+nStepsPrimary);`
173	`std::vector<cv::Mat> frames1Secondary(frames1Gray.begin()+2+nSteps, frames1Gray.begin()+2+2*nSteps);`	174	`std::vector<cv::Mat> frames1Secondary(frames1Gray.begin()+2+nStepsPrimary, frames1Gray.end());`
174	`std::vector<cv::Mat> F1Primary = getDFTComponents(frames1Primary);`	175	`std::vector<cv::Mat> F1Primary = getDFTComponents(frames1Primary);`
175	`cv::Mat up1Primary;`	176	`cv::Mat up1Primary;`
176	`cv::phase(F1Primary[2], -F1Primary[3], up1Primary);`	177	`cv::phase(F1Primary[2], -F1Primary[3], up1Primary);`
177	`//cv::Mat up1Secondary = getPhase(frames1Secondary[0], frames1Secondary[1], frames1Secondary[2]);`	178	`//cv::Mat up1Secondary = getPhase(frames1Secondary[0], frames1Secondary[1], frames1Secondary[2]);`
178	`std::vector<cv::Mat> F1Secondary = getDFTComponents(frames1Secondary);`	179	`std::vector<cv::Mat> F1Secondary = getDFTComponents(frames1Secondary);`
179	`cv::Mat up1Secondary;`	180	`cv::Mat up1Secondary;`
180	`cv::phase(F1Secondary[2], -F1Secondary[3], up1Secondary);`	181	`cv::phase(F1Secondary[2], -F1Secondary[3], up1Secondary);`
181	`cv::Mat up1Equivalent = up1Primary - up1Secondary;`	182	`cv::Mat up1Equivalent = up1Primary - up1Secondary;`
182	`up1Equivalent = cvtools::modulo(up1Equivalent, 2*pi);`	183	`up1Equivalent = cvtools::modulo(up1Equivalent, 2*pi);`
183	`cv::Mat up1 = unwrapWithCue(up1Primary, up1Equivalent, (float)screenCols/pPrimary);`	184	`cv::Mat up1 = unwrapWithCue(up1Primary, up1Equivalent, (float)screenCols/periodPrimary);`
184	`up1 = screenCols/(2pi);`	185	`up1 = screenCols/(2pi);`
185		186
186		187
187	`// Rectifying homographies (rotation+projections)`	188	`// Rectifying homographies (rotation+projections)`
188	`cv::Size frameSize(frameCols, frameRows);`	189	`cv::Size frameSize(frameCols, frameRows);`
189	`cv::Mat R, T;`	190	`cv::Mat R, T;`
190	`// stereoRectify segfaults unless R is double precision`	191	`// stereoRectify segfaults unless R is double precision`
191	`cv::Mat(calibration.R1).convertTo(R, CV_64F);`	192	`cv::Mat(calibration.R1).convertTo(R, CV_64F);`
192	`cv::Mat(calibration.T1).convertTo(T, CV_64F);`	193	`cv::Mat(calibration.T1).convertTo(T, CV_64F);`
193	`cv::Mat R0, R1, P0, P1, QRect;`	194	`cv::Mat R0, R1, P0, P1, QRect;`
194	`cv::stereoRectify(calibration.K0, calibration.k0, calibration.K1, calibration.k1, frameSize, R, T, R0, R1, P0, P1, QRect, 0);`	195	`cv::stereoRectify(calibration.K0, calibration.k0, calibration.K1, calibration.k1, frameSize, R, T, R0, R1, P0, P1, QRect, 0);`
195		196
196	`// Interpolation maps (lens distortion and rectification)`	197	`// Interpolation maps (lens distortion and rectification)`
197	`cv::Mat map0X, map0Y, map1X, map1Y;`	198	`cv::Mat map0X, map0Y, map1X, map1Y;`
198	`cv::initUndistortRectifyMap(calibration.K0, calibration.k0, R0, P0, frameSize, CV_32F, map0X, map0Y);`	199	`cv::initUndistortRectifyMap(calibration.K0, calibration.k0, R0, P0, frameSize, CV_32F, map0X, map0Y);`
199	`cv::initUndistortRectifyMap(calibration.K1, calibration.k1, R1, P1, frameSize, CV_32F, map1X, map1Y);`	200	`cv::initUndistortRectifyMap(calibration.K1, calibration.k1, R1, P1, frameSize, CV_32F, map1X, map1Y);`
200		201
201	`// Phase remaps`	202	`// Phase remaps`
202	`cv::Mat up0Rect, up1Rect;`	203	`cv::Mat up0Rect, up1Rect;`
203	`cv::remap(up0, up0Rect, map0X, map0Y, CV_INTER_CUBIC);`	204	`cv::remap(up0, up0Rect, map0X, map0Y, CV_INTER_LINEAR);`
204	`cv::remap(up1, up1Rect, map1X, map1Y, CV_INTER_CUBIC);`	205	`cv::remap(up1, up1Rect, map1X, map1Y, CV_INTER_LINEAR);`
205		206
206	`//cvtools::writeMat(up0Rect, "up0Rect.mat", "up0Rect");`	207	`//cvtools::writeMat(up0Rect, "up0Rect.mat", "up0Rect");`
207	`//cvtools::writeMat(up1Rect, "up1Rect.mat", "up1Rect");`	208	`//cvtools::writeMat(up1Rect, "up1Rect.mat", "up1Rect");`
208		209
209	`// Color debayer and remaps`	210	`// color debayer and remap`
210	`cv::Mat temp;`	-
211	`cv::Mat color0Rect, color1Rect;`	211	`cv::Mat color0Rect, color1Rect;`
-		212	`frames0[0].convertTo(color0Rect, CV_8UC1, 1.0/256.0);`
212	`cv::cvtColor(frames0[0], temp, CV_BayerBG2RGB);`	213	`cv::cvtColor(color0Rect, color0Rect, CV_BayerBG2RGB);`
213	`cv::remap(temp, color0Rect, map0X, map0Y, CV_INTER_CUBIC);`	214	`cv::remap(color0Rect, color0Rect, map0X, map0Y, CV_INTER_LINEAR);`
-		215
-		216	`frames1[0].convertTo(color1Rect, CV_8UC1, 1.0/256.0);`
214	`cv::cvtColor(frames1[0], temp, CV_BayerBG2RGB);`	217	`cv::cvtColor(color1Rect, color1Rect, CV_BayerBG2RGB);`
215	`cv::remap(temp, color1Rect, map1X, map1Y, CV_INTER_CUBIC);`	218	`cv::remap(color1Rect, color1Rect, map1X, map1Y, CV_INTER_LINEAR);`
-		219
-		220	`//cvtools::writeMat(frames0Rect[18], "frames0Rect_18.mat", "frames0Rect_18");`
-		221	`//cvtools::writeMat(frames0Rect[19], "frames0Rect_19.mat", "frames0Rect_19");`
216		222
217	`//cvtools::writeMat(color0Rect, "color0Rect.mat", "color0Rect");`	223	`//cvtools::writeMat(color0Rect, "color0Rect.mat", "color0Rect");`
218	`//cvtools::writeMat(color1Rect, "color1Rect.mat", "color1Rect");`	224	`//cvtools::writeMat(color1Rect, "color1Rect.mat", "color1Rect");`
219		225
220	`// On/off remaps`	226	`// On/off remaps`
221	`cv::Mat frames0OnRect, frames0OffRect;`	227	`cv::Mat frames0OnRect, frames0OffRect;`
222	`cv::remap(frames0Gray[0], frames0OnRect, map0X, map0Y, CV_INTER_CUBIC);`	228	`cv::remap(frames0Gray[0], frames0OnRect, map0X, map0Y, CV_INTER_LINEAR);`
223	`cv::remap(frames0Gray[1], frames0OffRect, map0X, map0Y, CV_INTER_CUBIC);`	229	`cv::remap(frames0Gray[1], frames0OffRect, map0X, map0Y, CV_INTER_LINEAR);`
224		230
225	`cv::Mat frames1OnRect, frames1OffRect;`	231	`cv::Mat frames1OnRect, frames1OffRect;`
226	`cv::remap(frames1Gray[0], frames1OnRect, map1X, map1Y, CV_INTER_CUBIC);`	232	`cv::remap(frames1Gray[0], frames1OnRect, map1X, map1Y, CV_INTER_LINEAR);`
227	`cv::remap(frames1Gray[1], frames1OffRect, map1X, map1Y, CV_INTER_CUBIC);`	233	`cv::remap(frames1Gray[1], frames1OffRect, map1X, map1Y, CV_INTER_LINEAR);`
228		234
229	`// Occlusion masks`	235	`// Occlusion masks`
230	`cv::Mat occlusion0Rect, occlusion1Rect;`	236	`cv::Mat occlusion0Rect, occlusion1Rect;`
231	`cv::subtract(frames0OnRect, frames0OffRect, occlusion0Rect);`	237	`cv::subtract(frames0OnRect, frames0OffRect, occlusion0Rect);`
232	`occlusion0Rect = occlusion0Rect > 10;`	238	`occlusion0Rect = (occlusion0Rect > 6400) & (occlusion0Rect < 50000);`
233	`cv::subtract(frames1OnRect, frames1OffRect, occlusion1Rect);`	239	`cv::subtract(frames1OnRect, frames1OffRect, occlusion1Rect);`
234	`occlusion1Rect = occlusion1Rect > 10;`	240	`occlusion1Rect = (occlusion1Rect > 6400) & (occlusion1Rect < 50000);`
235		241
236	`//cvtools::writeMat(occlusion0Rect, "occlusion0Rect.mat", "occlusion0Rect");`	242	`//cvtools::writeMat(occlusion0Rect, "occlusion0Rect.mat", "occlusion0Rect");`
237	`//cvtools::writeMat(occlusion1Rect, "occlusion1Rect.mat", "occlusion1Rect");`	243	`//cvtools::writeMat(occlusion1Rect, "occlusion1Rect.mat", "occlusion1Rect");`
238		244
239	`// Erode occlusion masks`	245	`// Erode occlusion masks`
240	`cv::Mat strel = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(5,5));`	246	`cv::Mat strel = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(5,5));`
241	`cv::erode(occlusion0Rect, occlusion0Rect, strel);`	247	`cv::erode(occlusion0Rect, occlusion0Rect, strel);`
242	`cv::erode(occlusion1Rect, occlusion1Rect, strel);`	248	`cv::erode(occlusion1Rect, occlusion1Rect, strel);`
243		249
244	`// Threshold on gradient of phase`	250	`// Threshold on gradient of phase`
245	`cv::Mat edges0;`	251	`cv::Mat edges0;`
246	`cv::Sobel(up0Rect, edges0, -1, 1, 0, 5);`	252	`cv::Sobel(up0Rect, edges0, -1, 1, 0, 5);`
247	`occlusion0Rect = occlusion0Rect & (abs(edges0) < 150);`	253	`occlusion0Rect = occlusion0Rect & (abs(edges0) < 150);`
248		254
249	`cv::Mat edges1;`	255	`cv::Mat edges1;`
250	`cv::Sobel(up1Rect, edges1, -1, 1, 0, 5);`	256	`cv::Sobel(up1Rect, edges1, -1, 1, 0, 5);`
251	`occlusion1Rect = occlusion1Rect & (abs(edges1) < 150);`	257	`occlusion1Rect = occlusion1Rect & (abs(edges1) < 150);`
252		258
253	`//cvtools::writeMat(edges0, "edges0.mat", "edges0");`	259	`//cvtools::writeMat(edges0, "edges0.mat", "edges0");`
254	`//cvtools::writeMat(edges1, "edges1.mat", "edges1");`	260	`//cvtools::writeMat(edges1, "edges1.mat", "edges1");`
255		261
256	`// Match phase maps`	262	`// Match phase maps`
257	`int frameRectRows = map0X.rows;`	263	`int frameRectRows = map0X.rows;`
258	`int frameRectCols = map0X.cols;`	264	`int frameRectCols = map0X.cols;`
259		265
260	`// camera0 against camera1`	266	`// camera0 against camera1`
261	`std::vector<cv::Vec2f> q0Rect, q1Rect;`	267	`std::vector<cv::Vec2f> q0Rect, q1Rect;`
262	`for(int row=0; row<frameRectRows; row++){`	268	`for(int row=0; row<frameRectRows; row++){`
263	`for(int col=0; col<frameRectCols; col++){`	269	`for(int col=0; col<frameRectCols; col++){`
264		270
265	`if(!occlusion0Rect.at<char>(row,col))`	271	`if(!occlusion0Rect.at<char>(row,col))`
266	`continue;`	272	`continue;`
267		273
268	`float up0i = up0Rect.at<float>(row,col);`	274	`float up0i = up0Rect.at<float>(row,col);`
269	`for(int col1=0; col1<up1Rect.cols-1; col1++){`	275	`for(int col1=0; col1<up1Rect.cols-1; col1++){`
270		276
271	`if(!occlusion1Rect.at<char>(row,col1) \|\| !occlusion1Rect.at<char>(row,col1+1))`	277	`if(!occlusion1Rect.at<char>(row,col1) \|\| !occlusion1Rect.at<char>(row,col1+1))`
272	`continue;`	278	`continue;`
273		279
274	`float up1Left = up1Rect.at<float>(row,col1);`	280	`float up1Left = up1Rect.at<float>(row,col1);`
275	`float up1Right = up1Rect.at<float>(row,col1+1);`	281	`float up1Right = up1Rect.at<float>(row,col1+1);`
276		282
277	`if((up1Left <= up0i) && (up0i <= up1Right) && (up0i-up1Left < 1) && (up1Right-up0i < 1)){`	283	`if((up1Left <= up0i) && (up0i <= up1Right) && (up0i-up1Left < 1) && (up1Right-up0i < 1)){`
278		284
279	`float col1i = col1 + (up0i-up1Left)/(up1Right-up1Left);`	285	`float col1i = col1 + (up0i-up1Left)/(up1Right-up1Left);`
280		286
281	`q0Rect.push_back(cv::Point2f(col, row));`	287	`q0Rect.push_back(cv::Point2f(col, row));`
282	`q1Rect.push_back(cv::Point2f(col1i, row));`	288	`q1Rect.push_back(cv::Point2f(col1i, row));`
283		289
284	`break;`	290	`break;`
285	`}`	291	`}`
286	`}`	292	`}`
287	`}`	293	`}`
288	`}`	294	`}`
289		295
290	`// // camera1 against camera0`	296	`// // camera1 against camera0`
291	`// for(int row=0; row<frameRectRows; row++){`	297	`// for(int row=0; row<frameRectRows; row++){`
292	`// for(int col=0; col<frameRectCols; col++){`	298	`// for(int col=0; col<frameRectCols; col++){`
293		299
294	`// if(!occlusion1Rect.at<char>(row,col))`	300	`// if(!occlusion1Rect.at<char>(row,col))`
295	`// continue;`	301	`// continue;`
296		302
297	`// float up1i = up1Rect.at<float>(row,col);`	303	`// float up1i = up1Rect.at<float>(row,col);`
298	`// for(int col0=0; col0<up0Rect.cols-1; col0++){`	304	`// for(int col0=0; col0<up0Rect.cols-1; col0++){`
299		305
300	`// if(!occlusion0Rect.at<char>(row,col0) \|\| !occlusion0Rect.at<char>(row,col0+1))`	306	`// if(!occlusion0Rect.at<char>(row,col0) \|\| !occlusion0Rect.at<char>(row,col0+1))`
301	`// continue;`	307	`// continue;`
302		308
303	`// float up0Left = up0Rect.at<float>(row,col0);`	309	`// float up0Left = up0Rect.at<float>(row,col0);`
304	`// float up0Right = up0Rect.at<float>(row,col0+1);`	310	`// float up0Right = up0Rect.at<float>(row,col0+1);`
305		311
306	`// if((up0Left <= up1i) && (up1i <= up0Right) && (up1i-up0Left < 1) && (up0Right-up1i < 1)){`	312	`// if((up0Left <= up1i) && (up1i <= up0Right) && (up1i-up0Left < 1) && (up0Right-up1i < 1)){`
307		313
308	`// float col0i = col0 + (up1i-up0Left)/(up0Right-up0Left);`	314	`// float col0i = col0 + (up1i-up0Left)/(up0Right-up0Left);`
309		315
310	`// q1Rect.push_back(cv::Point2f(col, row));`	316	`// q1Rect.push_back(cv::Point2f(col, row));`
311	`// q0Rect.push_back(cv::Point2f(col0i, row));`	317	`// q0Rect.push_back(cv::Point2f(col0i, row));`
312		318
313	`// break;`	319	`// break;`
314	`// }`	320	`// }`
315	`// }`	321	`// }`
316	`// }`	322	`// }`
317	`// }`	323	`// }`
318		324
319	`int nMatches = q0Rect.size();`	325	`int nMatches = q0Rect.size();`
320		326
321	`if(nMatches < 1){`	327	`if(nMatches < 1){`
322	`Q.resize(0);`	328	`Q.resize(0);`
323	`color.resize(0);`	329	`color.resize(0);`
324		330
325	`return;`	331	`return;`
326	`}`	332	`}`
327		333
328	`// Retrieve color information`	334	`// Retrieve color information`
329	`color.resize(nMatches);`	335	`color.resize(nMatches);`
330	`for(int i=0; i<nMatches; i++){`	336	`for(int i=0; i<nMatches; i++){`
331		337
332	`cv::Vec3b c0 = color0Rect.at<cv::Vec3b>(q0Rect[i][1], q0Rect[i][0]);`	338	`cv::Vec3b c0 = color0Rect.at<cv::Vec3b>(q0Rect[i][1], q0Rect[i][0]);`
333	`cv::Vec3b c1 = color1Rect.at<cv::Vec3b>(q1Rect[i][1], q1Rect[i][0]);`	339	`cv::Vec3b c1 = color1Rect.at<cv::Vec3b>(q1Rect[i][1], q1Rect[i][0]);`
334		340
335	`color[i] = 0.5c0 + 0.5c1;`	341	`color[i] = 0.5c0 + 0.5c1;`
336	`}`	342	`}`
337		343
338	`// Triangulate points`	344	`// Triangulate points`
339	`cv::Mat QMatHomogenous, QMat;`	345	`cv::Mat QMatHomogenous, QMat;`
340	`cv::triangulatePoints(P0, P1, q0Rect, q1Rect, QMatHomogenous);`	346	`cv::triangulatePoints(P0, P1, q0Rect, q1Rect, QMatHomogenous);`
341	`cvtools::convertMatFromHomogeneous(QMatHomogenous, QMat);`	347	`cvtools::convertMatFromHomogeneous(QMatHomogenous, QMat);`
342		348
343	`// Undo rectification`	349	`// Undo rectification`
344	`cv::Mat R0Inv;`	350	`cv::Mat R0Inv;`
345	`cv::Mat(R0.t()).convertTo(R0Inv, CV_32F);`	351	`cv::Mat(R0.t()).convertTo(R0Inv, CV_32F);`
346	`QMat = R0Inv*QMat;`	352	`QMat = R0Inv*QMat;`
347		353
348	`cvtools::matToPoints3f(QMat, Q);`	354	`cvtools::matToPoints3f(QMat, Q);`
349		355
350	`}`	356	`}`
351		357

Subversion Repositories seema-scanner

(root)/src/algorithm/AlgorithmPhaseShift.cpp @ 118 – Rev 113 → 118