[WIP] Move transformation logic to GeoModel properties

Author: Leguark

gempy/core/data/geo_model.py

@@ -15,6 +15,7 @@
 from gempy_engine.core.data.transforms import Transform, GlobalAnisotropy
 
 from .orientations import OrientationsTable
+from .surface_points import SurfacePointsTable
 from .structural_frame import StructuralFrame
 from .grid import Grid
 from ...modules.data_manipulation.engine_factory import interpolation_input_from_structural_frame
@@ -153,10 +154,10 @@ def solutions(self, value):
             dc_mesh = self._solutions.dc_meshes[e]
             if dc_mesh is None:
                 continue
-                
+
             # TODO: These meshes are in the order of the scalar field 
             world_coord_vertices = self.input_transform.apply_inverse(dc_mesh.vertices)
-            
+
             element.vertices = world_coord_vertices
             element.edges = (dc_mesh.edges if dc_mesh is not None else None)
 
@@ -171,14 +172,14 @@ def surface_points_copy(self):
         """This is a copy! Returns a SurfacePointsTable for all surface points across the structural elements"""
         surface_points_table = self.structural_frame.surface_points_copy
         return surface_points_table
-    
+
     @property
-    def surface_points_copy_transformed(self):
+    def surface_points_copy_transformed(self) -> SurfacePointsTable:
         og_sp = self.surface_points_copy
         total_transform: Transform = self.input_transform + self.grid.transform
         og_sp.xyz_view = total_transform.apply(og_sp.xyz)
         return og_sp
-        
+
     @property
     def surface_points(self):
         raise AttributeError("This property can only be set, not read. You can access the copy with `surface_points_copy` or"
@@ -192,17 +193,15 @@ def surface_points(self, value):
     def orientations_copy(self) -> OrientationsTable:
         """This is a copy! Returns a OrientationsTable for all orientations across the structural elements"""
         orientations_table = self.structural_frame.orientations_copy
-        if self.input_transform is not None:
-            transform = self.input_transform + self.grid.transform
-            orientations_table.model_transform = transform
         return orientations_table
-    
+
     @property
-    def orientations_copy_transformed(self):
+    def orientations_copy_transformed(self) -> OrientationsTable:
         # ! This is not done
         og_or = self.orientations_copy
         total_transform: Transform = self.input_transform + self.grid.transform
         og_or.xyz_view = total_transform.apply(og_or.xyz)
+        og_or.grads_view = total_transform.transform_gradient(og_or.grads)
         return og_or
 
     @property
@@ -217,28 +216,29 @@ def orientations(self, value):
     @property
     def project_bounds(self) -> np.ndarray:
         return self.grid.bounding_box
-    
+
     @property
     def extent_transformed(self) -> np.ndarray:
         transformed = self.input_transform.apply(self.project_bounds)  # ! grid already has the grid transform applied
         new_extents = np.array([transformed[:, 0].min(), transformed[:, 0].max(),
                                 transformed[:, 1].min(), transformed[:, 1].max(),
                                 transformed[:, 2].min(), transformed[:, 2].max()])
         return new_extents
-    
+
     @property
     def extent(self) -> np.ndarray:
         return self.grid.extent
 
     @property
     def interpolation_input_copy(self):
+        warnings.warn("This property is deprecated. Use directly "
+                      "`interpolation_input_from_structural_frame` instead.", DeprecationWarning)
+        
         if self.structural_frame.is_dirty is False:
             return self._interpolationInput
 
         self._interpolationInput = interpolation_input_from_structural_frame(
-            structural_frame=self.structural_frame,
-            grid=self.grid,
-            input_transform=self.input_transform
+            geo_model=self
         )
 
         return self._interpolationInput

gempy/core/data/orientations.py

@@ -73,6 +73,14 @@ def xyz_view(self, value: np.ndarray):
     def grads(self) -> np.ndarray:
         return np.array([self.data['G_x'], self.data['G_y'], self.data['G_z']]).T
 
+    @property
+    def grads_view(self) -> np.ndarray:
+        return self.data[['G_x', 'G_y', 'G_z']]
+    
+    @grads_view.setter
+    def grads_view(self, value: np.ndarray):
+        self.data['G_x'], self.data['G_y'], self.data['G_z'] = value.T
+    
     @property
     def nugget(self) -> np.ndarray:
         return self.data['nugget']

gempy/modules/data_manipulation/engine_factory.py

@@ -11,30 +11,33 @@
 from gempy_engine.core.data.transforms import Transform
 
 
-def interpolation_input_from_structural_frame(structural_frame: StructuralFrame, grid: Grid,
-                                              input_transform: Transform) -> InterpolationInput:
+def interpolation_input_from_structural_frame(geo_model: "GeoModel") -> InterpolationInput:
     _legacy_factor = 0
-
-    if LEGACY_COORDS := False:
-        _legacy_factor = 0.5
+    
+    structural_frame: StructuralFrame = geo_model.structural_frame
+    input_transform: Transform = geo_model.input_transform
+    grid: Grid = geo_model.grid
 
     total_transform: Transform = input_transform + grid.transform
 
-    surface_points_copy = structural_frame.surface_points_copy
+    surface_points_copy_transformed = geo_model.surface_points_copy_transformed
     surface_points: SurfacePoints = SurfacePoints(
-        sp_coords=total_transform.apply(surface_points_copy.xyz) + _legacy_factor,
-        nugget_effect_scalar=surface_points_copy.nugget
+        sp_coords=geo_model.surface_points_copy_transformed.xyz,
+        nugget_effect_scalar=surface_points_copy_transformed.nugget
     )
 
-    orientations_copy = structural_frame.orientations_copy
+    orientations_copy_transformed = geo_model.orientations_copy_transformed
     orientations: Orientations = Orientations(
-        dip_positions=total_transform.apply(orientations_copy.xyz) + _legacy_factor,
-        dip_gradients=total_transform.transform_gradient(orientations_copy.grads),
-        nugget_effect_grad=orientations_copy.nugget
+        dip_positions=orientations_copy_transformed.xyz,
+        dip_gradients=orientations_copy_transformed.grads,
+        nugget_effect_grad=orientations_copy_transformed.nugget
     )
 
-    grid: engine_grid.EngineGrid = _apply_input_transform_to_grids(grid, input_transform)
-
+    grid: engine_grid.EngineGrid = _apply_input_transform_to_grids(
+        grid=grid,
+        input_transform=input_transform,
+        extent_transformed=geo_model.extent_transformed
+    )
 
     interpolation_input: InterpolationInput = InterpolationInput(
         surface_points=surface_points,
@@ -46,12 +49,8 @@ def interpolation_input_from_structural_frame(structural_frame: StructuralFrame,
     return interpolation_input
 
 
-def _apply_input_transform_to_grids(grid: Grid, input_transform: Transform) -> engine_grid.EngineGrid:
-    transformed = input_transform.apply(grid.bounding_box)  # ! grid already has the grid transform applied
-    new_extents = np.array([transformed[:, 0].min(), transformed[:, 0].max(),
-                            transformed[:, 1].min(), transformed[:, 1].max(),
-                            transformed[:, 2].min(), transformed[:, 2].max()])
-
+def _apply_input_transform_to_grids(grid: Grid, input_transform: Transform, extent_transformed: np.ndarray) -> engine_grid.EngineGrid:
+    new_extents = extent_transformed
     # Initialize all variables to None
     octree_grid: Optional[engine_grid.RegularGrid] = None
     regular_grid: Optional[engine_grid.RegularGrid] = None