How to convert multiple Nifti1Image of different sizes to a nii.gz

[emmanuel-nwogu]

I have an equally-sized DICOM series whose images I crop using Otsu thresholding and contouring. This cropping leads to smaller images with various sizes (width, height). These cropped images are represented as 2D grayscale numpy arrays in my code. Currently, I am able to convert each image to a Nifti1Image using code resembling the piece below.

# Inspired by https://stackoverflow.com/a/28331076
import nibabel as nib
import numpy as np

data = np.arange(4*4).reshape(4,4) # This is the cropped image data
new_image = nib.Nifti1Image(data, affine=np.eye(4))

I am curious if there's a way to write these Nifti1Image objects, all containing differently sized image data, to a single "nii.gz" file.

EDIT: I would like to preserve the image sizes of these Nifti1Image objects too.

[ZviBaratz]

Hi @emmanuel-nwogu,

I hope it's OK I converted your issue to a discussion, since it is more a support question, rather than an issue with nibabel.

Unfortunately, I don't think it is possible for a single NIfTI file to hold differently sized 2D arrays to represent a single 3D array. However, I imagine this is practically equivalent to zero-padding the arrays to match the largest dimension sizes. If you do that after cropping, it might be difficult to realign the slices correctly. Therefore, I would suggest finding out how the slice with the largest dimensions is cropped, and then applying the same cropping to all the other slices. Does that make sense?

[emmanuel-nwogu]

Thanks for the reply. And yeah, I don't mind the conversion. Whatever works best for you.

Unfortunately, I don't think it is possible for a single NIfTI file to hold differently sized 2D arrays to represent a single 3D array.

Dang :(

Does that make sense?

Yeah, it does and I have considered that. Unfortunately, I need to preserve the integrity of the cropped images as cropping here is a sensitive preprocessing step. Thanks though. :)

[effigies]

Could you share your cropping code? It may be that you could mask the 2D arrays instead and keep the original dimensions.

[emmanuel-nwogu]

def get_largest_n_contours(image, n=1):
    contours_, hierarchy_ = cv2.findContours(image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_TC89_L1)
    contoured_coords_ = [cv2.boundingRect(cont) for cont in contours_]
    contoured_coords_.sort(key=lambda x: x[2] * x[3], reverse=True)
    if len(contoured_coords_) > n:
        contoured_coords_ = contoured_coords_[:n]
    return contoured_coords_

def apply_contour(original, thresh, n=1):
    coords = get_largest_n_contours(thresh, n)
    return [original[y:y + h, x:x + w] for (x, y, w, h) in coords]

for full_path in dicom_jpgs_path_list:
    img = cv2.imread(full_path, cv2.IMREAD_GRAYSCALE)
    left_img, right_img = np.split(img, 2, axis=1)
    _, left_thresh = cv2.threshold(left_img, thresh_val_, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    _, right_thresh = cv2.threshold(right_img, thresh_val_, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    contoured_left = apply_contour(left_img, left_thresh)[0]
    contoured_right = apply_contour(right_img, right_thresh)[0]

My code heavily resembles the above. For more context, these images are being cropped before segmentation and the integrity of the crop heavily affects the segmentation results.

[effigies]

Assuming you would like a 3D image where the slices need to be spatially related to one another, you'll either need to mask:

def mask(slab, coords):
    x, y, w, h = coords
    newslab = np.zeros_like(slab)
    newslab[y:y + h, x:x + w] = slab[y:y + h, x:x + w]
    return newslab

Or if you can't use the masked array directly, you can split this up and keep track of the original shape and coordinates of your cropped section:

def crop(slab, coords):
    x, y, w, h = coords
    return slab[y:y + h, x:x + w], slab.shape

def uncrop(cropped, coords, orig_shape):
    x, y, w, h = coords
    newslab = np.zeros(orig_shape)
    newslab[y:y + h, x:x + w] = cropped
    return newslab

def crop_and_process(slab, coords):
    cropped, orig_shape = crop(slab, coords)
    processed = do_something(cropped)
    return uncrop(processed, coords, orig_shape)