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

 #ifndef M_PI
     #define M_PI 3.14159265358979323846
 #endif
-static unsigned int nStepsPrimary = 16; // number of shifts/steps in primary
+static unsigned int nStepsPrimary = 32; // number of shifts/steps in primary
 static unsigned int nStepsSecondary = 16; // number of shifts/steps in secondary
 static unsigned int nStepsTertiary = 16; // number of shifts/steps in tertiary
-static float periodPrimary = 24; // primary period
+static float nPeriodPrimary = 256; // number of primary periods
-static float periodSecondary = 30; // primary period
+static float nPeriodSecondary = 16; // number of secondary periods
 // Algorithm
 static cv::Mat computePhaseVector(unsigned int length, float phase, float pitch){
     cv::Mat phaseVector(length, 1, CV_8UC3);
 AlgorithmPhaseShiftThreeFreq::AlgorithmPhaseShiftThreeFreq(unsigned int _screenCols, unsigned int _screenRows) : Algorithm(_screenCols, _screenRows){
     // Set N
     N = 2+nStepsPrimary+nStepsSecondary+nStepsTertiary;
-    // Determine the tertiary period to fulfill the heterodyne condition
-    float periodTertiary = (screenCols*periodPrimary*periodSecondary)/(periodPrimary*periodSecondary+2*screenCols*periodPrimary-screenCols*periodSecondary);
     // all on pattern
     cv::Mat allOn(1, screenCols, CV_8UC3, cv::Scalar::all(255));
     patterns.push_back(allOn);
     // all off pattern
     const float pi = M_PI;
     // Primary encoding patterns
     for(unsigned int i=0; i<nStepsPrimary; i++){
         float phase = 2.0*pi/nStepsPrimary * i;
-        float pitch = periodPrimary;
+        float pitch = screenCols/nPeriodPrimary;
         cv::Mat patternI(1,1,CV_8U);
         patternI = computePhaseVector(screenCols, phase, pitch);
         patterns.push_back(patternI.t());
+    }
     // Secondary encoding patterns
     for(unsigned int i=0; i<nStepsSecondary; i++){
         float phase = 2.0*pi/nStepsSecondary * i;
-        float pitch = periodSecondary;
+        float pitch = screenCols/nPeriodSecondary;
         cv::Mat patternI(1,1,CV_8U);
         patternI = computePhaseVector(screenCols, phase, pitch);
         patterns.push_back(patternI.t());
+    }
     // Tertiary encoding patterns
     for(unsigned int i=0; i<nStepsTertiary; i++){
         float phase = 2.0*pi/nStepsTertiary * i;
-        float pitch = periodTertiary;
+        float pitch = screenCols;
         cv::Mat patternI(1,1,CV_8U);
         patternI = computePhaseVector(screenCols, phase, pitch);
         patterns.push_back(patternI.t());
+    }
     cv::phase(F0Secondary[2], -F0Secondary[3], up0Secondary);
     std::vector<cv::Mat> F0Tertiary = getDFTComponents(frames0Tertiary);
     cv::Mat up0Tertiary;
     cv::phase(F0Tertiary[2], -F0Tertiary[3], up0Tertiary);
-    cv::Mat up0EquivalentPS = up0Primary - up0Secondary;
-    up0EquivalentPS = cvtools::modulo(up0EquivalentPS, 2.0*pi);
-    cv::Mat up0EquivalentST = up0Secondary - up0Tertiary;
+    cv::Mat up0Unwrap = unwrapWithCue(up0Secondary, up0Tertiary, nPeriodSecondary);
-    up0EquivalentST = cvtools::modulo(up0EquivalentST, 2.0*pi);
-    cv::Mat up0Equivalent = up0EquivalentPS - up0EquivalentST;
-    up0Equivalent = cvtools::modulo(up0Equivalent, 2.0*pi);
-    cv::Mat up0 = unwrapWithCue(up0Primary, up0Equivalent, (float)screenCols/periodPrimary);
+    cv::Mat up0 = unwrapWithCue(up0Primary, up0Unwrap, nPeriodPrimary);
     up0 *= screenCols/(2.0*pi);
     cv::Mat amplitude0;
     cv::magnitude(F0Primary[2], -F0Primary[3], amplitude0);
     // Decode camera1
     cv::phase(F1Secondary[2], -F1Secondary[3], up1Secondary);
     std::vector<cv::Mat> F1Tertiary = getDFTComponents(frames1Tertiary);
     cv::Mat up1Tertiary;
     cv::phase(F1Tertiary[2], -F1Tertiary[3], up1Tertiary);
-    cv::Mat up1EquivalentPS = up1Primary - up1Secondary;
-    up1EquivalentPS = cvtools::modulo(up1EquivalentPS, 2.0*pi);
-    cv::Mat up1EquivalentST = up1Secondary - up1Tertiary;
+    cv::Mat up1Unwrap = unwrapWithCue(up1Secondary, up1Tertiary, nPeriodSecondary);
-    up1EquivalentST = cvtools::modulo(up1EquivalentST, 2.0*pi);
-    cv::Mat up1Equivalent = up1EquivalentPS - up1EquivalentST;
-    up1Equivalent = cvtools::modulo(up1Equivalent, 2.0*pi);
-    cv::Mat up1 = unwrapWithCue(up1Primary, up1Equivalent, (float)screenCols/periodPrimary);
+    cv::Mat up1 = unwrapWithCue(up1Primary, up1Unwrap, nPeriodPrimary);
     up1 *= screenCols/(2.0*pi);
     cv::Mat amplitude1;
     cv::magnitude(F1Primary[2], -F1Primary[3], amplitude1);
 //cvtools::writeMat(up0Primary, "up0Primary.mat", "up0Primary");
 //cvtools::writeMat(up0Secondary, "up0Secondary.mat", "up0Secondary");
 //cvtools::writeMat(up0Tertiary, "up0Tertiary.mat", "up0Tertiary");
-//cvtools::writeMat(up0Equivalent, "up0Equivalent.mat", "up0Equivalent");
+//cvtools::writeMat(up0Unwrap, "up0Unwrap.mat", "up0Unwrap");
-cvtools::writeMat(up0Equivalent2, "up0Equivalent2.mat", "up0Equivalent2");
-//cvtools::writeMat(up0EquivalentPS, "up0EquivalentPS.mat", "up0EquivalentPS");
-//cvtools::writeMat(up0EquivalentST, "up0EquivalentST.mat", "up0EquivalentST");
 //cvtools::writeMat(up0, "up0.mat", "up0");
 //cvtools::writeMat(up1, "up1.mat", "up1");
 //cvtools::writeMat(amplitude0, "amplitude0.mat", "amplitude0");
     // Rectifying homographies (rotation+projections)
     // amplitude remaps
     cv::Mat amplitude0Rect, amplitude1Rect;
     cv::remap(amplitude0, amplitude0Rect, map0X, map0Y, CV_INTER_LINEAR);
     cv::remap(amplitude1, amplitude1Rect, map1X, map1Y, CV_INTER_LINEAR);
-//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 debayer and remap
     cv::Mat color0Rect, color1Rect;
 //    frames0[0].convertTo(color0Rect, CV_8UC1, 1.0/256.0);
     cv::cvtColor(frames0[0], color0Rect, CV_BayerBG2RGB);
     cv::subtract(frames0OnRect, frames0OffRect, occlusion0Rect);
     occlusion0Rect = (occlusion0Rect > 25) & (occlusion0Rect < 250);
     cv::subtract(frames1OnRect, frames1OffRect, occlusion1Rect);
     occlusion1Rect = (occlusion1Rect > 25) & (occlusion1Rect < 250);
-    // Threshold on energy at primary frequency
+//    // Threshold on energy at primary frequency
-    occlusion0Rect = occlusion0Rect & (amplitude0Rect > 5.0*nStepsPrimary);
+//    occlusion0Rect = occlusion0Rect & (amplitude0Rect > 5.0*nStepsPrimary);
-    occlusion1Rect = occlusion1Rect & (amplitude1Rect > 5.0*nStepsPrimary);
+//    occlusion1Rect = occlusion1Rect & (amplitude1Rect > 5.0*nStepsPrimary);
 //cvtools::writeMat(occlusion0Rect, "occlusion0Rect.mat", "occlusion0Rect");
 //cvtools::writeMat(occlusion1Rect, "occlusion1Rect.mat", "occlusion1Rect");
-    // Erode occlusion masks
+//    // Erode occlusion masks
-    cv::Mat strel = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(5,5));
+//    cv::Mat strel = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(5,5));
-    cv::erode(occlusion0Rect, occlusion0Rect, strel);
+//    cv::erode(occlusion0Rect, occlusion0Rect, strel);
-    cv::erode(occlusion1Rect, occlusion1Rect, 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) < 150);
     cv::Mat edges1;
     cv::Sobel(up1Rect, edges1, -1, 1, 1, 5);
     occlusion1Rect = occlusion1Rect & (abs(edges1) < 150);
 //cvtools::writeMat(edges0, "edges0.mat", "edges0");
                     continue;
                 float up1Left = up1Rect.at<float>(row,col1);
                 float up1Right = up1Rect.at<float>(row,col1+1);
-                if((up1Left <= up0i) && (up0i <= up1Right) && (up0i-up1Left < 0.5) && (up1Right-up0i < 0.5)){
+                if((up1Left <= up0i) && (up0i <= up1Right) && (up0i-up1Left < 1.0) && (up1Right-up0i < 1.0)){
                     float col1i = col1 + (up0i-up1Left)/(up1Right-up1Left);
                     q0Rect.push_back(cv::Point2f(col, row));
                     q1Rect.push_back(cv::Point2f(col1i, row));

Subversion Repositories seema-scanner

(root)/src/algorithm/AlgorithmPhaseShiftThreeFreq.cpp @ 235 – Rev 130 → 131