[WIP] Getting there

Author: Leguark

gempy_engine/API/dual_contouring/_dual_contouring.py

@@ -36,26 +36,27 @@ def compute_dual_contouring(dc_data_per_stack: DualContouringData, left_right_co
 
     # Check if we should use parallel processing
     use_parallel = _should_use_parallel_processing(dc_data_per_stack.n_surfaces_to_export, BackendTensor.engine_backend)
+    parallel_results = None
 
     if use_parallel:
         print(f"Using parallel processing for {dc_data_per_stack.n_surfaces_to_export} surfaces")
         parallel_results = _parallel_process_surfaces(dc_data_per_stack, left_right_codes, debug)
 
-        if parallel_results is not None:
-            # Convert parallel results to DualContouringMesh objects
-            stack_meshes = []
-            for vertices_numpy, indices_numpy in parallel_results:
-                if TRIMESH_LAST_PASS := True:
-                    vertices_numpy, indices_numpy = _last_pass(vertices_numpy, indices_numpy)
-                
-                stack_meshes.append(
-                    DualContouringMesh(
-                        vertices_numpy,
-                        indices_numpy,
-                        dc_data_per_stack
-                    )
-                )
-            return stack_meshes
+        # if parallel_results is not None:
+        #     # Convert parallel results to DualContouringMesh objects
+        #     stack_meshes = []
+        #     for vertices_numpy, indices_numpy in parallel_results:
+        #         if TRIMESH_LAST_PASS := True:
+        #             vertices_numpy, indices_numpy = _last_pass(vertices_numpy, indices_numpy)
+        #         
+        #         stack_meshes.append(
+        #             DualContouringMesh(
+        #                 vertices_numpy,
+        #                 indices_numpy,
+        #                 dc_data_per_stack
+        #             )
+        #         )
+        #     return stack_meshes
 
     # Fall back to sequential processing
     print(f"Using sequential processing for {dc_data_per_stack.n_surfaces_to_export} surfaces")
@@ -64,7 +65,27 @@ def compute_dual_contouring(dc_data_per_stack: DualContouringData, left_right_co
     last_surface_edge_idx = 0
     for i in range(dc_data_per_stack.n_surfaces_to_export):
         # @off
-        indices_numpy, vertices_numpy = _sequential_triangulation(dc_data_per_stack, debug, i, last_surface_edge_idx, left_right_codes, valid_edges_per_surface)
+        if parallel_results is not None:
+            _, vertices_numpy = _sequential_triangulation(
+                dc_data_per_stack,
+                debug, 
+                i, 
+                last_surface_edge_idx, 
+                left_right_codes, 
+                valid_edges_per_surface,
+                compute_indices=False 
+            )
+            indices_numpy = parallel_results[i]
+        else:
+            vertices_numpy, indices_numpy = _sequential_triangulation(
+                dc_data_per_stack,
+                debug, 
+                i, 
+                last_surface_edge_idx, 
+                left_right_codes, 
+                valid_edges_per_surface,
+                compute_indices=True
+            )
 
         if TRIMESH_LAST_PASS := True:
             vertices_numpy, indices_numpy = _last_pass(vertices_numpy, indices_numpy)

gempy_engine/modules/dual_contouring/_parallel_triangulation.py

@@ -161,7 +161,6 @@ def _process_single_surface(i, dc_data_per_stack, valid_edges_per_surface, left_
             valid_voxels = dc_data_per_surface.valid_voxels
             left_right_per_surface = left_right_codes[valid_voxels]
             valid_voxels_per_surface = dc_data_per_surface.valid_edges[valid_voxels]
-            voxel_normal_per_surface = voxel_normal[valid_voxels]
             tree_depth_per_surface = dc_data_per_surface.tree_depth
 
             print(f"DEBUG: Calling triangulate function")

gempy_engine/modules/dual_contouring/_sequential_triangulation.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 import numpy as np
 import warnings
 
@@ -8,7 +10,13 @@
 from ...modules.dual_contouring.fancy_triangulation import triangulate
 
 
-def _sequential_triangulation(dc_data_per_stack: DualContouringData, debug: bool, i: int, last_surface_edge_idx: int, left_right_codes, valid_edges_per_surface: ndarray[tuple[int, int, int], dtype[Any] | Any]) -> tuple[Any, Any]:
+def _sequential_triangulation(dc_data_per_stack: DualContouringData,
+                              debug: bool
+                              , i: int, last_surface_edge_idx: int, 
+                              left_right_codes, 
+                              valid_edges_per_surface,
+                              compute_indices=True
+                              ) -> tuple[Any, Any]:
     valid_edges: np.ndarray = valid_edges_per_surface[i]
     next_surface_edge_idx: int = valid_edges.sum() + last_surface_edge_idx
     slice_object: slice = slice(last_surface_edge_idx, next_surface_edge_idx)
@@ -24,11 +32,10 @@ def _sequential_triangulation(dc_data_per_stack: DualContouringData, debug: bool
         tree_depth=dc_data_per_stack.tree_depth
 
     )
-    vertices: np.ndarray = generate_dual_contouring_vertices(
-        dc_data_per_stack=dc_data_per_surface,
-        slice_surface=slice_object,
-        debug=debug
-    )
+    vertices_numpy = _generate_vertices(dc_data_per_surface, debug, slice_object)
+    
+    if not compute_indices:
+        return None, vertices_numpy
 
     if left_right_codes is None:
         # * Legacy triangulation
@@ -82,6 +89,15 @@ def _sequential_triangulation(dc_data_per_stack: DualContouringData, debug: bool
         indices = BackendTensor.t.concatenate(indices, axis=0)
 
     # @on
-    vertices_numpy = BackendTensor.t.to_numpy(vertices)
     indices_numpy = BackendTensor.t.to_numpy(indices)
     return indices_numpy, vertices_numpy
+
+
+def _generate_vertices(dc_data_per_surface: DualContouringData, debug: bool, slice_object: slice) -> Any:
+    vertices: np.ndarray = generate_dual_contouring_vertices(
+        dc_data_per_stack=dc_data_per_surface,
+        slice_surface=slice_object,
+        debug=debug
+    )
+    vertices_numpy = BackendTensor.t.to_numpy(vertices)
+    return vertices_numpy