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

 static bool getBit(int decimal, int N){
     return decimal & 1 << (N-1);
+}
-/*
+///*
- * Return the number of bits set in an integer
+// * Return the number of bits set in an integer
- */
+// */
-static int countBits(int n) {
+//static int countBits(int n) {
-  unsigned int c; // c accumulates the total bits set in v
+//  unsigned int c; // c accumulates the total bits set in v
-  for (c = 0; n>0; c++)
+//  for (c = 0; n>0; c++)
-    n &= n - 1; // clear the least significant bit set
+//    n &= n - 1; // clear the least significant bit set
-  return c;
+//  return c;
-}
+//}
 /*
  * Return the position of the least significant bit that is set
  */
 static int leastSignificantBitSet(int x){
     std::vector<cv::Vec4i>::iterator it;
     it = std::unique(edges.begin(), edges.end(), sortingEqual);
     edges.resize(std::distance(edges.begin(),it));
+}
-static cv::Vec3b getColorSubpix(const cv::Mat& img, cv::Point2f pt){
+//static cv::Vec3b getColorSubpix(const cv::Mat& img, cv::Point2f pt){
-    assert(!img.empty());
+//    assert(!img.empty());
-    assert(img.channels() == 3);
+//    assert(img.channels() == 3);
-    int x = (int)pt.x;
+//    int x = (int)pt.x;
-    int y = (int)pt.y;
+//    int y = (int)pt.y;
-    int x0 = cv::borderInterpolate(x,   img.cols, cv::BORDER_REFLECT_101);
+//    int x0 = cv::borderInterpolate(x,   img.cols, cv::BORDER_REFLECT_101);
-    int x1 = cv::borderInterpolate(x+1, img.cols, cv::BORDER_REFLECT_101);
+//    int x1 = cv::borderInterpolate(x+1, img.cols, cv::BORDER_REFLECT_101);
-    int y0 = cv::borderInterpolate(y,   img.rows, cv::BORDER_REFLECT_101);
+//    int y0 = cv::borderInterpolate(y,   img.rows, cv::BORDER_REFLECT_101);
-    int y1 = cv::borderInterpolate(y+1, img.rows, cv::BORDER_REFLECT_101);
+//    int y1 = cv::borderInterpolate(y+1, img.rows, cv::BORDER_REFLECT_101);
-    float a = pt.x - (float)x;
+//    float a = pt.x - (float)x;
-    float c = pt.y - (float)y;
+//    float c = pt.y - (float)y;
-    uchar b = (uchar)cvRound((img.at<cv::Vec3b>(y0, x0)[0] * (1.f - a) + img.at<cv::Vec3b>(y0, x1)[0] * a) * (1.f - c)
+//    uchar b = (uchar)cvRound((img.at<cv::Vec3b>(y0, x0)[0] * (1.f - a) + img.at<cv::Vec3b>(y0, x1)[0] * a) * (1.f - c)
-                           + (img.at<cv::Vec3b>(y1, x0)[0] * (1.f - a) + img.at<cv::Vec3b>(y1, x1)[0] * a) * c);
+//                           + (img.at<cv::Vec3b>(y1, x0)[0] * (1.f - a) + img.at<cv::Vec3b>(y1, x1)[0] * a) * c);
-    uchar g = (uchar)cvRound((img.at<cv::Vec3b>(y0, x0)[1] * (1.f - a) + img.at<cv::Vec3b>(y0, x1)[1] * a) * (1.f - c)
+//    uchar g = (uchar)cvRound((img.at<cv::Vec3b>(y0, x0)[1] * (1.f - a) + img.at<cv::Vec3b>(y0, x1)[1] * a) * (1.f - c)
-                           + (img.at<cv::Vec3b>(y1, x0)[1] * (1.f - a) + img.at<cv::Vec3b>(y1, x1)[1] * a) * c);
+//                           + (img.at<cv::Vec3b>(y1, x0)[1] * (1.f - a) + img.at<cv::Vec3b>(y1, x1)[1] * a) * c);
-    uchar r = (uchar)cvRound((img.at<cv::Vec3b>(y0, x0)[2] * (1.f - a) + img.at<cv::Vec3b>(y0, x1)[2] * a) * (1.f - c)
+//    uchar r = (uchar)cvRound((img.at<cv::Vec3b>(y0, x0)[2] * (1.f - a) + img.at<cv::Vec3b>(y0, x1)[2] * a) * (1.f - c)
-                           + (img.at<cv::Vec3b>(y1, x0)[2] * (1.f - a) + img.at<cv::Vec3b>(y1, x1)[2] * a) * c);
+//                           + (img.at<cv::Vec3b>(y1, x0)[2] * (1.f - a) + img.at<cv::Vec3b>(y1, x1)[2] * a) * c);
-    return cv::Vec3b(b, g, r);
+//    return cv::Vec3b(b, g, r);
-}
+//}
 void AlgorithmGrayCode::get3DPoints(SMCalibrationParameters calibration, const std::vector<cv::Mat>& frames0, const std::vector<cv::Mat>& frames1, std::vector<cv::Point3f>& Q, std::vector<cv::Vec3b>& color){
     assert(frames0.size() == N);
     assert(frames1.size() == N);
     cv::initUndistortRectifyMap(calibration.K1, calibration.k1, R1, P1, frameSize, CV_32F, map1X, map1Y);
     // gray-scale and remap
     std::vector<cv::Mat> frames0Rect(N);
     std::vector<cv::Mat> frames1Rect(N);
-    for(int i=0; i<N; i++){
+    for(unsigned int i=0; i<N; i++){
         cv::Mat temp;
         cv::cvtColor(frames0[i], temp, CV_BayerBG2GRAY);
         cv::remap(temp, frames0Rect[i], map0X, map0Y, CV_INTER_LINEAR);
         cv::cvtColor(frames1[i], temp, CV_BayerBG2GRAY);
         cv::remap(temp, frames1Rect[i], map1X, map1Y, CV_INTER_LINEAR);
     // decode patterns
     cv::Mat code0Rect(frameRectRows, frameRectCols, CV_32S, cv::Scalar(0));
     cv::Mat code1Rect(frameRectRows, frameRectCols, CV_32S, cv::Scalar(0));
     // into gray code
-    for(int i=0; i<Nbits; i++){
+    for(unsigned int i=0; i<Nbits; i++){
         cv::Mat temp, bit0, bit1;
         cv::compare(frames0Rect[i*2+2], frames0Rect[i*2+3], temp, cv::CMP_GT);
         temp.convertTo(bit0, CV_32S, 1.0/255.0);
         cv::add(code0Rect, bit0*twopowi(Nbits-i-1), code0Rect, cv::noArray(), CV_32S);
         getEdgeLabels(code0Rect.row(row), Nbits, edges0);
         getEdgeLabels(code1Rect.row(row), Nbits, edges1);
         // match edges
         std::vector<cv::Vec4i> matchedEdges0, matchedEdges1;
-        int i=0, j=0;
+        unsigned int i=0, j=0;
         while(i<edges0.size() && j<edges1.size()){
             if(edges0[i][3] == edges1[j][3]){
                 matchedEdges0.push_back(edges0[i]);
                 matchedEdges1.push_back(edges1[j]);
+            }
+        }
         // crude subpixel refinement
         // finds the intersection of linear interpolants in the positive/negative pattern
-        for(int i=0; i<matchedEdges0.size(); i++){
+        for(unsigned int i=0; i<matchedEdges0.size(); i++){
             int level = Nbits - leastSignificantBitSet(matchedEdges0[i][1]^matchedEdges0[i][2]);
             // refine for camera 0
             float c0 = matchedEdges0[i][0];

Subversion Repositories seema-scanner

(root)/src/algorithm/AlgorithmGrayCode.cpp – Rev 133 → 167