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

 #ifndef M_PI
     #define M_PI 3.14159265358979323846
 #endif
-static unsigned int nPhases = 50;
+static unsigned int nSteps = 20; // number of shifts/steps in primary
-static unsigned int nSteps = 10;
+static float pPrimary = 200; // primary period
 // Algorithm
 static cv::Mat computePhaseVector(unsigned int length, float phase, float pitch){
     cv::Mat phaseVector(length, 1, CV_8UC3);
+}
 AlgorithmPhaseShift::AlgorithmPhaseShift(unsigned int _screenCols, unsigned int _screenRows) : Algorithm(_screenCols, _screenRows){
     // Set N
-    N = 2+2*nSteps;
+    N = 2+nSteps+3;
+    // Determine the secondary (wider) period
+    float pSecondary = (screenCols*pPrimary)/(screenCols-pPrimary);
     // all on pattern
     cv::Mat allOn(1, screenCols, CV_8UC3, cv::Scalar::all(255));
     patterns.push_back(allOn);
     patterns.push_back(allOff);
     // Precompute encoded patterns
     const float pi = M_PI;
-    // Horizontally encoding patterns
+    // Primary encoding patterns
     for(unsigned int i=0; i<nSteps; i++){
         float phase = 2.0*pi/nSteps * i;
-        float pitch = (float)screenCols/(float)nPhases;
+        float pitch = pPrimary;
         cv::Mat patternI(1,1,CV_8U);
         patternI = computePhaseVector(screenCols, phase, pitch);
         patterns.push_back(patternI.t());
+    }
-    // Phase cue patterns
+    // Secondary encoding patterns
-    for(unsigned int i=0; i<nSteps; i++){
+    for(unsigned int i=0; i<3; i++){
-        float phase = 2.0*pi/nSteps * i;
+        float phase = 2.0*pi/3 * i;
-        float pitch = screenCols;
+        float pitch = pSecondary;
         cv::Mat patternI(1,1,CV_8U);
         patternI = computePhaseVector(screenCols, phase, pitch);
         patterns.push_back(patternI.t());
+    }
     return phase;
+}
 // Phase unwrapping by means of a phase cue
-cv::Mat unwrapWithCue(const cv::Mat up, const cv::Mat upCue, unsigned int nPhases){
+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);
         cv::cvtColor(frames0[i], frames0Gray[i], CV_RGB2GRAY);
         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> frames0Primary(frames0Gray.begin()+2, frames0Gray.begin()+2+nSteps);
-    std::vector<cv::Mat> frames0Cue(frames0Gray.begin()+2+nSteps, frames0Gray.begin()+2+nSteps+nSteps);
+    std::vector<cv::Mat> frames0Secondary(frames0Gray.begin()+2+nSteps, frames0Gray.begin()+2+nSteps+3);
-    std::vector<cv::Mat> F0Enc = getDFTComponents(frames0Enc);
+    std::vector<cv::Mat> F0Enc = getDFTComponents(frames0Primary);
-    cv::Mat up0;
+    cv::Mat up0Primary;
-    cv::phase(F0Enc[2], -F0Enc[3], up0);
+    cv::phase(F0Enc[2], -F0Enc[3], up0Primary);
-cvtools::writeMat(up0, "up0.mat", "up0");
-    std::vector<cv::Mat> F0Cue = getDFTComponents(frames0Cue);
+    cv::Mat up0Secondary = getPhase(frames0Secondary[0], frames0Secondary[1], frames0Secondary[2]);
-    cv::Mat up0Cue;
+    cv::Mat up0Equivalent = up0Primary - up0Secondary;
-    cv::phase(F0Cue[2], -F0Cue[3], up0Cue);
+    up0Equivalent = cvtools::modulo(up0Equivalent, 2*pi);
-    up0 = unwrapWithCue(up0, up0Cue, nPhases);
+    cv::Mat up0 = unwrapWithCue(up0Primary, up0Equivalent, (float)screenCols/pPrimary);
     up0 *= screenCols/(2*pi);
     // Decode camera1
-    std::vector<cv::Mat> frames1Enc(frames1Gray.begin()+2, frames1Gray.begin()+2+nSteps);
+    std::vector<cv::Mat> frames1Primary(frames1Gray.begin()+2, frames1Gray.begin()+2+nSteps);
-    std::vector<cv::Mat> frames1Cue(frames1Gray.begin()+2+nSteps, frames1Gray.begin()+2+nSteps+nSteps);
+    std::vector<cv::Mat> frames1Secondary(frames1Gray.begin()+2+nSteps, frames1Gray.begin()+2+nSteps+3);
-    std::vector<cv::Mat> f1Icomp = getDFTComponents(frames1Enc);
+    std::vector<cv::Mat> F1Enc = getDFTComponents(frames1Primary);
-    cv::Mat up1;
+    cv::Mat up1Primary;
-    cv::phase(f1Icomp[2], -f1Icomp[3], up1);
+    cv::phase(F1Enc[2], -F1Enc[3], up1Primary);
-cvtools::writeMat(up1, "up1.mat", "up1");
-    std::vector<cv::Mat> F1Cue = getDFTComponents(frames1Cue);
+    cv::Mat up1Secondary = getPhase(frames1Secondary[0], frames1Secondary[1], frames1Secondary[2]);
-    cv::Mat up1Cue;
+    cv::Mat up1Equivalent = up1Primary - up1Secondary;
-    cv::phase(F1Cue[2], -F1Cue[3], up1Cue);
+    up1Equivalent = cvtools::modulo(up1Equivalent, 2*pi);
-    up1 = unwrapWithCue(up1, up1Cue, nPhases);
+    cv::Mat up1 = unwrapWithCue(up1Primary, up1Equivalent, (float)screenCols/pPrimary);
     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
     // 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(up0Rect, "up0Rect.mat", "up0Rect");
-cvtools::writeMat(up1Rect, "up1Rect.mat", "up1Rect");
+//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(color0Rect, "color0Rect.mat", "color0Rect");
-cvtools::writeMat(color1Rect, "color1Rect.mat", "color1Rect");
+//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::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::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::Mat edges1;
     cv::Sobel(up1Rect, edges1, -1, 1, 0, 5);
     occlusion1Rect = occlusion1Rect & (abs(edges1) < 150);
-cvtools::writeMat(edges0, "edges0.mat", "edges0");
+//cvtools::writeMat(edges0, "edges0.mat", "edges0");
-cvtools::writeMat(edges1, "edges1.mat", "edges1");
+//cvtools::writeMat(edges1, "edges1.mat", "edges1");
-cvtools::writeMat(occlusion0Rect, "occlusion0Rect.mat", "occlusion0Rect");
-cvtools::writeMat(occlusion1Rect, "occlusion1Rect.mat", "occlusion1Rect");
     // 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;
                     continue;
                 float up1Left = up1Rect.at<float>(row,col1);
                 float up1Right = up1Rect.at<float>(row,col1+1);
-                if((up1Left <= up0i) && (up0i <= up1Right)){
+                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);

Subversion Repositories seema-scanner

(root)/src/algorithm/AlgorithmPhaseShift.cpp – Rev 73 → 74