py3dinterpolations 0.2.4__tar.gz → 0.3.1__tar.gz

{py3dinterpolations-0.2.4 → py3dinterpolations-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py3dinterpolations
-Version: 0.2.4
+Version: 0.3.1
 Summary: quick 3D interpolation with python
 Home-page: https://github.com/giocaizzi/py3dinterpolations
 Author: giocaizzi

{py3dinterpolations-0.2.4 → py3dinterpolations-0.3.1}/py3dinterpolations/__init__.py

@@ -1,7 +1,7 @@
 """quick 3D interpolation with python"""
 
 # Version
-__version__ = "0.2.4"
+__version__ = "0.3.1"
 
 # Credits
 __author__ = "Giorgio Caizzi"
@@ -11,6 +11,6 @@ __maintainer__ = __author__
 __email__ = "giocaizzi@gmail.com"
 
 from .core.griddata import GridData
-from .modelling import interpolate
+from .modelling.interpolate import interpolate
 
 __all__ = ["__version__", "GridData", "interpolate"]

{py3dinterpolations-0.2.4 → py3dinterpolations-0.3.1}/py3dinterpolations/core/griddata.py

@@ -14,7 +14,7 @@ class GridData:
 
     This object keeps track of the transformations (preprocessing)
     applied to the data, by storing the relative parameters in the
-    `preprocessing_params` attribute.
+    `preprocessor_params` attribute.
 
     Args:
         data (pd.DataFrame): source data
@@ -23,13 +23,15 @@ class GridData:
         Y (str): column name of the Y, default: "Y"
         Z (str): column name of the Z, default: "Z"
         V (str): column name of the V, default: "V"
-        preprocessing_params (dict): preprocessing parameters
+        preprocessor_params (dict): preprocessing parameters used
+            by the Preprocessor object that has generated the initiated
+            GridData object, default: {}
 
     Attributes:
         data (pd.DataFrame): data in GridData.data standard
-        preprocessing_params (dict): preprocessing parameters,
-            if some Preprocessing is applied this attribute is a dict
-            containing the preprocessing parameters
+        preprocessor_params (dict): preprocessing parameters used
+            by the Preprocessor object that has generated the initiated
+            GridData object, default: {}
         columns (dict): column names mapping
 
     Properties:
@@ -38,7 +40,7 @@ class GridData:
     """
 
     data = pd.DataFrame()
-    preprocessing_params = {}
+    preprocessor_params = {}
     columns = {}
 
     def __init__(
@@ -49,14 +51,14 @@ class GridData:
         Y: str = "Y",
         Z: str = "Z",
         V: str = "V",
-        preprocessing_params: dict = {},
+        preprocessor_params: dict = {},
     ):
-        # set preprocessing params, if passed
-
-        if isinstance(preprocessing_params, dict):
-            self.preprocessing_params = preprocessing_params
+        # set params of used by the Preprocessor object
+        # this is done with a new object with preprocessed data
+        if isinstance(preprocessor_params, dict):
+            self.preprocessor_params = preprocessor_params
         else:
-            raise ValueError("preprocessing_params must be a dict")
+            raise ValueError("preprocessor_params must be a dict")
 
         # set column names dictionary
         self.columns = {

{py3dinterpolations-0.2.4 → py3dinterpolations-0.3.1}/py3dinterpolations/plotting/plotting.py

@@ -6,8 +6,8 @@ import matplotlib.pyplot as plt
 import plotly.graph_objs as go
 
 from ..core.griddata import GridData
-from ..modelling.modeler import Modeler3D
-from ..modelling.preprocessing import reverse_preprocessing
+from ..modelling.modeler import Modeler
+from ..modelling.preprocessor import reverse_preprocessing
 
 
 def plot_downsampling(
@@ -15,8 +15,8 @@ def plot_downsampling(
     downsampled_griddata: GridData,
 ) -> Figure:
     if (
-        "normalization" in downsampled_griddata.preprocessing_params
-        or "standardization" in downsampled_griddata.preprocessing_params
+        "normalization" in downsampled_griddata.preprocessor_params
+        or "standardization" in downsampled_griddata.preprocessor_params
     ):
         downsampled_griddata = reverse_preprocessing(downsampled_griddata)
     # get data
@@ -87,7 +87,7 @@ def plot_model_epsilon(model) -> None:
 
 
 def plot_3d_model(
-    modeler: Modeler3D, plot_points: bool = False, scale_points=1.0, **kwargs
+    modeler: Modeler, plot_points: bool = False, scale_points=1.0, **kwargs
 ) -> go.Figure:
     """plot 3d model"""
     data = [
@@ -103,7 +103,7 @@ def plot_3d_model(
 
     if plot_points:
         # get correct points, if preprocessing was applied
-        if modeler.griddata.preprocessing_params:
+        if modeler.griddata.preprocessor_params:
             gd_reversed = reverse_preprocessing(modeler.griddata)
             points = gd_reversed.data.copy().reset_index()
         else:

{py3dinterpolations-0.2.4 → py3dinterpolations-0.3.1}/py3dinterpolations.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py3dinterpolations
-Version: 0.2.4
+Version: 0.3.1
 Summary: quick 3D interpolation with python
 Home-page: https://github.com/giocaizzi/py3dinterpolations
 Author: giocaizzi

{py3dinterpolations-0.2.4 → py3dinterpolations-0.3.1}/py3dinterpolations.egg-info/SOURCES.txt

@@ -10,11 +10,5 @@ py3dinterpolations.egg-info/top_level.txt
 py3dinterpolations/core/__init__.py
 py3dinterpolations/core/grid3d.py
 py3dinterpolations/core/griddata.py
-py3dinterpolations/modelling/__init__.py
-py3dinterpolations/modelling/modeler.py
-py3dinterpolations/modelling/preprocessing.py
-py3dinterpolations/modelling/models/__init__.py
-py3dinterpolations/modelling/models/deterministic.py
-py3dinterpolations/modelling/models/idw.py
 py3dinterpolations/plotting/__init__.py
 py3dinterpolations/plotting/plotting.py

{py3dinterpolations-0.2.4 → py3dinterpolations-0.3.1}/py3dinterpolations.egg-info/requires.txt

@@ -1,8 +1,9 @@
 pandas
 numpy
 matplotlib
-pykrige
 plotly
+pykrige
+scikit-learn
 
 [dev]
 

{py3dinterpolations-0.2.4 → py3dinterpolations-0.3.1}/setup.py

@@ -8,7 +8,7 @@ long_description = (this_directory / "README.md").read_text()
 
 setup(
     name="py3dinterpolations",
-    version="0.2.4",
+    version="0.3.1",
     description="quick 3D interpolation with python",
     long_description_content_type="text/markdown",
     long_description=long_description,
@@ -23,8 +23,9 @@ setup(
         "pandas",
         "numpy",
         "matplotlib",
-        "pykrige",
         "plotly",
+        "pykrige",
+        "scikit-learn",
     ],
     extras_require={
         "docs": [],

py3dinterpolations-0.2.4/py3dinterpolations/modelling/__init__.py

@@ -1,69 +0,0 @@
-"""modelling classes and functions"""
-
-from typing import Union, Tuple
-import numpy as np
-
-from ..core.griddata import GridData
-from ..core.grid3d import Grid3D
-from ..core import create_regulargrid3d_from_griddata
-from ..modelling.modeler import Modeler3D
-from ..modelling.preprocessing import Preprocessing
-
-
-def interpolate(
-    griddata: GridData,
-    model_name: str,
-    model_params: dict,
-    grid_resolution: float,
-    preprocess_kwags: dict = {},
-    predict_kwags: dict = {},
-    return_model: bool = False,
-) -> Union[np.ndarray, Tuple[np.ndarray, Modeler3D, Grid3D, GridData]]:
-    """interpolate griddata
-
-    Interpolate griddata using a Modeler3D instance that wraps all supported
-    models.
-    model_name and model_params.
-
-    The 3D grid is retrived from the training data.
-
-    If requested, the griddata is preprocessed using the Preprocessing class.
-
-    Args:
-        griddata (GridData): griddata to interpolate
-        model_name (str): model name
-        model_params (dict): model parameters
-        grid_resolution (float): grid resolution
-        preprocess_kwags (dict, optional): preprocessing parameters. Defaults to None.
-        predict_kwags (dict, optional): prediction parameters. Defaults to None.
-        return_model (bool, optional): return model. Defaults to False.
-
-    Returns:
-        Union[np.ndarray, Tuple[np.ndarray, Modeler3D, Grid3D, GridData]]:
-            interpolated griddata or all components
-
-    """
-    # retrive associated grid
-    grid3d = create_regulargrid3d_from_griddata(griddata, grid_resolution)
-
-    # preprocess griddata if needed
-    if preprocess_kwags is not None:
-        # preprocess
-        griddata = Preprocessing(griddata, **preprocess_kwags).preprocess()
-
-    # init Modeler3D
-    model = Modeler3D(
-        griddata=griddata,
-        grid3d=grid3d,
-        model_name=model_name,
-        model_params=model_params,
-    )
-
-    # make predictions
-    predictions = model.predict(**predict_kwags)
-
-    # return model
-    if return_model:
-        return predictions, model
-    else:
-        return predictions

py3dinterpolations-0.2.4/py3dinterpolations/modelling/modeler.py

@@ -1,131 +0,0 @@
-"""model wrapper for interpolation"""
-
-import numpy as np
-from typing import Union
-
-from ..core.griddata import GridData
-from ..core.grid3d import Grid3D
-from .models import ModelsWrapper
-
-
-class Modeler3D:
-    """modeler for wrapping 3d models from different libraries
-
-    Currently supports:
-        Statistical:
-            - Ordinary Kriging : `ordinary_kriging` (pykrige)
-        Deterministic:
-            - Inverse Distance Weighting : `idw`
-
-
-    This class is designed to allow future of sklearn models.
-
-    Defines a fit and a predict method, to be called
-    when interpolating.
-
-    Ensures correct input and output.
-
-    Args:
-        griddata (GridData): GridData istance
-        grid3d (Grid3D): Grid3D istance
-        model_name (str): model name, default `ordinary_kriging`
-        model_params (dict): model parameters
-
-    Attributes:
-        griddata (GridData): GridData istance
-        grid3d (Grid3D): Grid3D istance
-        model (object): model object
-        results (dict): dictionary with interpolated and variance grids
-    """
-
-    model: ModelsWrapper
-    results: Union[dict, np.ndarray]
-
-    def __init__(
-        self,
-        griddata: GridData,
-        grid3d: Grid3D,
-        model_name: str = "ordinary_kriging",
-        model_params: dict = {},
-    ):
-        # griddata and grid3d
-        self.griddata = griddata
-        self.grid3d = grid3d
-
-        # model
-        self.model = ModelsWrapper(
-            model_name,
-            self.griddata.numpy_data[:, 0],  # x
-            self.griddata.numpy_data[:, 1],  # y
-            self.griddata.numpy_data[:, 2],  # z
-            self.griddata.numpy_data[:, 3],  # value
-            **model_params,
-        )
-
-    def predict(self, **kwargs) -> np.ndarray:
-        """makes predictions considering all past preprocessing
-
-        - if preprocessing was applied, predict on normalized grid
-        - if standardized data, reverse standardization
-        - reshape from zxy to xyz (pykrige output)
-
-        Args:
-            grids_arrays (dict): dictionary with x, y, z grids 1d np.ndarray
-
-        Returns:
-            interpolated (np.ndarray): interpolated grid
-        """
-        # make predictions on normalized grid if preprocessing was applied
-        if self.griddata.preprocessing_params == {}:
-            grids_arrays = self.grid3d.grid
-        else:
-            grids_arrays = self.grid3d.normalized_grid
-
-        # predict
-        #
-        interpolated, variance = self.model.predict(
-            grids_arrays["X"],
-            grids_arrays["Y"],
-            grids_arrays["Z"],
-            **kwargs,
-        )
-
-        # if standardized data, reverse standardization
-        if "standardization" in self.griddata.preprocessing_params:
-            interpolated = _reverse_standardized(
-                interpolated, self.griddata.preprocessing_params["standardization"]
-            )
-            variance = _reverse_standardized(
-                variance, self.griddata.preprocessing_params["standardization"]
-            )
-
-        # reshape fron zxy to xyz
-        if self.model._model_name == "ordinary_kriging":
-            # reshape pykrige output
-            interpolated = _reshape_pykrige(interpolated)
-            variance = _reshape_pykrige(variance)
-
-        # save results
-        self.results = {
-            "interpolated": interpolated,
-            "variance": variance,
-        }
-
-        # sets results  also in associated grid3d
-        self.grid3d.results = self.results
-
-        # return interpolated grid
-        return interpolated
-
-
-def _reverse_standardized(data: np.ndarray, standardization: dict) -> np.ndarray:
-    """reverse standardization of a 1d numpy array
-
-    considers that data could be none, in which case returns an empty array
-    """
-    return data * standardization["std"] + standardization["mean"]
-
-
-def _reshape_pykrige(ndarray: np.ndarray) -> np.ndarray:
-    """reshape pykrige output to match the grid3d shape"""
-    return np.einsum("ZXY->XYZ", ndarray)

py3dinterpolations-0.2.4/py3dinterpolations/modelling/models/__init__.py

@@ -1,104 +0,0 @@
-"""models for 3D interpolation"""
-
-import numpy as np
-
-# EXTERNAL
-from pykrige.ok3d import OrdinaryKriging3D
-
-# INTERNAL
-from .idw import IDW
-
-
-SUPPORTED_MODELS = {
-    "statistical": {
-        "ordinary_kriging": OrdinaryKriging3D,  # pykrige
-    },
-    "deterministic": {
-        "idw": IDW,
-    },
-}
-
-
-def get_model_type(inner_key: str):
-    """get model type
-
-    Raises:
-        ValueError: if model not supported
-    """
-    for outer_key in SUPPORTED_MODELS:
-        if inner_key in SUPPORTED_MODELS[outer_key]:
-            return outer_key
-    # if gets here, model not supported
-    raise ValueError(f"model {inner_key} not supported")
-
-
-class ModelsWrapper:
-    """model wrappper
-
-    This class is designed to allow wrapping of different models
-    from different libraries, both external and internal to py3Dinterpolations.
-
-    Defines a fit and a predict method, to be called
-    when interpolating.
-
-    Args:
-        model_name (str): model name
-        \\*args: args for model
-        \\*\\*kwargs: kwargs for model
-
-    Attributes:
-        model (object): model object
-        model_type (str): model type
-        model_name (str): model name
-
-    """
-
-    @property
-    def model_type(self):
-        return self._model_type
-
-    @property
-    def model_name(self):
-        return self._model_name
-
-    @model_type.setter
-    def model_type(self, model_type: str):
-        self._model_type = model_type
-
-    @model_name.setter
-    def model_name(self, model_name: str):
-        self._model_name = model_name
-        self._model_type = get_model_type(self._model_name)
-
-    def __init__(self, model_name: str, *args, **kwargs):
-        self.model_name = model_name
-        self.model = SUPPORTED_MODELS[self.model_type][self.model_name](*args, **kwargs)
-
-    def fit(self):
-        # pykrige is already fitted
-        # deterministic models are not
-        pass
-
-    def predict(self, *args, **kwargs) -> tuple:
-        """predict method
-
-        Execute predictions for the model.
-
-        Args:
-            \\*args: args for model
-            \\*\\*kwargs: kwargs for model
-        """
-        if self.model_type == "statistical":
-            # returns both interpolated and variance grids
-
-            # quickfix for weird behacviour
-            # unpack first three args as x, y, z
-            x, y, z, *args = args
-            return self.model.execute(
-                *args, style="grid", xpoints=x, ypoints=y, zpoints=z, **kwargs
-            )
-        elif self.model_type == "deterministic":
-            # idw does not return variance
-            return self.model.compute(*args, **kwargs), np.ndarray([])
-        else:
-            raise ValueError(f"model {self.model_type} not supported")

py3dinterpolations-0.2.4/py3dinterpolations/modelling/models/deterministic.py

@@ -1,44 +0,0 @@
-"""base classes for all models"""
-
-import numpy as np
-
-
-class DeterministicModel:
-    """base class for all deterministic models
-
-    This class requires as initialization parameters:
-        - x, y, z: the coordinates of the points where the model will be evaluated
-        - values: the values of the points where the model will be evaluated
-
-    Args:
-        x (np.ndarray): x coordinates of the points where the model will be evaluated
-        y (np.ndarray): y coordinates of the points where the model will be evaluated
-        z (np.ndarray): z coordinates of the points where the model will be evaluated
-        values (np.ndarray): values of the points where the model will be evaluated
-
-    Attributes:
-        x (np.ndarray): x coordinates of the points where the model will be evaluated
-        y (np.ndarray): y coordinates of the points where the model will be evaluated
-        z (np.ndarray): z coordinates of the points where the model will be evaluated
-        values (np.ndarray): values of the points where the model will be evaluated
-    """
-
-    def __init__(
-        self,
-        x: np.ndarray,
-        y: np.ndarray,
-        z: np.ndarray,
-        values: np.ndarray,
-    ):
-        # deterministic model saves coordinates and values as attributes
-        self.x = x
-        self.y = y
-        self.z = z
-        self.values = values
-
-    def compute(self):
-        """compute the model
-
-        This method should be implemented in the child classes
-        """
-        pass

py3dinterpolations-0.2.4/py3dinterpolations/modelling/models/idw.py

@@ -1,111 +0,0 @@
-"""Inverse Distance Weighting (IDW) model"""
-
-import numpy as np
-import math
-
-from .deterministic import DeterministicModel
-
-
-class IDW(DeterministicModel):
-    """Simple IDW Model object
-
-    IDW: Inverse Distance Weigthting
-
-    Offers tweaking of the power parameter of the IDW model.
-
-    Could be really slow for large datasets, due to the use of loops.
-
-    TODO: Remove loopings use a vectorized approach
-
-    Args:
-        x (np.ndarray): x coordinates of the points where the model will be evaluated
-        y (np.ndarray): y coordinates of the points where the model will be evaluated
-        z (np.ndarray): z coordinates of the points where the model will be evaluated
-        values (np.ndarray): values of the points where the model will be evaluated
-        power (float): power of the IDW model
-
-    Attributes:
-        power (float): power of the IDW model
-        distance_matrix (np.ndarray): distance matrix between
-            observations and data points
-    """
-
-    def __init__(
-        self,
-        x: np.ndarray,
-        y: np.ndarray,
-        z: np.ndarray,
-        values: np.ndarray,
-        power: float = 1,
-    ):
-        # initialize parent class
-        super().__init__(x=x, y=y, z=z, values=values)
-
-        # set power
-        self.power = power
-
-    def _compute_point(
-        self,
-        x: float,
-        y: float,
-        z: float,
-        power: float,
-        threshold: float = 0.0000000001,
-    ) -> float:
-        """find value at a point
-
-        Loops through all the data points to estimate the value at a point
-        based on the Inverse Distance Weighting (IDW) method.
-        Might be really slow for large datasets.
-
-        This implementation however offers easy advanced parametrization with:
-        - n_points: number of points to use for the IDW estimation (TODO)
-        - max_distance: maximum distance to use for the IDW estimation (TODO)
-        """
-        nominator = 0
-        denominator = 0
-
-        # distance in 3d
-        for i in range(0, len(self.values)):
-            dist = math.sqrt(
-                (x - self.x[i]) * (x - self.x[i])
-                + (y - self.y[i]) * (y - self.y[i])
-                + (z - self.z[i]) * (z - self.z[i])
-            )
-
-            # If the point is really close to one of the data points,
-            # return the data point value to avoid singularities
-            # EXACT interpolations
-            if dist < threshold:
-                return self.values[i]
-
-            nominator = nominator + (self.values[i] / pow(dist, power))
-            denominator = denominator + (1 / pow(dist, power))
-
-        # Return NaN if the denominator is zero
-        if denominator > 0:
-            value = nominator / denominator
-        else:
-            value = np.nan
-        return value
-
-    def compute(
-        self, gridx: np.ndarray, gridy: np.ndarray, gridz: np.ndarray
-    ) -> np.ndarray:
-        meshx, meshy, meshz = np.meshgrid(gridx, gridy, gridz, indexing="xy")
-
-        # Create a new mesh to store the coordinates
-        new_mesh = np.zeros_like(meshx)
-
-        # Iterate over the indices of the arrays
-        for i in range(meshx.shape[0]):
-            for j in range(meshx.shape[1]):
-                for k in range(meshx.shape[2]):
-                    # Store the coordinates in the new mesh
-                    new_mesh[i, j, k] = self._compute_point(
-                        x=meshx[i, j, k],
-                        y=meshy[i, j, k],
-                        z=meshz[i, j, k],
-                        power=self.power,
-                    )
-        return new_mesh

py3dinterpolations-0.2.4/py3dinterpolations/modelling/preprocessing.py

@@ -1,159 +0,0 @@
-"""preprocessing objects"""
-
-import pandas as pd
-
-from ..core import GridData
-from typing import Union
-
-
-class Preprocessing:
-    """preprocessing class"""
-
-    preprocessing_params = {}
-
-    def __init__(
-        self,
-        griddata: GridData,
-        downsampling_res: Union[float, None] = None,
-        normalize_xyz: bool = True,
-        standardize_v: bool = True,
-    ):
-        self.griddata = griddata
-        self.downsampling_res = downsampling_res
-        self.normalize_xyz = normalize_xyz
-        self.standardize_v = standardize_v
-
-    def preprocess(self) -> GridData:
-        # get data
-        data = self.griddata.data.copy().reset_index()[["ID", "X", "Y", "Z", "V"]]
-
-        # first dowmsample
-        if self.downsampling_res is not None:
-            data = self._downsample_data(data)
-
-        # normalize
-        if self.normalize_xyz:
-            data = self._normalize_xyz(data)
-
-        # standardize
-        if self.standardize_v:
-            data = self._standardize_v(data)
-
-        # return new object with preprocessed data and parameters
-        return GridData(data, preprocessing_params=self.preprocessing_params)
-
-    def _normalize_xyz(self, data: pd.DataFrame) -> pd.DataFrame:
-        df = data.copy()
-        self.preprocessing_params["normalization"] = {}
-        for axis in ["X", "Y", "Z"]:
-            df[axis], axis_params = _normalize(df[axis])
-            self.preprocessing_params["normalization"][axis] = axis_params
-        return df
-
-    def _standardize_v(self, data: pd.DataFrame) -> pd.DataFrame:
-        df = data.copy()
-        df["V"], params = _standardize(df["V"])
-        self.preprocessing_params["standardization"] = params
-        return df
-
-    def _downsample_data(self, data: pd.DataFrame) -> pd.DataFrame:
-        """downsample data making the average by blocks of given resolution"""
-        self.preprocessing_params["downsampling"] = {
-            "resolution": self.downsampling_res
-        }
-        idfs = []
-        # loop over unique ids
-        for id in self.griddata.data.index.get_level_values("ID").unique():
-            # filter by id
-            idf = self.griddata.data.loc[
-                self.griddata.data.index.get_level_values("ID") == id
-            ].reset_index()
-            # save x,y values
-            x = idf["X"][0]
-            y = idf["Y"][0]
-            # extract z
-            idf = idf[["Z", "V"]]
-            # downsample by grouping in blocks of given resolution
-            # and taking the mean
-            idf = idf.groupby(
-                idf["Z"].apply(
-                    lambda x: self.preprocessing_params["downsampling"]["resolution"]
-                    * round(x / self.preprocessing_params["downsampling"]["resolution"])
-                )
-            )[["V"]].mean()
-            # new downsampled df
-            idf["X"] = x
-            idf["Y"] = y
-            idf["ID"] = id
-            idf.reset_index(inplace=True)  # reset index resulting from groupby
-            idfs.append(idf)
-        # return downsampled grid data
-
-        return pd.concat(idfs)
-
-
-def _standardize(series: pd.Series) -> tuple:
-    series = series.copy()
-    # save standardization parameters
-    params = {
-        "mean": series.mean(),
-        "std": series.std(),
-    }
-    # standardize
-    series = (series - params["mean"]) / (params["std"])
-    return series, params
-
-
-def _normalize(series: pd.Series) -> tuple:
-    series = series.copy()
-    # save normalization parameters
-    params = {
-        "min": series.min(),
-        "max": series.max(),
-    }
-    # normalize
-    series = (series - params["min"]) / (params["max"] - params["min"])
-    return series, params
-
-
-def reverse_preprocessing(griddata: GridData) -> GridData:
-    """reverse preprocessing of whole GridData object
-
-    reverse all reversible transformations that have been
-    applied to the GridData object.
-
-    This method reverses the operations of preprocessing of:
-        - Normalization of X Y Z
-        - Standardization of V
-
-    Note:
-        It cannot reverse downsampling!
-
-    Returns:
-        GridData: GridData object with the data with reversed preprocessing
-    """
-    if griddata.preprocessing_params is None:
-        raise ValueError("No preprocessing has been applied to the data")
-    else:
-        # get data
-        data = griddata.data.copy().reset_index()
-        if "normalization" in griddata.preprocessing_params:
-            # reverse normalization of X Y Z
-            # original_value = normalized_value * (max_value - min_value) + min_value
-            for axis in ["X", "Y", "Z"]:
-                data[axis] = (
-                    data[axis]
-                    * (
-                        griddata.preprocessing_params["normalization"][axis]["max"]
-                        - griddata.preprocessing_params["normalization"][axis]["min"]
-                    )
-                    + griddata.preprocessing_params["normalization"][axis]["min"]
-                )
-        if "standardization" in griddata.preprocessing_params:
-            # reverse standardization of V
-            data["V"] = (
-                data["V"] * griddata.preprocessing_params["standardization"]["std"]
-                + griddata.preprocessing_params["standardization"]["mean"]
-            )
-            # return
-        return GridData(data)