feat(json): Pass json string to poisson algorithm to use externally

Improve comunication callin this lib from external (C#, CLI...)

Author: mfdeveloper

surface_reconstruction/open3d_surface.py

@@ -5,69 +5,70 @@
 
 
 class Open3dSurface(SurfaceStrategy):
-
     parameters = {
-      'estimate_normals': [
-          {
-              'name': 'fast_normal_computation',
-              'description': 'Fast normal estimation',
-              'value': True
-          },
-          {
-              'name': 'normals',
-              'description': 'Points normals',
-              'value': (1, 3)
-          }
-      ],
-      'orient_normals_consistent_tangent_plane': [
-          {
-              'name': 'k',
-              'description': 'Nearest neighbors',
-              'value': 100
-          }
-      ],
-      'surface_reconstruction_screened_poisson': [
-          {
-              'name': 'depth',
-              'description': 'Maximum depth of the tree',
-              'value': 8
-          },
-          {
-              'name': 'width',
-              'description': 'Target width',
-              'value': 0
-          },
-          {
-              'name': 'scale',
-              'description': 'Ratio between the diameter of the cube',
-              'value': 1.1
-          },
-          {
-              'name': 'linear_fit',
-              'description': 'Use linear interpolation?',
-              'value': False
-          },
-          {
-              'name': 'n_threads',
-              'description': 'Number of threads used for reconstruction',
-              'value': -1
-          }
-      ]
+        'estimate_normals': [
+            {
+                'name': 'fast_normal_computation',
+                'description': 'Fast normal estimation',
+                'value': True
+            },
+            {
+                'name': 'normals',
+                'description': 'Points normals',
+                'value': (1, 3)
+            }
+        ],
+        'orient_normals_consistent_tangent_plane': [
+            {
+                'name': 'k',
+                'description': 'Nearest neighbors',
+                'value': 100
+            }
+        ],
+        'surface_reconstruction_screened_poisson': [
+            {
+                'name': 'depth',
+                'description': 'Maximum depth of the tree',
+                'value': 8
+            },
+            {
+                'name': 'width',
+                'description': 'Target width',
+                'value': 0
+            },
+            {
+                'name': 'scale',
+                'description': 'Ratio between the diameter of the cube',
+                'value': 1.1
+            },
+            {
+                'name': 'linear_fit',
+                'description': 'Use linear interpolation?',
+                'value': False
+            },
+            {
+                'name': 'n_threads',
+                'description': 'Number of threads used for reconstruction',
+                'value': -1
+            }
+        ]
     }
 
     def __init__(self, point_cloud_file="", output_file="", clean_up=True):
 
         self.point_cloud = PointCloud()
         self.mesh = TriangleMesh()
 
+        # raise ValueError(f"Contains the {point_cloud_file} attribute: {output_file}")
+
         super().__init__(point_cloud_file, output_file, clean_up)
 
     def load_file(self, file_path: str) -> PointCloud:
         print('Load point cloud file')
 
         self.point_cloud = o3d.io.read_point_cloud(
-          file_path,
-          print_progress=True
+            file_path,
+            print_progress=True
         )
 
         print(np.asarray(self.point_cloud.points))
@@ -124,12 +125,12 @@ def apply_filter(name: str, params_key_values: dict):
 
             # Save the generated Surface in a .ply file
             result = o3d.io.write_triangle_mesh(
-              output_file,
-              self.mesh,
-              compressed=True,
-              write_vertex_colors=True,
-              write_vertex_normals=True,
-              print_progress=True
+                output_file,
+                self.mesh,
+                compressed=True,
+                write_vertex_colors=True,
+                write_vertex_normals=True,
+                print_progress=True
             )
 
             if not result:

surface_reconstruction/surface_strategy.py

@@ -56,6 +56,19 @@ def poisson_mesh(self, save_file=True, **params: {}):
         """
         raise NotImplementedError
 
+    def poisson(self, json_filters: str = ""):
+        """
+        A surface reconstruction triangle method invoked by each library
+
+        :param json_filters:
+        :return:
+        """
+        if len(json_filters) == 0:
+            return self.poisson_mesh(save_file=True)
+
+        data = json.loads(json_filters)
+        return self.poisson_mesh(save_file=True, **{'filters': data})
+
     def default_parameters(self, return_json=True) -> Union[dict, str]:
         """
         Get all parameters required for all filters/methods to do a

tests/surface_reconstruction_test.py

@@ -1,11 +1,18 @@
 from __future__ import annotations
+
 from surface_reconstruction import SurfaceStrategy, PyMeshlabSurface, Open3dSurface, SurfaceReconstruction
 import unittest
 import json
+import os
 
 
 class SurfaceReconstructionTest(unittest.TestCase):
 
+    def setUp(self):
+        self.files_folder = os.path.join('../files', 'complex_terrain')
+        self.point_cloud_file = os.path.join(self.files_folder, 'list_vertex.ply')
+        self.output_file = os.path.join(self.files_folder, 'terrain.ply')
+
     def test_factory_strategies_libraries(self):
 
         surface = SurfaceReconstruction(method_type='pymeshlab')
@@ -57,5 +64,21 @@ def test_factory_strategy_parameters(self):
         self.assertIsInstance(open3d_parameters, str)
         self.assertGreater(len(open3d_parameters), 0)
 
+    def test_strategy_pass_json_parameters(self):
+
+        json_str = """
+        {"estimate_normals":{"fast_normal_computation":true,"normals":[1,3]},"orient_normals_consistent_tangent_plane":{"k":100},"surface_reconstruction_screened_poisson":{"depth":8,"width":0,"scale":1.1,"linear_fit":false,"n_threads":-1}}
+        """
+
+        surface: SurfaceStrategy = SurfaceReconstruction(
+            method_type='open3d',
+            point_cloud_file=self.point_cloud_file,
+            output_file=self.output_file
+        )
+
+        surface.poisson(json_filters=json_str)
+
+
+