mediml 0.9.9__py3-none-any.whl

MEDiml/processing/__init__.py

@@ -0,0 +1,6 @@
+from . import *
+from .compute_suv_map import *
+from .discretisation import *
+from .interpolation import *
+from .resegmentation import *
+from .segmentation import *

MEDiml/processing/compute_suv_map.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import numpy as np
+import pydicom
+
+
+def compute_suv_map(raw_pet: np.ndarray,
+                    dicom_h: pydicom.Dataset) -> np.ndarray:
+    """Computes the suv_map of a raw input PET volume. It is assumed that
+    the calibration factor was applied beforehand to the PET volume.
+    **E.g: raw_pet = raw_pet*RescaleSlope + RescaleIntercept.**
+
+    Args:
+        raw_pet (ndarray):3D array representing the PET volume in raw format.
+        dicom_h (pydicom.dataset.FileDataset): DICOM header of one of the
+            corresponding slice of ``raw_pet``.
+
+    Returns:
+        ndarray: ``raw_pet`` converted to SUVs (standard uptake values).
+    """
+    def dcm_hhmmss(date_str: str) -> float:
+        """"Converts to seconds
+
+        Args:
+            date_str (str): date string
+
+        Returns:
+            float: total seconds
+        """
+        # Converts to seconds
+        if not isinstance(date_str, str):
+            date_str = str(date_str)
+        hh = float(date_str[0:2])
+        mm = float(date_str[2:4])
+        ss = float(date_str[4:6])
+        tot_sec = hh*60.0*60.0 + mm*60.0 + ss
+        return tot_sec
+
+    def pydicom_has_tag(dcm_seq, tag):
+        # Checks if tag exists
+        return get_pydicom_meta_tag(dcm_seq, tag, test_tag=True)
+
+    def get_pydicom_meta_tag(dcm_seq, tag, tag_type=None, default=None,
+                            test_tag=False):
+        # Reads dicom tag
+        # Initialise with default
+        tag_value = default
+        # Read from header using simple itk
+        try:
+            tag_value = dcm_seq[tag].value
+        except KeyError:
+            if test_tag:
+                return False
+        if test_tag:
+            return True
+        # Find empty entries
+        if tag_value is not None:
+            if tag_value == "":
+                tag_value = default
+        # Cast to correct type (meta tags are usually passed as strings)
+        if tag_value is not None:
+            # String
+            if tag_type == "str":
+                tag_value = str(tag_value)
+            # Float
+            elif tag_type == "float":
+                tag_value = float(tag_value)
+            # Multiple floats
+            elif tag_type == "mult_float":
+                tag_value = [float(str_num) for str_num in tag_value]
+            # Integer
+            elif tag_type == "int":
+                tag_value = int(tag_value)
+            # Multiple floats
+            elif tag_type == "mult_int":
+                tag_value = [int(str_num) for str_num in tag_value]
+            # Boolean
+            elif tag_type == "bool":
+                tag_value = bool(tag_value)
+
+        return tag_value
+
+    # Get patient weight
+    if pydicom_has_tag(dcm_seq=dicom_h, tag=(0x0010, 0x1030)):
+        weight = get_pydicom_meta_tag(dcm_seq=dicom_h, tag=(0x0010, 0x1030),
+                                      tag_type="float") * 1000.0  # in grams
+    else:
+        weight = None
+    if weight is None:
+        weight = 75000.0  # estimation
+    try:
+        # Get Scan time
+        scantime = dcm_hhmmss(date_str=get_pydicom_meta_tag(
+            dcm_seq=dicom_h, tag=(0x0008, 0x0032), tag_type="str"))
+        # Start Time for the Radiopharmaceutical Injection
+        injection_time = dcm_hhmmss(date_str=get_pydicom_meta_tag(
+            dcm_seq=dicom_h[0x0054, 0x0016][0],
+            tag=(0x0018, 0x1072), tag_type="str"))
+        # Half Life for Radionuclide
+        half_life = get_pydicom_meta_tag(
+            dcm_seq=dicom_h[0x0054, 0x0016][0],
+            tag=(0x0018, 0x1075), tag_type="float")
+        # Total dose injected for Radionuclide
+        injected_dose = get_pydicom_meta_tag(
+            dcm_seq=dicom_h[0x0054, 0x0016][0],
+            tag=(0x0018, 0x1074), tag_type="float")
+        # Calculate decay
+        decay = np.exp(-np.log(2)*(scantime-injection_time)/half_life)
+        # Calculate the dose decayed during procedure
+        injected_dose_decay = injected_dose*decay  # in Bq
+    except KeyError:
+        # 90 min waiting time, 15 min preparation
+        decay = np.exp(-np.log(2)*(1.75*3600)/6588)
+        injected_dose_decay = 420000000 * decay  # 420 MBq
+
+    # Calculate SUV
+    suv_map = raw_pet * weight / injected_dose_decay
+
+    return suv_map

MEDiml/processing/discretisation.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+from copy import deepcopy
+from typing import Tuple
+
+import numpy as np
+from skimage.exposure import equalize_hist
+
+
+def equalization(vol_re: np.ndarray) -> np.ndarray:
+    """Performs histogram equalisation of the ROI imaging intensities.
+
+    Note:
+        This is a pure "what is contained within the roi" equalization. this is
+        not influenced by the :func:`user_set_min_val()` used for FBS discretisation.
+
+    Args:
+        vol_re (ndarray): 3D array of the image volume that will be studied with
+                          NaN value for the excluded voxels (voxels outside the ROI mask).
+
+    Returns:
+        ndarray: Same input image volume but with redistributed intensities.
+    """
+
+    # AZ: This was made part of the function call
+    # n_g = 64
+    # This is the default we will use. It means that when using 'FBS',
+    # n_q should be chosen wisely such
+    # that the total number of grey levels does not exceed 64, for all
+    # patients (recommended).
+    # This choice was amde by considering that the best equalization
+    # performance for "histeq.m" is obtained with low n_g.
+    # WARNING: The effective number of grey levels coming out of "histeq.m"
+    # may be lower than n_g.
+
+    # CONSERVE THE INDICES OF THE ROI
+    x_gl = np.ravel(vol_re)
+    ind_roi = np.where(~np.isnan(vol_re))
+    x_gl = x_gl[~np.isnan(x_gl)]
+
+    # ADJUST RANGE BETWEEN 0 and 1
+    min_val = np.min(x_gl)
+    max_val = np.max(x_gl)
+    x_gl_01 = (x_gl - min_val)/(max_val - min_val)
+
+    # EQUALIZATION
+    # x_gl_equal = equalize_hist(x_gl_01, nbins=n_g)
+    # AT THE MOMENT, WE CHOOSE TO USE THE DEFAULT NUMBER OF BINS OF
+    # equalize_hist.py (256)
+    x_gl_equal = equalize_hist(x_gl_01)
+    # RE-ADJUST TO CORRECT RANGE
+    x_gl_equal = (x_gl_equal - np.min(x_gl_equal)) / \
+        (np.max(x_gl_equal) - np.min(x_gl_equal))
+    x_gl_equal = x_gl_equal * (max_val - min_val)
+    x_gl_equal = x_gl_equal + min_val
+
+    # RECONSTRUCT THE VOLUME WITH EQUALIZED VALUES
+    vol_equal_re = deepcopy(vol_re)
+
+    vol_equal_re[ind_roi] = x_gl_equal
+
+    return vol_equal_re
+
+def discretize(vol_re: np.ndarray,
+                   discr_type: str,
+                   n_q: float=None,
+                   user_set_min_val: float=None,
+                   ivh=False) -> Tuple[np.ndarray, float]:
+    """Quantisizes the image intensities inside the ROI.
+
+    Note:
+        For 'FBS' type, it is assumed that re-segmentation with
+        proper range was already performed
+
+    Args:
+        vol_re (ndarray): 3D array of the image volume that will be studied with
+                          NaN value for the excluded voxels (voxels outside the ROI mask).
+        discr_type (str): Discretisaion approach/type must be: "FBS", "FBN", "FBSequal"
+                          or "FBNequal".
+        n_q (float): Number of bins for FBS algorithm and bin width for FBN algorithm.
+        user_set_min_val (float): Minimum of range re-segmentation for FBS discretisation,
+                                  for FBN discretisation, this value has no importance as an argument
+                                  and will not be used.
+        ivh (bool): Must be set to True for IVH (Intensity-Volume histogram) features.
+
+    Returns:
+        2-element tuple containing
+
+        - ndarray: Same input image volume but with discretised intensities.
+        - float: bin width.
+    """
+
+    # AZ: NOTE: the "type" variable that appeared in the MATLAB source code
+    # matches the name of a standard python function. I have therefore renamed
+    # this variable "discr_type"
+
+    # PARSING ARGUMENTS
+    vol_quant_re = deepcopy(vol_re)
+
+    if n_q is None:
+        return None
+
+    if not isinstance(n_q, float):
+        n_q = float(n_q)
+
+    if discr_type not in ["FBS", "FBN", "FBSequal", "FBNequal"]:
+        raise ValueError(
+            "discr_type must either be \"FBS\", \"FBN\", \"FBSequal\" or \"FBNequal\".")
+
+    # DISCRETISATION
+    if discr_type in ["FBS", "FBSequal"]:
+        if user_set_min_val:
+            min_val = deepcopy(user_set_min_val)
+        else:
+            min_val = np.nanmin(vol_quant_re)
+    else:
+        min_val = np.nanmin(vol_quant_re)
+
+    max_val = np.nanmax(vol_quant_re)
+
+    if discr_type == "FBS":
+        w_b = n_q
+        w_d = w_b
+        vol_quant_re = np.floor((vol_quant_re - min_val) / w_b) + 1.0
+    elif discr_type == "FBN":
+        w_b = (max_val - min_val) / n_q
+        w_d = 1.0
+        vol_quant_re = np.floor(
+            n_q * ((vol_quant_re - min_val)/(max_val - min_val))) + 1.0
+        vol_quant_re[vol_quant_re == np.nanmax(vol_quant_re)] = n_q
+    elif discr_type == "FBSequal":
+        w_b = n_q
+        w_d = w_b
+        vol_quant_re = equalization(vol_quant_re)
+        vol_quant_re = np.floor((vol_quant_re - min_val) / w_b) + 1.0
+    elif discr_type == "FBNequal":
+        w_b = (max_val - min_val) / n_q
+        w_d = 1.0
+        vol_quant_re = vol_quant_re.astype(np.float32)
+        vol_quant_re = equalization(vol_quant_re)
+        vol_quant_re = np.floor(
+            n_q * ((vol_quant_re - min_val)/(max_val - min_val))) + 1.0
+        vol_quant_re[vol_quant_re == np.nanmax(vol_quant_re)] = n_q
+    if ivh and discr_type in ["FBS", "FBSequal"]:
+        vol_quant_re = min_val + (vol_quant_re - 0.5) * w_b
+
+    return vol_quant_re, w_d

MEDiml/processing/interpolation.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+import logging
+from copy import deepcopy
+from typing import List
+
+import numpy as np
+
+from ..MEDscan import MEDscan
+from ..processing.segmentation import compute_box
+from ..utils.image_volume_obj import image_volume_obj
+from ..utils.imref import imref3d, intrinsicToWorld, worldToIntrinsic
+from ..utils.interp3 import interp3
+
+
+def interp_volume(
+        vol_obj_s: image_volume_obj,
+        medscan: MEDscan= None, 
+        vox_dim: List = None,
+        interp_met: str = None,
+        round_val: float = None,
+        image_type: str = None,
+        roi_obj_s: image_volume_obj = None,
+        box_string: str = None,
+        texture: bool = False) -> image_volume_obj:
+    """3D voxel interpolation on the input volume.
+
+    Args:
+        vol_obj_s (image_volume_obj): Imaging  that will be interpolated.
+        medscan (object): The MEDscan class object.
+        vox_dim (array): Array of the voxel dimension. The following format is used
+                         [Xin,Yin,Zslice], where Xin and Yin are the X (left to right) and
+                         Y (bottom to top) IN-PLANE resolutions, and Zslice is the slice spacing,
+                         no matter the orientation of the volume (i.e. axial , sagittal, coronal).
+        interp_met (str): {nearest, linear, spline, cubic} optional, Interpolation method
+        round_val (float): Rounding value. Must be between 0 and 1 for ROI interpolation
+                           and to a power of 10 for Image interpolation.
+        image_type (str): 'image' for imaging data interpolation and 'roi' for ROI mask data interpolation.
+        roi_obj_s (image_volume_obj): Mask data, will be used to compute a new specific box
+                                      and the new imref3d object for the imaging data.
+        box_string (str): Specifies the size if the box containing the ROI
+
+                          - 'full': full imaging data as output.
+                          - 'box': computes the smallest bounding box.
+                          - Ex: 'box10': 10 voxels in all three dimensions are added to \
+                            the smallest bounding box. The number after 'box' defines the \
+                            number of voxels to add.
+                          - Ex: '2box': Computes the smallest box and outputs double its \
+                            size. The number before 'box' defines the multiplication in size.
+        texture (bool): If True, the texture voxel spacing of ``MEDscan`` will be used for interpolation.
+    
+    Returns:
+        ndarray: 3D array of 1's and 0's defining the ROI mask.
+    """
+    try:
+        # PARSING ARGUMENTS
+        if vox_dim is None:
+            if medscan is None:
+                return deepcopy(vol_obj_s)
+            else:
+                if texture:
+                    vox_dim = medscan.params.process.scale_text
+                else:
+                    vox_dim = medscan.params.process.scale_non_text
+        if np.sum(vox_dim) == 0:
+            return deepcopy(vol_obj_s)
+        if len(vox_dim) == 2:
+            two_d = True
+        else:
+            two_d = False
+                
+        if image_type is None:
+            raise ValueError(
+                "The type of input image should be specified as \"image\" or \"roi\".")
+        elif image_type not in ["image", "roi"]:
+            raise ValueError(
+                "The type of input image should either be \"image\" or \"roi\".")
+        elif image_type == "image":
+            if not interp_met: 
+                if medscan:
+                    interp_met = medscan.params.process.vol_interp
+                else:
+                    raise ValueError("Interpolation method or MEDscan instance should be provided.")
+            if interp_met not in ["linear", "cubic", "spline"]:
+                raise ValueError(
+                    "Interpolation method for images should either be \"linear\", \"cubic\" or \"spline\".")
+            if medscan and not round_val:
+                round_val = medscan.params.process.gl_round
+            if round_val is not None:
+                if np.mod(np.log10(round_val), 1):
+                    raise ValueError("\"round_val\" should be a power of 10.")
+        else:
+            if not interp_met:
+                if medscan:
+                    interp_met = medscan.params.process.roi_interp
+                else:
+                    raise ValueError("Interpolation method or MEDscan instance should be provided.")
+            if interp_met not in ["nearest", "linear", "cubic"]:
+                raise ValueError(
+                    "Interpolation method for images should either be \"nearest\", \"linear\" or \"cubic\".")
+            if medscan and not round_val:
+                round_val = medscan.params.process.roi_pv
+            if round_val is not None:
+                if round_val < 0.0 or round_val > 1.0:
+                    raise ValueError("\"round_val\" must be between 0.0 and 1.0.")
+            else:
+                raise ValueError("\"round_val\" must be provided for \"roi\".")
+        if medscan and not box_string:
+            box_string = medscan.params.process.box_string
+        if roi_obj_s is None or box_string is None:
+            use_box = False
+        else:
+            use_box = True
+
+        # --> QUERIED POINTS: NEW INTERPOLATED VOLUME: "q" or "Q".
+        # --> SAMPLED POINTS: ORIGINAL VOLUME: "s" or "S".
+        # --> Always using XYZ coordinates (unless specifically noted),
+        #     not MATLAB IJK, so beware!
+
+        # INITIALIZATION
+        res_q = vox_dim
+        if two_d:
+            # If 2D, the resolution of the slice dimension of he queried volume is
+            # set to the same as the sampled volume.
+            res_q = np.concatenate((res_q, vol_obj_s.spatialRef.PixelExtentInWorldZ))
+
+        res_s = np.array([vol_obj_s.spatialRef.PixelExtentInWorldX,
+                        vol_obj_s.spatialRef.PixelExtentInWorldY,
+                        vol_obj_s.spatialRef.PixelExtentInWorldZ])
+
+        if np.array_equal(res_s, res_q):
+            return deepcopy(vol_obj_s)
+
+        spatial_ref_s = vol_obj_s.spatialRef
+        extent_s = np.array([spatial_ref_s.ImageExtentInWorldX,
+                            spatial_ref_s.ImageExtentInWorldY,
+                            spatial_ref_s.ImageExtentInWorldZ])
+        low_limits_s = np.array([spatial_ref_s.XWorldLimits[0],
+                            spatial_ref_s.YWorldLimits[0],
+                            spatial_ref_s.ZWorldLimits[0]])
+
+        # CREATING QUERIED "imref3d" OBJECT CENTERED ON SAMPLED VOLUME
+
+        # Switching to IJK (matlab) reference frame for "imref3d" computation.
+        # Putting a "ceil", according to IBSI standards. This is safer than "round".
+        size_q = np.ceil(np.around(np.divide(extent_s, res_q),
+                                decimals=3)).astype(int).tolist()
+
+        if two_d:
+            # If 2D, forcing the size of the queried volume in the slice dimension
+            # to be the same as the sample volume.
+            size_q[2] = vol_obj_s.spatialRef.ImageSize[2]
+
+        spatial_ref_q = imref3d(imageSize=size_q, 
+                            pixelExtentInWorldX=res_q[0],
+                            pixelExtentInWorldY=res_q[1],
+                            pixelExtentInWorldZ=res_q[2])
+
+        extent_q = np.array([spatial_ref_q.ImageExtentInWorldX,
+                            spatial_ref_q.ImageExtentInWorldY,
+                            spatial_ref_q.ImageExtentInWorldZ])
+        low_limits_q = np.array([spatial_ref_q.XWorldLimits[0],
+                            spatial_ref_q.YWorldLimits[0],
+                            spatial_ref_q.ZWorldLimits[0]])
+        diff = extent_q - extent_s
+        new_low_limits_q = low_limits_s - diff/2
+        spatial_ref_q.XWorldLimits = spatial_ref_q.XWorldLimits - \
+            (low_limits_q[0] - new_low_limits_q[0])
+        spatial_ref_q.YWorldLimits = spatial_ref_q.YWorldLimits - \
+            (low_limits_q[1] - new_low_limits_q[1])
+        spatial_ref_q.ZWorldLimits = spatial_ref_q.ZWorldLimits - \
+            (low_limits_q[2] - new_low_limits_q[2])
+
+        # REDUCE THE SIZE OF THE VOLUME PRIOR TO INTERPOLATION
+        # TODO check that compute_box vol and roi are intended to be the same!
+        if use_box:
+            _, _, tempSpatialRef = compute_box(
+                vol=roi_obj_s.data, roi=roi_obj_s.data, spatial_ref=vol_obj_s.spatialRef,
+                box_string=box_string)
+
+            size_temp = tempSpatialRef.ImageSize
+
+            # Getting world boundaries (center of voxels) of the new box
+            x_bound, y_bound, z_bound = intrinsicToWorld(R=tempSpatialRef,
+                                                    xIntrinsic=np.array(
+                                                        [0.0, size_temp[0]-1.0]),
+                                                    yIntrinsic=np.array(
+                                                        [0.0, size_temp[1]-1.0]),
+                                                    zIntrinsic=np.array([0.0, size_temp[2]-1.0]))
+
+            # Getting the image positions of the boundaries of the new box, IN THE
+            # FULL QUERIED FRAME OF REFERENCE (centered on the sampled frame of
+            # reference).
+            x_bound, y_bound, z_bound = worldToIntrinsic(
+                R=spatial_ref_q, xWorld=x_bound, yWorld=y_bound, zWorld=z_bound)
+
+            # Rounding to the nearest image position integer
+            x_bound = np.round(x_bound).astype(int)
+            y_bound = np.round(y_bound).astype(int)
+            z_bound = np.round(z_bound).astype(int)
+
+            size_q = np.array([x_bound[1] - x_bound[0] + 1, y_bound[1] -
+                            y_bound[0] + 1, z_bound[1] - z_bound[0] + 1])
+
+            # Converting back to world positions ion order to correctly define
+            # edges of the new box and thus center it onto the full queried
+            # reference frame
+            x_bound, y_bound, z_bound = intrinsicToWorld(R=spatial_ref_q,
+                                                    xIntrinsic=x_bound,
+                                                    yIntrinsic=y_bound,
+                                                    zIntrinsic=z_bound)
+
+            new_low_limits_q[0] = x_bound[0] - res_q[0]/2
+            new_low_limits_q[1] = y_bound[0] - res_q[1]/2
+            new_low_limits_q[2] = z_bound[0] - res_q[2]/2
+
+            spatial_ref_q = imref3d(imageSize=size_q, 
+                                pixelExtentInWorldX=res_q[0],
+                                pixelExtentInWorldY=res_q[1],
+                                pixelExtentInWorldZ=res_q[2])
+
+            spatial_ref_q.XWorldLimits -= spatial_ref_q.XWorldLimits[0] - \
+                new_low_limits_q[0]
+            spatial_ref_q.YWorldLimits -= spatial_ref_q.YWorldLimits[0] - \
+                new_low_limits_q[1]
+            spatial_ref_q.ZWorldLimits -= spatial_ref_q.ZWorldLimits[0] - \
+                new_low_limits_q[2]
+
+        # CREATING QUERIED XYZ POINTS
+        x_q = np.arange(size_q[0])
+        y_q = np.arange(size_q[1])
+        z_q = np.arange(size_q[2])
+        x_q, y_q, z_q = np.meshgrid(x_q, y_q, z_q, indexing='ij')
+        x_q, y_q, z_q = intrinsicToWorld(
+            R=spatial_ref_q, xIntrinsic=x_q, yIntrinsic=y_q, zIntrinsic=z_q)
+
+        # CONVERTING QUERIED XZY POINTS TO INTRINSIC COORDINATES IN THE SAMPLED
+        # REFERENCE FRAME
+        x_q, y_q, z_q = worldToIntrinsic(
+            R=spatial_ref_s, xWorld=x_q, yWorld=y_q, zWorld=z_q)
+
+        # INTERPOLATING VOLUME
+        data = interp3(v=vol_obj_s.data, x_q=x_q, y_q=y_q, z_q=z_q, method=interp_met)
+        vol_obj_q = image_volume_obj(data=data, spatial_ref=spatial_ref_q)
+
+        # ROUNDING
+        if image_type == "image":
+            # Grey level rounding for "image" type
+            if round_val is not None and (type(round_val) is int or type(round_val) is float):
+                # DELETE NEXT LINE WHEN THE RADIOMICS PARAMETER OPTIONS OF
+                # interp.glRound ARE FIXED
+                round_val = (-np.log10(round_val)).astype(int)
+                vol_obj_q.data = np.around(vol_obj_q.data, decimals=round_val)
+        else:
+            vol_obj_q.data[vol_obj_q.data >= round_val] = 1.0
+            vol_obj_q.data[vol_obj_q.data < round_val] = 0.0
+
+    except Exception as e:
+        if medscan:
+            if medscan.params.radiomics.scale_name:
+                message = f"\n PROBLEM WITH INTERPOLATION:\n {e}"
+                logging.error(message)
+                medscan.radiomics.image.update(
+                    {(medscan.params.radiomics.scale_name ): 'ERROR_PROCESSING'})
+            else:
+                message = f"\n PROBLEM WITH INTERPOLATION:\n {e}"
+                logging.error(message)
+                medscan.radiomics.image.update(
+                    {('scale'+(str(medscan.params.process.scale_non_text[0])).replace('.','dot')): 'ERROR_PROCESSING'})
+        else:
+            print(f"\n PROBLEM WITH INTERPOLATION:\n {e}")
+
+    return vol_obj_q

MEDiml/processing/resegmentation.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+
+from copy import deepcopy
+import numpy as np
+from numpy import ndarray
+
+
+def range_re_seg(vol: np.ndarray,
+                 roi: np.ndarray,
+                 im_range=None) -> ndarray:
+    """Removes voxels from the intensity mask that fall outside
+    the given range (intensities outside the range are set to 0).
+
+    Args:
+        vol (ndarray): Imaging data.
+        roi (ndarray): ROI mask with values of 0's and 1's.
+        im_range (ndarray): 1-D array with shape (1,2) of the re-segmentation intensity range.
+
+    Returns:
+        ndarray: Intensity mask with intensities within the re-segmentation range.
+    """
+
+    if im_range is not None and len(im_range) == 2:
+        roi = deepcopy(roi)
+        roi[vol < im_range[0]] = 0
+        roi[vol > im_range[1]] = 0
+
+    return roi
+
+def outlier_re_seg(vol: np.ndarray,
+                   roi: np.ndarray,
+                   outliers="") -> np.ndarray:
+    """Removes voxels with outlier intensities from the given mask
+    using the Collewet method.
+
+    Args:
+        vol (ndarray): Imaging data.
+        roi (ndarray): ROI mask with values of 0 and 1.
+        outliers (str, optional): Algo used to define outliers.
+                                  (For now this methods only implements "Collewet" method).
+
+    Returns:
+        ndarray: An array with values of 0 and 1.
+
+    Raises:
+        ValueError: If `outliers` is not "Collewet" or None.
+
+    Todo:
+        * Delete outliers argument or implements others outlining methods.
+    """
+
+    if outliers != '':
+        roi = deepcopy(roi)
+
+        if outliers == "Collewet":
+            u = np.mean(vol[roi == 1])
+            sigma = np.std(vol[roi == 1])
+
+            roi[vol > (u + 3*sigma)] = 0
+            roi[vol < (u - 3*sigma)] = 0
+        else:
+            raise ValueError("Outlier segmentation not defined.")
+
+    return roi