Add parmeters for frameviewer (+make its TSDF settings configurable)

Author: Algomorph

apps/train.py

@@ -22,7 +22,7 @@
 from settings.model import get_saved_model
 
 if __name__ == "__main__":
-    process_arguments()
+    args = process_arguments()
     torch.set_num_threads(Parameters.training.num_threads.value)
     torch.backends.cudnn.benchmark = False
 
@@ -48,11 +48,6 @@
     print("validation_labels_name          ", validation_labels_name)
     print()
 
-    # use_current_hyper = query.query_yes_no("\nThe above hyperparameters will be used. Do you wish to continue?", "yes")
-    # if not use_current_hyper:
-    #     print("Exiting. Please modify settings_general.py and run this script again.")
-    #     exit()
-
     #####################################################################################
     # Creating tf writer and folders 
     #####################################################################################
@@ -71,8 +66,8 @@
     val_writer = SummaryWriter(val_log_dir)
 
     # Copy the current options to the log directory.
-    options_file_in = os.path.abspath(os.path.join(os.path.dirname(__file__), "../settings/settings_general.py"))
-    options_file_out = os.path.join(log_dir, "settings.py")
+    options_file_in = args.settings_file
+    options_file_out = os.path.join(log_dir, "settings.yaml")
     copyfile(options_file_in, options_file_out)
 
     # Creation of alignment dir.

run_evaluate.sh

@@ -1,6 +1,6 @@
 
 # Specify the dataset split for which to run evaluation
-SPLIT="val"
+SPLIT="VALIDATION"
 
 export PYTHONPATH="$(pwd):$PYTHONPATH"
-python3 apps/evaluate.py --split=${SPLIT}
+python3 apps/evaluate.py --evaluate_split=${SPLIT}

run_frameviewer.py

@@ -1,29 +1,39 @@
 #!/usr/bin/python3
+from pathlib import Path
+
 import sys
-import argparse
-from apps.frameviewer.frameviewer import FrameViewerApp
-from settings import settings_general
+from apps.frameviewer.frameviewer import FrameViewerApp, CameraProjection
+from data.camera import load_intrinsic_matrix_entries_from_text_4x4_matrix
+from settings.frameviewer import FrameviewerParameters
+from ext_argparse import process_arguments
 import os.path
 
 PROGRAM_EXIT_SUCCESS = 0
 PROGRAM_EXIT_FAILURE = -1
 
 
 def main():
-    parser = argparse.ArgumentParser("App for visualizing RGB-D frame data.")
-    parser.add_argument("--input", "-i", type=str, help="Path to folder with frame data",
-                        default=os.path.join(settings_general.dataset_base_directory, "train/seq070"))
-    parser.add_argument("--output", "-o", type=str, help="Path to output folder",
-                        default=settings_general.default_output_directory)
-    args = parser.parse_args()
-    print("Reading data from ", args.input)
-
-    app = FrameViewerApp(args.input, args.output, 0)
+    default_configuration_path = os.path.join(Path(__file__).parent.resolve(), "configuration_files/frameviewer_parameters.yaml")
+    process_arguments(FrameviewerParameters, "An app to view a masked RGB-D sequence frame-by-frame and analyze target"
+                                             "hash blocks for the surface (in a spatially-hashed voxel volume)."
+                                             "Also allows to determine the optimal threshold for masking. ",
+                      default_settings_file=default_configuration_path,
+                      generate_default_settings_if_missing=True)
+    print("Reading data from ", FrameviewerParameters.input.value)
+
+    FrameViewerApp.VOXEL_BLOCK_SIZE_METERS = \
+        FrameviewerParameters.tsdf.voxel_size.value * FrameviewerParameters.tsdf.block_resolution.value
+    FrameViewerApp.VOXEL_BLOCK_SIZE_VOXELS = FrameviewerParameters.tsdf.block_resolution.value
+    FrameViewerApp.VOXEL_SIZE = FrameviewerParameters.tsdf.voxel_size.value
+
+    fx, fy, cx, cy = load_intrinsic_matrix_entries_from_text_4x4_matrix(os.path.join(FrameviewerParameters.input.value, "intrinsics.txt"))
+    FrameViewerApp.PROJECTION = CameraProjection(fx, fy, cx, cy)
+
+    app = FrameViewerApp(FrameviewerParameters.input.value, FrameviewerParameters.output.value, 0)
     app.launch()
 
     return PROGRAM_EXIT_SUCCESS
 
 
-# Warning: not currently supported and most-likely, broken!
 if __name__ == "__main__":
     sys.exit(main())

run_generate_and_evaluate.sh

@@ -1,12 +1,12 @@
 #!/bin/bash
-SPLIT="test"
+SPLIT="TEST"
 
 export PYTHONPATH="$(pwd):$PYTHONPATH"
 
 echo
 echo "GENERATE..."
-python3 apps/generate.py --split=${SPLIT}
+python3 apps/generate.py --generate_split=${SPLIT}  --deform_net.no-threshold_mask_predictions --deform_net.gn_max_matches_eval=100000
 
 echo
 echo "EVALUATE..."
-python3 apps/evaluate.py --split=${SPLIT}
+python3 apps/evaluate.py --evaluate_split=${SPLIT}

run_visualizer.py

@@ -3,18 +3,19 @@
 import os
 import argparse
 
-from settings import settings_general
+from settings import PathParameters, process_arguments
 from apps.visualizer.visualizerapp import VisualizerApp
 
 PROGRAM_EXIT_SUCCESS = 0
 PROGRAM_EXIT_FAILURE = -1
 
 
 def main():
+    process_arguments()
     parser = argparse.ArgumentParser("App for visualizing block allocation and generated mesh alignment.")
     run_output_folder = "21-08-09-18-22-01_BERLIN_advanced_pc"
     parser.add_argument("--output", "-o", type=str, help="Path to output folder",
-                        default=os.path.join(settings_general.output_directory, run_output_folder, "frame_output"))
+                        default=os.path.join(PathParameters.output_directory.value, run_output_folder, "frame_output"))
     parser.add_argument("--initial_frame", "-i", type=int, help="Index of the first frame to process",
                         default=-1)
     args = parser.parse_args()

settings/__init__.py

@@ -24,12 +24,18 @@ class Parameters(ParameterEnum):
     fusion: Type[FusionParameters] = FusionParameters
     training: Type[TrainingParameters] = TrainingParameters
     graph: Type[GraphParameters] = GraphParameters
+
     generate_split = Parameter(default=Split.VALIDATION, arg_type=Split,
-                               arg_help="Specify the dataset split for which to generate predictions")
+                               arg_help="Specify the dataset split for which to generate predictions.")
+    evaluate_split = Parameter(default=Split.VALIDATION, arg_type=Split,
+                               arg_help="Specify the dataset split for which to compute evaluation metrics. Assumes predictions have been generated.")
+
 
 
 def process_arguments(help_header="A Neural Non-Rigid Fusion Application"):
     import ext_argparse
     default_configuration_path = os.path.join(Path(__file__).parent.parent.resolve(), "configuration_files/nnrt_fusion_parameters.yaml")
-    ext_argparse.process_arguments(Parameters, help_header, default_settings_file=default_configuration_path,
-                                   generate_default_settings_if_missing=True)
+    return ext_argparse.process_arguments(Parameters, help_header, default_settings_file=default_configuration_path,
+                                          generate_default_settings_if_missing=True)
+
+

settings/frameviewer.py

@@ -0,0 +1,31 @@
+#  ================================================================
+#  Created by Gregory Kramida (https://github.com/Algomorph) on 9/24/21.
+#  Copyright (c) 2021 Gregory Kramida
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+
+#  http://www.apache.org/licenses/LICENSE-2.0
+
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#  ================================================================
+
+from ext_argparse import ParameterEnum, Parameter
+from typing import Type
+
+from settings.tsdf import TsdfParameters
+
+
+class FrameviewerParameters(ParameterEnum):
+    input = \
+        Parameter(default="datasets/DeepDeform/train/seq070", arg_type=str,
+                  arg_help="Path to folder with frame data.")
+    output = \
+        Parameter(default="output/train/seq070", arg_type=str,
+                  arg_help="Path to folder with output generated from the sequence (optional).")
+
+    tsdf: Type[TsdfParameters] = TsdfParameters

subprocedure_examples/opengl_rendering_test.py

@@ -12,12 +12,13 @@
 import data.presets as presets
 import tsdf_management.default_voxel_grid
 import data.camera
-from settings import settings_general
+from settings import process_arguments, PathParameters, DeformNetParameters
 
 PROGRAM_EXIT_SUCCESS = 0
 
 
 def main():
+    process_arguments()
     frame_dataset: StandaloneFrameDataset = presets.StandaloneFramePreset.BERLIN_0.value
 
     device = o3c.Device("cuda:0")
@@ -30,7 +31,7 @@ def main():
     intrinsics_open3d_cuda = o3d.core.Tensor(intrinsics_open3d_cpu.intrinsic_matrix, o3d.core.Dtype.Float32, device)
     extrinsics_open3d_cuda = o3d.core.Tensor.eye(4, o3d.core.Dtype.Float32, device)
 
-    volume.integrate(depth_image, color_image, intrinsics_open3d_cuda, extrinsics_open3d_cuda, settings_general.depth_scale, 3.0)
+    volume.integrate(depth_image, color_image, intrinsics_open3d_cuda, extrinsics_open3d_cuda, DeformNetParameters.depth_scale.value, 3.0)
     original_mesh: o3d.geometry.TriangleMesh = volume.extract_surface_mesh(-1, 0).to_legacy_triangle_mesh()
     renderer = PyTorch3DRenderer((depth_image.rows, depth_image.columns), device, intrinsics_open3d_cuda)
 
@@ -45,7 +46,7 @@ def offset_mesh_plus_x(mesh: o3d.geometry.TriangleMesh, offset: float) -> o3d.ge
         return _offset_mesh
 
     # prepare folders
-    root_output_directory = os.path.join(settings_general.output_directory, "berlin_x_offset_sequence")
+    root_output_directory = os.path.join(PathParameters.output_directory.value, "berlin_x_offset_sequence")
     depth_output_directory = os.path.join(root_output_directory, "depth")
     if not os.path.exists(depth_output_directory):
         os.makedirs(depth_output_directory)

tests/data_generation/animate_berlin_x_offset.py

@@ -12,12 +12,13 @@
 import data.presets as presets
 import tsdf_management.default_voxel_grid
 import data.camera
-from settings import settings_general
+from settings import process_arguments, PathParameters, DeformNetParameters
 
 PROGRAM_EXIT_SUCCESS = 0
 
 
 def main():
+    process_arguments()
     frame_dataset: StandaloneFrameDataset = presets.StandaloneFramePreset.BERLIN_0.value
 
     device = o3c.Device("cuda:0")
@@ -30,7 +31,7 @@ def main():
     intrinsics_open3d_cuda = o3d.core.Tensor(intrinsics_open3d_cpu.intrinsic_matrix, o3d.core.Dtype.Float32, device)
     extrinsics_open3d_cuda = o3d.core.Tensor.eye(4, o3d.core.Dtype.Float32, device)
 
-    volume.integrate(depth_image, color_image, intrinsics_open3d_cuda, extrinsics_open3d_cuda, settings_general.depth_scale, 3.0)
+    volume.integrate(depth_image, color_image, intrinsics_open3d_cuda, extrinsics_open3d_cuda, DeformNetParameters.depth_scale.value, 3.0)
     original_mesh: o3d.geometry.TriangleMesh = volume.extract_surface_mesh(-1, 0).to_legacy_triangle_mesh()
     renderer = PyTorch3DRenderer((depth_image.rows, depth_image.columns), device, intrinsics_open3d_cuda)
 
@@ -50,7 +51,7 @@ def scale_mesh_y(mesh: o3d.geometry.TriangleMesh, factor: float) -> o3d.geometry
         return _scaled_mesh
 
     # prepare folders
-    root_output_directory = os.path.join(settings_general.output_directory, "berlin_y_stretch_sequence")
+    root_output_directory = os.path.join(PathParameters.output_directory.value, "berlin_y_stretch_sequence")
     depth_output_directory = os.path.join(root_output_directory, "depth")
     if not os.path.exists(depth_output_directory):
         os.makedirs(depth_output_directory)