Subversion Repositories seema-scanner

Rev

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

Rev 188 Rev 189
Line 124... Line 124...
124 
    cv::phase(F0Second[2], -F0Second[3], up0Second);
 124 
    cv::phase(F0Second[2], -F0Second[3], up0Second);
125 
    std::vector<cv::Mat> F0Third = getDFTComponents(frames0Third);
 125 
    std::vector<cv::Mat> F0Third = getDFTComponents(frames0Third);
126 
    cv::Mat up0Third;
 126 
    cv::Mat up0Third;
127 
    cv::phase(F0Third[2], -F0Third[3], up0Third);
 127 
    cv::phase(F0Third[2], -F0Third[3], up0Third);
128 
 
 128 
 
129 
    cv::Mat up0EquivalentPS = up0First - up0Second;
 129 
    cv::Mat up0EquivalentFS = up0First - up0Second;
130 
    up0EquivalentPS = cvtools::modulo(up0EquivalentPS, 2.0*pi);
 130 
    up0EquivalentFS = cvtools::modulo(up0EquivalentFS, 2.0*pi);
131 
 
 131 
 
132 
    cv::Mat up0EquivalentPT = up0First - up0Third;
 132 
    cv::Mat up0EquivalentST = up0Second - up0Third;
133 
    up0EquivalentPT = cvtools::modulo(up0EquivalentPT, 2.0*pi);
 133 
    up0EquivalentST = cvtools::modulo(up0EquivalentST, 2.0*pi);
134 
 
 134 
 
135 
    cv::Mat up0EquivalentPST = up0EquivalentPS - up0EquivalentPT;
 135 
    cv::Mat up0EquivalentFST = up0EquivalentFS - up0EquivalentST;
136 
    up0EquivalentPST = cvtools::modulo(up0EquivalentPST, 2.0*pi);
 136 
    up0EquivalentFST = cvtools::modulo(up0EquivalentFST, 2.0*pi);
137 
 
 137 
 
138 
        // TODO: we should use backward phase unwrapping (Song Zhang term)...
 138 
        // TODO: we should use backward phase unwrapping (Song Zhang term)...
139 
 
 139 
 
140 
    cv::Mat up0 = unwrapWithCue(up0First, up0EquivalentPST, (float)screenCols/nPeriodsFirst);
 140 
    cv::Mat up0 = unwrapWithCue(up0First, up0EquivalentFST, (float)screenCols/nPeriodsFirst);
141 
    up0 *= screenCols/(2.0*pi);
 141 
    up0 *= screenCols/(2.0*pi);
142 
    cv::Mat amplitude0;
 142 
    cv::Mat amplitude0;
143 
    cv::magnitude(F0First[2], -F0First[3], amplitude0);
 143 
    cv::magnitude(F0First[2], -F0First[3], amplitude0);
144 
 
 144 
 
145 
    // Decode camera1
 145 
    // Decode camera1
Line 155... Line 155...
155 
    cv::phase(F1Second[2], -F1Second[3], up1Second);
 155 
    cv::phase(F1Second[2], -F1Second[3], up1Second);
156 
    std::vector<cv::Mat> F1Third = getDFTComponents(frames1Third);
 156 
    std::vector<cv::Mat> F1Third = getDFTComponents(frames1Third);
157 
    cv::Mat up1Third;
 157 
    cv::Mat up1Third;
158 
    cv::phase(F1Third[2], -F1Third[3], up1Third);
 158 
    cv::phase(F1Third[2], -F1Third[3], up1Third);
159 
 
 159 
 
160 
    cv::Mat up1EquivalentPS = up1First - up1Second;
 160 
    cv::Mat up1EquivalentFS = up1First - up1Second;
161 
    up1EquivalentPS = cvtools::modulo(up1EquivalentPS, 2.0*pi);
 161 
    up1EquivalentFS = cvtools::modulo(up1EquivalentFS, 2.0*pi);
162 
 
 162 
 
163 
    cv::Mat up1EquivalentST = up1Second - up1Third;
 163 
    cv::Mat up1EquivalentST = up1Second - up1Third;
164 
    up1EquivalentST = cvtools::modulo(up1EquivalentST, 2.0*pi);
 164 
    up1EquivalentST = cvtools::modulo(up1EquivalentST, 2.0*pi);
165 
 
 165 
 
166 
    cv::Mat up1EquivalentPST = up1EquivalentPS - up1EquivalentST;
 166 
    cv::Mat up1EquivalentFST = up1EquivalentFS - up1EquivalentST;
167 
    up1EquivalentPST = cvtools::modulo(up1EquivalentPST, 2.0*pi);
 167 
    up1EquivalentFST = cvtools::modulo(up1EquivalentFST, 2.0*pi);
168 
 
 168 
 
169 
    cv::Mat up1 = unwrapWithCue(up1First, up1EquivalentPST, (float)screenCols/nPeriodsFirst);
 169 
    cv::Mat up1 = unwrapWithCue(up1First, up1EquivalentFST, (float)screenCols/nPeriodsFirst);
170 
    up1 *= screenCols/(2.0*pi);
 170 
    up1 *= screenCols/(2.0*pi);
171 
    cv::Mat amplitude1;
 171 
    cv::Mat amplitude1;
172 
    cv::magnitude(F1First[2], -F1First[3], amplitude1);
 172 
    cv::magnitude(F1First[2], -F1First[3], amplitude1);
173 
 
 173 
 
174 
    #ifdef QT_DEBUG
 174 
    #ifdef QT_DEBUG
175 
        cvtools::writeMat(up0First, "up0First.mat", "up0First");
 175 
        cvtools::writeMat(up0First, "up0First.mat", "up0First");
176 
        cvtools::writeMat(up0Second, "up0Second.mat", "up0Second");
 176 
        cvtools::writeMat(up0Second, "up0Second.mat", "up0Second");
177 
        cvtools::writeMat(up0Third, "up0Third.mat", "up0Third");
 177 
        cvtools::writeMat(up0Third, "up0Third.mat", "up0Third");
178 
        cvtools::writeMat(up0EquivalentPS, "up0EquivalentPS.mat", "up0EquivalentPS");
 178 
        cvtools::writeMat(up0EquivalentFS, "up0EquivalentFS.mat", "up0EquivalentFS");
179 
        cvtools::writeMat(up0EquivalentPT, "up0EquivalentPT.mat", "up0EquivalentPT");
 179 
        cvtools::writeMat(up0EquivalentST, "up0EquivalentST.mat", "up0EquivalentST");
180 
        cvtools::writeMat(up0EquivalentPST, "up0EquivalentPST.mat", "up0EquivalentPST");
 180 
        cvtools::writeMat(up0EquivalentFST, "up0EquivalentFST.mat", "up0EquivalentFST");
181 
        cvtools::writeMat(up0, "up0.mat", "up0");
 181 
        cvtools::writeMat(up0, "up0.mat", "up0");
182 
        cvtools::writeMat(up1, "up1.mat", "up1");
 182 
        cvtools::writeMat(up1, "up1.mat", "up1");
183 
        cvtools::writeMat(amplitude0, "amplitude0.mat", "amplitude0");
 183 
        cvtools::writeMat(amplitude0, "amplitude0.mat", "amplitude0");
184 
 
 184 
 
185 
        cvtools::writeMat(amplitude0, "amplitude0.mat", "amplitude0");
 185 
        cvtools::writeMat(amplitude0, "amplitude0.mat", "amplitude0");
Line 243... Line 243...
243 
                    continue;
 243 
                    continue;
244 
 
 244 
 
245 
                float up1Left = up1.at<float>(row,col1);
 245 
                float up1Left = up1.at<float>(row,col1);
246 
                float up1Right = up1.at<float>(row,col1+1);
 246 
                float up1Right = up1.at<float>(row,col1+1);
247 
 
 247 
 
248 
                if((up1Left <= up0i) && (up0i <= up1Right) && (up0i-up1Left < 1.0) && (up1Right-up0i < 1.0)){
 248 
                if((up1Left <= up0i) && (up0i <= up1Right) && (up0i-up1Left < 1.0) && (up1Right-up0i < 1.0) && (up1Right-up1Left > 0.1)){
249 
 
 249 
 
250 
                    float col1i = col1 + (up0i-up1Left)/(up1Right-up1Left);
 250 
                    float col1i = col1 + (up0i-up1Left)/(up1Right-up1Left);
251 
 
 251 
 
252 
                    q0.push_back(cv::Point2f(col, row));
 252 
                    q0.push_back(cv::Point2f(col, row));
253 
                    q1.push_back(cv::Point2f(col1i, row));
 253 
                    q1.push_back(cv::Point2f(col1i, row));