[ENH] Integrate DUAL_CONTOURING_VERTEX_OVERLAP config flag and refactor vertex generation functions

Author: Leguark

gempy_engine/API/dual_contouring/multi_scalar_dual_contouring.py

@@ -4,9 +4,12 @@
 import numpy as np
 
 from gempy_engine.modules.dual_contouring._dual_contouring import compute_dual_contouring
+
+from ...modules.dual_contouring._dual_contouring_v2 import compute_dual_contouring_v2
 from ._experimental_water_tight_DC_1 import _experimental_water_tight
 from ._mask_buffer import MaskBuffer
 from ..interp_single.interp_features import interpolate_all_fields_no_octree
+from ...config import DUAL_CONTOURING_VERTEX_OVERLAP
 from ...core.backend_tensor import BackendTensor
 from ...core.data import InterpolationOptions
 from ...core.data.dual_contouring_data import DualContouringData
@@ -134,18 +137,15 @@ def dual_contouring_multi_scalar(
                 dc_data_per_surface_all.append(dc_data_per_surface)
                 left_right_per_mesh.append(all_left_right_codes[0][dc_data_per_surface.valid_voxels])
 
-        from gempy_engine.modules.dual_contouring._dual_contouring_v2 import compute_dual_contouring_v2
         all_meshes = compute_dual_contouring_v2(
             dc_data_list=dc_data_per_surface_all,
         )
     # endregion
-        if (options.debug or len(all_left_right_codes) > 1) and True:
+        if (len(all_left_right_codes) > 1) and DUAL_CONTOURING_VERTEX_OVERLAP:
             apply_faults_vertex_overlap(all_meshes, data_descriptor.stack_structure, left_right_per_mesh)
 
     return all_meshes
 
-    # ... existing code ...
-
 
 def _compute_meshes_legacy(all_left_right_codes: list[Any], all_mask_arrays: np.ndarray,
                            all_meshes: list[DualContouringMesh], all_stack_intersection: list[Any],

gempy_engine/config.py

@@ -32,6 +32,7 @@ class AvailableBackends(Flag):
 LINE_PROFILER_ENABLED = os.getenv('LINE_PROFILER_ENABLED', 'False') == 'True'
 SET_RAW_ARRAYS_IN_SOLUTION = os.getenv('SET_RAW_ARRAYS_IN_SOLUTION', 'True') == 'True'
 NOT_MAKE_INPUT_DEEP_COPY = os.getenv('NOT_MAKE_INPUT_DEEP_COPY', 'False') == 'True'
+DUAL_CONTOURING_VERTEX_OVERLAP = os.getenv('NOT_MAKE_INPUT_DEEP_COPY', 'False') == 'True'
 
 is_numpy_installed = find_spec("numpy") is not None
 is_tensorflow_installed = find_spec("tensorflow") is not None

gempy_engine/modules/dual_contouring/_dual_contouring_v2.py

@@ -1,7 +1,7 @@
 import os
 from typing import List
 
-from ._gen_vertices import _generate_vertices
+from ._gen_vertices import generate_dual_contouring_vertices
 from ._parallel_triangulation import _should_use_parallel_processing, _init_worker
 from ._sequential_triangulation import _compute_triangulation
 from ... import optional_dependencies
@@ -130,8 +130,7 @@ def _process_surface_batch_v2(surface_indices, dc_data_dicts, left_right_codes):
 
     return results
 def _process_one_surface(dc_data: DualContouringData, left_right_codes) -> DualContouringMesh:
-    vertices = _generate_vertices(dc_data, False, None)
-
+    vertices = generate_dual_contouring_vertices(dc_data, slice_surface=None, debug=False)
     # * Average gradient for the edges
     valid_edges = dc_data.valid_edges
     edges_normals = BackendTensor.t.zeros((valid_edges.shape[0], 12, 3), dtype=BackendTensor.dtype_obj)

gempy_engine/modules/dual_contouring/_gen_vertices.py

@@ -14,7 +14,7 @@ def _compute_vertices(dc_data_per_stack: DualContouringData,
                       valid_edges_per_surface) -> tuple[DualContouringData, Any]:
     """Compute vertices for a specific surface."""
     valid_edges: np.ndarray = valid_edges_per_surface[surface_i]
-   
+
     slice_object = _surface_slicer(surface_i, valid_edges_per_surface)
 
     dc_data_per_surface = DualContouringData(
@@ -27,19 +27,10 @@ def _compute_vertices(dc_data_per_stack: DualContouringData,
         tree_depth=dc_data_per_stack.tree_depth
     )
 
-    vertices_numpy = _generate_vertices(dc_data_per_surface, debug, slice_object)
+    vertices_numpy = generate_dual_contouring_vertices(dc_data_per_surface, slice_object, debug)
     return dc_data_per_surface, 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
-    )
-    return vertices
-
-
 def generate_dual_contouring_vertices(dc_data_per_stack: DualContouringData, slice_surface: Optional[slice] = None, debug: bool = False):
     # @off
     n_edges = dc_data_per_stack.n_valid_edges
@@ -48,10 +39,10 @@ def generate_dual_contouring_vertices(dc_data_per_stack: DualContouringData, sli
     if slice_surface is not None:
         xyz_on_edge = dc_data_per_stack.xyz_on_edge[slice_surface]
         gradients = dc_data_per_stack.gradients[slice_surface]
-    else: 
+    else:
         xyz_on_edge = dc_data_per_stack.xyz_on_edge
-        gradients = dc_data_per_stack.gradients 
-    # @on
+        gradients = dc_data_per_stack.gradients
+        # @on
 
     # * Coordinates for all posible edges (12) and 3 dummy edges_normals in the center
     edges_xyz = BackendTensor.tfnp.zeros((n_edges, 15, 3), dtype=BackendTensor.dtype_obj)