Docs

Author: tsing

src/app/App.cpp

@@ -65,7 +65,7 @@ int main(int argc, char** argv)
     // Initialize a reconstruct
     SLS::ReconstructorCPU reconstruct;
 
-    // Run reconstructio and get the point cloud
+    // Run reconstruction and get the point cloud
     auto pointCloud = reconstruct.reconstruct(bucketsVec);
 
     // Get extension of output file

src/app/CalibrateCamera.cpp

@@ -11,7 +11,6 @@ int main(int argc, char** argv)
     ImageFileProcessor cam("calibCam");
 
     // Calibrator takes a camera as input and output camera configuration.
-    std::cout<<"Input param: "<<p.get<std::string>("images")<<std::endl;
-    Calibrator::Calibrate(&cam, "../../data/alexander/rightCam/calib", p.get<std::string>("output"));
+    Calibrator::Calibrate(&cam, p.get<std::string>("images"), p.get<std::string>("output"));
     return 0;
 }

src/lib/core/ImageProcessor.h

@@ -32,14 +32,12 @@ using Buckets = std::vector<Bucket>;
 
 /*! Base class of image processor
  *
- * The camera defined here is a specific image input device for reconstruction
- * which includes the full acquisition pipeline.
- *
+ * The image processor includes the full acquisition pipeline.
  * ```
- * +-------+  +-----------+ +--------+   +--------+
- * | Get   |  |Undistort  | |Compute |   |Cast    |
- * | Image +-->Image      +->Mask    +--->Ray     |
- * +-------+  +-----------+ +--------+   +--------+
+ * +-------+  +-----------+ +--------+   +--------+   +--------+
+ * | Get   |  |Undistort  | |Compute |   |Cast    |   |Genearte|
+ * | Image +-->Image      +->Mask    +--->Ray     +--->Buckets |
+ * +-------+  +-----------+ +--------+   +--------+   +--------+
  * ```
  *
  * * The image acquisition is implemented as a forward iterator (getNextFrame)
@@ -53,9 +51,26 @@ using Buckets = std::vector<Bucket>;
  * than a threshold, the pixel is considered invalid and would be `0` in the
  * mask.
  *
- * * The camera can also cast a ray into the 3D space based on the intrinsic
+ * * The camera casts a ray into the 3D space based on the intrinsic
  * parameters.
  *
+ * * A buckets of rays is generated to pass to reconstructor.
+ *
+ * The Buckets is the data structure to hash the ray into projector pixel indices.
+ *
+ * ```
+ * ProjPixels(Buckets)   Rays
+ * +------------------+  +---+---+---+
+ * |       0          +->+R0 |R1 |R2 |
+ * +------------------+  +-------+---+
+ * |       1          +->+R3 |
+ * +------------------+  +----
+ *
+ * +------------------+  +---+
+ * |       n          +->+Rm |
+ * +------------------+  +---+
+ *
+ * ```
  */
 class ImageProcessor {
 protected:
@@ -103,7 +118,7 @@ class ImageProcessor {
         y = resY_;
     }
 
-    const unsigned char &getThreashold(const size_t &idx)
+    const unsigned char &getThreshold(const size_t &idx)
     {
         return thresholds_[idx];
     }
@@ -134,18 +149,21 @@ class ImageProcessor {
 
     // Interfaces
     /**
-     *!  Get a ray in world space by given pixel
+    *!  Get a ray in world space by given pixel
+    * \param x x coordinate of pixel
+    * \param y y coordinate of pixel
+    *
+    * \return Ray shot from camera to this pixel
+    */
+    virtual Ray getRay(const size_t &x, const size_t &y) = 0;
+
+    /**
+     * ! Get a ray by pixel index.
      *
-     * \param x x coordinate of pixel
-     * \param y y coordinate of pixel
+     * \param idx pixel index
      *
-     * \return Ray shot from camera to this pixel
+     * \returns Ray shot from the pixel.
      */
-
-    // Reconstruction relies on find intersection of two rays at the same point
-    // from two cameras. The rays can be get from the following functions.
-    virtual Ray getRay(const size_t &x, const size_t &y) = 0;
-
     virtual Ray getRay(const size_t &idx) = 0;
 
     virtual void setResolution(const size_t &x, const size_t &y)

src/lib/core/ReconstructorCPU.cpp

@@ -50,13 +50,13 @@ std::array<glm::vec3, 2> ReconstructorCPU::intersectionOfBucketMinDist_(
 }
 
 PointCloud ReconstructorCPU::reconstruct(
-    const std::vector<Buckets>& multiBuckets)
+    const std::vector<Buckets>& bucketsArray)
 {
     PointCloud res;
     LOG::startTimer();
-    for (size_t i = 0; i < multiBuckets[0].size(); i++) {
+    for (size_t i = 0; i < bucketsArray[0].size(); i++) {
         std::array<glm::vec3, 2> point =
-            intersectionOfBucket_(multiBuckets[0][i], multiBuckets[1][i]);
+            intersectionOfBucket_(bucketsArray[0][i], bucketsArray[1][i]);
         if (glm::all(glm::equal(point[0], glm::vec3(0.0))) &&
             glm::all(glm::equal(point[1], glm::vec3(0.0))))
             continue;

src/lib/core/ReconstructorCPU.h

@@ -6,29 +6,7 @@
 namespace SLS {
 
 // CPU reconstructor
-/*! 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.
+/*! Reconstruct point cloud from buckets provided by image processor.
  */
 class ReconstructorCPU : public Reconstructor {
 private:
@@ -60,8 +38,13 @@ class ReconstructorCPU : public Reconstructor {
 
 public:
 
-    // Interfaces
-    //! Reconstruct point cloud.
-    PointCloud reconstruct(const std::vector<Buckets>& multiBuckets) override;
+    /**
+     * !Synopsis  
+     *
+     * \param bucketsArray buckets for reconstruction
+     *
+     * \returns Point cloud
+     */
+    PointCloud reconstruct(const std::vector<Buckets>& bucketsArray) override;
 };
 }  // namespace SLS