More comment, less dead code

Author: tsing

src/app/App.cpp

@@ -45,6 +45,7 @@ int main(int argc, char** argv)
     auto pointCloud = reconstruct.reconstruct();
 
     auto extension = output.substr(output.find_last_of(".")+1);
+    pointCloud.exportPointCloud( p.get<std::string>("output"), extension);
     //SLS::exportPointCloud(output, extension, reconstruct);
 
     LOG::writeLog("DONE!\n");

src/lib/GrayCode/GrayCode.cpp

@@ -16,9 +16,14 @@ void GrayCode::generateGrayCode()
     // Set first frame to white
     grayCodes_[0] = cv::Mat(height_, width_, CV_8UC1, cv::Scalar(255));
     uchar flag = 0;
+
+    // Generate patterns to encode x pixels.
+    // For each column
 	for (size_t j=0; j<width_; j++)	
 	{
 		int rem=0, num=j, prevRem=j%2;
+
+        // For each bit in the column
 		for (size_t k=0; k<numColBits; k++)	
 		{
 			num=num/2;
@@ -42,15 +47,17 @@ void GrayCode::generateGrayCode()
 
 	}
 
+    // Generate patterns to encode y pixels
+    // For each row
 	for (size_t i=0;i<height_;i++)	
 	{
 		int rem=0, num=i, prevRem=i%2;
+        // For each bit in the row
 		for (size_t k=0; k<numRowBits; k++)	
 		{
 
 			num=num/2;
 			rem=num%2;
-
 			if ((rem==0 && prevRem==1) || (rem==1 && prevRem==0)) { 
 				flag=1;
 			}
@@ -68,7 +75,6 @@ void GrayCode::generateGrayCode()
 
 			prevRem=rem;
 		} 
-		
 	}
     for (size_t i=0; i<grayCodes_.size(); i++)
     {

src/lib/GrayCode/GrayCode.hpp

@@ -14,6 +14,14 @@ class GrayCode
         for (auto &img: grayCodes_)
             img.release();
     }
+
+    /*! Generate and display gray code
+     *
+     * The patterns are encoded by [gray code](https://en.wikipedia.org/wiki/Gray_code) to 
+     * avoid error.
+     * The binary are encoded separately for columns and rows. i.e. for a projector pixel (x, y)
+     * we have (BitSeqX, BitSeqY).
+     */
     void generateGrayCode();
 private:
     //! Projector width and height

src/lib/ReconstructorCUDA/ReconstructorCUDA.cu

@@ -18,7 +18,7 @@ void ReconstructorCUDA::addCamera(Camera *cam)
 }
 PointCloud ReconstructorCUDA::reconstruct()
 {
-    // For each camera, hack
+    // For each camera, supports only two cameras now.
     GPUBuckets buckets[2] =
     {
         GPUBuckets( projector_->getNumPixels(),110),

src/lib/ReconstructorCUDA/ReconstructorCUDA.cuh

@@ -32,11 +32,7 @@ struct GPUBucketsObj
         {
             return;
         }
-        //uint count = atomicAdd( &(count_[bktIdx]), 1);
-        //data_[count+bktIdx*MAX_CNT_PER_BKT_] = val;
         data_[atomicInc( &(count_[bktIdx]), MAX_CNT_PER_BKT_)+bktIdx*MAX_CNT_PER_BKT_] = val;
-        //if (bktIdx * MAX_CNT_PER_BKT_ > (1<<20)-1)
-        //    printf("Too big!\n");
     }
 };
 
@@ -70,30 +66,6 @@ public:
     }
     uint getNumBKTs() const{ return NUM_BKTS_;}
 
-    // Debug function
-    uint getMaxCount(uint idx) const
-    {
-        std::vector<uint> count_h;
-        count_h.resize(NUM_BKTS_);
-        gpuErrchk( cudaMemcpy( &(count_h[0]), count_, sizeof(uint)*NUM_BKTS_, cudaMemcpyDeviceToHost));
-        uint max = 0;
-        FILE *pFp = std::fopen((std::string("testBucket")+std::to_string((int)idx)+std::string(".ppm")).c_str(), "wb");
-        size_t w = 1024;
-        size_t h = 768;
-        if (pFp){
-            std::fprintf(pFp, "P5\n%zu\n%zu\n%d\n", (size_t )w, (size_t )h, 255);
-            for (size_t i=0; i<count_h.size(); i++)
-            {
-                if (count_h[i] > max) max = count_h[i];
-                if (count_h[i] != 0)
-                    putc((unsigned char) 255, pFp);
-                else
-                    putc((unsigned char) 0, pFp);
-            }
-        }
-        return max;
-    }
-
 };
 
 

src/lib/core/FileReader.cpp

@@ -136,15 +136,13 @@ void FileReader::computeShadowsAndThresholds()
                 shadowMask_.setBit(j+i*resY_);
             else
                 shadowMask_.clearBit(j+i*resY_);
+
+// Experimental: Calculate thresholds based on the contrast of each pixel
 #ifdef AUTO_CONTRAST
             thresholds_[j+i*resY_]=diff/2;
 #endif
         }
     }
-    // Output mask
-    std::string pgmFName=name_+".pgm";
-    LOG::writeLog("Writing mask to %s\n", pgmFName.c_str());
-    shadowMask_.writeToPGM(pgmFName.c_str(), resX_, resY_, true);
 }
 
 Ray FileReader::getRay(const size_t &x, const size_t &y)

src/lib/core/PointCloud.cpp

@@ -32,7 +32,7 @@ namespace SLS
                 memcpy (p.data(), &pointCloud[i], sizeof(float) * 6);
                 float sum = 0.0;
                 for (const auto &elem : p)
-                    sum += abs(elem);
+                    sum += std::abs(elem);
                 if (std::abs(sum - 0.0) < 0.0000001)
                     continue;
                 dataSS<<pointCloud[i+0]<<" "<<pointCloud[i+1]<<" "<<pointCloud[i+2]<<" "   

src/lib/core/PointCloud.hpp

@@ -14,8 +14,10 @@
 namespace SLS
 {
 
-//! A point cloud class
+//! Export pointcloud to obj file
 void exportPointCloud2OBJ(std::string fileName, const std::vector<float> &pointCloud);
+
+//! Export pointcloud to ply file with colors
 void exportPointCloud2PLY(std::string fileName, const std::vector<float> &pointCloud);
 
 /*! A point cloud class 
@@ -31,9 +33,13 @@ class PointCloud
      *  furthur processing on GPU.
      */
     std::vector<float> buffer_;
-    const size_t FLOATS_PER_POINT = 6;
+
+    //! Number of float elements per point. (x, y, z, r, g, b)
+    static const size_t FLOATS_PER_POINT = 6;
 public:
     PointCloud() {}
+
+    //! Initialize point cloud with number of points
     PointCloud(size_t numPoints)
     {
         buffer_.resize(numPoints * FLOATS_PER_POINT);

src/lib/core/Projector.h

@@ -30,20 +30,26 @@ class Projector
     size_t width_, height_;
 public:
     Projector() = delete;
+
     //! Initialize projector with height and width
     Projector(size_t width, size_t height):width_{width},height_{height}{}
+
     virtual ~Projector(){};
     /*! Return the size of project
      * \param w Output width
      * \param h Output height
      */
     void getSize(size_t &w, size_t &h){w = width_; h = height_;}
+
     //! Get width
     size_t getWidth() const {return width_;}
+
     //! Get height
     size_t getHeight() const {return height_;}
+
     //! Get number of pixels = getWidth() * getHeight()
     size_t getNumPixels() const {return width_ * height_;}
+
     /*! Get required number of frames to distinguish all of the projector pixel.
      *
      * The patterns are designed such that each projector pixel has a unique binary sequence. 

src/lib/core/ReconstructorCPU.cpp

@@ -39,25 +39,21 @@ void ReconstructorCPU::generateBuckets()
         xTimesY = x * y;
 
         // For each camera pixel
-        //assert(dynamic_cast<FileReader*>(cam)->getNumFrames() == projector_->getRequiredNumFrames()*2+2);
-
         for (size_t i = 0; i < xTimesY; i++) {
             if (!cam->queryMask(i)) // No need to process if in shadow
                 continue;
 
             cam->getNextFrame();
-            cam->getNextFrame();//skip first two frames
+            cam->getNextFrame(); //skip first two frames
 
             Dynamic_Bitset bits(projector_->getRequiredNumFrames());
 
             bool discard = false;
+
             // for each frame
             for (int bitIdx = projector_->getRequiredNumFrames() - 1; bitIdx >= 0; bitIdx--) {
-            //for (int bitIdx = 0; bitIdx <projector_->getRequiredNumFrames(); bitIdx++) {
 
-                //std::cout<<((FileReader*)cam)->getCurrentIdx()<<std::endl;
                 auto frame = cam->getNextFrame();
-                //std::cout<<((FileReader*)cam)->getCurrentIdx()<<std::endl;
                 auto invFrame = cam->getNextFrame();
                 unsigned char pixel = frame.at<uchar>(i % y, i / y);
                 unsigned char invPixel = invFrame.at<uchar>(i % y, i / y);
@@ -68,11 +64,6 @@ void ReconstructorCPU::generateBuckets()
                     // No need to do anything since the array is initialized as all zeros
                     bits.clearBit((size_t) bitIdx);
                     continue;
-                    //std::cout<<"-----\n"<<bits<<std::endl;
-                    //bits.clearBit(bitIdx);
-                    //std::cout<<std::setw(bits.size()-bitIdx)<<"c"<<std::endl;
-                    //std::cout<<bits<<std::endl;
-                   
                 }
                 else if (pixel > invPixel && pixel - invPixel > 
                         ((FileReader*)cam)->getWhiteThreshold(i)) {
@@ -85,22 +76,23 @@ void ReconstructorCPU::generateBuckets()
                     continue;
                 }
             } // end for each frame
-            if (!discard) {
 
+            // if the pixel is valid, add to bucket.
+            if (!discard) 
+            {
                 auto vec2Idx = bits.to_uint_gray();
                 if ( projector_->getWidth() > vec2Idx.x &&
                         vec2Idx.y < projector_->getHeight()) {
                     buckets_[camIdx][vec2Idx.x * projector_->getHeight() + vec2Idx.y].push_back(i);
                 }
             }
         }
-
         // Keep track of maximum number of pixels in a grid
-        unsigned  maxCount = 0;
-        for (const auto &bucket: buckets_[camIdx]){
-            if (bucket.size() > maxCount)
-                maxCount = bucket.size();
-        }
+        //unsigned  maxCount = 0;
+        //for (const auto &bucket: buckets_[camIdx]){
+        //    if (bucket.size() > maxCount)
+        //        maxCount = bucket.size();
+        //}
     }
 
 }
@@ -112,10 +104,8 @@ PointCloud ReconstructorCPU::reconstruct()
     size_t x,y;
     cameras_[0]->getResolution(x,y);
     initBuckets();
-
     LOG::startTimer();
-
-    for ( size_t i=0; i<buckets_[0].size(); i++)     // 1024*768
+    for ( size_t i=0; i<buckets_[0].size(); i++)
     {
         const auto &cam0bucket = buckets_[0][i];
         const auto &cam1bucket = buckets_[1][i];
@@ -150,7 +140,6 @@ PointCloud ReconstructorCPU::reconstruct()
                 }
             midPointAvg = midPointAvg/ptCount;
             {
-                //pointCloud_.push_back(1);
                 auto color0 = cameras_[0]->getColor(minCam0Idx);
                 auto color1 = cameras_[1]->getColor(minCam1Idx);
                 res.pushPoint( glm::vec3(midPointAvg), (color0 + color1) / 2.0f);

src/lib/core/ReconstructorCPU.h

@@ -27,18 +27,49 @@ namespace SLS
 class ReconstructorCPU: public Reconstructor
 {
 private:
+    /*! Reconstruction buckets of cameras
+     *
+     * In the reconstruction, camera pixels are assigned to different projector pixels. 
+     * Generally, one projector pixels contains more than one camera pixel. For each camera, we assign 
+     * pixels to projector pixels, and call those projector pixels buckets.
+     * ```
+     * ProjPixels(Buckets)   Camera pixels
+     * +------------------+  +---+---+---+
+     * |       0          +->+   |   |   |
+     * +------------------+  +-------+---+
+     * |       1          +->+   |
+     * +------------------+  +----
+     * 
+     * +------------------+  +---+---+
+     * |       n          +->+   |   |
+     * +------------------+  +---+---+
+     *
+     * ```
+     * The camera pixels in the same bucket of two different cameras are considered correspondent pixels,
+     * depth then can be extracted from those pixels.
+     */
     std::vector<std::vector<std::vector<size_t>>> buckets_;//[camIdx][ProjPixelIdx][camPixelIdx]
     void initBuckets();
     void generateBuckets();
 public:
+
+    /*! Create a reconstructor with given projector size
+    */
     ReconstructorCPU(const size_t projX, const size_t projY): 
         Reconstructor()
     {
             projector_ = new Projector(projX, projY);
     }
     ~ReconstructorCPU() override;
+
     //Interfaces
+    //! Reconstruct point cloud.
     PointCloud reconstruct() override;
+
+    /*! Add a camera to reconstructor\
+     *
+     * Accepts two camera now.
+     */
     void addCamera(Camera *cam) override;
 };
 } // namespace SLS