[WIP] Trying to figure out the mess I have with the transforms

Author: Leguark

gempy/core/data/geo_model.py

@@ -171,7 +171,8 @@ 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
         if self.input_transform is not None:
-            surface_points_table.model_transform = self.input_transform
+            transform = self.input_transform + self.grid.dense_grid.transform
+            surface_points_table.model_transform = transform
         return surface_points_table
 
     @property
@@ -188,7 +189,8 @@ 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:
-            orientations_table.model_transform = self.input_transform
+            transform = self.input_transform + self.grid.dense_grid.transform
+            orientations_table.model_transform = transform
         return orientations_table
 
     @property

gempy/core/data/grid.py

@@ -68,6 +68,14 @@ def extent(self):
     @extent.setter
     def extent(self, value):
         self._extent = value
+        
+    @property
+    def corner_min(self):
+        return self.extent[::2]
+    
+    @property
+    def corner_max(self):
+        return self.extent[1::2]
 
     @property
     def bounding_box(self):

gempy/core/data/grid_modules/grid_types.py

@@ -41,7 +41,7 @@ def _create_regular_grid_3d(self):
 
         # Transform the values
         if self.transform is not None:
-            self.values = self.transform.apply_with_pivot(
+            self.values = self.transform.apply_inverse_with_pivot(
                 points=values,
                 pivot=np.array([self.extent[0], self.extent[2], self.extent[4]])
             )
@@ -126,18 +126,18 @@ def _calculate_rotated_box_val(v1, v2):
                 [0, 0, 0, 1]
         ])
 
-        transform = Transform.from_matrix(rotation_matrix)
+        inverted_rotation_matrix = np.linalg.inv(rotation_matrix)
+        transform = Transform.from_matrix(inverted_rotation_matrix)
 
         # Calculate the extents in the new coordinate system
         extent_x = np.linalg.norm(v1)
         extent_y = np.linalg.norm(v2)
 
         # We transform the origin point1 to the new coordinates
         # [[ 5.47925650e+06  5.70152895e+06 -2.39200000e+02]]
-        vector = np.array([[x1, y1, zmin]])
-        origin_transformed = transform.apply_with_pivot(vector, pivot=vector[0])[0]
+        origin_ = [x1, y1, zmin]
 
-        xmin, ymin, zmin = origin_transformed
+        xmin, ymin, zmin = origin_
         xmax, ymax, zmax = xmin + extent_x, ymin + extent_y, zmin + zmax - zmin
 
         extent = np.array([xmin, xmax, ymin, ymax, zmin, zmax], dtype='float64')

gempy/modules/data_manipulation/engine_factory.py

@@ -48,18 +48,19 @@ def interpolation_input_from_structural_frame(structural_frame: StructuralFrame,
 
 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
+    grid.regular_grid.input_transform = input_transform
     new_extents = np.array([transformed[:, 0].min(), transformed[:, 0].max(),
                             transformed[:, 1].min(), transformed[:, 1].max(),
                             transformed[:, 2].min(), transformed[:, 2].max()])
-    
+
     # Initialize all variables to None
     octree_grid: Optional[engine_grid.RegularGrid] = None
     regular_grid: Optional[engine_grid.RegularGrid] = None
     custom_values: Optional[engine_grid.GenericGrid] = None
     topography_values: Optional[engine_grid.GenericGrid] = None
     section_values: Optional[engine_grid.GenericGrid] = None
     centered_grid: Optional[engine_grid.CenteredGrid] = None
-    
+
     if grid.GridTypes.DENSE in grid.active_grids:
         regular_grid = engine_grid.RegularGrid(
             orthogonal_extent=new_extents,

test/test_core/test_transfoms.py

@@ -86,3 +86,35 @@ def test_transform_operations_rotate():
     plt.show()
 
     assert np.allclose(original_points, inv_transformed_points)
+
+
+def test_transformed_data():
+    if transfromed_data := True:  # TODO: Expose this to user
+        xyz2 = surface_points.model_transform.apply_with_pivot(
+            points=xyz,
+            # pivot=np.array([5_478_256.5, 5_698_528.946534388,0]),
+            pivot=np.array([5.47825650e+06, 5.69852895e+06, -1.48920000e+03])
+
+        )
+
+        xyz = np.vstack([xyz, xyz2])
+
+
+    agggg = np.concatenate([mapped_array, mapped_array])
+
+    if transfromed_data := True:
+        orientations_xyz2 = orientations.model_transform.apply_with_pivot(
+            points=orientations_xyz,
+            pivot=np.array([5.47825650e+06, 5.69852895e+06, -1.48920000e+03])
+        )
+        orientations_grads2 = orientations.model_transform.transform_gradient(orientations_grads)
+        arrows_factor /= orientations.model_transform.isometric_scale
+
+        orientations_xyz = np.vstack([orientations_xyz, orientations_xyz2])
+
+
+        input_transform = regular_grid.input_transform
+        transformed = input_transform.apply(regular_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()])