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

                                    cv::Mat& phase,
                                    cv::Mat& energy) {
     std::vector<cv::Mat> fourier = getDFTComponents(frames);
     cv::phase(fourier[2], -fourier[3], phase);
     // Signal energy at unit frequency
     cv::magnitude(fourier[2], -fourier[3], amplitude);
     #pragma omp parallel sections
+    {
         #pragma omp section
+        {
             // Gray-scale and remap/rectify
             std::vector<cv::Mat> frames0Rect(N);
             for(unsigned int i=0; i<N; i++){
                 cv::Mat temp;
                 if(frames0[i].depth() == CV_8U)
                     cv::cvtColor(frames0[i], temp, CV_BayerBG2GRAY);
+                else if(frames0[i].channels() == 3)
+                    cv::cvtColor(frames0[i], temp, CV_RGB2GRAY);
                 else
                     temp = frames0[i];
                 cv::remap(temp, frames0Rect[i],
                           stereoRect.map0X, stereoRect.map0Y,
                           CV_INTER_LINEAR);
+            }
+            if(frames0[0].depth() == CV_8U) {
+                cv::Mat temp;
+                cv::cvtColor(frames0[0], temp, CV_BayerBG2RGB);
-            // If images are HDR (float), we need to convert to uchar
+                cv::remap(temp, color0, stereoRect.map0X, stereoRect.map0Y,
+                          CV_INTER_LINEAR);
+            }
+            else if(frames0[0].channels() == 1) {
-            frames0Rect[0].convertTo(color0, CV_32FC3);
+                frames0Rect[0].convertTo(color0, CV_32FC3);
+            }
+            else {
+                cv::remap(frames0[0], color0, stereoRect.map0X, stereoRect.map0Y,
+                          CV_INTER_LINEAR);
+            }
+            cv::Mat tmp;
+            color0.convertTo(tmp, CV_8U, 255.0);
+            cv::imwrite("color0.jpg", tmp);
             // Occlusion masks
             cv::subtract(frames0Rect[0], frames0Rect[1], occlusion0);
+            if(frames0Rect[0].depth() == CV_8U)
-            occlusion0 = (occlusion0 > 25) & (occlusion0 < 250);
+                occlusion0 = (occlusion0 > 25) & (occlusion0 < 250);
+            else
+                occlusion0 = (occlusion0 > 25.0 / 255.0) & (occlusion0 < 250.0 / 255.0);
             // Decode camera0
             std::vector<cv::Mat> frames0Primary(frames0Rect.begin()+2,
                                                 frames0Rect.begin()+2+nStepsPrimary);
             std::vector<cv::Mat> frames0Secondary(frames0Rect.begin()+2+nStepsPrimary,
                                           amplitude0Secondary,
                                           up0Secondary,
                                           energy0Secondary);
             unWrapPhaseMap(up0Primary, up0Secondary, up0);
             // Threshold on energy at primary frequency
+            if(frames0Rect[0].depth() == CV_8U)
-            occlusion0 = occlusion0 & (amplitude0Primary > 5.0*nStepsPrimary);
+                occlusion0 = occlusion0 & (amplitude0Primary > 5.0*nStepsPrimary);
+            else
+                occlusion0 = occlusion0 & (amplitude0Primary * 255.0 > 5.0*nStepsPrimary);
             // Threshold on energy ratios
             occlusion0 = occlusion0 & (amplitude0Primary > 0.25*energy0Primary);
             occlusion0 = occlusion0 & (amplitude0Secondary > 0.25*energy0Secondary);
             // // Erode occlusion masks
             cv::Mat edges0;
             cv::Sobel(up0, edges0, -1, 1, 1, 5);
             occlusion0 = occlusion0 & (abs(edges0) < 10);
             #ifdef SM_DEBUG
+                cv::Mat tmp;
+                double min, max;
+                cv::minMaxLoc(up0Primary, &min, &max);
+                up0Primary.convertTo(tmp, CV_8U, 255.0 / (max - min), -min * 255.0 / (max - min));
+                cv::imwrite("up0Primary.jpg", tmp & occlusion0);
+                cv::minMaxLoc(up0Secondary, &min, &max);
+                up0Secondary.convertTo(tmp, CV_8U, 255.0 / (max - min), -min * 255.0 / (max - min));
+                cv::imwrite("up0Secondary.jpg", tmp & occlusion0);
+                cv::minMaxLoc(up0, &min, &max);
+                up0.convertTo(tmp, CV_8U, 255.0 / (max - min),- min * 255.0 / (max - min));
+                cv::imwrite("up0.jpg", tmp & occlusion0);
+                cv::minMaxLoc(amplitude0Primary, &min, &max);
+                amplitude0Primary.convertTo(tmp, CV_8U, 255.0 / (max - min), -min * 255.0 / (max - min));
+                cv::imwrite("amplitude0Primary.jpg", tmp & occlusion0);
+                cv::minMaxLoc(amplitude0Secondary, &min, &max);
+                amplitude0Secondary.convertTo(tmp, CV_8U, 255.0 / (max - min), -min * 255.0 / (max - min));
+                cv::imwrite("amplitude0Secondary.jpg", tmp & occlusion0);
+                cv::minMaxLoc(energy0Primary, &min, &max);
+                energy0Primary.convertTo(tmp, CV_8U, 255.0 / (max - min),- min * 255.0 / (max - min));
+                cv::imwrite("energy0Primary.jpg", tmp & occlusion0);
+                cv::minMaxLoc(energy0Secondary, &min, &max);
+                energy0Secondary.convertTo(tmp, CV_8U, 255.0 / (max - min), -min * 255.0 / (max - min));
+                cv::imwrite("energy0Secondary.jpg", tmp & occlusion0);
                 cvtools::writeMat(up0Primary, "up0Primary.mat", "up0Primary");
                 cvtools::writeMat(up0Secondary, "up0Secondary.mat", "up0Secondary");
                 cvtools::writeMat(up0, "up0.mat", "up0");
                 cvtools::writeMat(amplitude0Primary,
                                   "amplitude0Primary.mat", "amplitude0Primary");
             for(unsigned int i=0; i<N; i++){
                 cv::Mat temp;
                 if(frames1[i].depth() == CV_8U)
                     cv::cvtColor(frames1[i], temp, CV_BayerBG2GRAY);
+                else if(frames1[i].channels() == 3)
+                    cv::cvtColor(frames1[i], temp, CV_RGB2GRAY);
                 else
                     temp = frames1[i];
                 cv::remap(temp, frames1Rect[i],
                           stereoRect.map1X, stereoRect.map1Y,
                           CV_INTER_LINEAR);
+            }
+            if(frames1[0].depth() == CV_8U) {
+                cv::Mat temp;
+                cv::cvtColor(frames1[0], temp, CV_BayerBG2RGB);
-            // If images are HDR (float), we need to convert to uchar
+                cv::remap(temp, color1, stereoRect.map1X, stereoRect.map1Y,
+                          CV_INTER_LINEAR);
+            }
+            else if(frames1[0].channels() == 1) {
-            frames1Rect[0].convertTo(color1, CV_32FC3);
+                frames1Rect[0].convertTo(color1, CV_32FC3);
+            }
+            else {
+                cv::remap(frames1[0], color1, stereoRect.map1X, stereoRect.map1Y,
+                          CV_INTER_LINEAR);
+            }
             // Occlusion masks
             cv::subtract(frames1Rect[0], frames1Rect[1], occlusion1);
+            if(frames1Rect[0].depth() == CV_8U)
-            occlusion1 = (occlusion1 > 25) & (occlusion1 < 250);
+                occlusion1 = (occlusion1 > 25) & (occlusion1 < 250);
+            else
+                occlusion1 = (occlusion1 > 25.0 / 255.0) & (occlusion1 < 250.0 / 255.0);
             // Decode camera1
             std::vector<cv::Mat> frames1Primary(frames1Rect.begin()+2,
                                                 frames1Rect.begin()+2+nStepsPrimary);
             std::vector<cv::Mat> frames1Secondary(frames1Rect.begin()+2+nStepsPrimary,
                                           energy1Secondary);
             unWrapPhaseMap(up1Primary, up1Secondary, up1);
             // Threshold on energy at primary frequency
+            if(frames1Rect[0].depth() == CV_8U)
-            occlusion1 = occlusion1 & (amplitude1Primary > 5.0*nStepsPrimary);
+                occlusion1 = occlusion1 & (amplitude1Primary > 5.0*nStepsPrimary);
+            else
+                occlusion1 = occlusion1 & (amplitude1Primary * 255.0 > 5.0*nStepsPrimary);
             // Threshold on energy ratios
             occlusion1 = occlusion1 & (amplitude1Primary > 0.25*energy1Primary);
             occlusion1 = occlusion1 & (amplitude1Secondary > 0.25*energy1Secondary);
             // // Erode occlusion masks
             cv::Mat edges1;
             cv::Sobel(up1, edges1, -1, 1, 1, 5);
             occlusion1 = occlusion1 & (abs(edges1) < 10);
             #ifdef SM_DEBUG
+                cv::Mat tmp;
+                double min, max;
+                cv::minMaxLoc(up1Primary, &min, &max);
+                up1Primary.convertTo(tmp, CV_8U, 255.0 / (max - min), -min * 255.0 / (max - min));
+                cv::imwrite("up1Primary.jpg", tmp & occlusion1);
+                cv::minMaxLoc(up1Secondary, &min, &max);
+                up1Secondary.convertTo(tmp, CV_8U, 255.0 / (max - min), -min * 255.0 / (max - min));
+                cv::imwrite("up1Secondary.jpg", tmp & occlusion1);
+                cv::minMaxLoc(up1, &min, &max);
+                up1.convertTo(tmp, CV_8U, 255.0 / (max - min),- min * 255.0 / (max - min));
+                cv::imwrite("up1.jpg", tmp & occlusion1);
+                cv::minMaxLoc(amplitude1Primary, &min, &max);
+                amplitude1Primary.convertTo(tmp, CV_8U, 255.0 / (max - min), -min * 255.0 / (max - min));
+                cv::imwrite("amplitude1Primary.jpg", tmp & occlusion1);
+                cv::minMaxLoc(amplitude1Secondary, &min, &max);
+                amplitude1Secondary.convertTo(tmp, CV_8U, 255.0 / (max - min), -min * 255.0 / (max - min));
+                cv::imwrite("amplitude1Secondary.jpg", tmp & occlusion1);
+                cv::minMaxLoc(energy1Primary, &min, &max);
+                energy1Primary.convertTo(tmp, CV_8U, 255.0 / (max - min),- min * 255.0 / (max - min));
+                cv::imwrite("energy1Primary.jpg", tmp & occlusion1);
+                cv::minMaxLoc(energy1Secondary, &min, &max);
+                energy1Secondary.convertTo(tmp, CV_8U, 255.0 / (max - min), -min * 255.0 / (max - min));
+                cv::imwrite("energy1Secondary.jpg", tmp & occlusion1);
                 cvtools::writeMat(up1Primary, "up1Primary.mat", "up1Primary");
                 cvtools::writeMat(up1Secondary, "up1Secondary.mat", "up1Secondary");
                 cvtools::writeMat(up1, "up1.mat", "up1");
                 cvtools::writeMat(amplitude1Primary,
                                   "amplitude1Primary.mat", "amplitude1Primary");
         for(unsigned int i=0; i<nMatches; i++){
             cv::Vec3f c0 = color0.at<cv::Vec3f>(int(q0[i][1]), int(q0[i][0]));
             cv::Vec3f c1 = color1.at<cv::Vec3f>(int(q1[i][1]), int(q1[i][0]));
-            color[i] = 0.5*c0 + 0.5*c1;
+            color[i] = (0.5*c0 + 0.5*c1);
+        }
+    }
     // Triangulate points
     triangulate(stereoRect, q0, q1, Q);

Subversion Repositories seema-scanner

(root)/src/algorithm/AlgorithmPhaseShiftTwoFreq.cpp – Rev 251 → 257