Subversion Repositories seema-scanner

Rev

Rev 71 | Rev 73 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 71 Rev 72
Line 28... Line 28...
28 
    return phaseVector;
 28 
    return phaseVector;
29 
}
 29 
}
30 
 
 30 
 
31 
AlgorithmPhaseShift::AlgorithmPhaseShift(unsigned int _screenCols, unsigned int _screenRows) : Algorithm(_screenCols, _screenRows){
 31 
AlgorithmPhaseShift::AlgorithmPhaseShift(unsigned int _screenCols, unsigned int _screenRows) : Algorithm(_screenCols, _screenRows){
32 
 
 32 
 
- 
 
 33 
    // Set N
- 
 
 34 
    N = 2+2*nSteps;
- 
 
 35 
 
33 
    // all on pattern
 36 
    // all on pattern
34 
    cv::Mat allOn(1, screenCols, CV_8UC3, cv::Scalar::all(255));
 37 
    cv::Mat allOn(1, screenCols, CV_8UC3, cv::Scalar::all(255));
35 
    patterns.push_back(allOn);
 38 
    patterns.push_back(allOn);
36 
 
 39 
 
37 
    // all off pattern
 40 
    // all off pattern
38 
    cv::Mat allOff(1, screenCols, CV_8UC3, cv::Scalar::all(0));
 41 
    cv::Mat allOff(1, screenCols, CV_8UC3, cv::Scalar::all(0));
39 
    patterns.push_back(allOff);
 42 
    patterns.push_back(allOff);
40 
 
 43 
 
41 
    // Set N
 - 
 
42 
    N = 2+nSteps+3;
 - 
 
43 
 
 - 
 
44 
    // Precompute encoded patterns
 44 
    // Precompute encoded patterns
45 
    const float pi = M_PI;
 45 
    const float pi = M_PI;
46 
 
 46 
 
47 
    // Horizontally encoding patterns
 47 
    // Horizontally encoding patterns
48 
    for(unsigned int i=0; i<nSteps; i++){
 48 
    for(unsigned int i=0; i<nSteps; i++){
Line 52... Line 52...
52 
        patternI = computePhaseVector(screenCols, phase, pitch);
 52 
        patternI = computePhaseVector(screenCols, phase, pitch);
53 
        patterns.push_back(patternI.t());
 53 
        patterns.push_back(patternI.t());
54 
    }
 54 
    }
55 
 
 55 
 
56 
    // Phase cue patterns
 56 
    // Phase cue patterns
57 
    for(unsigned int i=0; i<3; i++){
 57 
    for(unsigned int i=0; i<nSteps; i++){
58 
        float phase = 2.0*pi/3.0 * i;
 58 
        float phase = 2.0*pi/nSteps * i;
59 
        float pitch = screenCols;
 59 
        float pitch = screenCols;
60 
        cv::Mat patternI;
 60 
        cv::Mat patternI(1,1,CV_8U);
61 
        patternI = computePhaseVector(screenCols, phase, pitch);
 61 
        patternI = computePhaseVector(screenCols, phase, pitch);
62 
        patterns.push_back(patternI.t());
 62 
        patterns.push_back(patternI.t());
63 
    }
 63 
    }
64 
 
 64 
 
- 
 
 65 
 
65 
}
 66 
}
66 
 
 67 
 
67 
cv::Mat AlgorithmPhaseShift::getEncodingPattern(unsigned int depth){
 68 
cv::Mat AlgorithmPhaseShift::getEncodingPattern(unsigned int depth){
68 
    return patterns[depth];
 69 
    return patterns[depth];
69 
}
 70 
}
Line 139... Line 140...
139 
    assert(frames1.size() == N);
 140 
    assert(frames1.size() == N);
140 
 
 141 
 
141 
    int frameRows = frames0[0].rows;
 142 
    int frameRows = frames0[0].rows;
142 
    int frameCols = frames0[0].cols;
 143 
    int frameCols = frames0[0].cols;
143 
 
 144 
 
144 
    // Gray-scale
 145 
    // Gray-scale everything
145 
    std::vector<cv::Mat> frames0Gray(N);
 146 
    std::vector<cv::Mat> frames0Gray(N);
146 
    std::vector<cv::Mat> frames1Gray(N);
 147 
    std::vector<cv::Mat> frames1Gray(N);
147 
    for(int i=0; i<N; i++){
 148 
    for(int i=0; i<N; i++){
148 
        cv::cvtColor(frames0[i], frames0Gray[i], CV_RGB2GRAY);
 149 
        cv::cvtColor(frames0[i], frames0Gray[i], CV_RGB2GRAY);
149 
        cv::cvtColor(frames1[i], frames1Gray[i], CV_RGB2GRAY);
 150 
        cv::cvtColor(frames1[i], frames1Gray[i], CV_RGB2GRAY);
150 
    }
 151 
    }
151 
 
 152 
 
152 
    // Decode camera0
 153 
    // Decode camera0
153 
    std::vector<cv::Mat> frames0Enc(frames0Gray.begin()+2, frames0Gray.begin()+2+nSteps);
 154 
    std::vector<cv::Mat> frames0Enc(frames0Gray.begin()+2, frames0Gray.begin()+2+nSteps);
154 
    std::vector<cv::Mat> frames0Cue(frames0Gray.begin()+2+nSteps, frames0Gray.begin()+2+nSteps+3);
 155 
    std::vector<cv::Mat> frames0Cue(frames0Gray.begin()+2+nSteps, frames0Gray.begin()+2+nSteps+nSteps);
155 
    std::vector<cv::Mat> f0Icomp = getDFTComponents(frames0Enc);
 156 
    std::vector<cv::Mat> F0Enc = getDFTComponents(frames0Enc);
156 
    cv::Mat up0;
 157 
    cv::Mat up0;
157 
    cv::phase(f0Icomp[2], -f0Icomp[3], up0);
 158 
    cv::phase(F0Enc[2], -F0Enc[3], up0);
158 
cvtools::writeMat(up0, "up0.mat", "up0");
 159 
cvtools::writeMat(up0, "up0.mat", "up0");
- 
 
 160 
    std::vector<cv::Mat> F0Cue = getDFTComponents(frames0Cue);
- 
 
 161 
    cv::Mat up0Cue;
159 
    cv::Mat up0Cue = getPhase(frames0Cue[0], frames0Cue[1], frames0Cue[2]);
 162 
    cv::phase(F0Cue[2], -F0Cue[3], up0Cue);
160 
    up0 = unwrapWithCue(up0, up0Cue, nPhases);
 163 
    up0 = unwrapWithCue(up0, up0Cue, nPhases);
161 
    up0 *= screenCols/(2*pi);
 164 
    up0 *= screenCols/(2*pi);
162 
 
 165 
 
163 
    // Decode camera1
 166 
    // Decode camera1
164 
    std::vector<cv::Mat> frames1Enc(frames1Gray.begin()+2, frames1Gray.begin()+2+nSteps);
 167 
    std::vector<cv::Mat> frames1Enc(frames1Gray.begin()+2, frames1Gray.begin()+2+nSteps);
165 
    std::vector<cv::Mat> frames1Cue(frames1Gray.begin()+2+nSteps, frames1Gray.begin()+2+nSteps+3);
 168 
    std::vector<cv::Mat> frames1Cue(frames1Gray.begin()+2+nSteps, frames1Gray.begin()+2+nSteps+nSteps);
166 
    std::vector<cv::Mat> f1Icomp = getDFTComponents(frames1Enc);
 169 
    std::vector<cv::Mat> f1Icomp = getDFTComponents(frames1Enc);
167 
    cv::Mat up1;
 170 
    cv::Mat up1;
168 
    cv::phase(f1Icomp[2], -f1Icomp[3], up1);
 171 
    cv::phase(f1Icomp[2], -f1Icomp[3], up1);
169 
cvtools::writeMat(up1, "up1.mat", "up1");
 172 
cvtools::writeMat(up1, "up1.mat", "up1");
- 
 
 173 
    std::vector<cv::Mat> F1Cue = getDFTComponents(frames1Cue);
- 
 
 174 
    cv::Mat up1Cue;
170 
    cv::Mat up1Cue = getPhase(frames1Cue[0], frames1Cue[1], frames1Cue[2]);
 175 
    cv::phase(F1Cue[2], -F1Cue[3], up1Cue);
171 
    up1 = unwrapWithCue(up1, up1Cue, nPhases);
 176 
    up1 = unwrapWithCue(up1, up1Cue, nPhases);
172 
    up1 *= screenCols/(2*pi);
 177 
    up1 *= screenCols/(2*pi);
173 
 
 178 
 
174 
cvtools::writeMat(up0Cue, "up0Cue.mat", "up0Cue");
 179 
cvtools::writeMat(up0Cue, "up0Cue.mat", "up0Cue");
175 
cvtools::writeMat(up1Cue, "up1Cue.mat", "up1Cue");
 180 
cvtools::writeMat(up1Cue, "up1Cue.mat", "up1Cue");