dbdicom 0.2.0__py3-none-any.whl → 0.3.16__py3-none-any.whl

dbdicom/wrappers/sklearn.py

@@ -1,151 +0,0 @@
-import numpy as np
-from sklearn.cluster import KMeans
-import dbdicom.wrappers.scipy as scipy
-
-
-# https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html#sklearn.cluster.KMeans
-def kmeans(features, mask=None, n_clusters=2, multiple_series=False):
-    """
-    Labels structures in an image
-    
-    Wrapper for sklearn.cluster.KMeans function. 
-
-    Parameters
-    ----------
-    input: list of dbdicom series (one for each feature)
-    mask: optional mask for clustering
-    
-    Returns
-    -------
-    clusters : list of dbdicom series, with labels per cluster.
-    """
-
-    # If a mask is provided, map it onto the reference feature and 
-    # extract the indices of all pixels under the mask
-    if mask is not None:
-        mask.status.message('Reading mask array..')
-        mask = scipy.map_to(mask, features[0], mask=True)
-        mask_array, _ = mask.array(['SliceLocation', 'AcquisitionTime'], pixels_first=True)
-        mask_array = np.ravel(mask_array)
-        mask_indices = tuple(mask_array.nonzero())
-
-    # Ensure all the features are in the same geometry as the reference feature
-    features = scipy.overlay(features)
-
-    # Create array with shape (n_samples, n_features) and mask if needed.
-    array = []
-    for s, series in enumerate(features):
-        series.status.progress(s+1, len(features), 'Reading features..')
-        arr, headers = series.array(['SliceLocation', 'AcquisitionTime'], pixels_first=True)
-        shape = arr.shape 
-        arr = np.ravel(arr)
-        if mask is not None:
-            arr = arr[mask_indices]
-        array.append(arr)
-    array = np.vstack(array).T
-
-    # Perform the K-Means clustering.
-    series.status.message('Clustering. Please be patient - this is hard work..')
-    kmeans = KMeans(n_clusters=n_clusters, random_state=0, n_init=3, verbose=1).fit(array)
-    
-    # Create an output array for the labels
-    if mask is not None:
-        mask.status.message('Creating output array..')
-        array = np.zeros(shape)
-        array = np.ravel(array)
-        array[mask_indices] = 1+kmeans.labels_ 
-    else:
-        array = 1+kmeans.labels_
-    array = array.reshape(shape)
-
-    # Save the results
-    series.status.message('Saving clusters..')
-    if multiple_series:
-        # Save each cluster as a separate mask
-        clusters = []
-        for cluster in range(1,1+n_clusters):
-            array_cluster = np.zeros(array.shape)
-            array_cluster[array == cluster] = 1
-            series_cluster = features[0].new_sibling(SeriesDescription = 'KMeans cluster ' + str(cluster))
-            series_cluster.set_array(array_cluster, headers, pixels_first=True)
-            _reset_window(series_cluster, array_cluster)
-            clusters.append(series_cluster)
-    else:
-        # Save the label array in a single series
-        clusters = features[0].new_sibling(SeriesDescription = 'KMeans')
-        clusters.set_array(array, headers, pixels_first=True)
-        _reset_window(clusters, array)
-
-    return clusters
-
-
-
-def sequential_kmeans(features, mask=None, n_clusters=2, multiple_series=False):
-    """
-    Labels structures in an image using sequential k-means clustering
-    
-    Sequential here means that the clustering is always performed on a single feature
-    using the output of the previous iteration as a mask for the next.
-
-    Parameters
-    ----------
-    input: list of dbdicom series (one for each feature)
-    mask: optional mask for clustering
-    
-    Returns
-    -------
-    clusters : list of dbdicom series, with labels per cluster.
-    """
-
-    f = features[0]
-    clusters = kmeans([f], mask=mask, n_clusters=n_clusters, multiple_series=True)
-    for f in features[1:]:
-        cf = []
-        for mask in clusters:
-            cf += kmeans([f], mask=mask, n_clusters=n_clusters, multiple_series=True)
-            mask.remove()
-        clusters = cf
-
-    # Return clusters as a list
-    if multiple_series:
-        return clusters
-
-    # Return a single label series
-    label = masks_to_label(clusters)
-    for c in clusters:
-        c.remove()
-    return label
-
-
-
-def masks_to_label(masks):
-    "Convert a list of masks into a single label series"
-
-    # Ensure all the masks are in the same geometry
-    masks = scipy.overlay(masks)
-
-    # Create a single label array
-    array, headers = masks[0].array(['SliceLocation', 'AcquisitionTime'], pixels_first=True)
-    msg = 'Creating a single label image'
-    for m, mask in enumerate(masks[1:]):
-        mask.status.progress(m+1, len(masks)-1, msg)
-        arr, _ = mask.array(['SliceLocation', 'AcquisitionTime'], pixels_first=True)
-        ind = tuple(arr.nonzero())
-        array[ind] = m+2
-
-    # Save label array to disk
-    desc = masks[0].SeriesDescription
-    label = masks[0].new_sibling(SeriesDescription = desc + ' [Label]')
-    label.set_array(array, headers, pixels_first=True)  
-
-    return label    
-
-
-
-# Helper functions
-
-def _reset_window(image, array):
-    min = np.amin(array)
-    max = np.amax(array)
-    image.WindowCenter= (max+min)/2
-    image.WindowWidth = 0.9*(max-min)

dbdicom/wrappers/vreg.py

@@ -1,273 +0,0 @@
-import numpy as np
-from dbdicom.utils import vreg
-
-def print_current(vk):
-    print(vk)
-
-
-def _get_input(moving, static):
-
-    # Get affine matrices and check that there is a single value
-    affine_moving = moving.affine_matrix()
-    if isinstance(affine_moving, list):
-        msg = 'This function only works for series with a single slice group. \n'
-        msg += 'Multiple slice groups detected in moving series - please split the series first.'
-        raise ValueError(msg)
-    else:
-        affine_moving = affine_moving[0]
-    affine_static = static.affine_matrix()
-    if isinstance(affine_static, list):
-        msg = 'This function only works for series with a single slice group. \n'
-        msg += 'Multiple slice groups detected in static series - please split the series first.'
-        raise ValueError(msg)
-    else:
-        affine_static = affine_static[0]
-
-    # Get arrays for static and moving series
-    array_static, headers_static = static.array('SliceLocation', pixels_first=True, first_volume=True)
-    if array_static is None:
-        msg = 'Fixed series is empty - cannot perform alignment.'
-        raise ValueError(msg)
-    array_moving, headers_moving = moving.array('SliceLocation', pixels_first=True, first_volume=True)
-    if array_moving is None:
-        msg = 'Moving series is empty - cannot perform alignment.'
-        raise ValueError(msg)
-    
-    moving.message('Performing coregistration. Please be patient. Its hard work and I need to concentrate..')
-    
-    return array_static, affine_static, array_moving, affine_moving, headers_static, headers_moving
-
-
-
-
-
-def translation_sos(moving, static, tolerance=0.1):
-
-    array_static, affine_static, array_moving, affine_moving, headers, _ = _get_input(moving, static)
-
-    # Define initial values and optimization
-    _, _, static_pixel_spacing = vreg.affine_components(affine_static)
-    optimization = {
-        'method': 'GD', 
-        'options': {'gradient step': static_pixel_spacing, 'tolerance': tolerance}, 
-        'callback': lambda vk: moving.status.message('Current parameter: ' + str(vk)),
-    }
-    
-    # Align volumes
-    try:
-        translation_estimate = vreg.align(
-            moving = array_moving, 
-            moving_affine = affine_moving, 
-            static = array_static, 
-            static_affine = affine_static, 
-            parameters = np.array([0, 0, 0], dtype=np.float32), 
-            resolutions = [4,2,1], 
-            transformation =  vreg.translate,
-            metric = vreg.sum_of_squares,
-            optimization = optimization,
-        )
-    except:
-        print('Failed to align volumes..')
-        return None
-
-    coregistered = vreg.translate(array_moving, affine_moving, array_static.shape, affine_static, translation_estimate)
-    
-    # Save results as new dicom series
-    moving.message('Writing coregistered series to database..')
-    desc = moving.instance().SeriesDescription
-    coreg = moving.new_sibling(SeriesDescription = desc + ' [translation]')
-    coreg.set_array(coregistered, headers, pixels_first=True)
-    return coreg
-
-
-def rigid_sos(moving, static, tolerance=0.1):
-
-    array_static, affine_static, array_moving, affine_moving, headers, _ = _get_input(moving, static)
-
-    # Define initial values and optimization
-    _, _, static_pixel_spacing = vreg.affine_components(affine_static)
-    rot_gradient_step, translation_gradient_step, _ = vreg.affine_resolution(array_static.shape, static_pixel_spacing)
-    gradient_step = np.concatenate((1.0*rot_gradient_step, 0.5*translation_gradient_step))
-    optimization = {
-        'method': 'GD', 
-        'options': {'gradient step': gradient_step, 'tolerance': tolerance}, 
-        'callback': lambda vk: moving.message('Current parameter: ' + str(vk)),
-    }
-    
-    # Align volumes
-    try:
-        rigid_estimate = vreg.align(
-            moving = array_moving, 
-            moving_affine = affine_moving, 
-            static = array_static, 
-            static_affine = affine_static, 
-            parameters = np.array([0, 0, 0, 0, 0, 0], dtype=np.float32), 
-            resolutions = [4,2,1], 
-            transformation =  vreg.rigid,
-            metric = vreg.sum_of_squares,
-            optimization = optimization,
-        )
-    except:
-        print('Failed to align volumes..')
-        return None
-
-    coregistered = vreg.rigid(array_moving, affine_moving, array_static.shape, affine_static, rigid_estimate)
-    
-    moving.message('Writing coregistered series to database..')
-    
-    # Save results as new dicom series
-    desc = moving.instance().SeriesDescription
-    coreg = moving.new_sibling(SeriesDescription = desc + ' [rigid]')
-    coreg.set_array(coregistered, headers, pixels_first=True)
-    return coreg
-
-
-
-def sbs_translation_sos(moving, static, tolerance=0.1):
-
-    array_static, affine_static, array_moving, affine_moving, headers, headers_moving = _get_input(moving, static)
-    slice_thickness = [headers_moving[z].SliceThickness for z in range(headers_moving.size)]
-
-    # Define initial values and optimization
-    _, _, static_pixel_spacing = vreg.affine_components(affine_static)
-    optimization = {
-        'method': 'GD', 
-        'options': {'gradient step': static_pixel_spacing, 'tolerance': tolerance}, 
-    #    'callback': lambda vk: moving.message('Current parameter: ' + str(vk)),
-    }
-    
-    # Perform coregistration
-    estimate = vreg.align_slice_by_slice(
-        moving = array_moving, 
-        static = array_static, 
-        parameters =  np.array([0, 0, 0], dtype=np.float32), 
-        moving_affine = affine_moving, 
-        static_affine = affine_static, 
-        transformation = vreg.translate,
-        metric = vreg.sum_of_squares,
-        optimization = optimization,
-        resolutions = [4,2,1],
-        slice_thickness = slice_thickness,
-        progress = lambda z, nz: moving.progress(z, nz, 'Coregistering slice-by-slice using translations'),
-    )
-    
-    # Calculate coregistered
-    coregistered = vreg.transform_slice_by_slice(array_moving, affine_moving, array_static.shape, affine_static, estimate, vreg.translate, slice_thickness)
-    # coregistered = vreg.transform_slice_by_slice(
-    #     moving = array_moving, 
-    #     moving_affine = affine_moving, 
-    #     static_shape = array_static.shape, 
-    #     static_affine = affine_static, 
-    #     parameters = estimate, 
-    #     transformation = vreg.translate, 
-    #     slice_thickness = slice_thickness)
-
-    # Save results as new dicom series
-    moving.message('Writing coregistered series to database..')
-    desc = moving.instance().SeriesDescription
-    coreg = moving.new_sibling(SeriesDescription = desc + ' [sbs translation]')
-    coreg.set_array(coregistered, headers, pixels_first=True)
-
-    return coreg
-
-
-def sbs_rigid_around_com_sos(moving, static, tolerance=0.1):
-
-    array_static, affine_static, array_moving, affine_moving, headers, headers_moving = _get_input(moving, static)
-    slice_thickness = [headers_moving[z].SliceThickness for z in range(headers_moving.size)]
-
-    # Define initial values and optimization
-    _, _, static_pixel_spacing = vreg.affine_components(affine_static)
-    rot_gradient_step, translation_gradient_step, _ = vreg.affine_resolution(array_static.shape, static_pixel_spacing)
-    gradient_step = np.concatenate((1.0*rot_gradient_step, 0.5*translation_gradient_step))
-    optimization = {
-        'method': 'GD', 
-        'options': {'gradient step': gradient_step, 'tolerance': tolerance}, 
-        #'callback': lambda vk: moving.message('Current parameter: ' + str(vk)),
-    }
-
-    # Perform coregistration
-    estimate = vreg.align_slice_by_slice(
-        moving = array_moving, 
-        static = array_static, 
-        parameters = np.array([0, 0, 0, 0, 0, 0], dtype=np.float32), 
-        moving_affine = affine_moving, 
-        static_affine = affine_static, 
-        transformation = vreg.rigid_around_com,
-        metric = vreg.sum_of_squares,
-        optimization = optimization,
-        resolutions = [4,2,1],
-        slice_thickness = slice_thickness,
-        progress = lambda z, nz: moving.progress(z, nz, 'Coregistering slice-by-slice using rigid transformations'),
-    )
-
-    # The generic slice-by-slice transform does not work for center of mass rotations. 
-    # Calculate rotation center and use rigid rotation around given center instead.
-    estimate_center = [] 
-    for z in range(len(estimate)):
-        array_moving_z, affine_moving_z = vreg.extract_slice(array_moving, affine_moving, z, slice_thickness)
-        center = estimate[z][3:] + vreg.center_of_mass(vreg.to_3d(array_moving_z), affine_moving_z)
-        pars = np.concatenate((estimate[z][:3], center, estimate[z][3:]))
-        estimate_center.append(pars)
-    
-    # Calculate coregistered (using rigid around known center)
-    coregistered = vreg.transform_slice_by_slice(array_moving, affine_moving, array_static.shape, affine_static, estimate_center, vreg.rigid_around, slice_thickness)
-    # coregistered = vreg.transform_slice_by_slice(
-    #     moving = array_moving, 
-    #     moving_affine = affine_moving, 
-    #     static_shape = array_static.shape, 
-    #     static_affine = affine_static, 
-    #     parameters = estimate_center, 
-    #     transformation = vreg.rigid_around, 
-    #     slice_thickness = slice_thickness)
-
-    # Save results as new dicom series
-    moving.message('Writing coregistered series to database..')
-    desc = moving.instance().SeriesDescription
-    coreg = moving.new_sibling(SeriesDescription = desc + ' [sbs rigid com]')
-    coreg.set_array(coregistered, headers, pixels_first=True)
-
-    return coreg
-
-
-
-def rigid_around_com_sos(moving, static, tolerance=0.1):
-
-    array_static, affine_static, array_moving, affine_moving, headers, _ = _get_input(moving, static)
-
-    # Define initial values and optimization
-    _, _, static_pixel_spacing = vreg.affine_components(affine_static)
-    rot_gradient_step, translation_gradient_step, _ = vreg.affine_resolution(array_static.shape, static_pixel_spacing)
-    gradient_step = np.concatenate((1.0*rot_gradient_step, 0.5*translation_gradient_step))
-    optimization = {
-        'method': 'GD', 
-        'options': {'gradient step': gradient_step, 'tolerance': tolerance}, 
-        'callback': lambda vk: moving.message('Current parameter: ' + str(vk)),
-    }
-    
-    # Align volumes
-    try:
-        rigid_estimate = vreg.align(
-            moving = array_moving, 
-            moving_affine = affine_moving, 
-            static = array_static, 
-            static_affine = affine_static, 
-            parameters = np.array([0, 0, 0, 0, 0, 0], dtype=np.float32), 
-            resolutions = [4,2,1], 
-            transformation =  vreg.rigid_around_com,
-            metric = vreg.sum_of_squares,
-            optimization = optimization,
-        )
-    except:
-        print('Failed to align volumes..')
-        return None
-
-    coregistered = vreg.rigid_around_com(array_moving, affine_moving, array_static.shape, affine_static, rigid_estimate)
-    
-    moving.message('Writing coregistered series to database..')
-    
-    # Save results as new dicom series
-    desc = moving.instance().SeriesDescription
-    coreg = moving.new_sibling(SeriesDescription = desc + ' [rigid com]')
-    coreg.set_array(coregistered, headers, pixels_first=True)
-    return coreg