Beispiel #1
0
def register2D(fixed,
               moving,
               numberOfBins,
               sampling_percentage=0.1,
               learning_rate=1.1,
               min_step=0.001,
               relaxation_factor=0.8):

    best_resampler = reg.register(fixed, moving, numberOfBins,
                                  sampling_percentage)
    return best_resampler
Beispiel #2
0
def register2D(fixed,
               moving,
               numberOfBins,
               is_best_rotation=False,
               array_moving=None,
               flipped=False,
               sampling_percentage=0.1,
               learning_rate=1.1,
               min_step=0.001,
               relaxation_factor=0.8):
    to_flip = False
    # Flip axis and choose best fit during registration
    if flipped:
        # Construct a 3D image
        # 2 slices = original + flipped
        flipped_moving = sitk.Flip(moving, (True, False))
        moving_and_flipped = np.zeros(
            (2, moving.GetSize()[1], moving.GetSize()[0]), dtype=np.float32)
        moving_and_flipped[0, ...] = sitk.GetArrayFromImage(moving)
        moving_and_flipped[1, ...] = sitk.GetArrayFromImage(flipped_moving)
        array_flipped = moving_and_flipped
        #determines if symmetry of image is a better match
        best_resampler, index = reg.best_fit(
            fixed,
            array_flipped,
            numberOfBins,
            sampling_percentage,
            find_best_rotation=is_best_rotation,
            learning_rate=learning_rate,
            min_step=min_step,
            relaxation_factor=relaxation_factor)
        if index == 1:
            to_flip = True
    else:
        #normal registration
        best_resampler = reg.register(fixed,
                                      moving,
                                      numberOfBins,
                                      sampling_percentage,
                                      find_best_rotation=is_best_rotation,
                                      learning_rate=learning_rate,
                                      min_step=min_step,
                                      relaxation_factor=relaxation_factor)
    return best_resampler, to_flip
Beispiel #3
0
def registration_number_bins(outputname, min_bins, max_bins):
    """
    Registration over a range of bins
    for the sampling strategy

    Parameters
    ----------
    outputname: str
        output image name
    min_bins: int
        minimum number of bins
    max_bins: int
        maximum number of bins

    """
    for i in range(min_bins, max_bins):
        outname = os.path.splitext(outputname)[0] + "_bins" + str(i) + ".png"
        try:
            resampler = reg.register(fixed, moving, i)
            out = resampler.Execute(moving)
            out = sitk.Cast(sitk.RescaleIntensity(out), sitk.sitkUInt8)
            sitk.WriteImage(out, outname)
        except Exception as e:
            pass
normalized_dt_reference_itk = sitk.GetImageFromArray(normalized_dt_reference)
normalized_dt_target_itk = sitk.GetImageFromArray(normalized_dt_target)

normalized_dt_reference_itk = utils.local_max_dt(reference_itk)
normalized_dt_target_itk = utils.local_max_dt(target_itk)

# fig, ax = plt.subplots(1, 2)
# ax[0].imshow(normalized_dt_reference)
# ax[1].imshow(normalized_dt_target)
# plt.show()

R = reg.register(reference_itk,
                 target_itk,
                 15,
                 0.1,
                 find_best_rotation=True,
                 learning_rate=0.00001,
                 update_DT=False,
                 normalize_DT=False)
out = R.Execute(dt_target)

R_update = reg.register(normalized_dt_reference_itk,
                        normalized_dt_target_itk,
                        15,
                        0.1,
                        find_best_rotation=True,
                        learning_rate=0.00001,
                        update_DT=False,
                        normalize_DT=True)
out_norm = R_update.Execute(normalized_dt_target_itk)
out_update = R_update.Execute(dt_target)
target = np.pad(target, 25)

noise = np.random.normal(mean_noise, stddev_noise, reference.shape)
# reference += noise
# target += noise

reference_itk = sitk.GetImageFromArray(reference)
target_original_itk = sitk.GetImageFromArray(target_original)
target_itk = sitk.GetImageFromArray(target)

dt_reference = utils.compute_DT(reference_itk)
dt_target = utils.compute_DT(target_itk)
dt_target_original = utils.compute_DT(target_original_itk)


R_intensity = reg.register(reference_itk, target_itk, 10, 0.001, find_best_rotation=True, use_DT=False, learning_rate=0.00000001)
out_intensity = R_intensity.Execute(target_itk)

R_shape = reg.register(reference_itk, target_itk, 10, 0.001, find_best_rotation=True, learning_rate=0.00000001)
out_shape = R_shape.Execute(target_itk)

sitk.WriteImage(sitk.Cast(out_intensity, sitk.sitkUInt8), "registered_intensity.tif")
sitk.WriteImage(sitk.Cast(out_shape, sitk.sitkUInt8), "registered_shape.tif")
sitk.WriteImage(dt_reference, "dt_reference.tif")
sitk.WriteImage(dt_target, "dt_target.tif")
sitk.WriteImage(dt_target_original, "dt_target_original.tif")
sitk.WriteImage(sitk.Cast(reference_itk, sitk.sitkUInt8), "reference.tif")
sitk.WriteImage(sitk.Cast(target_itk, sitk.sitkUInt8), "target.tif")
sitk.WriteImage(sitk.Cast(target_original_itk, sitk.sitkUInt8), "target_original.tif")