removing unused variables

build.sh

@@ -10,6 +10,6 @@ cmake ../src -DCMAKE_INSTALL_PREFIX=~/open3d_install #-DPYTHON_EXECUTABLE=/usr/b
 make -j
 
 # this will copy the libs and headers to ~/open3d_install/lib & ~/open3d_install/include
-make install
+# make install
 
 echo

src/CMakeLists.txt

@@ -48,7 +48,7 @@ option(BUILD_EXPERIMENTAL        "Build the Open3D experimental programs"   ON)
 option(BUILD_EIGEN3              "Build eigen3 from source"                 OFF)
 option(BUILD_GLEW                "Build glew from source"                   OFF)
 option(BUILD_GLFW                "Build glfw from source"                   OFF)
-option(BUILD_JPEG                "Build jpeg from source"                   ON)
+option(BUILD_JPEG                "Build jpeg from source"                   OFF)
 option(BUILD_JSONCPP             "Build json from source"                   OFF)
 option(BUILD_PNG                 "Build png from source"                    OFF)
 option(BUILD_PYBIND11            "Build pybind11 from source"               ON)

src/Core/ColorMap/ColorMapOptimization.cpp

@@ -114,9 +114,8 @@ std::tuple<std::vector<std::vector<int>>, std::vector<std::vector<int>>>
         const PinholeCameraTrajectory& camera,
         const ColorMapOptmizationOption& option)
 {
-    int n_camera = camera.extrinsic_.size();
-    int n_vertex = mesh.vertices_.size();
-    const double MAX_DEPTH = 10000000.0;
+    auto n_camera = camera.extrinsic_.size();
+    auto n_vertex = mesh.vertices_.size();
     std::vector<std::vector<int>> visiblity_vertex_to_image;
     std::vector<std::vector<int>> visiblity_image_to_vertex;
     visiblity_vertex_to_image.resize(n_vertex);
@@ -125,8 +124,6 @@ std::tuple<std::vector<std::vector<int>>, std::vector<std::vector<int>>>
 #pragma omp parallel for schedule(static)
 #endif
     for (int c = 0; c < n_camera; c++) {
-        int h = images_rgbd[c].depth_.height_;
-        int w = images_rgbd[c].depth_.width_;
         int viscnt = 0;
         for (int vertex_id = 0; vertex_id < n_vertex; vertex_id++) {
             Eigen::Vector3d X = mesh.vertices_[vertex_id];
@@ -164,7 +161,7 @@ std::vector<ImageWarpingField> MakeWarpingFields(
         const ColorMapOptmizationOption& option)
 {
     std::vector<ImageWarpingField> fields;
-    for (size_t i = 0; i < images.size(); i++) {
+    for (auto i = 0; i < images.size(); i++) {
         int width = images[i]->width_;
         int height = images[i]->height_;
         fields.push_back(ImageWarpingField(width, height,
@@ -222,14 +219,15 @@ void SetProxyIntensityForVertex(const TriangleMesh& mesh,
         const std::vector<std::vector<int>>& visiblity_vertex_to_image,
         std::vector<double>& proxy_intensity)
 {
-    int n_vertex = mesh.vertices_.size();
+    auto n_vertex = mesh.vertices_.size();
     proxy_intensity.resize(n_vertex);
 
 #pragma omp parallel for schedule(static)
-    for (int i = 0; i < n_vertex; i++) {
+    for (auto i = 0; i < n_vertex; i++) {
         proxy_intensity[i] = 0.0;
         float sum = 0.0;
-        for (int iter = 0; iter < visiblity_vertex_to_image[i].size(); iter++) {
+        for (auto iter = 0; iter < visiblity_vertex_to_image[i].size();
+                iter++) {
             int j = visiblity_vertex_to_image[i][iter];
             float gray;
             bool valid = false;
@@ -253,14 +251,15 @@ void SetProxyIntensityForVertex(const TriangleMesh& mesh,
         const std::vector<std::vector<int>>& visiblity_vertex_to_image,
         std::vector<double>& proxy_intensity)
 {
-    int n_vertex = mesh.vertices_.size();
+    auto n_vertex = mesh.vertices_.size();
     proxy_intensity.resize(n_vertex);
 
 #pragma omp parallel for num_threads( 8 )
-    for (int i = 0; i < n_vertex; i++) {
+    for (auto i = 0; i < n_vertex; i++) {
         proxy_intensity[i] = 0.0;
         float sum = 0.0;
-        for (int iter = 0; iter < visiblity_vertex_to_image[i].size(); iter++) {
+        for (auto iter = 0; iter < visiblity_vertex_to_image[i].size();
+                iter++) {
             int j = visiblity_vertex_to_image[i][iter];
             float gray;
             bool valid = false;
@@ -290,8 +289,8 @@ void OptimizeImageCoorNonrigid(
         std::vector<double>& proxy_intensity,
         const ColorMapOptmizationOption& option)
 {
-    int n_vertex = mesh.vertices_.size();
-    int n_camera = camera.extrinsic_.size();
+    auto n_vertex = mesh.vertices_.size();
+    auto n_camera = camera.extrinsic_.size();
     Eigen::Matrix4d intr = Eigen::Matrix4d::Zero();
     intr.block<3,3>(0,0) = camera.intrinsic_.intrinsic_matrix_;
     intr(3, 3) = 1.0;
@@ -320,8 +319,8 @@ void OptimizeImageCoorNonrigid(
             pose = camera.extrinsic_[i];
             double anchor_step = warping_fields[i].anchor_step_;
             double anchor_w = warping_fields[i].anchor_w_;
-            double anchor_h = warping_fields[i].anchor_h_;
-            for (int iter = 0; iter < visiblity_image_to_vertex[i].size(); iter++) {
+            for (auto iter = 0; iter < visiblity_image_to_vertex[i].size();
+                    iter++) {
                 int j = visiblity_image_to_vertex[i][iter];
                 Eigen::Vector3d V = mesh.vertices_[j];
                 Eigen::Vector4d G = pose * Eigen::Vector4d(V(0), V(1), V(2), 1);
@@ -428,7 +427,6 @@ void OptimizeImageCoorNonrigid(
                 aff_mat.translation() =
                         Eigen::Vector3d(result(3), result(4), result(5));
                 pose = aff_mat.matrix() * pose;
-
                 for (int j = 0; j < nonrigidval; j++) {
                     warping_fields[i].flow_(j) += result(6 + j);
                 }
@@ -457,8 +455,7 @@ void OptimizeImageCoorRigid(
         const ColorMapOptmizationOption& option)
 {
     int total_num_ = 0;
-    int n_vertex = mesh.vertices_.size();
-    int n_camera = camera.extrinsic_.size();
+    auto n_camera = camera.extrinsic_.size();
     Eigen::Matrix4d intr = Eigen::Matrix4d::Zero();
     intr.block<3,3>(0,0) = camera.intrinsic_.intrinsic_matrix_;
     intr(3, 3) = 1.0;
@@ -482,7 +479,8 @@ void OptimizeImageCoorRigid(
             int this_num = 0;
             Eigen::Matrix4d pose;
             pose = camera.extrinsic_[i];
-            for (int iter = 0; iter < visiblity_image_to_vertex[i].size(); iter++) {
+            for (auto iter = 0; iter < visiblity_image_to_vertex[i].size();
+                    iter++) {
                 int j = visiblity_image_to_vertex[i][iter];
                 Eigen::Vector3d V = mesh.vertices_[j];
                 Eigen::Vector4d G = pose * Eigen::Vector4d(V(0), V(1), V(2), 1);
@@ -552,17 +550,17 @@ void SetGeometryColorAverage(TriangleMesh& mesh,
         const PinholeCameraTrajectory& camera,
         const std::vector<std::vector<int>>& visiblity_vertex_to_image)
 {
-    int n_vertex = mesh.vertices_.size();
+    auto n_vertex = mesh.vertices_.size();
     mesh.vertex_colors_.clear();
     mesh.vertex_colors_.resize(n_vertex);
 #pragma omp parallel for schedule(static)
     for (int i = 0; i < n_vertex; i++) {
         mesh.vertex_colors_[i] = Eigen::Vector3d::Zero();
         double sum = 0.0;
-        for (int iter = 0; iter < visiblity_vertex_to_image[i].size(); iter++) {
+        for (auto iter = 0; iter < visiblity_vertex_to_image[i].size();
+                iter++) {
             int j = visiblity_vertex_to_image[i][iter];
             unsigned char r_temp, g_temp, b_temp;
-            float u, v;
             bool valid = false;
             std::tie(valid, r_temp) = QueryImageIntensity<unsigned char>(
                     images_rgbd[j].color_, warping_fields[j],
@@ -592,14 +590,15 @@ void SetGeometryColorAverage(TriangleMesh& mesh,
         const PinholeCameraTrajectory& camera,
         const std::vector<std::vector<int>>& visiblity_vertex_to_image)
 {
-    int n_vertex = mesh.vertices_.size();
+    auto n_vertex = mesh.vertices_.size();
     mesh.vertex_colors_.clear();
     mesh.vertex_colors_.resize(n_vertex);
 #pragma omp parallel for schedule(static)
     for (int i = 0; i < n_vertex; i++) {
         mesh.vertex_colors_[i] = Eigen::Vector3d::Zero();
         double sum = 0.0;
-        for (int iter = 0; iter < visiblity_vertex_to_image[i].size(); iter++) {
+        for (auto iter = 0; iter < visiblity_vertex_to_image[i].size();
+                iter++) {
             int j = visiblity_vertex_to_image[i][iter];
             unsigned char r_temp, g_temp, b_temp;
             bool valid = false;
@@ -628,7 +627,7 @@ std::tuple<std::vector<std::shared_ptr<Image>>,
         std::vector<std::shared_ptr<Image>>> MakeGradientImages(
         const std::vector<RGBDImage>& images_rgbd)
 {
-    size_t n_images = images_rgbd.size();
+    auto n_images = images_rgbd.size();
     std::vector<std::shared_ptr<Image>> images_gray;
     std::vector<std::shared_ptr<Image>> images_dx;
     std::vector<std::shared_ptr<Image>> images_dy;
@@ -649,7 +648,7 @@ std::vector<Image> MakeDepthMasks(
         const std::vector<RGBDImage>& images_rgbd,
         const ColorMapOptmizationOption& option)
 {
-    size_t n_images = images_rgbd.size();
+    auto n_images = images_rgbd.size();
     std::vector<Image> images_mask;
     for (int i=0; i<n_images; i++) {
         PrintDebug("[MakeDepthMasks] Image %d/%d\n", i, n_images);

src/Python/Tutorial/Advanced/color_map_optimization.py

@@ -8,7 +8,7 @@
 sys.path.append("../Utility")
 from common import *
 
-path = "/Users/jaesikpa/Downloads/fountain_small/"
+path = "[path_to_fountain_dataset]"
 debug_mode = False
 
 if __name__ == "__main__":

src/Python/Tutorial/Misc/sampling.py

@@ -0,0 +1,57 @@
+# Open3D: www.open3d.org
+# The MIT License (MIT)
+# See license file or visit www.open3d.org for details
+
+from open3d import *
+import os, sys
+sys.path.append("../Utility")
+from common import *
+sys.path.append("../Advanced")
+from trajectory_io import *
+from shutil import copyfile
+
+if __name__ == "__main__":
+    set_verbosity_level(VerbosityLevel.Debug)
+
+    path = "[path_to_reconstruction_system_output]"
+    out_path = "[path_to_sampled_frames_are_located]"
+    make_folder(out_path)
+    make_folder(out_path + "depth/")
+    make_folder(out_path + "image/")
+    make_folder(out_path + "scene/")
+    sampling_rate = 30
+
+    depth_image_path = get_file_list(
+            os.path.join(path, "depth/"), extension = ".png")
+    color_image_path = get_file_list(
+            os.path.join(path, "image/"), extension = ".jpg")
+    pose_graph_global = read_pose_graph(path +
+            template_global_posegraph_optimized)
+    n_fragments = len(depth_image_path) // n_frames_per_fragment + 1
+    pose_graph_fragments = []
+    for i in range(n_fragments):
+        pose_graph_fragment = read_pose_graph(path +
+                template_fragment_posegraph_optimized % i)
+        pose_graph_fragments.append(pose_graph_fragment)
+
+    depth_image_path_new = []
+    color_image_path_new = []
+    traj = []
+    cnt = 0
+    for i in range(len(depth_image_path)):
+        if i % sampling_rate == 0:
+            metadata = [cnt, cnt, len(depth_image_path) // sampling_rate + 1]
+            print(metadata)
+            fragment_id = i // n_frames_per_fragment
+            local_frame_id = i - fragment_id * n_frames_per_fragment
+            traj.append(CameraPose(metadata, np.dot(
+                    pose_graph_global.nodes[fragment_id].pose,
+                    pose_graph_fragments[fragment_id].nodes[local_frame_id].pose)))
+            copyfile(depth_image_path[i], out_path + "depth/" + \
+                    os.path.basename(depth_image_path[i]))
+            copyfile(color_image_path[i], out_path + "image/" + \
+                    os.path.basename(color_image_path[i]))
+            cnt += 1
+    copyfile(path + "/scene/cropped.ply",
+            out_path + "/scene/integrated.ply")
+    write_trajectory(traj, out_path + "scene/key.log")