import SimpleITK as sitk import numpy as np import scipy.ndimage as ndimage from scipy.ndimage import distance_transform_edt from scipy.ndimage import label, find_objects def split_connected_components(labels, label_value, offset, min_volume=400, top_n=6): """ Split the region with the specified label_value into multiple connected components and reassign labels. Parameters: labels (np.ndarray): Input label array label_value (int): The label value to split offset (int): Offset used to generate new label values min_volume (int): Minimum volume to retain connected components top_n (int): Retain the top-n connected components by volume Returns: np.ndarray: Relabeled array """ # Get a binary mask where the label is equal to label_value binary_mask = (labels == label_value) structure = np.array([[[0, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 1, 0], [1, 1, 1], [0, 1, 0]], [[0, 0, 0], [0, 1, 0], [0, 0, 0]]], dtype=int) # Use scipy.ndimage.label to mark connected components labeled_array, num_features = label(binary_mask, structure=structure) # Create new_labels as a copy of the input labels new_labels = labels.copy() # Get the volume of all connected components volumes = [np.sum(labeled_array == i) for i in range(1, num_features + 1)] # Get indices of the top-n connected components by volume top_n_indices = np.argsort(volumes)[-top_n:][::-1] top_n_volumes_labels = [(volumes[i], i + 1) for i in top_n_indices] # Note that component indices start from 1 # Iterate through all connected components in descending order of volume and reassign labels to avoid conflicts current_label = offset for volume, i in top_n_volumes_labels: region_mask = (labeled_array == i) if volume >= min_volume: new_labels[region_mask] = current_label current_label += 1 else: new_labels[region_mask] = 0 return new_labels def remove_small_connected_components(prediction, min_volume, label_values): """ Remove small connected components and set them as background. Parameters: prediction (np.ndarray): Model output predictions min_volume (int): Minimum volume to retain connected components label_values (list): List of label values to process Returns: np.ndarray: Processed prediction array """ new_prediction = prediction.copy() # Define the connectivity structure for identifying connected components structure = np.array([[[0, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 1, 0], [1, 1, 1], [0, 1, 0]], [[0, 0, 0], [0, 1, 0], [0, 0, 0]]], dtype=int) for index, label_value in enumerate(label_values): print(f"Processing label {label_value}:") # Get binary mask for the specified label binary_mask = (prediction == label_value) minimum = min_volume[index] labeled_array, num_features = label(binary_mask, structure=structure) # Get slices of each connected component slices = find_objects(labeled_array) retained_sizes = [] removed_sizes = [] # Iterate through each connected component and remove those smaller than the minimum volume for i, slice_ in enumerate(slices): region_size = np.sum(labeled_array[slice_] == (i + 1)) if region_size <= minimum: removed_sizes.append(region_size) new_prediction[labeled_array == (i + 1)] = 0 else: retained_sizes.append(region_size) # Print the sizes of retained and removed regions if retained_sizes: print(f" Retained regions sizes: {retained_sizes}") if removed_sizes: print(f" Removed regions sizes: {removed_sizes}") return new_prediction def calculate_iou(label1, label2): intersection = np.logical_and(label1, label2).sum() union = np.logical_or(label1, label2).sum() return intersection / union def relabel_connected_components(segmentation): """ Handle partial confusion between left and right hip bones in stage0 segmentation. Parameters: segmentation (np.ndarray): The segmentation labels from stage0. Returns: np.ndarray: Relabeled segmentation with confusion resolved. """ # Detect connected components for labels 2 and 3 label_2, num_features_2 = ndimage.label(segmentation == 2) label_3, num_features_3 = ndimage.label(segmentation == 3) # Create arrays to store the sizes of the connected components size_2 = np.bincount(label_2.ravel()) size_3 = np.bincount(label_3.ravel()) # Initialize a new segmentation array for relabeling new_segmentation = np.copy(segmentation) # Create a structural element to detect boundaries, suitable for 3D struct = ndimage.generate_binary_structure(3, 1) # Iterate over the connected components for label 2 for label in range(1, num_features_2 + 1): current_region = (label_2 == label) neighbors = ndimage.binary_dilation(current_region, structure=struct) & (segmentation == 3) if neighbors.any(): touching_labels_3 = np.unique(label_3[neighbors]) for lbl_3 in touching_labels_3: if lbl_3 > 0: if 5 * size_2[label] < size_3[lbl_3]: print(f"Change: class_2 (size: {size_2[label]}) -> class_3 (size: {size_3[lbl_3]})") new_segmentation[current_region] = 3 elif 5 * size_3[lbl_3] < size_2[label]: print(f"Change: class_3 (size: {size_3[lbl_3]}) -> class_2 (size: {size_2[label]})") new_segmentation[label_3 == lbl_3] = 2 return new_segmentation def refine_labels(label1, label2, threshold=0.99): """ Refine label2 based on reference from label1 if IoU is below the threshold. Parameters: label1 (np.ndarray): The reference label. label2 (np.ndarray): The label to be refined. threshold (float): IoU threshold for refinement. Default is 0.99. Returns: np.ndarray: Refined label. """ iou = calculate_iou(label1 > 0, label2 > 0) # Calculate IoU considering only foreground and background if iou >= threshold: return label2 print('Refining label...') fixed_label2 = label2.copy() # Label the connected components in label2 structure = np.array([[[0, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 1, 0], [1, 1, 1], [0, 1, 0]], [[0, 0, 0], [0, 1, 0], [0, 0, 0]]], dtype=int) labeled_a, num_features_a = label(label2, structure=structure) # Iterate over the connected components in label2 for component_id in range(1, num_features_a + 1): component_mask = (labeled_a == component_id) if not np.any(component_mask & (label1 > 0)): # If there is no intersection with label1, set the component to background fixed_label2[component_mask] = 0 # Foreground areas in label1 that are background in label2 fg_to_bg_mask = (label1 > 0) & (label2 == 0) # Find the nearest foreground pixel label if fg_to_bg_mask.any(): distance, indices = distance_transform_edt(fixed_label2 == 0, return_indices=True) nearest_foreground = label2[tuple(indices)] fixed_label2[fg_to_bg_mask] = nearest_foreground[fg_to_bg_mask] return fixed_label2 def process_final_label(segmentation): """ Process the final segmentation labels by refining the connected components of specific labels. Parameters: segmentation (np.ndarray): The final segmentation labels. Returns: np.ndarray: Refined segmentation with certain connected components removed or relabeled. """ # Initialize a new segmentation array for relabeling new_segmentation = np.copy(segmentation) # Mask out sacrum labels (set to background) segmentation = np.where((segmentation >= 1) & (segmentation <= 10), 0, segmentation) # Detect connected components for labels 11 and 21 label_11, num_features_11 = ndimage.label(segmentation == 11) label_21, num_features_21 = ndimage.label(segmentation == 21) # Calculate the size of each connected component size_11 = np.bincount(label_11.ravel()) size_21 = np.bincount(label_21.ravel()) # Find the index of the largest connected component for labels 11 and 21 largest_label_11_index = np.argmax(size_11[1:]) + 1 # Skip index 0 (background) largest_label_21_index = np.argmax(size_21[1:]) + 1 assert num_features_11 > 0 and num_features_21 > 0, "label 11 and label 21 have no connected components!!" # Remove the largest connected components from label_11 and label_21 (mark them as background) label_11[label_11 == largest_label_11_index] = 0 # Mark largest connected component as background num_features_11 -= 1 # Update the number of connected components label_21[label_21 == largest_label_21_index] = 0 # Mark largest connected component as background num_features_21 -= 1 # Update the number of connected components # Create a structural element for boundary detection, suitable for 3D struct = ndimage.generate_binary_structure(3, 1) # Define a function to process connected components for a given label def process_label(label, segment_label, num_features): if num_features < 1: return # Do not process if no connected components remain after removing the largest one for lbl in range(1, num_features + 1): current_region = (label == lbl) neighbors = ndimage.binary_dilation(current_region, structure=struct) & (segmentation != segment_label) if neighbors.any(): # Find all touching labels, excluding background touching_labels = np.unique(segmentation[neighbors]) touching_labels = touching_labels[touching_labels != 0] # Exclude background touching_labels = touching_labels[touching_labels != segment_label] # Exclude current label if touching_labels.size > 0: # Calculate the volume of each touching label touching_label_sizes = {label: np.sum(segmentation == label) for label in touching_labels} # Find the touching label with the largest volume max_touching_label = max(touching_label_sizes, key=touching_label_sizes.get) print(f"Changing segment {lbl} from {segment_label} to {max_touching_label}") new_segmentation[current_region] = max_touching_label # Process connected components for label 11 process_label(label_11, 11, num_features_11) # Process connected components for label 21 process_label(label_21, 21, num_features_21) return new_segmentation if __name__ == "__main__": labels = sitk.ReadImage( "/home/ypy/Code/PENGWIN-example-algorithm-main/PENGWIN-challenge-packages/preliminary-development-phase-ct/stage1_label_after_remove_101_1.nii.gz") spacing = labels.GetSpacing() direction = labels.GetDirection() origin = labels.GetOrigin() labels = sitk.GetArrayFromImage(labels) # label_value = 2 # offset = 22 # new_labels = split_connected_components(labels, label_value, offset) # new_labels = np.where(new_labels == 1, 21, new_labels) # new_labels = remove_small_connected_components(labels, 20000, [1, 2, 3]) new_labels = relabel_connected_components(labels) save_label = sitk.GetImageFromArray(new_labels.astype(np.int8)) save_label.SetSpacing(spacing) save_label.SetDirection(direction) save_label.SetOrigin(origin) sitk.WriteImage(save_label, "stage1_label_after.nii.gz", useCompression=True)