# :cpp:func:`Image::SetSpacing() <itk::simple::Image::SetSpacing>` can be used to get and set spacing respectively. # # **Direction Matrix** # Mapping/rotation between direction of the pixel/voxel axes and physical directions. Default is identity matrix. The matrix is passed as a 1D array in row-major form. # # :cpp:func:`Image::GetDirection() <itk::simple::Image::GetDirection>` and # :cpp:func:`Image::SetDirection() <itk::simple::Image::SetDirection>` can be used to get and set direction matrix respectively. # # .. note :: # All the transformations like rotation or affine transform are done on the underlying physical space. You can think of image of a view of this physical space. # # Let's illustrate this in python: from downloaddata import fetch_data as fdata image = sitk.ReadImage( fdata("nac-hncma-atlas2013-Slicer4Version/Data/A1_grayT1.nrrd")) print("Pixel Type {}".format(image.GetPixelID())) print("Size {}".format(image.GetSize())) print("Origin {}".format(image.GetOrigin())) print("Spacing {}".format(image.GetSpacing())) print("Direction {}".format(image.GetDirection())) ############################################################################## # Transform voxels to physical space # ---------------------------------- # # Following equation can be used to convert voxel coordinates/indices to physical coordinates: # # .. math:: #
Laboratory at Brigham and Women's Hospital has a wonderful `Multi-modality MRI-based Atlas of the Brain <http://www.spl.harvard.edu/publications/item/view/2037>`_ that we can use. Please note, what is done here is for convenience and is not the common way images are displayed for radiological work. Get Images ---------- """ import matplotlib.pyplot as plt import SimpleITK as sitk from downloaddata import fetch_data as fdata from myshow import myshow img_T1 = sitk.ReadImage( fdata("nac-hncma-atlas2013-Slicer4Version/Data/A1_grayT1.nrrd")) img_T2 = sitk.ReadImage( fdata("nac-hncma-atlas2013-Slicer4Version/Data/A1_grayT2.nrrd")) img_labels = sitk.ReadImage( fdata("nac-hncma-atlas2013-Slicer4Version/Data/hncma-atlas.nrrd")) myshow(img_T1, title='T1') myshow(img_T2, title='T2') myshow(sitk.LabelToRGB(img_labels), title='lables') ############################################################################## # Visualize another axis. size = img_T1.GetSize() myshow(img_T1[:, size[1] // 2, :])
Visualizing 2D images ===================== In this example, we will explore using matplotlib to display images in our notebooks, and work towards developing a reusable function to display 2D,3D, color for SimpleITK images. """ import matplotlib.pyplot as plt import SimpleITK as sitk from downloaddata import fetch_data as fdata ############################################################################## # Fetch and read image img1 = sitk.ReadImage(fdata("cthead1.png")) img2 = sitk.ReadImage(fdata("VM1111Shrink-RGB.png")) ############################################################################## # SimpleITK has a built in `Show` method which saves the image to disk and # launches a user configurable program ( defaults to ImageJ ), to display the # image. # # .. code-block:: python # # sitk.Show(img1, title="cthead1") # sitk.Show(img2, title="Visible Human Head") # # Plotting with ``matplotlib`` # ---------------------------- # You can also use matplotlib to show images.
def test(): # show the standard fiducial list fixed_fiducial_points, moving_fiducial_points = ru.load_RIRE_ground_truth( fdata("ct_T1.standard")) print "The standard fiducial points are ", fixed_fiducial_points print "The standard fiducial points shape ", type(moving_fiducial_points) # test_data = fdata("training_001_ct.mha") fixed_data = "/home/maguangshen/PycharmProjects/SPL/Data_SPL/test_resampled_MRI.mha" fixed_img = sitk.ReadImage(fixed_data, sitk.sitkFloat32) moving_data = "/home/maguangshen/PycharmProjects/SPL/Data_SPL/test_US_before.mha" moving_img = sitk.ReadImage(moving_data, sitk.sitkFloat32) # This is the list -- can be used for numpy array # Read the MRI fiducial csv_MRI = "/home/maguangshen/PycharmProjects/SPL/Data_SPL/Case23-MRI.csv" fiducial_MRI, fiducial_MRI_list = Read_tsv(csv_MRI) print "The fiducials of MRI are ", fiducial_MRI_list # Read the US fiducial csv_US = "/home/maguangshen/PycharmProjects/SPL/Data_SPL/Case23-beforeUS.csv" fiducial_US, fiducial_US_list = Read_tsv(csv_US) print "The ficucials of US are ", fiducial_US_list R, t = ru.absolute_orientation_m(fiducial_MRI_list, fiducial_US_list) print "The testing R is ", R print "The testing T is ", t print "The R flatten is ", R.flatten() # Set up the registration parameters reference_transform = sitk.Euler3DTransform() # Euler 3D Transform reference_transform.SetMatrix(R.flatten()) # Flatten the R matrix reference_transform.SetTranslation(t) # Set the translation vector reference_errors_mean, reference_errors_std, _, reference_errors_max, _ = ru.registration_errors( reference_transform, fiducial_MRI_list, fiducial_US_list) print( 'Reference data errors (FRE) in millimeters, mean(std): {:.2f}({:.2f}), max: {:.2f}' .format(reference_errors_mean, reference_errors_std, reference_errors_max)) # Viz the results to map all the points # Generate a reference dataset from the reference transformation # Apply the transformation first based on the fiducial registration results fixed_points = ru.generate_random_pointset( image=fixed_img, num_points=100) # generate random point sets from the volume dataset moving_points = [ reference_transform.TransformPoint(p) for p in fixed_points ] # Compute the TRE prior to the registration pre_errors_mean, pre_errors_std, pre_errors_min, pre_errors_max, _ = ru.registration_errors( sitk.Euler3DTransform(), fixed_points, moving_points, display_errors=True) print( 'Before registration, errors (TRE) in millimeters, mean(std): {:.2f}({:.2f}), max: {:.2f}' .format(pre_errors_mean, pre_errors_std, pre_errors_max)) ## Initial alignment # Initialization of the transform initial_transform = sitk.CenteredTransformInitializer( sitk.Cast(fixed_img, moving_img.GetPixelID()), moving_img, sitk.Euler3DTransform(), sitk.CenteredTransformInitializerFilter.GEOMETRY) initial_errors_mean, initial_errors_std, initial_errors_min, initial_errors_max, _ = ru.registration_errors( initial_transform, fixed_points, moving_points, min_err=pre_errors_min, max_err=pre_errors_max, display_errors=True) print( 'After initialization, errors (TRE) in millimeters, mean(std): {:.2f}({:.2f}), max: {:.2f}' .format(initial_errors_mean, initial_errors_std, initial_errors_max)) # Begin registration registration_method = sitk.ImageRegistrationMethod() registration_method.SetMetricAsMattesMutualInformation( numberOfHistogramBins=50) # Define the number of bins as 50 registration_method.SetMetricSamplingStrategy( registration_method.RANDOM) # Define the registration_method.SetMetricSamplingPercentage( 0.01) # Default sampling percentage is 0.01 registration_method.SetInterpolator( sitk.sitkNearestNeighbor) # Replace with sitkLinear registration_method.SetOptimizerAsGradientDescent( learningRate=1.0, numberOfIterations=100) # Increase to 1000 registration_method.SetOptimizerScalesFromPhysicalShift( ) # Understand the optimization method registration_method.SetInitialTransform( initial_transform, inPlace=False) # Apply the initial transform # Add the callback to display the similarity value registration_method.AddCommand(sitk.sitkStartEvent, rc.metric_and_reference_start_plot) registration_method.AddCommand(sitk.sitkEndEvent, rc.metric_and_reference_end_plot) registration_method.AddCommand( sitk.sitkIterationEvent, lambda: rc.metric_and_reference_plot_values( registration_method, fixed_points, moving_points)) final_transform_single_scale = registration_method.Execute( sitk.Cast(fixed_img, sitk.sitkFloat32), sitk.Cast(moving_img, sitk.sitkFloat32)) print('Final metric value: {0}'.format( registration_method.GetMetricValue())) print('Optimizer\'s stopping condition, {0}'.format( registration_method.GetOptimizerStopConditionDescription())) final_errors_mean, final_errors_std, _, final_errors_max, _ = ru.registration_errors( final_transform_single_scale, fixed_points, moving_points, min_err=initial_errors_min, max_err=initial_errors_max, display_errors=True) print( 'After registration, errors in millimeters, mean(std): {:.2f}({:.2f}), max: {:.2f}' .format(final_errors_mean, final_errors_std, final_errors_max)) final_errors_mean, final_errors_std, _, final_errors_max, _ = ru.registration_errors( final_transform_single_scale, fixed_points, moving_points, display_errors=True)
the input images' to be overlapping. """ import matplotlib.pyplot as plt import SimpleITK as sitk from downloaddata import fetch_data as fdata from myshow import myshow, myshow3d ############################################################################## # LabelOverlay In 2D # ------------------ # We start by loading a segmented image. As the segmentation is just an image # with integral data, we can display the labels as we would any other image. img1 = sitk.ReadImage(fdata("cthead1.png")) img1_seg = sitk.ReadImage(fdata("2th_cthead1.png")) myshow(img1, title="cthead1") myshow(img1_seg, title="Label Image as Grayscale") ############################################################################## # We can also map the scalar label image to a color image as shown below. myshow(sitk.LabelToRGB(img1_seg), title="Label Image as RGB") ############################################################################## # Most filters which take multiple images as arguments require that the images # occupy the same physical space. That is the pixel you are operating must # refer to the same location. Luckily for us our image and labels do occupy the # same physical space, allowing us to overlay the segmentation onto the