def test_downsample_images(): DOWNSAMPLE_RATIO = 2.0 # Import succeeds from hasi.align import mesh_to_image, downsample_images # Downsample succeeds images = downsample_images([target_healthy_image, target_unhealthy_image], DOWNSAMPLE_RATIO) assert (len(images) == 2) # Downsampled image dimensions adjusted by expected ratio assert (itk.size(images[0]) == [ int(itk.size(target_healthy_image)[dim] / DOWNSAMPLE_RATIO) for dim in range(dimension) ]) assert (itk.spacing(images[0]) == [ itk.spacing(target_healthy_image)[dim] * DOWNSAMPLE_RATIO for dim in range(dimension) ]) assert (itk.size(images[1]) == [ int(itk.size(target_unhealthy_image)[dim] / DOWNSAMPLE_RATIO) for dim in range(dimension) ]) assert (itk.spacing(images[1]) == [ itk.spacing(target_unhealthy_image)[dim] * DOWNSAMPLE_RATIO for dim in range(dimension) ])
def test_mesh_to_image(): # Import succeeds from hasi.align import mesh_to_image # Mesh-to-image executes without error images = mesh_to_image([template_mesh, target_mesh]) # Images were generated assert (all([ type(image) == itk.Image[mesh_pixel_type, dimension] for image in images ])) # Images occupy the same physical space assert (all( [itk.spacing(image) == itk.spacing(images[0]) for image in images])) assert (all([itk.size(image) == itk.size(images[0]) for image in images])) assert (all( [itk.origin(image) == itk.origin(images[0]) for image in images])) # Mesh-to-image can run with reference image image_from_reference = mesh_to_image(target_mesh, reference_image=images[0]) # Type and image attributes match previous output assert (type(image_from_reference) == type(images[0])) assert (itk.spacing(image_from_reference) == itk.spacing(images[0])) assert (itk.size(image_from_reference) == itk.size(images[0])) assert (itk.origin(image_from_reference) == itk.origin(images[0]))
def paste_to_common_space(images:list) -> list: image_type = type(images[0]) pixel_type, dimension = itk.template(images[0])[1] resized_images = list() # Verify spacing is equivalent SPACING_TOLERANCE = 1e-7 assert(all([itk.spacing(images[idx])[dim] - itk.spacing(images[0])[dim] < SPACING_TOLERANCE for dim in range(dimension) for idx in range(1,len(images))])) # Get largest common region max_size = itk.size(images[0]) for image in images: max_size = [max(max_size[i], itk.size(image)[i]) for i in range(len(max_size))] # Define paste region for image in images: region = itk.ImageRegion[dimension]() region.SetSize(max_size) region.SetIndex([0] * dimension) new_image = type(images[0]).New(regions=region, spacing=image.GetSpacing()) new_image.Allocate() resized_image = itk.paste_image_filter(source_image=image, source_region=image.GetLargestPossibleRegion(), destination_image=new_image, destination_index=[0] * dimension, ttype=type(image)) resized_images.append(resized_image) return resized_images
def add(self, dose_file): lockfile = dose_file + ".lock" dose = None n_primaries = 0 t0 = datetime.now() logger.debug("lockfile exists" if os.path. exists(lockfile) else "lockfile does not exist") lock = SoftFileLock(lockfile) try: # TODO: the length of the timeout should maybe be configured in the system configuration with lock.acquire(timeout=3): t1 = datetime.now() logger.debug("acquiring lock file took {} seconds".format( (t1 - t0).total_seconds())) ########################## n_primaries = self.get_nprimaries(dose_file) if n_primaries < 1: logger.warn( f"dose file seems to be based on too few primaries ({n_primaries})" ) elif bool(self.mass) and bool(self.mask): simdose = itk.imread(dose_file) logger.debug( "resampling dose with size {} using mass file of size {} to target size {}" .format(itk.size(simdose), itk.size(self.mass), itk.size(self.mask))) dose = mass_weighted_resampling(simdose, self.mass, self.mask) del simdose else: dose = itk.imread(dose_file) logger.debug("read dose with size {}".format( itk.size(dose))) t2 = datetime.now() logger.debug( "acquiring dose data {} file took {} seconds".format( os.path.basename(dose_file), (t2 - t1).total_seconds())) if self.wmin > n_primaries: self.wmin = n_primaries if self.wmax < n_primaries: self.wmax = n_primaries except Timeout: logger.warn( "failed to acquire lock for {} for 3 seconds, giving up for now" .format(dose_file)) return if not bool(dose): logger.warn("skipping {}".format(dose_file)) return adose = itk.array_from_image(dose) if adose.shape != self.dosesum.shape: raise RuntimeError( "PROGRAMMING ERROR: dose shape {} differs from expected shape {}" .format(adose.shape, self.dosesum.shape)) self.dosesum += adose # n_primaries * (adose / n_primaries) self.dose2sum += adose**2 / n_primaries # n_primaries * (adose / n_primaries)**2 self.weightsum += n_primaries self.n += 1
def enclosing_geometry(img1, img2): """ Does img1 enclose img2? This function could be used to test whether img2 can be used as a reference image for resampling img1. """ if equal_geometry(img1, img2): return True o1 = np.array(itk.origin(img1)) o2 = np.array(itk.origin(img2)) s1 = np.array(itk.spacing(img1)) s2 = np.array(itk.spacing(img2)) n1 = np.array(itk.size(img1)) n2 = np.array(itk.size(img2)) # compute corners lower1 = o1 - 0.5 * s1 lower2 = o2 - 0.5 * s2 upper1 = o1 + (n1 - 0.5) * s1 upper2 = o2 + (n2 - 0.5) * s2 ####################################################################### # for debugging: percentages of img2 that are inside/outside of img1. # ####################################################################### bb1 = bounding_box(img=img1) vol1 = bb1.volume bb2 = bounding_box(img=img2) vol2 = bb2.volume assert (vol2 > 0) bb2.intersect(bb1) overlap = bb2.volume outside = vol2 - bb2.volume overlap_percent = overlap * 100. / vol2 outside_percent = outside * 100. / vol2 logger.debug(f"vol img2={vol1} vol img2={vol2}") logger.debug( f"part of img2 that overlaps with img1: {overlap} or {overlap_percent} percent" ) logger.debug( f"part of img2 that is outside img1: {outside} or {outside_percent} percent" ) ####################################################################### # end debugging section # ####################################################################### # now check the lower corner if (np.logical_not(np.isclose(lower1, lower2)) * (lower1 > lower2)).any(): return False # now check the upper corner if (np.logical_not(np.isclose(upper1, upper2)) * (upper1 < upper2)).any(): return False return True
def ITKUSCurvilinearScanconvert_File(input_filepath,\ dim =3,\ scan_angle = np.pi/2.0,\ radius_start = 12.4,\ radius_stop = 117.5,\ sz_output = (1108,725),\ spacing_output = (0.15, 0.15, 0.15)): ## Retrive the dimension of inputImage #dim = itkImg.ImageDimension frames = 0 sz_output = (1108, 725) origin_output = [0.0, 0.0] iType_CurvilinearImg = itk.CurvilinearArraySpecialCoordinatesImage[itk.F, dim] iType_SCUSImg = itk.Image[itk.F, dim] iFileReaderUSRF = itk.ImageFileReader[iType_CurvilinearImg].New() iFileReaderUSRF.SetFileName(input_filepath) iFileReaderUSRF.UpdateOutputInformation() iimg_curvilinear = iFileReaderUSRF.GetOutput() if dim == 3: frames = int(itk.size(iimg_curvilinear)[2]) sz_output = (1108, 725, frames) origin_output = [0.0, 0.0, 0.0] spacing_output = (0.15, 0.15, 0.15) else: sz_output = (1108, 725) origin_output = [0.0, 0.0] spacing_output = (0.15, 0.15) isz_curvilinear = iimg_curvilinear.GetLargestPossibleRegion().GetSize() ## Computing the parameters of curvilinear sacn-conversion lateral_angular_separation = scan_angle / (isz_curvilinear[1] - 1) radius_scan = (radius_stop - radius_start) / (isz_curvilinear[0] - 1) # sz_output = (1108,725, frames) # origin_output = [0.0, 0.0, 0.0] origin_output[0] = sz_output[0] * spacing_output[0] / -2.0 origin_output[1] = radius_start * np.cos(scan_angle / 2) iimg_curvilinear.SetLateralAngularSeparation(lateral_angular_separation) iimg_curvilinear.SetFirstSampleDistance(radius_start) iimg_curvilinear.SetRadiusSampleSize(radius_scan) ## Resample Image #iType_UCharImg = itk.Image[itk.UC, dim] iFilter_resample = itk.ResampleImageFilter[iType_CurvilinearImg, iType_SCUSImg].New() iFilter_resample.SetInput(iimg_curvilinear) iFilter_resample.SetSize(sz_output) iFilter_resample.SetOutputSpacing(spacing_output) iFilter_resample.SetOutputOrigin(origin_output) iFilter_resample.UpdateLargestPossibleRegion() ## Return a scan-converted US BMode image return iFilter_resample.GetOutput()
def test_itk_registration(self): import os os.environ["FOOTSTEPS_NAME"] = "test" import footsteps icon_registration.test_utils.download_test_data() model = icon_registration.pretrained_models.OAI_knees_registration_model( pretrained=True) image_A = itk.imread( str(icon_registration.test_utils.TEST_DATA_DIR / "knees_diverse_sizes" / #"9126260_20060921_SAG_3D_DESS_LEFT_11309302_image.nii.gz") "9487462_20081003_SAG_3D_DESS_RIGHT_11495603_image.nii.gz")) image_B = itk.imread( str(icon_registration.test_utils.TEST_DATA_DIR / "knees_diverse_sizes" / "9225063_20090413_SAG_3D_DESS_RIGHT_12784112_image.nii.gz")) print(image_A.GetLargestPossibleRegion().GetSize()) print(image_B.GetLargestPossibleRegion().GetSize()) print(image_A.GetSpacing()) print(image_B.GetSpacing()) phi_AB, phi_BA = icon_registration.itk_wrapper.register_pair( model, image_A, image_B) assert (isinstance(phi_AB, itk.CompositeTransform)) interpolator = itk.LinearInterpolateImageFunction.New(image_A) warped_image_A = itk.resample_image_filter( image_A, transform=phi_AB, interpolator=interpolator, size=itk.size(image_B), output_spacing=itk.spacing(image_B), output_direction=image_B.GetDirection(), output_origin=image_B.GetOrigin()) plt.imshow( np.array(itk.checker_board_image_filter(warped_image_A, image_B))[40]) plt.colorbar() plt.savefig(footsteps.output_dir + "grid.png") plt.clf() plt.imshow(np.array(warped_image_A)[40]) plt.savefig(footsteps.output_dir + "warped.png") plt.clf() reference = np.load(icon_registration.test_utils.TEST_DATA_DIR / "warped.npy") np.save(footsteps.output_dir + "warped.npy", itk.array_from_image(warped_image_A)[40]) self.assertLess( np.mean( np.abs(reference - itk.array_from_image(warped_image_A)[40])), 1e-6)
def ITKUSCurvilinearScanconvert_File(input_filepath,\ dim =3,\ scan_angle = np.pi/2.0,\ radius_start = 12.4,\ radius_stop = 117.5,\ sz_output = (1108,725),\ spacing_output = (0.15, 0.15, 0.15)): ## Retrive the dimension of inputImage #dim = itkImg.ImageDimension frames = 0 sz_output = (1108,725) origin_output = [0.0, 0.0] iType_CurvilinearImg = itk.CurvilinearArraySpecialCoordinatesImage[itk.F, dim] iType_SCUSImg = itk.Image[itk.F, dim] iFileReaderUSRF = itk.ImageFileReader[iType_CurvilinearImg].New() iFileReaderUSRF.SetFileName(input_filepath) iFileReaderUSRF.UpdateOutputInformation() iimg_curvilinear = iFileReaderUSRF.GetOutput() if dim == 3: frames = int(itk.size(iimg_curvilinear)[2]) sz_output = (1108,725, frames) origin_output = [0.0, 0.0, 0.0] spacing_output = (0.15, 0.15, 0.15) else: sz_output = (1108,725) origin_output = [0.0, 0.0] spacing_output = (0.15, 0.15) isz_curvilinear = iimg_curvilinear.GetLargestPossibleRegion().GetSize() ## Computing the parameters of curvilinear sacn-conversion lateral_angular_separation = scan_angle / (isz_curvilinear[1]-1) radius_scan = (radius_stop - radius_start) / (isz_curvilinear[0]-1) # sz_output = (1108,725, frames) # origin_output = [0.0, 0.0, 0.0] origin_output[0] = sz_output[0] * spacing_output[0]/ -2.0 origin_output[1] = radius_start * np.cos(scan_angle/2) iimg_curvilinear.SetLateralAngularSeparation(lateral_angular_separation) iimg_curvilinear.SetFirstSampleDistance(radius_start) iimg_curvilinear.SetRadiusSampleSize(radius_scan) ## Resample Image #iType_UCharImg = itk.Image[itk.UC, dim] iFilter_resample = itk.ResampleImageFilter[iType_CurvilinearImg, iType_SCUSImg].New() iFilter_resample.SetInput(iimg_curvilinear) iFilter_resample.SetSize(sz_output) iFilter_resample.SetOutputSpacing(spacing_output) iFilter_resample.SetOutputOrigin(origin_output) iFilter_resample.UpdateLargestPossibleRegion() ## Return a scan-converted US BMode image return iFilter_resample.GetOutput()
def test_paste_to_common_space(): # Import succeeds from hasi.align import mesh_to_image, paste_to_common_space # Paste succeeds resized_images = paste_to_common_space( [target_healthy_image, target_unhealthy_image]) assert (len(resized_images) == 2) # Verify common space TOLERANCE = 1e-6 assert (itk.size(resized_images[0]) == itk.size(resized_images[1])) assert (all([ itk.spacing(resized_images[0])[dim] - itk.spacing(resized_images[1])[dim] < TOLERANCE for dim in range(dimension) ]))
def _get_spatial_shape(self, img: Image) -> Sequence: """ Get the spatial shape of image data, it doesn't contain the channel dim. Args: img: a ITK image object loaded from a image file. """ return list(itk.size(img))
def _get_spatial_shape(self, img) -> np.ndarray: """ Get the spatial shape of image data, it doesn't contain the channel dim. Args: img: a ITK image object loaded from a image file. """ shape = list(itk.size(img)) shape.reverse() return np.asarray(shape)
def _get_spatial_shape(self, img): """ Get the spatial shape of image data, it doesn't contain the channel dim. Args: img: a ITK image object loaded from a image file. """ # the img data should have no channel dim or the last dim is channel shape = list(itk.size(img)) shape.reverse() return np.asarray(shape)
def attenuation_local(prim_per_proj, proj_path): if not os.path.exists(proj_path): os.makedirs(proj_path) interp_secfolder = 'interpolated_secondaries' if not os.path.exists(interp_secfolder): os.makedirs(interp_secfolder) #IMC=PMC×#primaries_per_projection×(512/128)^2+SMC size_primary = 512 size_scatter = 64 factor = prim_per_proj * pow(size_primary / size_scatter, 2) # get all the primary projections primary_files = sorted(glob.glob('./output/primary*.mha')) interpolate_secondaries(secondary_folder, interp_secfolder, 4, len(primary_files)) for projnum, primary_filename in enumerate(primary_files): # load the primary, secondary, and flatfield primary = itk.imread(primary_filename) flatfield = itk.imread(primary_filename.replace( "primary", "flatfield")) #not needed anymore - secondaries only have half the projections, so the secondary projection number = projnum/2 #second_projnum = projnum // 4 #secondary = itk.imread(f'./output/secondary{second_projnum:04d}.mha') secondary = itk.imread( f'{interp_secfolder}/secondary{projnum:04d}.mha') resizedsecondary = gt.applyTransformation( input=secondary, newsize=itk.size(primary), neworigin=itk.origin(primary), adaptive=True, force_resample=True) flatfield = itk.MultiplyImageFilter(flatfield, factor) prim_second = itk.AddImageFilter( itk.MultiplyImageFilter(primary, factor), resizedsecondary) #flatfield_sq = itk.MultiplyImageFilter(flatfield,flatfield) S = itk.DivideImageFilter(prim_second, flatfield) S = itk.MultiplyImageFilter(S, itk.MedianImageFilter(flatfield)) attenuation = itk.LogImageFilter(S) #attenuation = itk.LogImageFilter(itk.DivideImageFilter(prim_second,flatfield)) attenuation = itk.MultiplyImageFilter(attenuation, -1) itk.imwrite( attenuation, primary_filename.replace('./output/primary', f'{proj_path}/attenuation_sec'))
def downsample_images(images:list, ratio:float) -> list: assert(ratio > 1.0) downsampled_image_list = list() for image in images: new_spacing = [spacing * ratio for spacing in itk.spacing(image)] new_size = [int(size / ratio) for size in itk.size(image)] downsampled_image = itk.resample_image_filter(image, size=new_size, output_origin=itk.origin(image), output_spacing=new_spacing) downsampled_image_list.append(downsampled_image) return downsampled_image_list
def compute_real_width_and_height(image, width, height): image_size = itk.size(image) if width is None and height is None: width = DEFAULT_WIDTH height = DEFAULT_HEIGHT elif width is None: width = int(math.ceil(image_size[0] / image_size[1] * height)) elif height is None: height = int(math.ceil(image_size[1] / image_size[0] * width)) if not height >= 1 or not width >= 1: raise Exception( "`height` and `width` must be greater than or equal to 1") return width, height
def create_backend_obj( cls, data_array: NdarrayOrTensor, channel_dim: Optional[int] = 0, affine: Optional[NdarrayOrTensor] = None, dtype: DtypeLike = np.float32, affine_lps_to_ras: bool = True, **kwargs, ): """ Create an ITK object from ``data_array``. This method assumes a 'channel-last' ``data_array``. Args: data_array: input data array. channel_dim: channel dimension of the data array. This is used to create a Vector Image if it is not ``None``. affine: affine matrix of the data array. This is used to compute `spacing`, `direction` and `origin`. dtype: output data type. affine_lps_to_ras: whether to convert the affine matrix from "LPS" to "RAS". Defaults to ``True``. Set to ``True`` to be consistent with ``NibabelWriter``, otherwise the affine matrix is assumed already in the ITK convention. kwargs: keyword arguments. Current `itk.GetImageFromArray` will read ``ttype`` from this dictionary. see also: - https://github.com/InsightSoftwareConsortium/ITK/blob/v5.2.1/Wrapping/Generators/Python/itk/support/extras.py#L389 """ data_array = super().create_backend_obj(data_array) _is_vec = channel_dim is not None if _is_vec: data_array = np.moveaxis(data_array, -1, 0) # from channel last to channel first data_array = data_array.T.astype(dtype, copy=True, order="C") itk_obj = itk.GetImageFromArray(data_array, is_vector=_is_vec, ttype=kwargs.pop("ttype", None)) d = len(itk.size(itk_obj)) if affine is None: affine = np.eye(d + 1, dtype=np.float64) _affine = convert_data_type(affine, np.ndarray)[0] if affine_lps_to_ras: _affine = orientation_ras_lps(to_affine_nd(d, _affine)) spacing = affine_to_spacing(_affine, r=d) _direction: np.ndarray = np.diag(1 / spacing) _direction = _affine[:d, :d] @ _direction itk_obj.SetSpacing(spacing.tolist()) itk_obj.SetOrigin(_affine[:d, -1].tolist()) itk_obj.SetDirection(itk.GetMatrixFromArray(_direction)) return itk_obj
def vtk_image_from_image(image): """Convert an itk.Image to a vtk.vtkImageData.""" import itk import vtk from vtk.util.numpy_support import numpy_to_vtk array = itk.array_view_from_image(image) vtk_image = vtk.vtkImageData() data_array = numpy_to_vtk(array.reshape(-1)) data_array.SetNumberOfComponents(image.GetNumberOfComponentsPerPixel()) data_array.SetName('Scalars') # Always set Scalars for (future?) multi-component volume rendering vtk_image.GetPointData().SetScalars(data_array) dim = image.GetImageDimension() spacing = [ 1.0, ] * 3 spacing[:dim] = image.GetSpacing() vtk_image.SetSpacing(spacing) origin = [ 0.0, ] * 3 origin[:dim] = image.GetOrigin() vtk_image.SetOrigin(origin) dims = [ 1, ] * 3 dims[:dim] = itk.size(image) vtk_image.SetDimensions(dims) # Todo: Add Direction with VTK 9 if image.GetImageDimension() == 3: PixelType = itk.template(image)[1][0] if PixelType == itk.Vector: vtk_image.GetPointData().SetVectors(data_array) elif PixelType == itk.CovariantVector: vtk_image.GetPointData().SetVectors(data_array) elif PixelType == itk.SymmetricSecondRankTensor: vtk_image.GetPointData().SetTensors(data_array) elif PixelType == itk.DiffusionTensor3D: vtk_image.GetPointData().SetTensors(data_array) return vtk_image
def smooth_and_resample(image, width, height): # Set input image origin to 0,0 as we do not want to worry about it. image.SetOrigin([0, 0]) original_size = itk.size(image) original_spacing = image.GetSpacing() # We need to create a new Python variable to compute # the new size as `size_im` that was returned above is # actually a reference that points to the value that is # contained in the image. new_size = itk.Size[OUTPUT_IMAGE_DIMENSION]() new_size[0] = width new_size[1] = height SpacingType = itk.Vector[itk.D, OUTPUT_IMAGE_DIMENSION] scale = SpacingType() new_spacing = SpacingType() for ii in range(OUTPUT_IMAGE_DIMENSION): scale[ii] = float(original_size[ii]) / float(new_size[ii]) new_spacing[ii] = scale[ii] * original_spacing[ii] # Make output image isotropic since jpeg does not have spacing information. # We keep the largest spacing, to avoid cutting the image along one # direction. if new_spacing[0] > new_spacing[1]: new_spacing[1] = new_spacing[0] else: new_spacing[0] = new_spacing[1] sigma = SpacingType() for ii in [0, 1]: sigma[ii] = 2 * new_spacing[ii] / math.pi variance = sigma * sigma gaussian_image = itk.DiscreteGaussianImageFilter(image, UseImageSpacing=True, Variance=variance) resampled_image = itk.ResampleImageFilter(gaussian_image, Size=new_size, OutputSpacing=new_spacing) return resampled_image
def xarray_from_image(l_image): """Convert an itk.Image to an xarray.DataArray. Origin and spacing metadata is preserved in the xarray's coords. The Direction is set in the `direction` attribute. Dims are labeled as `x`, `y`, `z`, and `c`. This interface is and behavior is experimental and is subject to possible future changes.""" import xarray as xr import itk import numpy as np array_view = itk.array_view_from_image(l_image) l_spacing = itk.spacing(l_image) l_origin = itk.origin(l_image) l_size = itk.size(l_image) direction = np.flip(itk.array_from_matrix(l_image.GetDirection())) spatial_dimension = l_image.GetImageDimension() spatial_dims = ("x", "y", "z") coords = {} for l_index, dim in enumerate(spatial_dims[:spatial_dimension]): coords[dim] = np.linspace( l_origin[l_index], l_origin[l_index] + (l_size[l_index] - 1) * l_spacing[l_index], l_size[l_index], dtype=np.float64, ) dims = list(reversed(spatial_dims[:spatial_dimension])) components = l_image.GetNumberOfComponentsPerPixel() if components > 1: dims.append("c") coords["c"] = np.arange(components, dtype=np.uint64) data_array = xr.DataArray(array_view, dims=dims, coords=coords, attrs={"direction": direction}) return data_array
medianCENP, Sigma=0.05) sizeCENP = itk.PhysicalSizeOpeningImageFilter.IUC3IUC3.New( gaussianCENP, Lambda=0.36) subCENP = itk.SubtractImageFilter.IUC3IUC3IUC3.New(gaussianCENP, sizeCENP) size2CENP = itk.PhysicalSizeOpeningImageFilter.IUC3IUC3.New( subCENP, Lambda=0.02) maskCENP = itk.LabelMapMaskImageFilter.LM3IUC3.New( lmNuclei, size2CENP, Label=0) thCENP = itk.BinaryThresholdImageFilter.IUC3IUC3.New( maskCENP, LowerThreshold=35) statsCENP = itk.BinaryImageToStatisticsLabelMapFilter.IUC3IUC3LM3.New( thCENP, subCENP) # create a new image to store the CENP centers, so they can be easily reused to check the distribution cenpSpotsImg = itk.Image.UC3.New( Regions=itk.size(readerNuclei), Spacing=itk.spacing(readerNuclei)) cenpSpotsImg.Allocate() cenpSpotsImg.FillBuffer(0) if opts.visualValidation: # create a new image to store the CENP segmentation cenpImg = itk.LabelMap._3.New( Regions=itk.size(readerNuclei), Spacing=itk.spacing(readerNuclei)) fullCENP = itk.LabelMapToBinaryImageFilter.LM3IUC3.New(cenpImg) dilateCENP = itk.BinaryDilateImageFilter.IUC3IUC3SE3.New( fullCENP, Kernel=itk.strel(3, [10, 10, 3])) borderCENP = itk.BinaryBorderImageFilter.IUC3IUC3.New(dilateCENP) outsideMask = itk.BinaryThresholdImageFilter.IUC3IUC3.New( lm2iNuclei, UpperThreshold=0) relabelCENP = itk.NaryRelabelImageFilter.IUC3IUC3.New( outsideMask, borderCENP)
def ConvertRF2BMode(inputFilePath, outputFilePath): ## Check print inputFilePath print outputFilePath ## Initialize Dimension = 3 ## Load RF data InputPixelType = itk.F ImageType = itk.Image[InputPixelType, Dimension] reader = itk.ImageFileReader[ImageType].New() reader.SetFileName(inputFilePath) # reader.Update() ## Generate Pre-Scanconversion Data from the RF file PreSc_BMode_Filter = itk.BModeImageFilter[ImageType, ImageType].New() PreSc_BMode_Filter.SetInput(reader.GetOutput()) PreSc_BMode_Filter.SetDirection(1) # PreSc_BMode_Filter.Update() PreSc_BMode = PreSc_BMode_Filter.GetOutput() InputRF_Size = itk.size(PreSc_BMode) print '----------------' print InputRF_Size[0] print InputRF_Size[1] print InputRF_Size[2] RF_Sz_Z = InputRF_Size[2] # output_size = (1108, 725, RF_Sz_Z) # # print "---- Before ----" # print "The type of RF_Sz_Z: %s" % type(RF_Sz_Z) # print "The type of output_size: %s" % type(output_size) # # print "---- After -----" # RF_Sz_Z_Int = int(RF_Sz_Z) # output_size_Int = (1108, 725, RF_Sz_Z_Int) # print "The type of RF_Sz_Z_Int: %s" % type(RF_Sz_Z_Int) # print "The type of output_size_Int: %s" % type(output_size_Int) ## Scanconversion #01. Rescale the image's intensity CurvilinearImageType = itk.CurvilinearArraySpecialCoordinatesImage[itk.UC, Dimension] rescale_filter = itk.RescaleIntensityImageFilter[ImageType, CurvilinearImageType].New() #rescale_filter.SetInput(PreSc_BMode)#(bmode_filter.GetOutput()) rescale_filter.SetInput(PreSc_BMode_Filter.GetOutput()) rescale_filter.UpdateLargestPossibleRegion() curvilinear = rescale_filter.GetOutput() # writer = itk.ImageFileWriter[CurvilinearImageType].New() # writer.SetFileName(outputFilePath) # writer.SetInput(curvilinear) # writer.Update() #02. Scanconversion curvilinear_size = curvilinear.GetLargestPossibleRegion().GetSize() #lateral_angular_separation = (np.pi / 2.0 + np.pi / 4.0) / (curvilinear_size[1] - 1) lateral_angular_separation = (np.pi / 2.0 ) / (curvilinear_size[1] - 1) radius_start = 12.4 radius_stop = 117.5 curvilinear.SetLateralAngularSeparation(lateral_angular_separation) curvilinear.SetFirstSampleDistance(radius_start) curvilinear.SetRadiusSampleSize((radius_stop - radius_start) / (curvilinear_size[0] - 1)) #output_size = (800, 800) #output_size = (1108, 725) output_size = (int(1108), int(725), int(RF_Sz_Z)) print output_size output_spacing = (float(0.15), float(0.15), float(0.15)) output_origin = [float(0.0), float(0.0), float(0.0)] output_origin[0] = float(output_size[0] * output_spacing[0] / -2.0) output_origin[1] = float(radius_start * np.cos(np.pi / 4.0)) UCharImageType = itk.Image[itk.UC, Dimension] resample_filter = itk.ResampleImageFilter[CurvilinearImageType, UCharImageType].New() resample_filter.SetInput(curvilinear) resample_filter.SetSize(output_size) resample_filter.SetOutputSpacing(output_spacing) resample_filter.SetOutputOrigin(output_origin) resample_filter.UpdateLargestPossibleRegion() bmode_image2 = resample_filter.GetOutput() bmode_image2.DisconnectPipeline() writer = itk.ImageFileWriter[UCharImageType].New() writer.SetFileName(outputFilePath) writer.SetInput(bmode_image2) writer.Update() print '------------------------' print 'Done'
# # Example on the use of the MeanImageFilter # import itk from sys import argv dim = 2 PixelType = itk.F ImageType = itk.Image[PixelType, dim] reader = itk.ImageFileReader[ImageType].New( FileName=argv[1] ) fftFilter = itk.FFTWRealToComplexConjugateImageFilter[PixelType, dim].New(reader) fftFilter2 = itk.FFTWComplexConjugateToRealImageFilter[PixelType, dim].New(fftFilter) cast = itk.CastImageFilter[ImageType, itk.Image[itk.UC, dim]].New( fftFilter2 ) itk.write(cast, argv[2]) print itk.size(fftFilter).GetElement(0), itk.size(fftFilter).GetElement(1)
input_image_file = sys.argv[1] spacing_fraction = float(sys.argv[2]) sigma_fraction = float(sys.argv[3]) output_image_file_label_image_interpolator = sys.argv[4] output_image_file_nearest_neighbor_interpolator = sys.argv[5] input_image = itk.imread(input_image_file) resize_filter = itk.ResampleImageFilter.New(input_image) input_spacing = itk.spacing(input_image) output_spacing = [s * spacing_fraction for s in input_spacing] resize_filter.SetOutputSpacing(output_spacing) input_size = itk.size(input_image) output_size = [ int(s * input_spacing[dim] / spacing_fraction) for dim, s in enumerate(input_size) ] resize_filter.SetSize(output_size) gaussian_interpolator = itk.LabelImageGaussianInterpolateImageFunction.New(input_image) sigma = [s * sigma_fraction for s in output_spacing] gaussian_interpolator.SetSigma(sigma) gaussian_interpolator.SetAlpha(3.0) resize_filter.SetInterpolator(gaussian_interpolator) itk.imwrite(resize_filter, output_image_file_label_image_interpolator) nearest_neighbor_interpolator = itk.NearestNeighborInterpolateImageFunction.New( input_image
def Estimate_USRF_ReferenceSpectrum(input_filepath, side_lines=5, fft1D_size=128, subregion_depth_fraction=1.0): InputPixelType = itk.ctype('float') Dimension = 2 ImageType = itk.Image[InputPixelType, Dimension] reader = itk.ImageFileReader[ImageType].New() reader.SetFileName(input_filepath) input_RF = reader.GetOutput() # Apply missing spacing information if 'LinearProbe' in input_filepath: change_information = itk.ChangeInformationImageFilter.New(input_RF) change_information.SetUseReferenceImage(True) change_information.SetChangeSpacing(True) output_spacing = [1.0, 1.0] size = itk.size(input_RF) sos = 1540. fs = 30000. output_spacing[0] = sos / (2 * fs) transducer_width = 30.0 output_spacing[1] = transducer_width / (size[1] - 1) change_information.SetOutputSpacing(output_spacing) input_RF = change_information.GetOutput() input_RF.UpdateOutputInformation() # Look for the peak signal amplitude in a sub-region subregion_filter = itk.RegionOfInterestImageFilter.New(input_RF) subregion = itk.region(input_RF) input_size = itk.size(input_RF) input_index = itk.index(input_RF) # Skip the initial 10% of the beamline, which is in the nearfield subregion_index = itk.Index[Dimension]() subregion_index[0] = int(input_size[0] * 0.1) subregion_index[1] = input_index[1] subregion.SetIndex(subregion_index) subregion_size = itk.Size[Dimension]() subregion_size[0] = input_size[0] - subregion_index[0] subregion_size[0] = subregion_size[0] - int((1. - subregion_depth_fraction) * subregion_size[0]) subregion_size[1] = input_size[1] subregion.SetSize(subregion_size) subregion_filter.SetRegionOfInterest(subregion) subregion_filter.UpdateLargestPossibleRegion() subregion_image = subregion_filter.GetOutput() max_calculator = itk.MinimumMaximumImageCalculator.New(subregion_image) max_calculator.ComputeMaximum() max_index = max_calculator.GetIndexOfMaximum() SideLinesPixelType = itk.ctype('unsigned char') SideLinesImageType = itk.Image[SideLinesPixelType, Dimension] side_lines_image = SideLinesImageType.New() side_lines_image.CopyInformation(subregion_image) side_lines_image.SetRegions(subregion_image.GetLargestPossibleRegion()) side_lines_image.Allocate() side_lines_image.FillBuffer(side_lines) spectra_window_filter = itk.Spectra1DSupportWindowImageFilter.New(side_lines_image) spectra_window_filter.SetFFT1DSize(fft1D_size) spectra_filter = itk.Spectra1DImageFilter.New(subregion_filter) spectra_filter.SetSupportWindowImage(spectra_window_filter.GetOutput()) spectra_filter.UpdateLargestPossibleRegion() reference_spectrum_filter = itk.RegionOfInterestImageFilter.New(spectra_filter) reference_spectrum_region = itk.region(spectra_filter.GetOutput()) reference_spectrum_region.SetIndex(max_index) reference_spectrum_size = itk.Size[Dimension]() reference_spectrum_size.Fill(1) reference_spectrum_region.SetSize(reference_spectrum_size) reference_spectrum_filter.SetRegionOfInterest(reference_spectrum_region) input_dir, input_file = os.path.split(input_filepath) output_dir = os.path.join(input_dir, 'ReferenceSpectrum') if not os.path.exists(output_dir): os.makedirs(output_dir) input_filename, input_fileext = os.path.splitext(input_file) identifier = '_ReferenceSpectrum_side_lines_{:02d}_fft1d_size_{:03d}.mha'.format(side_lines, fft1D_size) output_file = os.path.join(output_dir, input_filename + identifier) writer = itk.ImageFileWriter.New(reference_spectrum_filter) writer.SetFileName(output_file) writer.SetUseCompression(True) writer.Update()
def process(in_dir, out_dir, width, height, slices): if not slices >= 2: raise Exception("`slices` must me greater or equal to 1.") # Create output directory if necessary. if not os.path.exists(out_dir): os.makedirs(out_dir) file_names = get_filenames(in_dir) dicom_reader = ImageSeriesReader(FileNames=file_names) dicom_reader.MetaDataDictionaryArrayUpdateOn() dicom_reader.Update() meta_dict = dicom_reader.GetMetaDataDictionaryArray()[0] image = dicom_reader.GetOutput() # Rescaling is performed on the entire input image instead of on a # per-slice basis to allow rescaling the image based on its global # minimum and maximum if `width` and `center` tags are not defined # in the DICOM. The output of this function is scaled between 0 and 255. rescaled_image = rescale_dicom_image_intensity(image, meta_dict) width, height = compute_real_width_and_height(rescaled_image, width, height) image_dimension = rescaled_image.GetImageDimension() # Verifies that input image is 3D. This allows to simplify the logic after. if image_dimension != INPUT_IMAGE_DIMENSION: raise Exception("Input must be a %dD image. %d dimensions found." % (INPUT_IMAGE_DIMENSION, image_dimension)) # Process each slice independently. This allows to only resample and # rescale the slices that will be saved at the end. NOTE: One could have # created a pipeline with `itk.pipeline()` which would only be run in the # end and only process requested regions, e.g. slice by slice. This method # would be useful if one wanted to resample the image in 3D instead of # processing each slice independently but is not necessary for now. image_size = itk.size(rescaled_image) size_sampling_dim = image_size[SLICING_DIMENSION] region = itk.ImageRegion[INPUT_IMAGE_DIMENSION]() new_size = itk.Size[INPUT_IMAGE_DIMENSION]() image_index = itk.Index[INPUT_IMAGE_DIMENSION]() for ii in range(INPUT_IMAGE_DIMENSION - 1): new_size[ii] = image_size[ii] new_size[INPUT_IMAGE_DIMENSION - 1] = 0 region.SetSize(new_size) CollapsedImageType = itk.Image[itk.template(rescaled_image)[1][0], OUTPUT_IMAGE_DIMENSION] list_indices = [] for ii in range(slices): slice_index = int((size_sampling_dim - 1) * ii / (slices - 1)) image_index[SLICING_DIMENSION] = slice_index list_indices.append(slice_index) region.SetIndex(image_index) slice_image_filter = itk.ExtractImageFilter[ rescaled_image, CollapsedImageType].New(rescaled_image, ExtractionRegion=region) slice_image_filter.SetDirectionCollapseToIdentity() slice_image_filter.Update() resampled_image = smooth_and_resample(slice_image_filter.GetOutput(), width, height) save_as_jpeg(resampled_image, out_dir, slice_index) # Generate JSON file generate_json(out_dir, list_indices)
import itk from sys import argv dim = 2 PType = itk.US IType = itk.Image[PType, dim] reader = itk.ImageFileReader[IType].New(FileName=argv[1]) inputImage = reader.GetOutput() # it is not required to update the filter: itk.size() update it # to get the information it needs size = itk.size(inputImage) scale = itk.ScaleTransform[itk.D, dim].New(Parameters=[eval( argv[3] ), eval( argv[3] )]) # sequence typemap is not supported yet for itk::Point centralPoint = itk.Point[itk.D, dim]() centralPoint[0] = size[0] / 2. centralPoint[1] = size[1] / 2. scale.SetCenter( centralPoint ) interpolator = itkLinearInterpolateImageFunction[PType, dime, itk.D].New() resampler = itkResampleImageFilter[IType, IType].New(reader) resampler.SetTransform( scale.GetPointer() ) resampler.SetInterpolator( interpolator.GetPointer() ) resampler.SetSize( size ) resampler.SetOutputSpacing( inputImage.GetSpacing() ) writer = itk.ImageFileWriter[IType].New(resampler, FileName=argv[2])
def Convert_USRF_BMode(inputFilePath): Input_Dir, Input_File = os.path.split(inputFilePath) Input_FileName, Input_FileExt = os.path.splitext(Input_File) ## Set Output Dir Out_Dir = Input_Dir +'/BMode/' if not os.path.exists(Out_Dir): os.makedirs(Out_Dir) ## Load RF data InputPixelType = itk.ctype('float') Dimension = 2 ImageType = itk.Image[InputPixelType, Dimension] direction = 0 reader = itk.ImageFileReader[ImageType].New() reader.SetFileName(inputFilePath) # Remove low frequency artifacts on the Interson array probe filterFunction = itk.ButterworthBandpass1DFilterFunction.New() # < 2 MHz filterFunction.SetLowerFrequency( 0.12 ) filterFunction.SetOrder( 7 ) ComplexPixelType = itk.complex[InputPixelType] ComplexImageType = itk.Image[ComplexPixelType, Dimension] frequencyFilter = itk.FrequencyDomain1DImageFilter[ComplexImageType, ComplexImageType].New() frequencyFilter.SetDirection(direction) filterFunctionBase = itk.FrequencyDomain1DFilterFunction.New() frequencyFilter.SetFilterFunction(filterFunctionBase.cast(filterFunction)) ## Generate Pre-Scanconversion Data from the RF file bMode_Filter = itk.BModeImageFilter[ImageType, ImageType].New() bMode_Filter.SetInput(reader.GetOutput()) bMode_Filter.SetDirection(direction) bMode_Filter.SetFrequencyFilter(frequencyFilter) bMode_Filter.Update() bMode = bMode_Filter.GetOutput() writerInput = bMode # Apply missing spacing information if 'LinearProbe' in inputFilePath: changeInformation = itk.ChangeInformationImageFilter.New(bMode) changeInformation.SetUseReferenceImage(True) changeInformation.SetChangeSpacing(True) output_spacing = [1.0, 1.0] size = itk.size(bMode) sos = 1540. fs = 30000. output_spacing[0] = sos / (2 * fs) transducer_width = 30.0 output_spacing[1] = transducer_width / (size[1] - 1) changeInformation.SetOutputSpacing(output_spacing) writerInput = changeInformation.GetOutput() outputFilePath = Out_Dir + Input_FileName + '_BMode.mha' print(outputFilePath) writer = itk.ImageFileWriter[ImageType].New() writer.SetFileName(outputFilePath) writer.SetInput(writerInput) writer.SetUseCompression(True) writer.Update()
def Convert_USRF_BMode(inputFilePath): Input_Dir, Input_File = os.path.split(inputFilePath) Input_FileName, Input_FileExt = os.path.splitext(Input_File) ## Set Output Dir Out_Dir = Input_Dir + '/BMode/' if not os.path.exists(Out_Dir): os.makedirs(Out_Dir) ## Load RF data InputPixelType = itk.ctype('float') Dimension = 2 ImageType = itk.Image[InputPixelType, Dimension] direction = 0 reader = itk.ImageFileReader[ImageType].New() reader.SetFileName(inputFilePath) # Remove low frequency artifacts on the Interson array probe filterFunction = itk.ButterworthBandpass1DFilterFunction.New() # < 2 MHz filterFunction.SetLowerFrequency(0.12) filterFunction.SetOrder(7) ComplexPixelType = itk.complex[InputPixelType] ComplexImageType = itk.Image[ComplexPixelType, Dimension] frequencyFilter = itk.FrequencyDomain1DImageFilter[ComplexImageType, ComplexImageType].New() frequencyFilter.SetDirection(direction) filterFunctionBase = itk.FrequencyDomain1DFilterFunction.New() frequencyFilter.SetFilterFunction(filterFunctionBase.cast(filterFunction)) ## Generate Pre-Scanconversion Data from the RF file bMode_Filter = itk.BModeImageFilter[ImageType, ImageType].New() bMode_Filter.SetInput(reader.GetOutput()) bMode_Filter.SetDirection(direction) bMode_Filter.SetFrequencyFilter(frequencyFilter) bMode_Filter.Update() bMode = bMode_Filter.GetOutput() writerInput = bMode # Apply missing spacing information if 'LinearProbe' in inputFilePath: changeInformation = itk.ChangeInformationImageFilter.New(bMode) changeInformation.SetUseReferenceImage(True) changeInformation.SetChangeSpacing(True) output_spacing = [1.0, 1.0] size = itk.size(bMode) sos = 1540. fs = 30000. output_spacing[0] = sos / (2 * fs) transducer_width = 30.0 output_spacing[1] = transducer_width / (size[1] - 1) changeInformation.SetOutputSpacing(output_spacing) writerInput = changeInformation.GetOutput() outputFilePath = Out_Dir + Input_FileName + '_BMode.mha' print(outputFilePath) writer = itk.ImageFileWriter[ImageType].New() writer.SetFileName(outputFilePath) writer.SetInput(writerInput) writer.SetUseCompression(True) writer.Update()
lmNuclei = li2lm lmNuclei() # keep only one nucleus in the pre-filtered cenp image mask = itk.LabelMapMaskImageFilter.LM3IUS3.New(lmNuclei, sub, Crop=True, CropBorder=1, Label=3) # search a nice threshold - it will be based on the values of the brightests regions (spots) rmax = itk.RegionalMaximaImageFilter.IUS3IUS3.New(mask, FullyConnected=True) rmaxbi2lm = itk.BinaryImageToStatisticsLabelMapFilter.IUS3IUS3LM3.New(rmax, mask, FullyConnected=True) rmaxRelabel = itk.StatisticsRelabelLabelMapFilter.LM3.New(rmaxbi2lm, Attribute="Maximum") # and locate the spots th = itk.BinaryThresholdImageFilter.IUS3IUC3.New(mask) # convert them to a label map representation bi2lm = itk.BinaryImageToStatisticsLabelMapFilter.IUC3IUS3LM3.New(th, sub, FullyConnected=True) # visualisation result = itk.LabelMap._3.New(Regions=itk.size(cenp)) # border = itk.LabelContourImageFilter.IUC3IUC3.New(auto_progress=False)#, FullyConnected=True) # obo3 = itk.ObjectByObjectLabelMapFilter.LM3.New(li2lm, Filter=border, PadSize=6) border = itk.LabelContourImageFilter.IUC2IUC2.New(auto_progress=False)#, FullyConnected=True) slice = itk.SliceBySliceImageFilter.IUC3IUC3.New(nuclei, Filter=border) obo3 = itk.LabelImageToLabelMapFilter.IUC3LM3.New(slice) obo3() dilate2 = itk.BinaryDilateImageFilter.IUC3IUC3SE3.New(Kernel=itk.strel(3,[3,3,1]), auto_progress=False) dilate3 = itk.BinaryDilateImageFilter.IUC3IUC3SE3.New(dilate2, Kernel=itk.FlatStructuringElement._3.Cross(1), auto_progress=False) border2 = itk.SubtractImageFilter.IUC3IUC3IUC3.New(dilate3, dilate2, auto_progress=False) obo2 = itk.ObjectByObjectLabelMapFilter.LM3.New(bi2lm, InputFilter=dilate2, OutputFilter=border2, PadSize=6) crop = itk.AutoCropLabelMapFilter.LM3.New(result, CropBorder=[30,30,10]) window = itk.IntensityWindowingImageFilter.IUS3IUS3.New(cenp, OutputMinimum=0, OutputMaximum=255)
if argv[2] == "Ball": print "Ball" strel = itk.FlatStructuringElement[2].Ball(int(argv[3])) elif argv[2] == "Box": print "Box" strel = itk.FlatStructuringElement[2].Box(int(argv[3])) elif argv[2] == "FromImage": print "FromImage" reader = itk.ImageFileReader.IUC2.New(FileName=argv[3]) strel = itk.FlatStructuringElement[2].FromImageUC(reader.GetOutput()) else: print "invalid arguement: " + argv[2] exit(1) img = strel.GetImageUC() size = itk.size(img) for y in range(0, size.GetElement(1)): for x in range(0, size.GetElement(0)): if img.GetPixel([x, y]): print "X", else: print " ", print "\n", itk.write(img, argv[1]) # writer = itk.ImageFileWriter.IUC2.New(FileName=argv[1], Input=img ) # itk.echo(writer) # writer.Update()
try: itk.ctype("dummy") raise Exception("unknown C type should send an exception") except KeyError: pass # test output assert itk.output(reader) == reader.GetOutput() assert itk.output(1) == 1 # test the deprecated image assert itk.image(reader) == reader.GetOutput() assert itk.image(1) == 1 # test size s = itk.size(reader) assert s[0] == s[1] == 256 s = itk.size(reader.GetOutput()) assert s[0] == s[1] == 256 # test physical size s = itk.physical_size(reader) assert s[0] == s[1] == 256.0 s = itk.physical_size(reader.GetOutput()) assert s[0] == s[1] == 256.0 # test spacing s = itk.spacing(reader) assert s[0] == s[1] == 1.0 s = itk.spacing(reader.GetOutput()) assert s[0] == s[1] == 1.0
def ConvertRF2BMode(inputFilePath, outputFilePath): ## Check print inputFilePath print outputFilePath ## Initialize Dimension = 3 ## Load RF data InputPixelType = itk.F ImageType = itk.Image[InputPixelType, Dimension] reader = itk.ImageFileReader[ImageType].New() reader.SetFileName(inputFilePath) # reader.Update() ## Generate Pre-Scanconversion Data from the RF file PreSc_BMode_Filter = itk.BModeImageFilter[ImageType, ImageType].New() PreSc_BMode_Filter.SetInput(reader.GetOutput()) PreSc_BMode_Filter.SetDirection(1) # PreSc_BMode_Filter.Update() PreSc_BMode = PreSc_BMode_Filter.GetOutput() InputRF_Size = itk.size(PreSc_BMode) print '----------------' print InputRF_Size[0] print InputRF_Size[1] print InputRF_Size[2] RF_Sz_Z = InputRF_Size[2] # output_size = (1108, 725, RF_Sz_Z) # # print "---- Before ----" # print "The type of RF_Sz_Z: %s" % type(RF_Sz_Z) # print "The type of output_size: %s" % type(output_size) # # print "---- After -----" # RF_Sz_Z_Int = int(RF_Sz_Z) # output_size_Int = (1108, 725, RF_Sz_Z_Int) # print "The type of RF_Sz_Z_Int: %s" % type(RF_Sz_Z_Int) # print "The type of output_size_Int: %s" % type(output_size_Int) ## Scanconversion #01. Rescale the image's intensity CurvilinearImageType = itk.CurvilinearArraySpecialCoordinatesImage[ itk.UC, Dimension] rescale_filter = itk.RescaleIntensityImageFilter[ ImageType, CurvilinearImageType].New() #rescale_filter.SetInput(PreSc_BMode)#(bmode_filter.GetOutput()) rescale_filter.SetInput(PreSc_BMode_Filter.GetOutput()) rescale_filter.UpdateLargestPossibleRegion() curvilinear = rescale_filter.GetOutput() # writer = itk.ImageFileWriter[CurvilinearImageType].New() # writer.SetFileName(outputFilePath) # writer.SetInput(curvilinear) # writer.Update() #02. Scanconversion curvilinear_size = curvilinear.GetLargestPossibleRegion().GetSize() #lateral_angular_separation = (np.pi / 2.0 + np.pi / 4.0) / (curvilinear_size[1] - 1) lateral_angular_separation = (np.pi / 2.0) / (curvilinear_size[1] - 1) radius_start = 12.4 radius_stop = 117.5 curvilinear.SetLateralAngularSeparation(lateral_angular_separation) curvilinear.SetFirstSampleDistance(radius_start) curvilinear.SetRadiusSampleSize( (radius_stop - radius_start) / (curvilinear_size[0] - 1)) #output_size = (800, 800) #output_size = (1108, 725) output_size = (int(1108), int(725), int(RF_Sz_Z)) print output_size output_spacing = (float(0.15), float(0.15), float(0.15)) output_origin = [float(0.0), float(0.0), float(0.0)] output_origin[0] = float(output_size[0] * output_spacing[0] / -2.0) output_origin[1] = float(radius_start * np.cos(np.pi / 4.0)) UCharImageType = itk.Image[itk.UC, Dimension] resample_filter = itk.ResampleImageFilter[CurvilinearImageType, UCharImageType].New() resample_filter.SetInput(curvilinear) resample_filter.SetSize(output_size) resample_filter.SetOutputSpacing(output_spacing) resample_filter.SetOutputOrigin(output_origin) resample_filter.UpdateLargestPossibleRegion() bmode_image2 = resample_filter.GetOutput() bmode_image2.DisconnectPipeline() writer = itk.ImageFileWriter[UCharImageType].New() writer.SetFileName(outputFilePath) writer.SetInput(bmode_image2) writer.Update() print '------------------------' print 'Done'
PIXWIDTH %(pixelWidth)s; PIXHEIGHT %(pixelHeight)s; RELPOSITION %(sliceSpacing)s; """ # and a line per slice sliceDescriptorTpl = "SLICE %(sliceName)s %(fileName)s;\n" # lets convert all the files for f in sys.argv[2:] : # display the file name, to know on what we are working log( f ) # change the file name reader.SetFileName( f ) numberOfSlices = itk.size( reader )[2] spacing = itk.spacing( reader ) lsmName = f[:-4] descriptorDir = "%s/%s/sdf" % ( destDir, lsmName ) mkdir( descriptorDir ) # set the number of slices for the name generator names.SetEndIndex( numberOfSlices - 1 ) # now iterate over all the channel for c in range( 0, reader.GetNumberOfChannels() ) : channelName = reader.SetChannel( c ) # again, print the channel name to know what is done currently log( channelName )
def checkerboard(image1, image2, pattern=3, invert=False, **viewer_kwargs): # noqa: C901 """Compare two images with a checkerboard pattern. This is particularly useful for examining registration results. Parameters ---------- image1 : array_like, itk.Image, or vtk.vtkImageData First image to use in the checkerboard. image2 : array_like, itk.Image, or vtk.vtkImageData Second image to use in the checkerboard. pattern : int, optional, default: 3 Size of the checkerboard pattern. invert : bool, optional, default: False Swap inputs. viewer_kwargs : optional Keyword arguments for the viewer. See help(itkwidgets.view). """ itk_image1 = to_itk_image(image1) itk_image2 = to_itk_image(image2) input1 = itk_image1 input2 = itk_image2 region_image1 = itk_image1.GetLargestPossibleRegion() region_image2 = itk_image2.GetLargestPossibleRegion() same_physical_space = \ np.allclose(np.array(itk_image1.GetOrigin()), np.array(itk_image2.GetOrigin())) and \ np.allclose(np.array(itk_image1.GetSpacing()), np.array(itk_image2.GetSpacing())) and \ itk_image1.GetDirection() == itk_image2.GetDirection() and \ np.allclose(np.array(region_image1.GetIndex()), np.array(region_image2.GetIndex())) and \ np.allclose( np.array( region_image1.GetSize()), np.array( region_image2.GetSize())) if not same_physical_space: upsample_image2 = True if itk_image1.GetSpacing() != itk_image2.GetSpacing(): min1 = min(itk_image1.GetSpacing()) min2 = min(itk_image2.GetSpacing()) if min2 < min1: upsample_image2 = False else: size1 = max(itk.size(itk_image1)) size2 = max(itk.size(itk_image1)) if size2 > size1: upsample_image2 = False if upsample_image2: resampler = itk.ResampleImageFilter.New(itk_image2) resampler.UseReferenceImageOn() resampler.SetReferenceImage(itk_image1) resampler.Update() input2 = resampler.GetOutput() else: resampler = itk.ResampleImageFilter.New(itk_image1) resampler.UseReferenceImageOn() resampler.SetReferenceImage(itk_image2) resampler.Update() input1 = resampler.GetOutput() checkerboard_filter = itk.CheckerBoardImageFilter.New(input1, input2) dimension = itk_image1.GetImageDimension() checker_pattern = [pattern] * dimension checkerboard_filter.SetCheckerPattern(checker_pattern) checkerboard_filter_inverse = itk.CheckerBoardImageFilter.New( input2, input1) if invert: checkerboard_filter_inverse.Update() checkerboard = checkerboard_filter_inverse.GetOutput() else: checkerboard_filter.Update() checkerboard = checkerboard_filter.GetOutput() if 'annotations' not in viewer_kwargs: viewer_kwargs['annotations'] = False if 'interpolation' not in viewer_kwargs: viewer_kwargs['interpolation'] = False if 'ui_collapsed' not in viewer_kwargs: viewer_kwargs['ui_collapsed'] = True viewer = Viewer(image=checkerboard, **viewer_kwargs) # Heuristic to specify the max pattern size max_size1 = int(min(itk.size(itk_image1)) / 8) max_size1 = max(max_size1, pattern * 2) max_size2 = int(min(itk.size(itk_image2)) / 8) max_size2 = max(max_size2, pattern * 2) max_size = max(max_size1, max_size2) pattern_slider = widgets.IntSlider(value=pattern, min=2, max=max_size, step=1, description='Pattern size:') invert_checkbox = widgets.Checkbox(value=invert, description='Invert') def update_checkerboard(change): checker_pattern = [pattern_slider.value] * dimension checkerboard_filter.SetCheckerPattern(checker_pattern) checkerboard_filter_inverse.SetCheckerPattern(checker_pattern) if invert_checkbox.value: checkerboard_filter_inverse.Update() viewer.image = checkerboard_filter_inverse.GetOutput() else: checkerboard_filter.Update() viewer.image = checkerboard_filter.GetOutput() pattern_slider.observe(update_checkerboard, ['value']) invert_checkbox.observe(update_checkerboard, ['value']) widget = widgets.VBox( [viewer, widgets.HBox([pattern_slider, invert_checkbox])]) return widget
def copy_images(images_training, images_test, task_id, task_name_3D, trainingimage_ch0_name, trainingimage_ch1_name, testimage_ch0_name, testimage_ch1_name, ROI_list, ROI_list_alternatenames, label_dict): image_identifier_3D = 'CBCT_3D' # copy the 3D cbct images to imagesTr in .nii.gz format global taskfolder_3D taskfolder_3D = f'{nnUNet_raw_data}/Task{task_id:03d}_{task_name_3D}' json_filename_3D = f'{taskfolder_3D}/dataset.json' imagesTr_foldername_3D = f'{taskfolder_3D}/imagesTr/' imagesTs_foldername_3D = f'{taskfolder_3D}/imagesTs/' labelsTr_foldername_3D = f'{taskfolder_3D}/labelsTr/' labelsTs_foldername_3D = f'{taskfolder_3D}/labelsTs/' maybe_mkdir_p(imagesTr_foldername_3D) maybe_mkdir_p(imagesTs_foldername_3D) maybe_mkdir_p(labelsTr_foldername_3D) maybe_mkdir_p(labelsTs_foldername_3D) open(f"{taskfolder_3D}/errorlog.txt", "w").close() train_patient_names = [] test_patient_names = [] patient_ind = 0 for patient_folder in sorted(glob.glob(f'{images_training}/*')): print(patient_folder) with open(f'{taskfolder_3D}/errorlog.txt', 'a') as f: f.write(str(patient_ind) + " - " + patient_folder + ": \n") casename_3D = f'{image_identifier_3D}_{patient_ind:04d}' train_patient_names.append(casename_3D) # channel 1 = simu CBCT if 'CLB' in patient_folder: if (apply_matching == False) & ('correctedN4' in trainingimage_ch1_name): cbct_image_path = f'{patient_folder}/{realCBCT_N4imagename}' elif (apply_matching == False) & ('swn_normalized' in trainingimage_ch1_name): cbct_image_path = f'{patient_folder}/{realCBCT_SWNimagename}' else: cbct_image_path = glob.glob(f'{patient_folder}/cbct*.mhd')[0] else: cbct_image_path = f'{patient_folder}/{trainingimage_ch1_name}' # reduce image size and save in the 3D task folder cbct_3D_filename = f'{imagesTr_foldername_3D}/{casename_3D}_0001.nii.gz' #if (apply_matching == False) & ('correctedN4' in trainingimage_name): # no need to resize, already 2 mm spacing # #shutil.copy(cbct_image_path, imagesTr_foldername_3D) # #os.rename(f'{imagesTr_foldername_3D}/{trainingimage_name}', cbct_3D_filename) # convert_command= f'gt_image_convert {cbct_image_path} -o {cbct_3D_filename}' #else: # convert_command= f'gt_affine_transform -i {cbct_image_path} --newspacing=2,2,2 -o {cbct_3D_filename} -fr -a' if spacing2mm == True: convert_command = f'gt_affine_transform -i {cbct_image_path} --newspacing=2,2,2 -o {cbct_3D_filename} -fr -a' os.system(convert_command) else: convert_command = f'gt_image_convert {cbct_image_path} -o {cbct_3D_filename}' os.system(convert_command) # load the simu CBCT image to get the size cbct_image = itk.imread(cbct_3D_filename) cbct_origin = cbct_image.GetOrigin() # channel 0 = real CT if 'CLB' in patient_folder: if (apply_matching == False) & ('correctedN4' in trainingimage_ch0_name): ct_image_path = f'{patient_folder}/{realCBCT_N4imagename}' elif (apply_matching == False) & ('swn_normalized' in trainingimage_ch0_name): ct_image_path = f'{patient_folder}/{realCBCT_SWNimagename}' else: ct_image_path = glob.glob(f'{patient_folder}/cbct*.mhd')[0] else: ct_image_path = f'{patient_folder}/{trainingimage_ch0_name}' # reduce image size and save in the 3D task folder ct_3D_filename = f'{imagesTr_foldername_3D}/{casename_3D}_0000.nii.gz' ct_image = itk.imread(ct_image_path) # resize the image to same size as the simulated cbct if itk.size(cbct_image) == itk.size(ct_image): if spacing2mm == True: convert_command = f'gt_affine_transform -i {ct_image_path} --newspacing=2,2,2 -o {ct_3D_filename} -fr -a' os.system(convert_command) else: convert_command = f'gt_image_convert {ct_image_path} -o {ct_3D_filename}' os.system(convert_command) else: ct_image = gt.applyTransformation(input=ct_image, like=cbct_image, force_resample=True, pad=-1024) itk.imwrite(ct_image, ct_3D_filename) # copy and register label (ROI) with the cbct ROI_dir = f'{patient_folder}/ROI' allRoisImage = create_segmentation_map(ROI_list, ROI_list_alternatenames, ROI_dir, cbct_3D_filename, '') label_3D_filename = f'{labelsTr_foldername_3D}/{casename_3D}.nii.gz' if cropimages == True: crop_training_images(cbct_3D_filename, ct_3D_filename, label_3D_filename, allRoisImage) else: itk.imwrite(allRoisImage, label_3D_filename) patient_ind = patient_ind + 1 #patient_ind = patient_ind + 1 for patient_folder in sorted(glob.glob(f'{images_test}/*')): # if rennes images, the name of the cbct is different and there are more than one cbct per patient if 'Rennes' in patient_folder: cbctimage_prefix = 'cbct' ctimage_prefix = 'pseudo_rec' if (apply_matching == False) & ('correctedN4' in testimage_ch0_name): for cbct_image_path in sorted( glob.glob( f'{patient_folder}/{cbctimage_prefix}*_N4folder/{realCBCT_N4imagename}' )): cbct_id = os.path.dirname(cbct_image_path).replace( f'{patient_folder}/{cbctimage_prefix}', '').replace('_N4folder', '') with open(f'{taskfolder_3D}/errorlog.txt', 'a') as f: f.write( str(patient_ind) + " - " + patient_folder + " - cbct id " + cbct_id + " : \n") print(patient_folder) casename_3D = f'{image_identifier_3D}_{patient_ind:04d}' test_patient_names.append(casename_3D) # channel 1 = real CBCT # save in 3D_outputfolder cbct_3D_filename = f'{imagesTs_foldername_3D}/{casename_3D}_0001.nii.gz' #convert_command= f'gt_image_convert {cbct_image_path} -o {cbct_3D_filename}' #os.system(convert_command) if spacing2mm == True: convert_command = f'gt_affine_transform -i {cbct_image_path} --newspacing=2,2,2 -o {cbct_3D_filename} -fr -a' os.system(convert_command) else: convert_command = f'gt_image_convert {cbct_image_path} -o {cbct_3D_filename}' os.system(convert_command) # load the real CBCT image to get the size cbct_image = itk.imread(cbct_3D_filename) cbct_origin = cbct_image.GetOrigin() # channel 0 = pseudo CT ct_image_path = cbct_image_path.replace( 'realCBCT', 'pseudoCT') # save in the 3D task folder ct_3D_filename = f'{imagesTs_foldername_3D}/{casename_3D}_0000.nii.gz' ct_image = itk.imread(ct_image_path) # resize the image to same size as the real cbct ct_image = gt.applyTransformation(input=ct_image, like=cbct_image, force_resample=True, pad=-1024) itk.imwrite(ct_image, ct_3D_filename) # copy and register label (ROI) with the cbct ROI_dir = f'{patient_folder}/ROI' allRoisImage = create_segmentation_map( ROI_list, ROI_list_alternatenames, ROI_dir, cbct_3D_filename, cbct_id) label_3D_filename = f'{labelsTs_foldername_3D}/{casename_3D}.nii.gz' itk.imwrite(allRoisImage, label_3D_filename) patient_ind = patient_ind + 1 elif (apply_matching == False) & ('swn_normalized' in testimage_ch0_name): for cbct_image_path in sorted( glob.glob( f'{patient_folder}/{cbctimage_prefix}*_SWNfolder/{realCBCT_SWNimagename}' )): cbct_id = os.path.dirname(cbct_image_path).replace( f'{patient_folder}/{cbctimage_prefix}', '').replace('_SWNfolder', '') with open(f'{taskfolder_3D}/errorlog.txt', 'a') as f: f.write( str(patient_ind) + " - " + patient_folder + " - cbct id " + cbct_id + " : \n") print(patient_folder) casename_3D = f'{image_identifier_3D}_{patient_ind:04d}' test_patient_names.append(casename_3D) # channel 1 = real CBCT # save in 3D_outputfolder cbct_3D_filename = f'{imagesTs_foldername_3D}/{casename_3D}_0001.nii.gz' #convert_command= f'gt_image_convert {cbct_image_path} -o {cbct_3D_filename}' #os.system(convert_command) if spacing2mm == True: convert_command = f'gt_affine_transform -i {cbct_image_path} --newspacing=2,2,2 -o {cbct_3D_filename} -fr -a' os.system(convert_command) else: convert_command = f'gt_image_convert {cbct_image_path} -o {cbct_3D_filename}' os.system(convert_command) # load the real CBCT image to get the size cbct_image = itk.imread(cbct_3D_filename) cbct_origin = cbct_image.GetOrigin() # channel 0 = pseudo CT ct_image_path = cbct_image_path.replace( 'realCBCT', 'pseudoCT') # save in the 3D task folder ct_3D_filename = f'{imagesTs_foldername_3D}/{casename_3D}_0000.nii.gz' ct_image = itk.imread(ct_image_path) # resize the image to same size as the real cbct ct_image = gt.applyTransformation(input=ct_image, like=cbct_image, force_resample=True, pad=-1024) itk.imwrite(ct_image, ct_3D_filename) # copy and register label (ROI) with the cbct ROI_dir = f'{patient_folder}/ROI' allRoisImage = create_segmentation_map( ROI_list, ROI_list_alternatenames, ROI_dir, cbct_3D_filename, cbct_id) label_3D_filename = f'{labelsTs_foldername_3D}/{casename_3D}.nii.gz' itk.imwrite(allRoisImage, label_3D_filename) patient_ind = patient_ind + 1 else: for cbct_image_path in sorted( glob.glob( f'{patient_folder}/{cbctimage_prefix}*.nii.gz')): cbct_id = os.path.basename(cbct_image_path).replace( f'{cbctimage_prefix}', '').replace('.nii.gz', '') with open(f'{taskfolder_3D}/errorlog.txt', 'a') as f: f.write( str(patient_ind) + " - " + patient_folder + " - cbct id " + cbct_id + " : \n") print(patient_folder) casename_3D = f'{image_identifier_3D}_{patient_ind:04d}' test_patient_names.append(casename_3D) # channel 1 = real CBCT # convert to float convert_command = f'clitkImageConvert -i {cbct_image_path} -o {cbct_image_path} -t float' os.system(convert_command) # save in 3D_outputfolder cbct_3D_filename = f'{imagesTs_foldername_3D}/{casename_3D}_0001.nii.gz' #convert_command= f'gt_image_convert {cbct_image_path} -o {cbct_3D_filename}' #os.system(convert_command) if spacing2mm == True: convert_command = f'gt_affine_transform -i {cbct_image_path} --newspacing=2,2,2 -o {cbct_3D_filename} -fr -a' os.system(convert_command) else: convert_command = f'gt_image_convert {cbct_image_path} -o {cbct_3D_filename}' os.system(convert_command) # channel 0 = pseudo CT ct_image_path = f'{patient_folder}/{ctimage_prefix}{cbct_id}.nii.gz' # convert to float convert_command = f'clitkImageConvert -i {ct_image_path} -o {ct_image_path} -t float' os.system(convert_command) # save in the 3D task folder ct_3D_filename = f'{imagesTs_foldername_3D}/{casename_3D}_0000.nii.gz' # resize the image to same size as the real cbct elastix_command = f'elastix -f {cbct_image_path} -m {ct_image_path} -p {elastix_param_file} -out {elastix_folder}' os.system(elastix_command) registered_ct_path = f'{elastix_folder}/result.0.mhd' if spacing2mm == True: convert_command = f'gt_affine_transform -i {registered_ct_path} --newspacing=2,2,2 -o {ct_3D_filename} -fr -a' os.system(convert_command) else: convert_command = f'gt_image_convert {registered_ct_path} -o {ct_3D_filename}' os.system(convert_command) # copy and register label (ROI) with the cbct ROI_dir = f'{patient_folder}/ROI' allRoisImage = create_segmentation_map( ROI_list, ROI_list_alternatenames, ROI_dir, cbct_3D_filename, cbct_id) label_3D_filename = f'{labelsTs_foldername_3D}/{casename_3D}.nii.gz' itk.imwrite(allRoisImage, label_3D_filename) patient_ind = patient_ind + 1 # dataset.json 3D json_dict = {} json_dict['name'] = task_name_3D json_dict['description'] = "" json_dict['tensorImageSize'] = "4D" json_dict['reference'] = "saphir" json_dict['licence'] = "" json_dict['release'] = "0.0" json_dict['modality'] = { "0": "CT", "1": "CT", } json_dict['labels'] = label_dict json_dict['numTraining'] = len(train_patient_names) json_dict['numTest'] = len(test_patient_names) json_dict['training'] = [{ 'image': "./imagesTr/%s.nii.gz" % i, "label": "./labelsTr/%s.nii.gz" % i } for i in train_patient_names] json_dict['test'] = [ "./imagesTs/%s.nii.gz" % i for i in test_patient_names ] save_json(json_dict, json_filename_3D)
if opts.visualValidation: overlayNuclei = itk.LabelOverlayImageFilter.IUC3IUC3IRGBUC3.New(readerNuclei, lm2iNuclei) readerCENP = itk.lsm(channel=1, fileName=inputImageName) medianCENP = itk.MedianImageFilter.IUC3IUC3.New(readerCENP) gaussianCENP = itk.SmoothingRecursiveGaussianImageFilter.IUC3IUC3.New(medianCENP, Sigma=0.05) sizeCENP = itk.PhysicalSizeOpeningImageFilter.IUC3IUC3.New(gaussianCENP, Lambda=0.36) subCENP = itk.SubtractImageFilter.IUC3IUC3IUC3.New(gaussianCENP, sizeCENP) size2CENP = itk.PhysicalSizeOpeningImageFilter.IUC3IUC3.New(subCENP, Lambda=0.02) maskCENP = itk.LabelMapMaskImageFilter.LM3IUC3.New(lmNuclei, size2CENP, Label=0) thCENP = itk.BinaryThresholdImageFilter.IUC3IUC3.New(maskCENP, LowerThreshold=35) statsCENP = itk.BinaryImageToStatisticsLabelMapFilter.IUC3IUC3LM3.New(thCENP, subCENP) # create a new image to store the CENP centers, so they can be easily reused to check the distribution cenpSpotsImg = itk.Image.UC3.New(Regions=itk.size(readerNuclei), Spacing=itk.spacing(readerNuclei)) cenpSpotsImg.Allocate() cenpSpotsImg.FillBuffer(0) if opts.visualValidation: # create a new image to store the CENP segmentation cenpImg = itk.LabelMap._3.New(Regions=itk.size(readerNuclei), Spacing=itk.spacing(readerNuclei)) fullCENP = itk.LabelMapToBinaryImageFilter.LM3IUC3.New(cenpImg) dilateCENP = itk.BinaryDilateImageFilter.IUC3IUC3SE3.New(fullCENP, Kernel=itk.strel(3, [10, 10, 3])) borderCENP = itk.BinaryBorderImageFilter.IUC3IUC3.New(dilateCENP) outsideMask = itk.BinaryThresholdImageFilter.IUC3IUC3.New(lm2iNuclei, UpperThreshold=0) relabelCENP = itk.NaryRelabelImageFilter.IUC3IUC3.New(outsideMask, borderCENP) overlayCENP = itk.LabelOverlayImageFilter.IUC3IUC3IRGBUC3.New(readerCENP, relabelCENP) if 'blasto' in inputImageName:
assert itk.image(1) == 1 # test strel # should work with the image type, an image instance or a filter # and should work with a list, a tuple, an int or an itk.Size for s in [2, (2, 2), [2, 2], itk.Size[2](2)] : st = itk.strel(dim, s) (tpl, param) = itk.template(st) assert tpl == itk.FlatStructuringElement assert param[0] == dim assert st.GetRadius().GetElement(0) == st.GetRadius().GetElement(1) == 2 # test size s = itk.size(reader) assert s.GetElement(0) == s.GetElement(1) == 256 s = itk.size(reader.GetOutput()) assert s.GetElement(0) == s.GetElement(1) == 256 s = itk.size(reader.GetOutput().GetPointer()) assert s.GetElement(0) == s.GetElement(1) == 256 # test range assert itk.range(reader) == (0, 255) assert itk.range(reader.GetOutput()) == (0, 255) assert itk.range(reader.GetOutput().GetPointer()) == (0, 255) # test write itk.write(reader, sys.argv[2])
if argv[2] == "Ball": print "Ball" strel = itk.FlatStructuringElement[2].Ball( int( argv[3] ) ) elif argv[2] == "Box": print "Box" strel = itk.FlatStructuringElement[2].Box( int( argv[3] ) ) elif argv[2] == "FromImage": print "FromImage" reader = itk.ImageFileReader.IUC2.New( FileName=argv[3] ) strel = itk.FlatStructuringElement[2].FromImageUC( reader.GetOutput() ) else: print "invalid arguement: " + argv[2] exit(1) img = strel.GetImageUC() size = itk.size( img ) for y in range(0, size.GetElement(1)): for x in range(0, size.GetElement(0)): if img.GetPixel( [x, y] ): print "X", else: print " ", print "\n", itk.write( img, argv[1] ) # writer = itk.ImageFileWriter.IUC2.New(FileName=argv[1], Input=img ) # itk.echo(writer) # writer.Update()
assert itk.ctype("short") == itk.SS try: itk.ctype("dummy") raise Exception("unknown C type should send an exception") except KeyError: pass # test output assert itk.output(reader) == reader.GetOutput() assert itk.output(1) == 1 # test the deprecated image assert itk.image(reader) == reader.GetOutput() assert itk.image(1) == 1 # test size s = itk.size(reader) assert s[0] == s[1] == 256 s = itk.size(reader.GetOutput()) assert s[0] == s[1] == 256 # test physical size s = itk.physical_size(reader) assert s[0] == s[1] == 256.0 s = itk.physical_size(reader.GetOutput()) assert s[0] == s[1] == 256.0 # test spacing s = itk.spacing(reader) assert s[0] == s[1] == 1.0 s = itk.spacing(reader.GetOutput()) assert s[0] == s[1] == 1.0
import itk import argparse parser = argparse.ArgumentParser(description="Get Image Size.") parser.add_argument("input_image") args = parser.parse_args() image = itk.imread(args.input_image, itk.UC) region = image.GetLargestPossibleRegion() size = region.GetSize() print(size) # Equivalently size = itk.size(image) print(size) # Corresponds to the NumPy ndarray shape. Note that the ordering is reversed. print(np.asarray(image).shape) # An example image had w = 200 and h = 100 # (it is wider than it is tall). The above output # 200 x 100 # so w = GetSize()[0] # and h = GetSize()[1] # A pixel inside the region indexInside = itk.Index[2]() indexInside[0] = 150
def Convert_USRF_Spectra(input_filepath, reference_path, output_path, side_lines=5, fft1D_size=128): InputPixelType = itk.ctype('float') Dimension = 2 ImageType = itk.Image[InputPixelType, Dimension] reader = itk.ImageFileReader[ImageType].New() reader.SetFileName(input_filepath) input_RF = reader.GetOutput() # Apply missing spacing information if 'LinearProbe' in input_filepath: change_information = itk.ChangeInformationImageFilter.New(input_RF) change_information.SetUseReferenceImage(True) change_information.SetChangeSpacing(True) output_spacing = [1.0, 1.0] size = itk.size(input_RF) sos = 1540. fs = 30000. output_spacing[0] = sos / (2 * fs) transducer_width = 30.0 output_spacing[1] = transducer_width / (size[1] - 1) change_information.SetOutputSpacing(output_spacing) input_RF = change_information.GetOutput() input_RF.UpdateOutputInformation() SideLinesPixelType = itk.ctype('unsigned char') SideLinesImageType = itk.Image[SideLinesPixelType, Dimension] side_lines_image = SideLinesImageType.New() side_lines_image.CopyInformation(input_RF) side_lines_image.SetRegions(input_RF.GetLargestPossibleRegion()) side_lines_image.Allocate() side_lines_image.FillBuffer(side_lines) spectra_window_filter = itk.Spectra1DSupportWindowImageFilter.New(side_lines_image) spectra_window_filter.SetFFT1DSize(fft1D_size) spectra_window_filter.SetStep(8) spectra_window_filter.UpdateLargestPossibleRegion() support_window_image = spectra_window_filter.GetOutput() SpectraImageType = itk.VectorImage[InputPixelType, Dimension] reference_reader = itk.ImageFileReader[SpectraImageType].New() basename = os.path.splitext(os.path.basename(input_filepath))[0] reference_path = os.path.join(os.path.dirname(input_filepath), reference_path) reference_glob = glob.glob(os.path.join(reference_path, basename[:-11] + '*.mha')) if len(reference_glob) != 1: print('Reference spectra file not found') print('Found: ', reference_glob) sys.exit(1) reference_reader.SetFileName(reference_glob[0]) reference_reader.UpdateLargestPossibleRegion() reference_spectra_image = SpectraImageType.New() reference_spectra_image.CopyInformation(support_window_image) reference_spectra_image.SetRegions(support_window_image.GetLargestPossibleRegion()) reference_spectra_image.SetNumberOfComponentsPerPixel(reference_reader.GetOutput().GetNumberOfComponentsPerPixel()) reference_spectra_image.Allocate() reference_index = itk.Index[Dimension]() reference_index.Fill(0) reference_spectrum = reference_reader.GetOutput().GetPixel(reference_index) reference_spectra_image.FillBuffer(reference_spectrum) spectra_filter = itk.Spectra1DImageFilter.New(input_RF) spectra_filter.SetSupportWindowImage(spectra_window_filter.GetOutput()) spectra_filter.SetReferenceSpectraImage(reference_spectra_image) spectra_filter.UpdateLargestPossibleRegion() output_path = os.path.join(os.path.dirname(input_filepath), output_path) if not os.path.exists(output_path): os.makedirs(output_path) identifier = '_Spectra_side_lines_{:02d}_fft1d_size_{:03d}.mha'.format(side_lines, fft1D_size) output_filepath = os.path.join(output_path, basename + identifier) writer = itk.ImageFileWriter.New(spectra_filter) writer.SetFileName(output_filepath) writer.Update()
import itk Dimension = 2 PixelType = itk.UC ImageType = itk.Image[PixelType, Dimension] image_size = [10, 10] image = ImageType.New() image.SetRegions(image_size) image.Allocate() duplicate_image = itk.image_duplicator(image) print(duplicate_image) def itkSizeToList(size): l = [] for i in range(size.GetSizeDimension()): l.append(size[i]) return l assert itkSizeToList(itk.size(duplicate_image)) == image_size
# binarize the image th = itk.BinaryThresholdImageFilter.IUS2IUS2.New(proj1D, InsideValue=1) # and count the pixels to get the resolution on the z axis labelShape = itk.LabelShapeImageFilter.IUS2.New(th) # count the object to display a warning label = itk.ConnectedComponentImageFilter.IUS2IUS2.New(th) relabel = itk.RelabelComponentImageFilter.IUS2IUS2.New(label) for f in sys.argv[1:]: reader.SetFileName(f) projz.UpdateLargestPossibleRegion() m, M = itk.range(projz) watershed.SetLevel(m + (M - m) / 2) upperdim.SetNewDimensionSapcing(itk.spacing(reader)[2]) upperdim.SetNewDimensionSize(itk.size(reader)[2]) upperdim.UpdateLargestPossibleRegion() # to get a valid number of labels # store the results so we can compute the mean and the meadian for # all the beads in the image results = [] for l in range(1, wrelabel.GetNumberOfObjects() + 1): selectedLabel.SetUpperThreshold(l) selectedLabel.SetLowerThreshold(l) proj1D.UpdateLargestPossibleRegion() m, M = itk.range(proj1D) th.SetLowerThreshold((M - m) / 2) labelShape.UpdateLargestPossibleRegion() relabel.UpdateLargestPossibleRegion()