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

 #ifndef M_PI
     #define M_PI 3.14159265358979323846
 #endif
-static unsigned int nPhases = 8;
+static unsigned int nPhases = 40;
-static unsigned int nSteps = 8;
+static unsigned int nSteps = 20;
 // Algorithm
 static cv::Mat computePhaseVector(unsigned int length, float phase, float pitch){
     cv::Mat phaseVector(length, 1, CV_8UC3);
     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));
+        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;
+}
 // 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::vector<cv::Mat> framesReverse = frames;
-    std::reverse(framesReverse.begin(), framesReverse.end());
+//    std::reverse(framesReverse.begin(), framesReverse.end());
     // DFT approach
     cv::Mat I;
     cv::merge(frames, I);
     unsigned int w = I.cols;
         cv::cvtColor(frames1[i], frames1Gray[i], CV_RGB2GRAY);
+    }
     // Decode camera0
     std::vector<cv::Mat> frames0Enc(frames0Gray.begin()+2, frames0Gray.begin()+2+nSteps);
-    std::vector<cv::Mat> frames0Cue(frames0Gray.begin()+2+nSteps, frames0Gray.begin()+nSteps+2+nSteps+3);
+    std::vector<cv::Mat> frames0Cue(frames0Gray.begin()+2+nSteps, frames0Gray.begin()+2+nSteps+3);
     std::vector<cv::Mat> f0Icomp = getDFTComponents(frames0Enc);
     cv::Mat up0;
     cv::phase(f0Icomp[2], -f0Icomp[3], up0);
+cvtools::writeMat(up0, "up0.mat", "up0");
     cv::Mat up0Cue = getPhase(frames0Cue[0], frames0Cue[1], frames0Cue[2]);
     up0 = unwrapWithCue(up0, up0Cue, nPhases);
     up0 *= screenCols/(2*pi);
     // Decode camera1
     std::vector<cv::Mat> frames1Enc(frames1Gray.begin()+2, frames1Gray.begin()+2+nSteps);
-    std::vector<cv::Mat> frames1Cue(frames1Gray.begin()+2+nSteps, frames1Gray.begin()+nSteps+2+nSteps+3);
+    std::vector<cv::Mat> frames1Cue(frames1Gray.begin()+2+nSteps, frames1Gray.begin()+2+nSteps+3);
     std::vector<cv::Mat> f1Icomp = getDFTComponents(frames1Enc);
     cv::Mat up1;
     cv::phase(f1Icomp[2], -f1Icomp[3], up1);
+cvtools::writeMat(up1, "up1.mat", "up1");
     cv::Mat up1Cue = getPhase(frames1Cue[0], frames1Cue[1], frames1Cue[2]);
     up1 = unwrapWithCue(up1, up1Cue, nPhases);
     up1 *= screenCols/(2*pi);
+cvtools::writeMat(up0Cue, "up0Cue.mat", "up0Cue");
+cvtools::writeMat(up1Cue, "up1Cue.mat", "up1Cue");
     // 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);
     // Phase remaps
     cv::Mat up0Rect, up1Rect;
     cv::remap(up0, up0Rect, map0X, map0Y, CV_INTER_CUBIC);
     cv::remap(up1, up1Rect, map1X, map1Y, CV_INTER_CUBIC);
+cvtools::writeMat(up0Rect, "up0Rect.mat", "up0Rect");
+cvtools::writeMat(up1Rect, "up1Rect.mat", "up1Rect");
     // Color remaps
     cv::Mat color0Rect, color1Rect;
     cv::remap(frames0[0], color0Rect, map0X, map0Y, CV_INTER_CUBIC);
     cv::remap(frames1[0], color1Rect, map1X, map1Y, CV_INTER_CUBIC);
+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_CUBIC);
     cv::remap(frames0Gray[1], frames0OffRect, map0X, map0Y, CV_INTER_CUBIC);
     cv::Mat frames1OnRect, frames1OffRect;
-    cv::remap(frames1Gray[0], frames1OnRect, map0X, map0Y, CV_INTER_CUBIC);
+    cv::remap(frames1Gray[0], frames1OnRect, map1X, map1Y, CV_INTER_CUBIC);
-    cv::remap(frames1Gray[1], frames1OffRect, map0X, map0Y, CV_INTER_CUBIC);
+    cv::remap(frames1Gray[1], frames1OffRect, map1X, map1Y, CV_INTER_CUBIC);
     // Occlusion masks
     cv::Mat occlusion0Rect, occlusion1Rect;
     cv::subtract(frames0OnRect, frames0OffRect, occlusion0Rect);
     occlusion0Rect = occlusion0Rect > 50;
     cv::subtract(frames1OnRect, frames1OffRect, occlusion1Rect);
     occlusion1Rect = occlusion1Rect > 50;
+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(3,3));
     cv::erode(occlusion0Rect, occlusion0Rect, strel);
     cv::erode(occlusion1Rect, occlusion1Rect, strel);
+    // Threshold on gradient of phase
+    cv::Mat edges0;
+    cv::Sobel(up0Rect, edges0, -1, 1, 1, 5);
+    occlusion0Rect = occlusion0Rect & (abs(edges0) < 5);
+    cv::Mat edges1;
+    cv::Sobel(up1Rect, edges1, -1, 1, 1, 5);
+    occlusion1Rect = occlusion1Rect & (abs(edges1) < 5);
+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
                     float col1i = col1 + (up0i-up1Left)/(up1Right-up1Left);
                     q0Rect.push_back(cv::Point2f(col, row));
                     q1Rect.push_back(cv::Point2f(col1i, row));
+                    break;
+                }
+            }
+        }

Subversion Repositories seema-scanner

(root)/src/algorithm/AlgorithmPhaseShift.cpp – Rev 70 → 71