dbdicom 0.2.6__py3-none-any.whl → 0.3.0__py3-none-any.whl

dbdicom/ds/types/parametric_map.py

@@ -1,226 +0,0 @@
-"""Remnant code from old version - saved here for now"""
-
-from pydicom.dataset import Dataset
-import numpy as np
-import datetime
-
-
-  
-class ParametricMap(object):
-    def selectParametricMap(self, dicom, imageArray, argument):
-        methodName = argument
-        method = getattr(self, methodName, lambda: "No valid Parametric Map chosen")
-        return method(dicom, imageArray)
-
-    def RGB(self, dicom, imageArray):
-        dicom.PhotometricInterpretation = 'RGB'
-        dicom.SamplesPerPixel = 3
-        dicom.BitsAllocated = 8
-        dicom.BitsStored = 8
-        dicom.HighBit = 7
-        dicom.add_new(0x00280006, 'US', 0) # Planar Configuration
-        dicom.RescaleSlope = 1
-        dicom.RescaleIntercept = 0
-        pixelArray = imageArray.astype(np.uint8) # Should we multiply by 255?
-        dicom.WindowCenter = int((np.amax(imageArray) - np.amin(imageArray)) / 2)
-        dicom.WindowWidth = np.absolute(int(np.amax(imageArray) - np.amin(imageArray)))
-        dicom.PixelData = pixelArray.tobytes()
-        return
-
-    def ADC(self, dicom, imageArray):
-        # The commented parts are to apply when we decide to include Parametric Map IOD. No readers can deal with this yet
-        # dicom.SOPClassUID = '1.2.840.10008.5.1.4.1.1.67'
-        dicom.SeriesDescription = "Apparent Diffusion Coefficient (um2/s)"
-        dicom.Modality = "RWV"
-        dicom.FrameLaterality = "U"
-        dicom.DerivedPixelContrast = "ADC"
-        dicom.BitsAllocated = 32
-        dicom.PixelRepresentation = 1
-        dicom.PhotometricInterpretation = "MONOCHROME2"
-        dicom.PixelAspectRatio = ["1", "1"] # Need to have a better look at this
-        dicom.RescaleSlope = 1
-        dicom.RescaleIntercept = 0
-        # Rotate the image back to the original orientation
-        imageArray = np.transpose(imageArray)
-        dicom.Rows = np.shape(imageArray)[-2]
-        dicom.Columns = np.shape(imageArray)[-1]
-        dicom.WindowCenter = int((np.amax(imageArray) - np.amin(imageArray)) / 2)
-        dicom.WindowWidth = np.absolute(int(np.amax(imageArray) - np.amin(imageArray)))
-        dicom.FloatPixelData = bytes(imageArray.astype(np.float32).flatten())
-        del dicom.PixelData, dicom.BitsStored, dicom.HighBit
-
-        dicom.RealWorldValueMappingSequence = [Dataset(), Dataset(), Dataset(), Dataset()]
-        dicom.RealWorldValueMappingSequence[0].QuantityDefinitionSequence = [Dataset(), Dataset()]
-        dicom.RealWorldValueMappingSequence[0].QuantityDefinitionSequence[0].ValueType = "CODE"
-        dicom.RealWorldValueMappingSequence[0].QuantityDefinitionSequence[1].ConceptCodeSequence = [Dataset(), Dataset(), Dataset()]
-        dicom.RealWorldValueMappingSequence[0].QuantityDefinitionSequence[1].ConceptCodeSequence[0].CodeValue = "113041"
-        dicom.RealWorldValueMappingSequence[0].QuantityDefinitionSequence[1].ConceptCodeSequence[1].CodingSchemeDesignator = "DCM"
-        dicom.RealWorldValueMappingSequence[0].QuantityDefinitionSequence[1].ConceptCodeSequence[2].CodeMeaning = "Apparent Diffusion Coefficient"
-        dicom.RealWorldValueMappingSequence[1].MeasurementUnitsCodeSequence = [Dataset(), Dataset(), Dataset()]
-        dicom.RealWorldValueMappingSequence[1].MeasurementUnitsCodeSequence[0].CodeValue = "um2/s"
-        dicom.RealWorldValueMappingSequence[1].MeasurementUnitsCodeSequence[1].CodingSchemeDesignator = "UCUM"
-        dicom.RealWorldValueMappingSequence[1].MeasurementUnitsCodeSequence[2].CodeMeaning = "um2/s"
-        dicom.RealWorldValueMappingSequence[2].RealWorldValueSlope = 1
-        
-        anatomyString = dicom.BodyPartExamined
-        saveAnatomicalInfo(anatomyString, dicom.RealWorldValueMappingSequence[3])
-
-        return
-
-    def T2Star(self, dicom, imageArray):
-        dicom.PixelSpacing = [3, 3] # find a mechanism to pass reconstruct pixel here
-        return
-
-    def SEG(self, dicom, imageArray):
-        #dicom.SOPClassUID = '1.2.840.10008.5.1.4.1.1.66.4' # WILL NOT BE USED HERE - This is for PACS. There will be another one for DICOM Standard
-        # The commented parts are to apply when we decide to include SEG IOD. No readers can deal with this yet
-        dicom.BitsAllocated = 8 # According to Federov DICOM Standard this should be 1-bit
-        dicom.BitsStored = 8
-        dicom.HighBit = 7
-        #dicom.SmallestImagePixelValue = 0
-        #dicom.LargestImagePixelValue = int(np.amax(imageArray)) # max 255
-        dicom.add_new('0x00280106', 'US', 0) # Minimum
-        dicom.add_new('0x00280107', 'US', int(np.amax(imageArray))) # Maximum
-        dicom.PixelRepresentation = 0
-        dicom.SamplesPerPixel = 1
-        #dicom.WindowCenter = 0.5
-        #dicom.WindowWidth = 1.1
-        dicom.add_new('0x00281050', 'DS', 0.5) # WindowCenter
-        dicom.add_new('0x00281051', 'DS', 1.1) # WindowWidth
-        #dicom.RescaleIntercept = 0
-        #dicom.RescaleSlope = 1
-        dicom.add_new('0x00281052', 'DS', 0) # RescaleIntercept
-        dicom.add_new('0x00281053', 'DS', 1) # RescaleSlope
-        dicom.LossyImageCompression = '00'
-        pixelArray = np.transpose(imageArray.astype(np.uint8)) # Should we multiply by 255?
-        dicom.PixelData = pixelArray.tobytes()
-
-        dicom.Modality = 'SEG'
-        dicom.SegmentationType = 'FRACTIONAL'
-        dicom.MaximumFractionalValue = int(np.amax(imageArray)) # max 255
-        dicom.SegmentationFractionalType = 'OCCUPANCY'
-
-        # Segment Labels
-        if hasattr(dicom, "ImageComments"):
-            dicom.ContentDescription = dicom.ImageComments.split('_')[-1] # 'Image segmentation'
-            segment_numbers = np.unique(pixelArray)
-            segment_dictionary = dict(list(enumerate(segment_numbers)))
-            segment_label = dicom.ImageComments.split('_')[-1]
-            segment_dictionary[0] = 'Background'
-            segment_dictionary[1] = segment_label
-            for key in segment_dictionary:
-                dicom.SegmentSequence = [Dataset(), Dataset(), Dataset(), Dataset(), Dataset(), Dataset()]
-                dicom.SegmentSequence[0].SegmentAlgorithmType = 'MANUAL'
-                dicom.SegmentSequence[1].SegmentNumber = key
-                dicom.SegmentSequence[2].SegmentDescription = str(segment_dictionary[key])
-                dicom.SegmentSequence[3].SegmentLabel = str(segment_dictionary[key])
-                dicom.SegmentSequence[4].SegmentAlgorithmName = "Weasel"
-                if hasattr(dicom, "BodyPartExamined"):
-                    anatomyString = dicom.BodyPartExamined
-                    saveAnatomicalInfo(anatomyString, dicom.SegmentSequence[5])
-        else:
-            dicom.ContentDescription = "Mask with no label"
-
-        return
-
-    def Registration(self, dicom, imageArray):
-        dicom.Modality = "REG"
-        return
-
-    def Signal(self, dicom, imageArray):
-        dicom.Modality = "RWV"
-        dicom.DerivedPixelContrast = "GraphPlot"
-        dicom.PhotometricInterpretation = "MONOCHROME2"
-        dicom.RescaleSlope = 1
-        dicom.RescaleIntercept = 0
-        imageArray = np.transpose(imageArray.astype(np.float32))
-        center = (np.amax(imageArray) + np.amin(imageArray)) / 2
-        width = np.amax(imageArray) - np.amin(imageArray)
-        dicom.add_new('0x00281050', 'DS', center)
-        dicom.add_new('0x00281051', 'DS', width)
-        dicom.BitsAllocated = 32
-        dicom.Rows = np.shape(imageArray)[0]
-        dicom.Columns = np.shape(imageArray)[1]
-        dicom.FloatPixelData = bytes(imageArray.flatten())
-        del dicom.PixelData, dicom.BitsStored, dicom.HighBit
-        return
-
-# Could insert a method regarding ROI colours, like in ITK-SNAP???
-def saveAnatomicalInfo(anatomyString, dicom):
-    try:
-        # FOR NOW, THE PRIORITY WILL BE ON KIDNEY
-        if "KIDNEY" or "ABDOMEN" in anatomyString.upper():
-            dicom.AnatomicRegionSequence = [Dataset(), Dataset(), Dataset()]
-            dicom.AnatomicRegionSequence[0].CodeValue = "T-71000"
-            dicom.AnatomicRegionSequence[1].CodingSchemeDesignator = "SRT"
-            dicom.AnatomicRegionSequence[2].CodeMeaning = "Kidney"
-        elif "LIVER" in anatomyString.upper():
-            dicom.AnatomicRegionSequence = [Dataset(), Dataset(), Dataset()]
-            dicom.AnatomicRegionSequence[0].CodeValue = "T-62000"
-            dicom.AnatomicRegionSequence[1].CodingSchemeDesignator = "SRT"
-            dicom.AnatomicRegionSequence[2].CodeMeaning = "Liver"
-        elif "PROSTATE" in anatomyString.upper():
-            dicom.AnatomicRegionSequence = [Dataset(), Dataset(), Dataset()]
-            dicom.AnatomicRegionSequence[0].CodeValue = "T-9200B"
-            dicom.AnatomicRegionSequence[1].CodingSchemeDesignator = "SRT"
-            dicom.AnatomicRegionSequence[2].CodeMeaning = "Prostate"      
-        elif "BODY" in anatomyString.upper():
-            dicom.AnatomicRegionSequence = [Dataset(), Dataset(), Dataset()]
-            dicom.AnatomicRegionSequence[0].CodeValue = "P5-0905E"
-            dicom.AnatomicRegionSequence[1].CodingSchemeDesignator = "LN"
-            dicom.AnatomicRegionSequence[2].CodeMeaning = "MRI whole body"
-    except:
-        pass
-    return
-
-def editDicom(newDicom, imageArray, parametricMap):
-
-    callCase = ParametricMap()
-    callCase.selectParametricMap(newDicom, imageArray, parametricMap)
-
-    dt = datetime.datetime.now()
-    timeStr = dt.strftime('%H%M%S')  # long format with micro seconds
-    newDicom.PerformedProcedureStepStartDate = dt.strftime('%Y%m%d')
-    newDicom.PerformedProcedureStepStartTime = timeStr
-    newDicom.PerformedProcedureStepDescription = "Post-processing application"
-
-    return newDicom
-
-    # Series, Instance and Class for Reference
-    #newDicom.ReferencedSeriesSequence = [Dataset(), Dataset()]
-    #newDicom.ReferencedSeriesSequence[0].SeriesInstanceUID = dicom_data.SeriesInstanceUID
-    #newDicom.ReferencedSeriesSequence[1].ReferencedInstanceSequence = [Dataset(), Dataset()]
-    #newDicom.ReferencedSeriesSequence[1].ReferencedInstanceSequence[0].ReferencedSOPClassUID = dicom_data.SOPClassUID
-    #newDicom.ReferencedSeriesSequence[1].ReferencedInstanceSequence[1].ReferencedSOPInstanceUID = dicom_data.SOPInstanceUID
-
-# rwv_sequence = Sequence()
-        # dicom.RealWorldValueMappingSequence = rwv_sequence
-        # rwv_slope = Dataset()
-        # rwv_slope.RealWorldValueSlope = 1
-        # rwv_sequence.append(rwv_slope)
-
-        # quantity_def = Dataset()
-        # quantity_def_sequence = Sequence()
-        # quantity_def.QuantityDefinitionSequence = quantity_def_sequence
-        # value_type = Dataset()
-        # value_type.ValueType = "CODE"
-        # quantity_def_sequence.append(value_type)
-        # concept_code = Dataset()
-        # concept_code_sequence = Sequence()
-        # concept_code.ConceptCodeSequence = concept_code_sequence
-        # code_code = Dataset()
-        # code_code.CodeValue = "113041"
-        # code_code.CodingSchemeDesignator = "DCM"
-        # code_code.CodeMeaning = "Apparent Diffusion Coefficient"
-        # concept_code_sequence.append(code_code)
-        # rwv_sequence.append(quantity_def)
-
-        # measure_units = Dataset()
-        # measure_units_sequence = Sequence()
-        # measure_units.MeasurementUnitsCodeSequence = measure_units_sequence
-        # measure_code = Dataset()
-        # measure_code.CodeValue = "um2/s"
-        # measure_code.CodingSchemeDesignator = "UCUM"
-        # measure_code.CodeMeaning = "um2/s"
-        # measure_units_sequence.append(measure_code)
-        # rwv_sequence.append(measure_units)

dbdicom/extensions/__init__.py

@@ -1,9 +0,0 @@
-from . import (
-    dipy,
-    elastix,
-    numpy,
-    scipy, 
-    skimage,
-    sklearn,
-    matplotlib,
-)

dbdicom/extensions/dipy.py

@@ -1,448 +0,0 @@
-import numpy as np
-from dipy.align.imwarp import SymmetricDiffeomorphicRegistration
-from dipy.align.metrics import CCMetric, EMMetric, SSDMetric
-from dipy.align.imaffine import MutualInformationMetric, AffineRegistration, transform_centers_of_mass
-from dipy.align.transforms import (
-    TranslationTransform2D, RigidTransform2D, AffineTransform2D,
-    TranslationTransform3D, RigidTransform3D, AffineTransform3D)
-from dipy.align import center_of_mass
-from dipy.align.vector_fields import (
-    warp_3d_nn, 
-    warp_3d, 
-    warp_2d_nn,
-    warp_2d, 
-    invert_vector_field_fixed_point_3d, 
-    invert_vector_field_fixed_point_2d,
-)
-
-from dipy.segment.mask import median_otsu as median_otsu_np
-import dbdicom.extensions.vreg as vreg
-
-
-def median_otsu(series, **kwargs):
-
-    # Get arrays for fixed and moving series
-    array, headers = series.array('SliceLocation', pixels_first=True)
-
-    # Apply Otsu
-    mask = np.empty(array.shape)
-    cnt=0
-    for z in range(array.shape[2]):
-        for k in range(array.shape[3]):
-            cnt+=1
-            series.status.progress(cnt, array.shape[2]*array.shape[3], 'Applying Otsu segmentation..')
-            image = np.squeeze(array[:,:,z,k])
-            array[:,:,z,k], mask[:,:,z,k] = median_otsu_np(image, **kwargs)
-
-    # Create new series
-    masked_series = series.new_sibling(suffix='masked')
-    otsu_mask = series.new_sibling(suffix ='otsu mask')
-
-    # Set values and return
-    masked_series.set_array(array, headers, pixels_first=True)
-    otsu_mask.set_array(mask, headers, pixels_first=True)
-    return masked_series, otsu_mask
-
-
-def align_center_of_mass_3d(moving, fixed):
-
-    # Get arrays for fixed and moving series
-    array_moving, headers_moving = moving.array(sortby='SliceLocation', pixels_first=True, first_volume=True)
-    array_fixed = vreg.array(fixed, on=moving, sortby='SliceLocation', pixels_first=True, first_volume=True)
-
-    # Coregister fixed and moving slice-by-slice
-    identity = np.eye(4)
-    array_moving, _ = center_of_mass(array_moving, array_fixed, static_affine=identity, moving_affine=identity)
-
-    # Create new series
-    moved = moving.new_sibling(suffix='aligned')
-    moved.set_array(array_moving, headers_moving, pixels_first=True)
-
-    return moved
-
-
-def coregister_translation_3d(moving, fixed):
-
-    # Get arrays for fixed and moving series
-    array_moving, headers_moving = moving.array(sortby='SliceLocation', pixels_first=True, first_volume=True)
-    array_fixed = vreg.array(fixed, on=moving, sortby='SliceLocation', pixels_first=True, first_volume=True)
-
-    # Set up coregistration
-    metric = MutualInformationMetric(nbins=32, sampling_proportion=None,)
-    affreg = AffineRegistration(
-        metric = metric,
-        level_iters = [10000, 1000, 100],
-        sigmas = [3.0, 1.0, 0.0],
-        factors = [4, 2, 1],
-    )
-    transform = TranslationTransform3D()
-    params0 = None
-
-    # Perform coregistration
-    moving.message('Performing coregistration..')
-    mapping = affreg.optimize(array_fixed, array_moving, transform, params0)
-    coregistered = mapping.transform(array_moving, 'linear')
-
-    # Save as DICOM
-    coreg = moving.new_sibling(suffix='translated')
-    coreg.set_array(coregistered, headers_moving, pixels_first=True)
-
-    return coreg
-
-
-def coregister_rigid_3d(moving, fixed):
-
-    # Get arrays for fixed and moving series
-    array_moving, headers_moving = moving.array(sortby='SliceLocation', pixels_first=True, first_volume=True)
-    array_fixed = vreg.array(fixed, on=moving, sortby='SliceLocation', pixels_first=True, first_volume=True)
-
-    # Setup coregistration
-    metric = MutualInformationMetric(nbins=32, sampling_proportion=None)
-    affreg = AffineRegistration(
-        metric = metric,
-        level_iters = [10000, 1000, 100],
-        sigmas = [3.0, 1.0, 0.0],
-        factors = [4, 2, 1],
-    )
-    transform = RigidTransform3D()
-    params0 = None
-
-    # Perform coregistration
-    moving.message('Performing coregistration..')
-    mapping = affreg.optimize(array_fixed, array_moving, transform, params0)
-    coregistered = mapping.transform(array_moving, 'linear')
-
-    # Save as DICOM
-    coreg = moving.new_sibling(suffix='rigid transform')
-    coreg.set_array(coregistered, headers_moving, pixels_first=True)
-    return coreg
-
-
-
-def coregister_affine_3d(moving, fixed):
-
-    # Get arrays for fixed and moving series
-    array_moving, headers_moving = moving.array(sortby='SliceLocation', pixels_first=True, first_volume=True)
-    array_fixed = vreg.array(fixed, on=moving, sortby='SliceLocation', pixels_first=True, first_volume=True)
-
-    # Setup coregistration
-    metric = MutualInformationMetric(nbins=32, sampling_proportion=None)
-    affreg = AffineRegistration(
-        metric = metric,
-        level_iters = [10000, 1000, 100],
-        sigmas = [3.0, 1.0, 0.0],
-        factors = [4, 2, 1],
-    )
-    transform = AffineTransform3D()
-    params0 = None
-
-    # Perform coregistration
-    moving.message('Performing coregistration..')
-    mapping = affreg.optimize(array_fixed, array_moving, transform, params0)
-    coregistered = mapping.transform(array_moving, 'linear')
-
-    # Save as DICOM
-    coreg = moving.new_sibling(suffix='rigid transform')
-    coreg.set_array(coregistered, headers_moving, pixels_first=True)
-    return coreg
-
-
-def coregister_deformable_3d(moving, fixed, **kwargs):
-
-    # Get arrays for fixed and moving series
-    array_moving, headers_moving = moving.array(sortby='SliceLocation', pixels_first=True, first_volume=True)
-    array_fixed = vreg.array(fixed, on=moving, sortby='SliceLocation', pixels_first=True, first_volume=True)
-
-    # Perform coregistration
-    moving.status.message('Performing coregistration..')
-    array_moving, deformation = _coregister_arrays(array_fixed, array_moving, **kwargs)
-
-    # Create new series
-    coreg = moving.new_sibling(suffix='registered')
-    deform = moving.new_sibling(suffix='deformation field')
-
-    # Set arrays
-    coreg.set_array(array_moving, headers_moving, pixels_first=True)
-    for dim in range(deformation.shape[-1]):
-        deform.set_array(deformation[...,dim], headers_moving, pixels_first=True)
-
-    # Return coregistered images and deformation field
-    return coreg, deform
-
-
-def align_center_of_mass_2d(moving, fixed):
-
-    # Get arrays for fixed and moving series
-    zaxis = 'SliceLocation'
-    array_moving = moving.pixel_values(zaxis)
-    array_fixed = vreg.pixel_values(fixed, zaxis, on=moving)
-
-    # Coregister fixed and moving slice-by-slice
-    id = np.eye(3)
-    for z in range(array_moving.shape[2]):
-        moving.progress(z+1, array_moving.shape[2], 'Performing coregistration..')
-        c_of_mass = transform_centers_of_mass(array_fixed[:,:,z], id, array_moving[:,:,z], id)
-        array_moving[:,:,z] = c_of_mass.transform(array_moving[:,:,z])
-
-    # Save as DICOM (new API)
-    coreg = moving.copy(SeriesDescription=moving.SeriesDescription + ' [coreg]')
-    coreg.set_pixel_values(array_moving, coords=moving.coords(zaxis))
-    return coreg
-
-
-
-def coregister_translation_2d(moving, fixed):
-
-    # # Get arrays for fixed and moving series (old API)
-    # array_moving, headers_moving = moving.array(sortby='SliceLocation', pixels_first=True, first_volume=True)
-    # array_fixed = vreg.array(fixed, on=moving, sortby='SliceLocation', pixels_first=True, first_volume=True)
-
-    # Get arrays for fixed and moving series (new API)
-    #zaxis = ('SliceLocation',)
-    zaxis = 'SliceLocation'
-    array_moving = moving.pixel_values(zaxis)
-    array_fixed = vreg.pixel_values(fixed, zaxis, on=moving)
-
-    # Set up coregistration
-    metric = MutualInformationMetric(nbins=32, sampling_proportion=None)
-    affreg = AffineRegistration(
-        metric = metric,
-        level_iters = [10000, 1000, 100],
-        sigmas = [3.0, 1.0, 0.0],
-        factors = [4, 2, 1],
-    )
-    transform = TranslationTransform2D()
-
-    # Coregister fixed and moving slice-by-slice
-    for z in range(array_moving.shape[2]):
-        moving.progress(z+1, array_moving.shape[2], 'Performing coregistration..')
-        # Coregister slice
-        params0 = None
-        mapping = affreg.optimize(array_fixed[:,:,z], array_moving[:,:,z], transform, params0)
-        array_moving[:,:,z] = mapping.transform(array_moving[:,:,z], 'linear')
-
-    # # Save as DICOM (old API)
-    # coreg = moving.new_sibling(suffix= 'registered')
-    # coreg.set_array(array_moving, headers_moving, pixels_first=True)
-
-    # Save as DICOM (new API)
-    coreg = moving.copy(SeriesDescription=moving.SeriesDescription + ' [coreg]')
-    coreg.set_pixel_values(array_moving, coords=moving.coords(zaxis))
-    return coreg
-
-
-def coregister_rigid_2d(moving, fixed):
-
-    # Get arrays for fixed and moving series
-    array_moving, headers_moving = moving.array(sortby='SliceLocation', pixels_first=True, first_volume=True)
-    array_fixed = vreg.array(fixed, on=moving, sortby='SliceLocation', pixels_first=True, first_volume=True)
-
-    # Set up coregistration
-    metric = MutualInformationMetric(nbins=32, sampling_proportion=None)
-    affreg = AffineRegistration(
-        metric = metric,
-        level_iters = [10000, 1000, 100],
-        sigmas = [3.0, 1.0, 0.0],
-        factors = [4, 2, 1],
-    )
-    transform = RigidTransform2D()
-
-    # Coregister fixed and moving slice-by-slice
-    for z in range(array_moving.shape[2]):
-        moving.status.progress(z+1, array_moving.shape[2], 'Performing coregistration..')
-        # Coregister slice
-        params0 = None
-        mapping = affreg.optimize(array_fixed[:,:,z], array_moving[:,:,z], transform, params0)
-        array_moving[:,:,z] = mapping.transform(array_moving[:,:,z], 'linear')
-
-    # Save as DICOM
-    coreg = moving.new_sibling(suffix= 'registered')
-    coreg.set_array(array_moving, headers_moving, pixels_first=True)
-    return coreg
-
-
-def coregister_affine_2d(moving, fixed):
-
-    # Get arrays for fixed and moving series
-    array_moving, headers_moving = moving.array(sortby='SliceLocation', pixels_first=True, first_volume=True)
-    array_fixed = vreg.array(fixed, on=moving, sortby='SliceLocation', pixels_first=True, first_volume=True)
-
-    # Set up coregistration
-    metric = MutualInformationMetric(nbins=32, sampling_proportion=None)
-    affreg = AffineRegistration(
-        metric = metric,
-        level_iters = [10000, 1000, 100],
-        sigmas = [3.0, 1.0, 0.0],
-        factors = [4, 2, 1],
-    )
-    transform = AffineTransform2D()
-
-    # Coregister fixed and moving slice-by-slice
-    for z in range(array_moving.shape[2]):
-        moving.status.progress(z+1, array_moving.shape[2], 'Performing coregistration..')
-        # Coregister slice
-        params0 = None
-        mapping = affreg.optimize(array_fixed[:,:,z], array_moving[:,:,z], transform, params0)
-        array_moving[:,:,z] =mapping.transform(array_moving[:,:,z], 'linear')
-
-    # Save as DICOM
-    coreg = moving.new_sibling(suffix= 'registered')
-    coreg.set_array(array_moving, headers_moving, pixels_first=True)
-    return coreg
-
-
-
-def coregister_deformable_2d(moving, fixed, **kwargs):
-
-    # Get arrays for fixed and moving series
-    array_moving, headers_moving = moving.array(sortby='SliceLocation', pixels_first=True, first_volume=True)
-    array_fixed = vreg.array(fixed, on=moving, sortby='SliceLocation', pixels_first=True, first_volume=True)
-
-    # Coregister fixed and moving slice-by-slice
-    deformation = np.empty(array_moving.shape + (2,))
-    for z in range(array_moving.shape[2]):
-        moving.status.progress(z+1, array_moving.shape[2], 'Performing coregistration..')
-        coreg, deform = _coregister_arrays(array_fixed[:,:,z], array_moving[:,:,z], **kwargs)
-        array_moving[:,:,z] = coreg
-        deformation[:,:,z,:] = deform
-
-    # Create new series
-    coreg = moving.new_sibling(suffix= 'registered')
-    deform = moving.new_sibling(suffix='deformation field')
-
-    # Set values & return
-    coreg.set_array(array_moving, headers_moving, pixels_first=True)
-    for dim in range(deformation.shape[-1]):
-        deform.set_array(deformation[...,dim], headers_moving, pixels_first=True)
-    return coreg, deform
-
-
-
-
-
-
-def invert_deformation_field(deformation_field, **kwargs):
-
-    # Get array
-    array, headers = deformation_field.array('SliceLocation', pixels_first=True)
-
-    # Invert
-    array = _invert_deformation_field_array(array, deformation_field.status, **kwargs)
-
-    # Create new series
-    inv = deformation_field.new_sibling(suffix='inverse')
-    inv.set_array(array, headers, pixels_first=True)
-
-    return inv
-
-
-def warp(image, deformation_field, **kwargs):
-
-    # Get arrays
-    array, headers = image.array('SliceLocation', pixels_first=True, first_volume=True)
-    array_deform = vreg.array(deformation_field, on=image, sortby='SliceLocation', pixels_first=True)
-
-    # Perform warping
-    array = _warp_array(array, array_deform, image.status, **kwargs)
-
-    # Create new series
-    warped = image.new_sibling(suffix='warped')
-    warped.set_array(array, headers, pixels_first=True)
-
-    return warped
-
-
-
-### ARRAY functions
-
-
-
-
-def _invert_deformation_field_array(array, status, max_iter=10, tolerance=0.1):
-    status.message('Inverting deformation field..')
-    dim = array.shape[-1]
-    d_world2grid = np.eye(dim+1)
-    spacing = np.ones(dim)
-    if dim==3:
-        return invert_vector_field_fixed_point_3d(array, d_world2grid, spacing, max_iter, tolerance)
-    elif dim==2:
-        nslices = array.shape[2]
-        for z in range(nslices):
-            status.progress(z+1, nslices, 'Inverting deformation field..')
-            array[:,:,z] = invert_vector_field_fixed_point_2d(array[:,:,z], d_world2grid, spacing, max_iter, tolerance)
-        return array
-    else:
-        msg = 'This series is not a deformation field.'
-        msg += 'A deformation field must have either 2 or 3 components.'
-        raise ValueError(msg)
-
-
-def _warp_array(array, deform, status, interpolate=True):
-    status.message('Warping array..')
-    dim = deform.shape[-1]
-    if dim==3:
-        if interpolate:
-            return warp_3d(array, deform)
-        else:
-            return warp_3d_nn(array, deform)
-    elif dim==2:
-        nslices = deform.shape[2]
-        for z in range(nslices):
-            status.progress(z+1, nslices, 'Warping array..')
-            if interpolate:
-                array[:,:,z] = warp_2d(array[:,:,z], deform[:,:,z,:])
-            else:
-                array[:,:,z] = warp_2d_nn(array[:,:,z], deform[:,:,z,:])
-        return array
-    else:
-        msg = 'This series is not a deformation field.'
-        msg += 'A deformation field must have either 2 or 3 components.'
-        raise ValueError(msg)
-
-      
-def _coregister_arrays(fixed, moving, transformation='Symmetric Diffeomorphic', metric="Cross-Correlation"):
-    """
-    Coregister two arrays and return coregistered + deformation field 
-    """
-
-    dim = fixed.ndim
-
-    # 3D registration does not seem to work with smaller slabs
-    # Exclude this case
-    if dim == 3:
-        if fixed.shape[-1] < 6:
-            msg = 'The 3D volume does not have enough slices for 3D registration. \n'
-            msg += 'Try 2D registration instead.'
-            raise ValueError(msg)
-        
-    # Define the metric
-    if metric == "Cross-Correlation":
-        sigma_diff = 3.0    # Gaussian Kernel
-        radius = 4          # Window for local CC
-        metric = CCMetric(dim, sigma_diff, radius)
-    elif metric == 'Expectation-Maximization':
-        metric = EMMetric(dim, smooth=1.0)
-    elif metric == 'Sum of Squared Differences':
-        metric = SSDMetric(dim, smooth=4.0)
-    else:
-        msg = 'The metric ' + metric + ' is currently not implemented.'
-        raise ValueError(msg) 
-
-    # Define the deformation model
-    if transformation == 'Symmetric Diffeomorphic':
-        level_iters = [200, 100, 50, 25]
-        sdr = SymmetricDiffeomorphicRegistration(metric, level_iters, inv_iter=50)
-    else:
-        msg = 'The transform ' + transformation + ' is currently not implemented.'
-        raise ValueError(msg) 
-
-    # Perform the optimization, return a DiffeomorphicMap object
-    mapping = sdr.optimize(fixed, moving)
-
-    # Get forward deformation field
-    deformation_field = mapping.get_forward_field()
-
-    # Warp the moving image
-    warped_moving = mapping.transform(moving, 'linear')
-
-    return warped_moving, deformation_field