mediml 0.9.9__py3-none-any.whl

MEDiml/utils/imref.py

@@ -0,0 +1,340 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from typing import Tuple, Union
+
+import numpy as np
+
+
+def intrinsicToWorld(R, xIntrinsic: float, yIntrinsic: float, zIntrinsic:float) -> Tuple[float, float, float]:
+    """Convert from intrinsic to world coordinates.
+
+    Args:
+        R (imref3d): imref3d object (same functionality of MATLAB imref3d class)
+        xIntrinsic (float):  Coordinates along the x-dimension in the intrinsic coordinate system
+        yIntrinsic (float):  Coordinates along the y-dimension in the intrinsic coordinate system
+        zIntrinsic (float):  Coordinates along the z-dimension in the intrinsic coordinate system
+
+    Returns:
+        float: world coordinates
+    """
+    return R.intrinsicToWorld(xIntrinsic=xIntrinsic, yIntrinsic=yIntrinsic, zIntrinsic=zIntrinsic)
+
+
+def worldToIntrinsic(R, xWorld: float, yWorld: float, zWorld: float) -> Tuple[float, float, float] :
+    """Convert from world coordinates to intrinsic.
+
+    Args:
+        R (imref3d): imref3d object (same functionality of MATLAB imref3d class)
+        xWorld (float): Coordinates along the x-dimension in the intrinsic coordinate system
+        yWorld (float): Coordinates along the y-dimension in the intrinsic coordinate system
+        zWorld (float): Coordinates along the z-dimension in the intrinsic coordinate system
+
+    Returns:
+        _type_: intrinsic coordinates
+    """
+    return R.worldToIntrinsic(xWorld=xWorld, yWorld=yWorld, zWorld=zWorld)
+
+
+def sizes_match(R, A):
+    """Compares whether the two imref3d objects have the same size.
+
+    Args:
+        R (imref3d): First imref3d object.
+        A (imref3d): Second imref3d object.
+
+    Returns:
+        bool: True if ``R`` and ``A`` have the same size, and false if not.
+
+    """
+    return np.all(R.imageSize == A.imageSize)
+
+
+class imref3d:
+    """This class mirrors the functionality of the matlab imref3d class
+
+    An `imref3d object <https://www.mathworks.com/help/images/ref/imref3d.html>`_ 
+    stores the relationship between the intrinsic coordinates 
+    anchored to the columns,  rows, and planes of a 3-D image and the spatial 
+    location of the same column, row, and plane locations in a world coordinate system.
+
+    The image is sampled regularly in the planar world-x, world-y, and world-z coordinates 
+    of the coordinate system such that intrinsic-x, -y and -z values align with world-x, -y 
+    and -z values, respectively. The resolution in each dimension can be different.
+
+    Args:
+        ImageSize (ndarray, optional): Number of elements in each spatial dimension, 
+                                       specified as a 3-element positive row vector.
+        PixelExtentInWorldX (float, optional): Size of a single pixel in the x-dimension 
+                                               measured in the world coordinate system.
+        PixelExtentInWorldY (float, optional): Size of a single pixel in the y-dimension 
+                                               measured in the world coordinate system.
+        PixelExtentInWorldZ (float, optional): Size of a single pixel in the z-dimension 
+                                               measured in the world coordinate system.
+        xWorldLimits (ndarray, optional): Limits of image in world x, specified as a 2-element row vector, 
+                                          [xMin xMax].
+        yWorldLimits (ndarray, optional): Limits of image in world y, specified as a 2-element row vector, 
+                                          [yMin yMax].
+        zWorldLimits (ndarray, optional): Limits of image in world z, specified as a 2-element row vector, 
+                                          [zMin zMax].
+        
+    Attributes:
+        ImageSize (ndarray): Number of elements in each spatial dimension, 
+                             specified as a 3-element positive row vector.
+        PixelExtentInWorldX (float): Size of a single pixel in the x-dimension 
+                                     measured in the world coordinate system.
+        PixelExtentInWorldY (float): Size of a single pixel in the y-dimension 
+                                     measured in the world coordinate system.
+        PixelExtentInWorldZ (float): Size of a single pixel in the z-dimension 
+                                     measured in the world coordinate system.
+        XIntrinsicLimits (ndarray): Limits of image in intrinsic units in the x-dimension, 
+                                    specified as a 2-element row vector [xMin xMax].
+        YIntrinsicLimits (ndarray): Limits of image in intrinsic units in the y-dimension, 
+                                    specified as a 2-element row vector [yMin yMax].
+        ZIntrinsicLimits (ndarray): Limits of image in intrinsic units in the z-dimension, 
+                                    specified as a 2-element row vector [zMin zMax].
+        ImageExtentInWorldX (float): Span of image in the x-dimension in 
+                                     the world coordinate system.
+        ImageExtentInWorldY (float): Span of image in the y-dimension in 
+                                     the world coordinate system.
+        ImageExtentInWorldZ (float): Span of image in the z-dimension in 
+                                     the world coordinate system.
+        xWorldLimits (ndarray): Limits of image in world x, specified as a 2-element row vector, 
+                                [xMin xMax].
+        yWorldLimits (ndarray): Limits of image in world y, specified as a 2-element row vector, 
+                                [yMin yMax].
+        zWorldLimits (ndarray): Limits of image in world z, specified as a 2-element row vector, 
+                                [zMin zMax].
+    """
+
+    def __init__(self, 
+                imageSize=None, 
+                pixelExtentInWorldX=1.0,
+                pixelExtentInWorldY=1.0, 
+                pixelExtentInWorldZ=1.0,
+                xWorldLimits=None, 
+                yWorldLimits=None, 
+                zWorldLimits=None) -> None:
+
+        # Check if imageSize is an ndarray, and cast to ndarray otherwise
+        self.ImageSize = self._parse_to_ndarray(x=imageSize, n=3)
+
+        # Size of single voxels along axis in world coordinate system.
+        # Equivalent to voxel spacing.
+        self.PixelExtentInWorldX = pixelExtentInWorldX
+        self.PixelExtentInWorldY = pixelExtentInWorldY
+        self.PixelExtentInWorldZ = pixelExtentInWorldZ
+
+        # Limits of the image in intrinsic coordinates
+        # AZ: this differs from DICOM, which assumes that the origin lies
+        # at the center of the first voxel.
+        if imageSize is not None:
+            self.XIntrinsicLimits = np.array([-0.5, imageSize[0]-0.5])
+            self.YIntrinsicLimits = np.array([-0.5, imageSize[1]-0.5])
+            self.ZIntrinsicLimits = np.array([-0.5, imageSize[2]-0.5])
+        else:
+            self.XIntrinsicLimits = None
+            self.YIntrinsicLimits = None
+            self.ZIntrinsicLimits = None
+
+        # Size of the image in world coordinates
+        if imageSize is not None:
+            self.ImageExtentInWorldX = imageSize[0] * pixelExtentInWorldX
+            self.ImageExtentInWorldY = imageSize[1] * pixelExtentInWorldY
+            self.ImageExtentInWorldZ = imageSize[2] * pixelExtentInWorldZ
+        else:
+            self.ImageExtentInWorldX = None
+            self.ImageExtentInWorldY = None
+            self.ImageExtentInWorldZ = None
+
+        # Limits of the image in the world coordinates
+        self.XWorldLimits = self._parse_to_ndarray(x=xWorldLimits, n=2)
+        self.YWorldLimits = self._parse_to_ndarray(x=yWorldLimits, n=2)
+        self.ZWorldLimits = self._parse_to_ndarray(x=zWorldLimits, n=2)
+
+        if xWorldLimits is None and imageSize is not None:
+            self.XWorldLimits = np.array([0.0, self.ImageExtentInWorldX])
+        if yWorldLimits is None and imageSize is not None:
+            self.YWorldLimits = np.array([0.0, self.ImageExtentInWorldY])
+        if zWorldLimits is None and imageSize is not None:
+            self.ZWorldLimits = np.array([0.0, self.ImageExtentInWorldZ])
+
+    def _parse_to_ndarray(self,
+                          x: np.iterable,
+                          n=None) -> np.ndarray:
+        """Internal function to cast input to a numpy array.
+
+        Args:
+            x (iterable): Object that supports __iter__.
+            n (int, optional): expected length.
+
+        Returns:
+            ndarray: iterable input as a numpy array.
+        """
+        if x is not None:
+            # Cast to ndarray
+            if not isinstance(x, np.ndarray):
+                x = np.array(x)
+
+            # Check length
+            if n is not None:
+                if not len(x) == n:
+                    raise ValueError(
+                        "Length of array does not meet the expected length.", len(x), n)
+
+        return x
+
+    def intrinsicToWorld(self, 
+                         xIntrinsic: np.ndarray, 
+                         yIntrinsic: np.ndarray, 
+                         zIntrinsic: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """Convert from intrinsic to world coordinates.
+
+        Args:
+            xIntrinsic (ndarray): Coordinates along the x-dimension in the intrinsic coordinate system.
+            yIntrinsic (ndarray): Coordinates along the y-dimension in the intrinsic coordinate system.
+            zIntrinsic (ndarray): Coordinates along the z-dimension in the intrinsic coordinate system.
+
+        Returns:
+            Tuple[np.ndarray, np.ndarray, np.ndarray]: [xWorld, yWorld, zWorld] in world coordinate system.
+        """
+        xWorld = (self.XWorldLimits[0] + 0.5*self.PixelExtentInWorldX) + \
+            xIntrinsic * self.PixelExtentInWorldX
+        yWorld = (self.YWorldLimits[0] + 0.5*self.PixelExtentInWorldY) + \
+            yIntrinsic * self.PixelExtentInWorldY
+        zWorld = (self.ZWorldLimits[0] + 0.5*self.PixelExtentInWorldZ) + \
+            zIntrinsic * self.PixelExtentInWorldZ
+
+        return xWorld, yWorld, zWorld
+
+    def worldToIntrinsic(self, 
+                         xWorld: np.ndarray, 
+                         yWorld: np.ndarray, 
+                         zWorld: np.ndarray)-> Union[np.ndarray,
+                                                     np.ndarray,
+                                                     np.ndarray]:
+        """Converts from world coordinates to intrinsic coordinates.
+
+        Args:
+            xWorld (ndarray): Coordinates along the x-dimension in the world coordinate system.
+            yWorld (ndarray): Coordinates along the y-dimension in the world coordinate system.
+            zWorld (ndarray): Coordinates along the z-dimension in the world coordinate system.
+
+        Returns:
+            ndarray: [xIntrinsic,yIntrinsic,zIntrinsic] in intrinsic coordinate system.
+        """
+
+        xIntrinsic = (
+            xWorld - (self.XWorldLimits[0] + 0.5*self.PixelExtentInWorldX)) / self.PixelExtentInWorldX
+        yIntrinsic = (
+            yWorld - (self.YWorldLimits[0] + 0.5*self.PixelExtentInWorldY)) / self.PixelExtentInWorldY
+        zIntrinsic = (
+            zWorld - (self.ZWorldLimits[0] + 0.5*self.PixelExtentInWorldZ)) / self.PixelExtentInWorldZ
+
+        return xIntrinsic, yIntrinsic, zIntrinsic
+
+    def contains_point(self,
+                       xWorld: np.ndarray,
+                       yWorld: np.ndarray,
+                       zWorld: np.ndarray) -> np.ndarray:
+        """Determines which points defined by ``xWorld``, ``yWorld`` and ``zWorld``.
+
+        Args:
+            xWorld (ndarray): Coordinates along the x-dimension in the world coordinate system.
+            yWorld (ndarray): Coordinates along the y-dimension in the world coordinate system.
+            zWorld (ndarray): Coordinates along the z-dimension in the world coordinate system.
+
+        Returns:
+            ndarray: boolean array for coordinate sets that are within the bounds of the image.
+        """
+        xInside = np.logical_and(
+            xWorld >= self.XWorldLimits[0], xWorld <= self.XWorldLimits[1])
+        yInside = np.logical_and(
+            yWorld >= self.YWorldLimits[0], yWorld <= self.YWorldLimits[1])
+        zInside = np.logical_and(
+            zWorld >= self.ZWorldLimits[0], zWorld <= self.ZWorldLimits[1])
+
+        return xInside + yInside + zInside == 3
+
+    def WorldLimits(self,
+                    axis=None,
+                    newValue=None) -> Union[np.ndarray, None]:
+        """Sets the WorldLimits to the new value for the given ``axis``.
+        If the newValue is None, the method returns the attribute value.
+
+        Args:
+            axis (str, optional): Specify the dimension, must be 'X', 'Y' or 'Z'.
+            newValue (iterable, optional): New value for the WorldLimits attribute.
+
+        Returns:
+            ndarray: Limits of image in world along the axis-dimension.
+        """
+        if newValue is None:
+            # Get value
+            if axis == "X":
+                return self.XWorldLimits
+            elif axis == "Y":
+                return self.YWorldLimits
+            elif axis == "Z":
+                return self.ZWorldLimits
+        else:
+            # Set value
+            if axis == "X":
+                self.XWorldLimits = self._parse_to_ndarray(x=newValue, n=2)
+            elif axis == "Y":
+                self.YWorldLimits = self._parse_to_ndarray(x=newValue, n=2)
+            elif axis == "Z":
+                self.ZWorldLimits = self._parse_to_ndarray(x=newValue, n=2)
+
+    def PixelExtentInWorld(self, axis=None) -> Union[float, None]:
+        """Returns the PixelExtentInWorld attribute value for the given ``axis``.
+
+        Args:
+            axis (str, optional): Specify the dimension, must be 'X', 'Y' or 'Z'.
+
+        Returns:
+            float: Size of a single pixel in the axis-dimension measured in the world coordinate system.
+        """
+        if axis == "X":
+            return self.PixelExtentInWorldX
+        elif axis == "Y":
+            return self.PixelExtentInWorldY
+        elif axis == "Z":
+            return self.PixelExtentInWorldZ
+
+    def IntrinsicLimits(self,
+                        axis=None) -> Union[np.ndarray,
+                                            None]:
+        """Returns the IntrinsicLimits attribute value for the given ``axis``.
+
+        Args:
+            axis (str, optional): Specify the dimension, must be 'X', 'Y' or 'Z'.
+
+        Returns:
+            ndarray: Limits of image in intrinsic units in the axis-dimension, specified as a 2-element row vector [xMin xMax].
+        """
+        if axis == "X":
+            return self.XIntrinsicLimits
+        elif axis == "Y":
+            return self.YIntrinsicLimits
+        elif axis == "Z":
+            return self.ZIntrinsicLimits
+
+    def ImageExtentInWorld(self,
+                           axis=None) -> Union[float,
+                                               None]:
+        """Returns the ImageExtentInWorld attribute value for the given ``axis``.
+
+        Args:
+            axis (str, optional): Specify the dimension, must be 'X', 'Y' or 'Z'.
+
+        Returns:
+            ndarray: Span of image in the axis-dimension in the world coordinate system.
+
+        """
+        if axis == "X":
+            return self.ImageExtentInWorldX
+        elif axis == "Y":
+            return self.ImageExtentInWorldY
+        elif axis == "Z":
+            return self.ImageExtentInWorldZ

MEDiml/utils/initialize_features_names.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+from typing import Dict, List, Tuple
+
+
+def initialize_features_names(image_space_struct: Dict) -> Tuple[List, List]:
+    """Finds all the features names from `image_space_struct`
+
+    Args:
+        image_space_struct(Dict): Dictionary of the extracted features (Texture & Non-texture)
+    
+    Returns:
+        Tuple[List, List]: Two lists of the texture and non-texture features names found in the `image_space_struct`.
+    """
+    # First entry is the names of feature types. Second entry is the name of
+    # the features for a given feature type. Third entry is the name of the
+    # extraction parameters for all features of a given feature type.
+    non_text_cell = [0] * 3
+    # First entry is the names of feature types. Second entry is the name of
+    # the features for a given feature type. Third entry is the name of the
+    # extraction parameters for all features of a given feature type.
+    text_cell = [0] * 3
+
+    # NON-TEXTURE FEATURES
+    field_non_text = [key for key in image_space_struct.keys() if key != 'texture']
+    n_non_text_type = len(field_non_text)
+    non_text_cell[0] = field_non_text
+    non_text_cell[1] = [0] * n_non_text_type
+    non_text_cell[2] = [0] * n_non_text_type
+
+    for t in range(0, n_non_text_type):
+        dic_image_space_struct_non_text = image_space_struct[non_text_cell[0][t]]
+        field_params_non_text = [
+            key for key in dic_image_space_struct_non_text.keys()]
+        dic_image_space_struct_params_non_text = image_space_struct[non_text_cell[0]
+                                                               [t]][field_params_non_text[0]]
+        field_feat_non_text = [
+            key for key in dic_image_space_struct_params_non_text.keys()]
+        non_text_cell[1][t] = field_feat_non_text
+        non_text_cell[2][t] = field_params_non_text
+
+    # TEXTURE FEATURES
+    dic_image_space_struct_texture = image_space_struct['texture']
+    field_text = [key for key in dic_image_space_struct_texture.keys()]
+    n_text_type = len(field_text)
+    text_cell[0] = field_text
+    text_cell[1] = [0] * n_text_type
+    text_cell[2] = [0] * n_text_type
+
+    for t in range(0, n_text_type):
+        dic_image_space_struct_text = image_space_struct['texture'][text_cell[0][t]]
+        field_params_text = [key for key in dic_image_space_struct_text.keys()]
+        dic_image_space_struct_params_text = image_space_struct['texture'][text_cell[0]
+                                                                       [t]][field_params_text[0]]
+        field_feat_text = [
+            key for key in dic_image_space_struct_params_text.keys()]
+        text_cell[1][t] = field_feat_text
+        text_cell[2][t] = field_params_text
+
+    return non_text_cell, text_cell

MEDiml/utils/inpolygon.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import numpy as np
+
+
+def inpolygon(x_q: np.ndarray,
+              y_q: np.ndarray,
+              x_v: np.ndarray,
+              y_v: np.ndarray) -> np.ndarray:
+    """Implements similar functionality MATLAB inpolygon.
+    Finds points located inside or on edge of polygonal region.
+
+    Note: 
+        Unlike matlab inpolygon, this function does not determine the
+        status of single points :math:`(x_q, y_q)`. Instead, it determines the 
+        status for an entire grid by ray-casting.
+
+    Args:
+        x_q (ndarray): x-coordinates of query points, in intrinsic reference system.
+        y_q (ndarray): y-coordinates of query points, in intrinsic reference system.
+        x_q (ndarray): x-coordinates of polygon vertices, in intrinsic reference system.
+        y_q (ndarray): y-coordinates of polygon vertices, in intrinsic reference system.
+
+    Returns:
+        ndarray: boolean array indicating if the query points are on the edge of the polygon area.
+
+    """
+    def ray_line_intersection(ray_orig, ray_dir, vert_1, vert_2):
+        """
+        
+        """
+        epsilon = 0.000001
+
+        # Define edge
+        edge_line = vert_1 - vert_2
+
+        # Define ray vertices
+        r_vert_1 = ray_orig
+        r_vert_2 = ray_orig + ray_dir
+        edge_ray = - ray_dir
+
+        # Calculate determinant - if close to 0, lines are parallel and will
+        # not intersect
+        det = np.cross(edge_ray, edge_line)
+        if (det > -epsilon) and (det < epsilon):
+            return np.nan
+
+        # Calculate inverse of the determinant
+        inv_det = 1.0 / det
+
+        # Calculate determinant
+        a11 = np.cross(r_vert_1, r_vert_2)
+        a21 = np.cross(vert_1, vert_2)
+
+        # Solve for x
+        a12 = edge_ray[0]
+        a22 = edge_line[0]
+        x = np.linalg.det(np.array([[a11, a12], [a21, a22]])) * inv_det
+
+        # Solve for y
+        b12 = edge_ray[1]
+        b22 = edge_line[1]
+        y = np.linalg.det(np.array([[a11, b12], [a21, b22]])) * inv_det
+
+        t = np.array([x, y])
+
+        # Check whether the solution falls within the line segment
+        u1 = np.around(np.dot(edge_line, edge_line), 5)
+        u2 = np.around(np.dot(edge_line, vert_1-t), 5)
+        if (u2 / u1) < 0.0 or (u2 / u1) > 1.0:
+            return np.nan
+
+        # Return scalar length from ray origin
+        t_scal = np.linalg.norm(ray_orig - t)
+
+        return t_scal
+
+    # These are hacks to actually make this function work
+    spacing = np.array([1.0, 1.0])
+    origin = np.array([0.0, 0.0])
+    shape = np.array([np.max(x_q) + 1, np.max(y_q) + 1])
+    # shape = np.array([np.max(x_q), np.max(y_q)]) Original from Alex
+    vertices = np.vstack((x_v, y_v)).transpose()
+    lines = np.vstack(
+        ([np.arange(0, len(x_v))], [np.arange(-1, len(x_v) - 1)])).transpose()
+
+    # Set up line vertices
+    vertex_a = vertices[lines[:, 0], :]
+    vertex_b = vertices[lines[:, 1], :]
+
+    # Remove lines with length 0 and center on the origin
+    line_mask = np.sum(np.abs(vertex_a - vertex_b), axis=1) > 0.0
+    vertex_a = vertex_a[line_mask] - origin
+    vertex_b = vertex_b[line_mask] - origin
+
+    # Find extent of contours in x
+    x_min_ind = int(
+        np.max([np.floor(np.min(vertices[:, 0]) / spacing[0]), 0.0]))
+    x_max_ind = int(
+        np.min([np.ceil(np.max(vertices[:, 0]) / spacing[0]), shape[0] * 1.0]))
+
+    # Set up voxel grid and y-span
+    vox_grid = np.zeros(shape, dtype=int)
+    vox_span = origin[1] + np.arange(0, shape[1]) * spacing[1]
+
+    # Set ray origin and direction (starts at negative y, and travels towards
+    # positive y
+    ray_origin = np.array([0.0, -1.0])
+    ray_dir = np.array([0.0, 1.0])
+
+    for x_ind in np.arange(x_min_ind, x_max_ind):
+        # Update ray origin
+        ray_origin[0] = origin[0] + x_ind * spacing[0]
+
+        # Scan both forward and backward to resolve points located on
+        # the polygon
+        vox_col_frwd = np.zeros(np.shape(vox_span), dtype=int)
+        vox_col_bkwd = np.zeros(np.shape(vox_span), dtype=int)
+
+        # Find lines that are intersected by the ray
+        ray_hit = np.sum(
+            np.sign(np.vstack((vertex_a[:, 0], vertex_b[:, 0])) - ray_origin[0]), axis=0)
+
+        # If the ray crosses a vertex, the sum of the sign is 0 when the ray
+        # does not hit an vertex point, and -1 or 1 when it does.
+        # In the latter case, we only keep of the vertices for each hit.
+        simplex_mask = np.logical_or(ray_hit == 0, ray_hit == 1)
+
+        # Go to next iterator if mask is empty
+        if np.sum(simplex_mask) == 0:
+            continue
+
+        # Determine the selected vertices
+        selected_verts = np.squeeze(np.where(simplex_mask))
+
+        # Find intercept of rays with lines
+        t_scal = np.array([ray_line_intersection(ray_orig=ray_origin, ray_dir=ray_dir,
+                                                 vert_1=vertex_a[ii, :], vert_2=vertex_b[ii, :]) for ii in selected_verts])
+
+        # Remove invalid results
+        t_scal = t_scal[np.isfinite(t_scal)]
+        if t_scal.size == 0:
+            continue
+
+        # Update vox_col based on t_scal. This basically adds a 1 for all
+        # voxels that lie behind the line intersections
+        # of the ray.
+        for t_curr in t_scal:
+            vox_col_frwd[vox_span > t_curr + ray_origin[1]] += 1
+        for t_curr in t_scal:
+            vox_col_bkwd[vox_span < t_curr + ray_origin[1]] += 1
+
+        # Voxels in the roi cross an uneven number of meshes from the origin
+        vox_grid[x_ind,
+                 :] += np.logical_and(vox_col_frwd % 2, vox_col_bkwd % 2)
+
+    return vox_grid.astype(dtype=bool)

MEDiml/utils/interp3.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import numpy as np
+from scipy.ndimage import map_coordinates
+
+
+def interp3(v, x_q, y_q, z_q, method) -> np.ndarray:
+    """`Interpolation for 3-D gridded data <https://www.mathworks.com/help/matlab/ref/interp3.html>`_\
+    in meshgrid format, implements similar functionality MATLAB interp3.
+
+    Args:
+        X, Y, Z (ndarray) : Query points, should be intrinsic coordinates.
+        method (str): {nearest, linear, spline, cubic}, Interpolation ``method``.
+
+    Returns:
+        ndarray: Array of interpolated values.
+    
+    Raises:
+        ValueError: If ``method`` is not 'nearest', 'linear', 'spline' or 'cubic'.
+
+    """
+
+    # Parse method
+    if method == "nearest":
+        spline_order = 0
+    elif method == "linear":
+        spline_order = 1
+    elif method in ["spline", "cubic"]:
+        spline_order = 3
+    else:
+        raise ValueError("Interpolator not implemented.")
+
+    size = np.size(x_q)
+    coord_X = np.reshape(x_q, size, order='F')
+    coord_Y = np.reshape(y_q, size, order='F')
+    coord_Z = np.reshape(z_q, size, order='F')
+    coordinates = np.array([coord_X, coord_Y, coord_Z]).astype(np.float32)
+    v_q = map_coordinates(input=v.astype(
+        np.float32), coordinates=coordinates, order=spline_order, mode='nearest')
+    v_q = np.reshape(v_q, np.shape(x_q), order='F')
+
+    return v_q

MEDiml/utils/json_utils.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import json
+import pathlib
+from typing import Dict
+
+
+def _is_jsonable(data: any, cls: object) -> bool:
+    """Checks if the given ``data`` is JSON serializable.
+
+    Args:
+        data (Any): ``Data`` that will be checked.
+        cls(object, optional): Costum JSONDecoder subclass. If not specified JSONDecoder is used. 
+
+    Returns:
+        bool: True if the given ``data`` is serializable, False if not.
+    """
+    try:
+        json.dumps(data, cls=cls)
+        return True
+    except (TypeError, OverflowError):
+        return False
+
+
+def posix_to_string(dictionnary: Dict) -> Dict:
+    """Converts all Pathlib.Path to str [Pathlib is not serializable].
+
+    Args:
+        dictionnary (Dict):  dict with Pathlib.Path values to convert.
+
+    Returns:
+        Dict: ``dictionnary`` with all Pathlib.Path converted to str.
+    """
+    for key, value in dictionnary.items():
+        if type(value) is dict:
+            value = posix_to_string(value)
+        else:
+            if issubclass(type(value), (pathlib.WindowsPath, pathlib.PosixPath, pathlib.Path)):
+               dictionnary[key] = str(value)
+    
+    return dictionnary
+
+def load_json(file_path: pathlib.Path) -> Dict:
+    """Wrapper to json.load function.
+
+    Args:
+        file_path (Path): Path of the json file to load.
+
+    Returns:
+        Dict: The loaded json file.
+     
+    """
+    with open(file_path, 'r') as fp:
+        return json.load(fp)
+
+
+def save_json(file_path: pathlib.Path, data: any, cls=None) -> None:
+    """Wrapper to json.dump function.
+
+    Args:
+        file_path (Path): Path to write the json file to.
+        data (Any): Data to write to the given path. Must be serializable by JSON.
+        cls(object, optional): Costum JSONDecoder subclass. If not specified JSONDecoder is used. 
+
+    Returns:
+        None: saves the ``data`` in JSON file to the ``file_path``.
+
+    Raises:
+        TypeError: If ``data`` is not JSON serializable.
+    """
+    if _is_jsonable(data, cls):
+        with open(file_path, 'w') as fp:
+            json.dump(data, fp, indent=4, cls=cls)
+    else:
+        raise TypeError("The given data is not JSON serializable. \
+            We rocommend using a costum encoder.")