def onCTSeg3D_lungButtonClicked(self): if self.image_loaded == True: #sigma = self.sigmaSlider.value #default value of sigma output_filepath = str(self.path + self.image_name + self.labelpostfix2 + self.filetype) label_sitk = su.PullFromSlicer(self.label_name) image_sitk = su.PullFromSlicer(self.image_name) print("Image and label array generated.") print("output_filepath is: ", output_filepath) seg_alg = AutoCT_LungSegWizard.CT_seg_alg_lung( image_sitk, label_sitk) seg = seg_alg.setup() ifw = sitk.ImageFileWriter() ifw.SetFileName(output_filepath) ifw.SetUseCompression(True) ifw.Execute(seg) semi_label_path = output_filepath semi_label = slicer.util.loadVolume(semi_label_path, properties={'labelmap': True}, returnNode=True) self.semi_label_path = semi_label_path labelNode = slicer.util.getNode(pattern=self.image_name + self.labelpostfix2) self.labelNode = labelNode self.auto3DGen()
def onCTSeg3D_tumorButtonClicked(self): if self.image_loaded == True: node_num = self.noduleSlider.value / 2 #default value of sigma # node_num1 = self.noduleSlider1.getInt #default value of sigma node_num = int(node_num) print("nodule number is: ", node_num) output_filepath = str(self.path + self.image_name + self.labelpostfix1 + "_" + str(node_num) + self.filetype) label_sitk = su.PullFromSlicer(self.label_name) image_sitk = su.PullFromSlicer(self.image_name) print("Image and label array generated.") print("output_filepath is: ", output_filepath) #self.multiplier = 1 seg_alg = AutoCT_LungSegWizard.CT_seg_alg_tumor( image_sitk, label_sitk) #self.multi = tune seg = seg_alg.setup() ifw = sitk.ImageFileWriter() ifw.SetFileName(output_filepath) ifw.SetUseCompression(True) ifw.Execute(seg) semi_label_path = output_filepath semi_label = slicer.util.loadVolume(semi_label_path, properties={'labelmap': True}, returnNode=True) self.semi_label_path = semi_label_path labelNode = slicer.util.getNode(pattern=self.image_name + self.labelpostfix1 + "_" + str(node_num)) self.labelNode = labelNode self.auto3DGen()
def ImageModelSnapshot(self, dataNode, labelNode, outputDir, IDcurrPatient, ImageFilePath, progress_filename, selLabels=False, levels=False): cast1 = vtk.vtkImageCast() cast1.SetOutputScalarTypeToInt() cast1.SetInputConnection(labelNode.GetImageDataConnection()) cast1.Update() labelNode.SetImageDataConnection(cast1.GetOutputPort()) cast2 = vtk.vtkImageCast() cast2.SetOutputScalarTypeToInt() cast2.SetInputConnection(dataNode.GetImageDataConnection()) cast2.Update() dataNode.SetImageDataConnection(cast2.GetOutputPort()) labelNode.SetOrigin(dataNode.GetOrigin()) try: imageNodeSITK = su.PullFromSlicer(dataNode.GetName()) labelNodeSITK = su.PullFromSlicer(labelNode.GetName()) labelArraySITK = sitk.GetArrayFromImage(labelNodeSITK) lbound, hbound = squeeze(self, labelArraySITK, labelNode) self.cmaj = sitk.CropImageFilter() self.cmaj.SetLowerBoundaryCropSize(lbound) self.cmaj.SetUpperBoundaryCropSize(hbound) zoomLabelNodeSITK = self.cmaj.Execute(labelNodeSITK) zoomImageNodeSITK = self.cmaj.Execute(imageNodeSITK) zoomLabelNodeName = 'zoomLabelNode' + '_' + IDcurrPatient zoomImageNodeName = 'zoomImageNode' + '_' + IDcurrPatient su.PushToSlicer(zoomLabelNodeSITK, zoomLabelNodeName) su.PushToSlicer(zoomImageNodeSITK, zoomImageNodeName) zoomLabelNode = slicer.util.getNode(zoomLabelNodeName) zoomImageNode = slicer.util.getNode(zoomImageNodeName) zoomLabelNodeArraySITK = sitk.GetArrayFromImage(zoomLabelNodeSITK) zoomLabelNodeArraySITK = numpy.where(zoomLabelNodeArraySITK == 0, numpy.NAN, zoomLabelNodeArraySITK) maxZind = find_LargestSlices(self, zoomLabelNodeArraySITK) imgOutputDir = str(outputDir) modelHandler(ImageFilePath, zoomImageNode, zoomLabelNode, imgOutputDir, IDcurrPatient, maxZind) return (maxZind) except Exception, e: with open(progress_filename, mode='a') as printfile: printfile.write('ERROR: ' + str(e) + '\n') os.makedirs(os.path.join(outputDir, IDcurrPatient + '_flagged')) return (-1, -1, -1)
def calculateAgatstonScores(self): #Just temporary code, will calculate statistics and show in table print "Calculating Statistics" calcium = su.PullFromSlicer(self.labelNode.GetName()) all_labels = [0, 1, 2, 3, 4, 5, 6] heart = su.PullFromSlicer(self.grayscaleNode.GetName()) sliceAgatstonPerLabel = self.computeSlicewiseAgatstonScores( calcium, heart, all_labels) #print sliceAgatstonPerLabel self.computeOverallAgatstonScore(sliceAgatstonPerLabel)
def custom_function(imageNode, imageNodeSavename, labelNode, labelNodeSavename): imagesitk = su.PullFromSlicer(imageNode.GetName()) labelsitk = su.PullFromSlicer(labelNode.GetName()) labelarray = sitk.GetArrayFromImage(labelsitk) #min, max = squeeze(labelarray) #labelarraycrop = labelarray[ min[0]:max[0], min[1]:max[1], min[2]:max[2] ]: for slicez in labelarray: if slicez[slicez != 0].size > 0: nmin, nmax = squeeze(slicez[None, :, :]) for rowind, row in enumerate(slicez[:nmax[1]]): if (rowind >= nmin[1] + 1) and (row[row != 0].size < 3): prevrow = slicez[rowind - 1] nextrow = slicez[rowind + 1] if (nextrow[nextrow != 0].size > 2): row = rowInterpolator(prevrow, nextrow, row) elif (nextrow[nextrow != 0].size < 3): newidx = rowind while (newidx < (nmax[1])): newidx += 1 finalrow = slicez[newidx] if (finalrow[finalrow != 0].size > 2): break slicez[rowind:newidx] = multiRowInterpolator( prevrow, finalrow, slicez, rowind, newidx) newlabelsitk = sitk.GetImageFromArray(labelarray) newlabelsitk.SetOrigin(labelsitk.GetOrigin()) newlabelsitk.SetSpacing(labelsitk.GetSpacing()) newlabelsitk.SetDirection(labelsitk.GetDirection()) newlabelnodename = labelNodeSavename.replace('.nrrd', '') + '_interp_corrected' su.PushToSlicer(newlabelsitk, newlabelnodename) newlabelNode = slicer.util.getNode(newlabelnodename) newlabelNode.LabelMapOn() labelMapnodeDisplayNode = slicer.vtkMRMLScalarVolumeDisplayNode() slicer.mrmlScene.AddNode(labelMapnodeDisplayNode) newlabelNode.SetAndObserveDisplayNodeID(labelMapnodeDisplayNode.GetID()) labelMapnodeDisplayNode.SetAndObserveColorNodeID( 'vtkMRMLColorTableNodeFileGenericColors.txt') labelMapnodeDisplayNode.SetInputImageDataConnection( newlabelNode.GetImageDataConnection()) labelMapnodeDisplayNode.UpdateImageDataPipeline() return imageNode, newlabelNode, newlabelnodename
def VolumeIntensityCorrection(volume, logFilePath): spacing = volume.GetSpacing() origin = volume.GetOrigin() ras2ijk = vtk.vtkMatrix4x4() ijk2ras = vtk.vtkMatrix4x4() volume.GetRASToIJKMatrix(ras2ijk) volume.GetIJKToRASMatrix(ijk2ras) imgsitk = su.PullFromSlicer(volume.GetName()) imgsitk_array = sitk.GetArrayFromImage(imgsitk) imgsitk_array = imgsitk_array.__sub__(imgsitk_array.min()) imgsitk = sitk.GetImageFromArray(imgsitk_array) outputImageName = volume.GetName() + '_corrected' su.PushToSlicer(imgsitk, outputImageName) volumeCorrected = slicer.util.getNode(outputImageName) volumeCorrected.SetOrigin(origin) volumeCorrected.SetSpacing(spacing) volumeCorrected.SetRASToIJKMatrix(ras2ijk) volumeCorrected.SetIJKToRASMatrix(ijk2ras) with open(logFilePath, mode='a') as logfile: logfile.write("\tCORRECTED: Image intensity values corrected: " + volumeCorrected.GetName() + '\n') return volumeCorrected
def run(self, inputVolume, outputVolume, imageThreshold, enableScreenshots, filterType): """ Run the actual algorithm """ start = time.time() #if not self.isValidInputOutputData(inputVolume, outputVolume): # slicer.util.errorDisplay('Input volume is the same as output volume. Choose a different output volume.') #return False logging.info('Processing started') # Compute the thresholded output volume using the Threshold Scalar Volume CLI module # cliParams = {'InputVolume': inputVolume.GetID(), 'OutputVolume': outputVolume.GetID(), 'ThresholdValue' : imageThreshold, 'ThresholdType' : 'Above'} # cliNode = slicer.cli.run(slicer.modules.thresholdscalarvolume, None, cliParams, wait_for_completion=True) # Capture screenshot if enableScreenshots: self.takeScreenshot('SpineSegTest-Start', 'MyScreenshot', -1) inputImage = sitkUtils.PullFromSlicer(inputVolume.GetName()) # # TODO: rest of ifs for our filter possibilites if filterType == "Gaussian Filter": imageFilter = sitk.MeanImageFilter() outputImage = imageFilter.Execute(inputImage) imageFilter = sitk.ThresholdImageFilter() outputImage = imageFilter.Execute(outputImage, 200, 1400, 1) imageFilter = sitk.ThresholdMaximumConnectedComponentsImageFilter() outputImage = imageFilter.Execute(outputImage) sitkUtils.PushToSlicer(outputImage, outputVolume.GetName()) return True elif filterType == "Edge Detection": imageFilter = sitk.MeanImageFilter() outputImage = imageFilter.Execute(inputImage) imageFilter = sitk.ThresholdImageFilter() outputImage = imageFilter.Execute(inputImage, 300, 1400, 1) imageFilter = sitk.ScalarConnectedComponentImageFilter() outputImage = imageFilter.Execute(outputImage) sitkUtils.PushToSlicer(outputImage, outputVolume.GetName()) return True elif filterType == "Threshold Image": imageFilter = sitk.MeanImageFilter() outputImage = imageFilter.Execute(inputImage) imageFilter = sitk.BinaryOpeningByReconstructionImageFilter() outputImage = imageFilter.Execute(outputImage) imageFilter = sitk.ThresholdImageFilter() outputImage = imageFilter.Execute(inputImage, 200, 1400, 1) #imageFilter = sitk.MaximumEntropyThresholdImageFilter() #outputImage = imageFilter.Execute(inputImage) sitkUtils.PushToSlicer(outputImage, outputVolume.GetName(), overwrite=True) end = time.time() print(end - start) outputImData = outputVolume.GetImageData()
def runThreshold(self, masterNode, labelNode): masterImage = sitkUtils.PullFromSlicer(masterNode.GetID()) labelArray = slicer.util.array(labelNode.GetID()) masterArray = slicer.util.array(masterNode.GetID()) connectedThresholdIF = SimpleITK.ConnectedThresholdImageFilter() connectedThresholdIF.SetLower(mean - (1.5 * std)) connectedThresholdIF.SetUpper(mean + (1.5 * std)) print('Centroid:', int(centroidX), int(centroidY)) connectedThresholdIF.SetSeed([int(centroidX), int(centroidY), maskZ]) print('starting: connected threshold filter') thresholdImage = connectedThresholdIF.Execute(masterImage) # take this out for now, as time costly and may be best to close holes in 2D ''' print('starting: fill holes filter') fillHoleIF = SimpleITK.GrayscaleFillholeImageFilter() connectedImage = fillHoleIF.Execute(thresholdImage) ''' sitkUtils.PushToSlicer(thresholdImage, 'connectedImage') #print('save self.connected image') '''
def vectorfieldToDisplacementField(self, vectorfieldPath, referenceNode, displacementFieldPath): stream = self.getDataStreamFromVectorField(vectorfieldPath) referenceImage = su.PullFromSlicer(referenceNode.GetID()) shape = list(referenceImage.GetSize()) shape.reverse() # Example of 2D shape at this point: [1, 540, 940] # Blockmatching output might be 2D is2D = shape[0] == 1 componentsPerVector = 2 if is2D else 3 shape.append(componentsPerVector) reshaped = stream.reshape(shape) # Force the output to be 3D if is2D: zeros = np.zeros_like( reshaped[..., :1]) # z component of the vectors reshaped = np.concatenate((reshaped, zeros), axis=3) reshaped[..., :2] *= -1 # RAS to LPS displacementImage = sitk.GetImageFromArray(reshaped) displacementImage.SetOrigin(referenceImage.GetOrigin()) displacementImage.SetDirection(referenceImage.GetDirection()) displacementImage.SetSpacing(referenceImage.GetSpacing()) # TODO: convert the image directly into a transform to save space and time sitk.WriteImage(displacementImage, displacementFieldPath) transformNode = slicer.util.loadTransform(displacementFieldPath, returnNode=True)[1] return transformNode
def denoising_nonlocalmeans(Nom_image, Nom_label): image=su.PullFromSlicer(Nom_image) image=sitk.Shrink(image, [2,2,2]) label=su.PullFromSlicer(Nom_label) timeRMR1 = time.time() DenoiseFilter=sitk.PatchBasedDenoisingImageFilter() #Execute (const Image &image1, double kernelBandwidthSigma, uint32_t patchRadius, #uint32_t numberOfIterations, uint32_t numberOfSamplePatches, double sampleVariance, PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, #double noiseSigma, double noiseModelFidelityWeight, bool alwaysTreatComponentsAsEuclidean, bool kernelBandwidthEstimation, double kernelBandwidthMultiplicationFactor, #uint32_t kernelBandwidthUpdateFrequency, double kernelBandwidthFractionPixelsForEstimation) DenoiseFilter.SetAlwaysTreatComponentsAsEuclidean(True) DenoiseFilter.SetKernelBandwidthEstimation(True) DenoiseFilter.SetKernelBandwidthFractionPixelsForEstimation(0.5) #double KernelBandwidthFractionPixelsForEstimation #DenoiseFilter.SetKernelBandwidthMultiplicationFactor() #(double KernelBandwidthMultiplicationFactor) #DenoiseFilter.SetKernelBandwidthSigma(400) #(double KernelBandwidthSigma) #faible voire pas d'influence #DenoiseFilter.SetKernelBandwidthUpdateFrequency() #(uint32_t KernelBandwidthUpdateFrequency 1 par defaut) DenoiseFilter.SetNoiseModel(3) #(NoiseModelType NoiseModel) #NoiseModelType { NOMODEL:0, GAUSSIAN:1, RICIAN:2, POISSON:3} DenoiseFilter.SetNoiseModelFidelityWeight(0.05) #(double NoiseModelFidelityWeight entre 0 et 1)# This weight controls the balance between the smoothing and the closeness to the noisy data. #DenoiseFilter.SetNoiseSigma(0.50) #(double NoiseSigma)#usualy 5% of min max of an image ##############pas d'influence #DenoiseFilter.SetNumberOfIterations(1) #(uint32_t NumberOfIterations 1 par defaut) DenoiseFilter.SetNumberOfSamplePatches(200) #(uint32_t NumberOfSamplePatches)#200->100, 41 a 23s mais filtre plus DenoiseFilter.SetPatchRadius(4) #(uint32_t PatchRadius) # 2->10s 4->41s 6->121s ##############paramétre critique #DenoiseFilter.SetSampleVariance(400) #(double SampleVariance) #pas d'influence? ImageDenoised=DenoiseFilter.Execute(image) timeRMR2 = time.time() TimeForrunFunctionRMR2 = timeRMR2 - timeRMR1 print(u"La fonction de traitement s'est executée en " + str(TimeForrunFunctionRMR2) +" secondes") print("\n") print(DenoiseFilter.GetNumberOfSamplePatches()) #200 print("\n") print (DenoiseFilter.GetSampleVariance()) #400 print("\n") print(DenoiseFilter.GetNoiseSigma()) #0.0 print("\n") print(DenoiseFilter.GetNumberOfIterations()) #1 print("\n") print(DenoiseFilter.GetKernelBandwidthSigma()) #400.0 print("\n") stat_filter=sitk.LabelIntensityStatisticsImageFilter() stat_filter.Execute(label,image) #attention à l'ordre print(stat_filter.GetStandardDeviation(1)/stat_filter.GetMean(1)) print("\n") stat_filter.Execute(label,ImageDenoised) #attention à l'ordre print(stat_filter.GetStandardDeviation(1)/stat_filter.GetMean(1)) su.PushToSlicer(ImageDenoised,'ImageDenoisedbyPatchBasedDenoisingImageFilter')
def run(self, inputVolume, outputVolume, minValue, maxValue, imageFilter): ''' :param inputVolume: the input image volume :param outputVolume: the output image volume :param minValue: the min threshold selected by user :param maxValue: the max threshold select by user Gets the inputVolume name, pulls the image from slicer, adds the filter and threshold based on the user defined variables ''' #Get the input info inputImage = inputVolume.GetName() image = sitkUtils.PullFromSlicer(inputImage) outputImage = outputVolume.GetName() image = self.resizeImage(image) #resampleFilter = SimpleITK.ResampleImageFilter() #resampleFilter.SetOutputSpacing((1,1,1)) #image = resampleFilter.Execute(image) #Add the filter to the image imgSmooth = self.addFilterToImage(image, imageFilter) # Threshold the image with user-set threshold values #imgWhiteMatter = SimpleITK.ConnectedThreshold(image1=sitkUtils.PullFromSlicer(outputImage), seedList=[(255,0,0)], lower=minValue, upper=maxValue, replaceValue=1) imgWhiteMatter = self.thresholdImage(minValue, maxValue) #Rescale and cast imgSmooth to match type of imgWhiteMatter (int) imgSmoothInt = SimpleITK.Cast(SimpleITK.RescaleIntensity(imgSmooth), imgWhiteMatter.GetPixelID()) #overlay = SimpleITK.LabelMapOverlayImageFilter() #overlay.SetOpacity(0.6) #overlay = overlay.Execute(imgSmoothInt, imgWhiteMatter) #sitkUtils.PushToSlicer(overlay, 'test', 0, True) # overlay imgWhiteMatter on imgSmoothInt imgWhiteMatterNoHoles = SimpleITK.VotingBinaryHoleFilling( image1=imgWhiteMatter, radius=((2, 2, 2)), majorityThreshold=1, backgroundValue=0, foregroundValue=1) #sitkUtils.PushToSlicer(imgWhiteMatterNoHoles, "imgWhiteMatter", 2, True) sitkUtils.PushToSlicer(imgWhiteMatterNoHoles, "imgWhiteMatter", 2, True) sitkUtils.PushToSlicer(imgSmoothInt, outputImage, 0, True) #node = slicer.util.getNode("imgWhiteMatter") #node = node.GetScalarVolumeDisplayNode() #node.SetOpacity(0.5) print("\n")
def addGaussianNoise(inputImageNode, outputImageNodeName, sd, mean): input = sitk.Cast(sitkUtils.PullFromSlicer(inputImageNode.GetID()), sitk.sitkUInt16) noiseFilter = sitk.AdditiveGaussianNoiseImageFilter() noiseFilter.SetDebug(False) noiseFilter.SetMean(mean) noiseFilter.SetSeed(0) noiseFilter.SetStandardDeviation(sd) output = noiseFilter.Execute(input) sitkUtils.PushToSlicer(output, outputImageNodeName, 0, True)
def denoising_BayesShrinkAndVIsuShrink(Nom_image): image=su.PullFromSlicer(NomDeLImage) NumpyImage=sitk.GetArrayFromImage(image) # Estimate the average noise standard deviation across color channels. sigma_est = estimate_sigma(NumpyImage, multichannel=True, average_sigmas=True) # Due to clipping in random_noise, the estimate will be a bit smaller than the # specified sigma. print(f"Estimated Gaussian noise standard deviation = {sigma_est}") im_bayes = denoise_wavelet(NumpyImage, multichannel=True, convert2ycbcr=True, method='BayesShrink', mode='soft',rescale_sigma=True) im_visushrink = denoise_wavelet(NumpyImage, multichannel=True, convert2ycbcr=True, method='VisuShrink', mode='soft',sigma=sigma_est, rescale_sigma=True) su.PushToSlicer(im_bayes,'image_DenoisWave_level0-'+str(Nlevel)) su.PushToSlicer(im_visushrink,'image_DenoisWave_level0-'+str(Nlevel))
def wavelet_denoising(NomDeLImage, Nlevel): image=su.PullFromSlicer(NomDeLImage) NumpyImage=sitk.GetArrayFromImage(image) max_lev = 6 # how many levels of decomposition to draw coeffs = pywt.wavedecn(NumpyImage, 'db2', mode='zero', level=max_lev) #voir https://pywavelets.readthedocs.io/en/latest/ref/nd-dwt-and-idwt.html#pywt.wavedecn for i in range(Nlevel-max_lev): coeffs[(max_lev-i)] = {k: np.zeros_like(v) for k, v in coeffs[(max_lev-i)].items()} #remove highest frequency coeffs[-(max_lev-i)] = {k: np.zeros_like(v) for k, v in coeffs[-(max_lev-i)].items()} #remove highest frequency matrice_ondelette=pywt.waverecn(coeffs, 'db2') #mode periodic ou zero image_ondelette=sitk.GetImageFromArray(matrice_ondelette) image_ondelette.SetSpacing(image.GetSpacing()) image_ondelette.SetDirection(image.GetDirection()) image_ondelette.SetOrigin(image.GetOrigin()) su.PushToSlicer(image_ondelette,'image_DenoisWave_level0-'+str(Nlevel))
def wavelet_denoising2(NomDeLImage, Nlevel): image=su.PullFromSlicer(NomDeLImage) NumpyImage=sitk.GetArrayFromImage(image) max_lev = 6 # how many levels of decomposition to draw coeffs = pywt.wavedecn(NumpyImage, 'db2', mode='zero', level=max_lev) #voir https://pywavelets.readthedocs.io/en/latest/ref/nd-dwt-and-idwt.html#pywt.wavedecn for levelR in range (max_lev-Nlevel): sigma = (1/0.6745) * maddest( coeffs[max_lev-levelR] ) uthresh = sigma * np.sqrt( 2*np.log( len( NumpyImage ) ) ) coeffs[(max_lev-levelR)] = ( pywt.threshold( i, value=uthresh, mode='hard' ) for i in coeffs[(max_lev-levelR)] ) matrice_ondelette=pywt.waverecn(coeffs, 'db2', mode='per') #mode periodic ou zero image_ondelette=sitk.GetImageFromArray(matrice_ondelette) image_ondelette.SetSpacing(image.GetSpacing()) image_ondelette.SetDirection(image.GetDirection()) image_ondelette.SetOrigin(image.GetOrigin()) su.PushToSlicer(image_ondelette,'image_DenoisWave_level0-'+str(Nlevel))
def cropToZoom(volumeNode, minBounds, maxBounds, label=False): # bring image and label node to sitk, crop both to tumor region (for zooming in) # send cropped image and label back to slicer cmaj = sitk.CropImageFilter() cmaj.SetLowerBoundaryCropSize(minBounds) cmaj.SetUpperBoundaryCropSize(maxBounds) sitkVolumeNode = su.PullFromSlicer(volumeNode.GetName()) sitkZoomVolumeNode = cmaj.Execute(sitkVolumeNode) zoomVolumeNodeName = volumeNode.GetName() + '_' + 'zoomed' if label: su.PushLabel(sitkZoomVolumeNode, zoomVolumeNodeName) else: su.PushBackground(sitkZoomVolumeNode, zoomVolumeNodeName) zoomVolumeNode = slicer.util.getNode(zoomVolumeNodeName) return zoomVolumeNode
def extractMaxZSlice(volumeNode, Zind): sitkVolumeNode = su.PullFromSlicer(volumeNode.GetName()) pixelID = sitkVolumeNode.GetPixelIDValue() FlipYAxis = sitk.FlipImageFilter() FlipYAxis.SetFlipAxes([False, True, False]) sizeZ = list(sitkVolumeNode.GetSize()) sizeZ[2] = 0 indexZ = [0, 0, Zind] ExtractorZ = sitk.ExtractImageFilter() ExtractorZ.SetSize(sizeZ) ExtractorZ.SetIndex(indexZ) sitkZSlice = ExtractorZ.Execute(sitkVolumeNode) ZSliceName = 'maxz_' + volumeNode.GetName() su.PushToSlicer(sitkZSlice, ZSliceName) ZSliceNode = slicer.util.getNode(ZSliceName) return ZSliceNode
def Ondelette_raconte(NomDeLImage): timeRMR1 = time.time() image=su.PullFromSlicer(NomDeLImage) NumpyImage=sitk.GetArrayFromImage(image) max_lev = 2 # how many levels of decomposition to draw c = pywt.wavedecn(NumpyImage, 'db2', mode='zero', level=max_lev) #voir https://pywavelets.readthedocs.io/en/latest/ref/nd-dwt-and-idwt.html#pywt.wavedecn #coeffs[-2] = {k: np.zeros_like(v) for k, v in coeffs[-2].items()} #matrice_ondelette=pywt.waverecn(c, 'db2') mode periodic ou zero #image_ondelette=sitk.GetImageFromArray(matrice_ondelette) #su.PushToSlicer(image_ondelette,'image_ondelette') c_arr,c_slices= pywt.coeffs_to_array(c, padding=0, axes=None) ddd=c_arr[c_slices[2]['ddd']] #ddd=sitk.GetImageFromArray(c_arr[c_slices[2]['ddd']]) #details aaa=c_arr[c_slices[0]] #aaa=sitk.GetImageFromArray(c_arr[c_slices[0]]) #average IndiceQualite=SpatialFrequencyOptim2(ddd)/SpatialFrequencyOptim2(aaa) print IndiceQualite timeRMR2 = time.time() TimeForrunFunctionRMR2 = timeRMR2 - timeRMR1 print(u"La fonction de traitement s'est executée en " + str(TimeForrunFunctionRMR2) +" secondes")
def createHoleFilledVolumeNode(self, ventricleVolume, thresholdValue, samplingFactor, morphologyParameters): holeFillKernelSize = morphologyParameters[0] maskKernelSize = morphologyParameters[1] resampleFilter = sitk.ResampleImageFilter() ventricleImage = sitk.Cast(sitkUtils.PullFromSlicer(ventricleVolume.GetID()), sitk.sitkInt16) resampleFilter.SetSize(numpy.array(ventricleImage.GetSize()) / samplingFactor) resampleFilter.SetOutputSpacing(numpy.array(ventricleImage.GetSpacing()) * samplingFactor) resampleFilter.SetOutputDirection(ventricleImage.GetDirection()) resampleFilter.SetOutputOrigin(numpy.array(ventricleImage.GetOrigin())) resampledImage = resampleFilter.Execute(ventricleImage) thresholdFilter = sitk.BinaryThresholdImageFilter() thresholdImage = thresholdFilter.Execute(resampledImage, thresholdValue, 10000, 1, 0) padFilter = sitk.ConstantPadImageFilter() padFilter.SetPadLowerBound(holeFillKernelSize) padFilter.SetPadUpperBound(holeFillKernelSize) paddedImage = padFilter.Execute(thresholdImage) dilateFilter = sitk.BinaryDilateImageFilter() dilateFilter.SetKernelRadius(holeFillKernelSize) dilateFilter.SetBackgroundValue(0) dilateFilter.SetForegroundValue(1) dilatedImage = dilateFilter.Execute(paddedImage) erodeFilter = sitk.BinaryErodeImageFilter() erodeFilter.SetKernelRadius(holeFillKernelSize) erodeFilter.SetBackgroundValue(0) erodeFilter.SetForegroundValue(1) erodedImage = erodeFilter.Execute(dilatedImage) fillHoleFilter = sitk.BinaryFillholeImageFilter() holefilledImage = fillHoleFilter.Execute(erodedImage) dilateFilter = sitk.BinaryDilateImageFilter() dilateFilter.SetKernelRadius(maskKernelSize) dilateFilter.SetBackgroundValue(0) dilateFilter.SetForegroundValue(1) dilatedImage = dilateFilter.Execute(holefilledImage) subtractFilter = sitk.SubtractImageFilter() subtractedImage = subtractFilter.Execute(dilatedImage, holefilledImage) holefilledImageNode = sitkUtils.PushToSlicer(holefilledImage, "holefilledImage", 0, False) subtractedImageNode = sitkUtils.PushToSlicer(subtractedImage, "subtractedImage", 0, False) return holefilledImageNode, subtractedImageNode
def getCropBoundaries(labelNode): sitkLabelNode = su.PullFromSlicer(labelNode.GetName()) labelArray = sitk.GetArrayFromImage(sitkLabelNode) zmin = 0 zmax = labelArray.shape[0] zmin = minfinder(labelArray) zmax = maxfinder(labelArray) Xmat = np.rollaxis(labelArray, 2) xmin = 0 xmax = Xmat.shape[0] xmin = minfinder(Xmat) xmax = maxfinder(Xmat) Ymat = np.rollaxis(labelArray, 1) ymin = 0 ymax = Ymat.shape[0] ymin = minfinder(Ymat) ymax = maxfinder(Ymat) cube = (200.00, 200.00, 200.00) # lung # use (100.00,100.00,100.00) pad cube for brain tumors dims = tuple(map(lambda x: x - 1, labelNode.GetImageData().GetDimensions())) spacing = labelNode.GetSpacing() minCoordinates = (xmin, ymin, zmin) maxCoordinates = (xmax, ymax, zmax) minCoordinates, maxCoordinates = padXYZ(dims, spacing, minCoordinates, maxCoordinates, cube=cube) lbound = minCoordinates hbound = tuple(map(lambda (x, y): x - y, zip(dims, maxCoordinates))) return lbound, hbound
def thresholdImage(self, minValue=150, maxValue=1000): ''' :param image, outputName, threshold values: image that requires threshold, output name, and threshold values Executes a threshold filter on the image and pushes it back to slicer. ''' #Pull it from slicer image = sitkUtils.PullFromSlicer("imgSmooth") #Set the filter thresholdFilter = SimpleITK.BinaryThresholdImageFilter() #Set the value for something inside the threshold to be 1 thresholdFilter.SetInsideValue(1) #Set the value for something outside the threshold to be 0 thresholdFilter.SetOutsideValue(0) #Set the max and min threshold values thresholdFilter.SetLowerThreshold(minValue) thresholdFilter.SetUpperThreshold(maxValue) #execute the filter on the image thresholdedImage = thresholdFilter.Execute(image) #push it to slicer, overwrite current output node #sitkUtils.PushToSlicer(thresholdedImage, "imgWhiteMatter",2, True) return thresholdedImage
def ImageModelSnapshot(imageNode, labelNode, outputImagePath, progress_filename): castScalarToInt(imageNode) castScalarToInt(labelNode) # center label to origin of image, if needed #labelNode.SetOrigin(imageNode.GetOrigin()) try: minBounds, maxBounds = getCropBoundaries(labelNode) zoomImageNode = cropToZoom(imageNode, minBounds, maxBounds, label=False) zoomLabelNode = cropToZoom(labelNode, minBounds, maxBounds, label=True) sitkZoomLabelNode = su.PullFromSlicer(zoomLabelNode.GetName()) zoomLabelNodeArray = sitk.GetArrayFromImage(sitkZoomLabelNode) zoomLabelNodeArray = np.where(zoomLabelNodeArray == 0, np.NAN, zoomLabelNodeArray) # Find index of Z axis slice with largest surface area in the label node maxZind = findLargestSurfaceAreaSlice(zoomLabelNodeArray) outputImage = modelHandler(zoomImageNode, zoomLabelNode, maxZind) writer = vtk.vtkPNGWriter() writer.SetFileName(outputImagePath) writer.SetInputData(outputImage) writer.Write() return (maxZind) except Exception, e: with open(progress_filename, mode='a') as printfile: printfile.write('ERROR: ' + str(e) + '\n\n') print "ERROR: Error Creating", outputImagePath, str(e) return (-1, -1, -1)
def thresholdRangeScan(self, inputVolume1, threshold1, threshold2, volumeName): #cast = sitk.CastImageFilter() inputVolumeName1 = inputVolume1.GetName() image1 = sitkUtils.PullFromSlicer(inputVolumeName1) #image1Cast = cast.Execute(image1) #inputVolumeName2 = inputVolume2.GetName() #image2 = sitkUtils.PullFromSlicer(inputVolumeName2) #image2Cast = cast.Execute(image2) thresholdFilter = sitk.ThresholdImageFilter() thresholdFilter.SetLower(threshold1) thresholdFilter.SetUpper(threshold2) thresholdFilter.SetOutsideValue(0) thresholdedImage = thresholdFilter.Execute(image1) sitkUtils.PushToSlicer(thresholdedImage, volumeName, True) thresholdedVolume = slicer.util.getNode(volumeName) return thresholdedVolume
def runThreshold(self): # Sets minimum threshold value based on KEV80 or KEV120 if self.KEV80: self.lowerThresholdValue = 167 calciumName = "{0}_80KEV_{1}HU_Calcium_Label".format( self.inputVolumeName, self.lowerThresholdValue) elif self.KEV120: self.lowerThresholdValue = 130 calciumName = "{0}_120KEV_{1}HU_Calcium_Label".format( self.inputVolumeName, self.lowerThresholdValue) print "Thresholding at {0}".format(self.lowerThresholdValue) inputVolume = su.PullFromSlicer(self.inputVolumeName) thresholdImage = sitk.BinaryThreshold(inputVolume, self.lowerThresholdValue, self.upperThresholdValue) castedThresholdImage = sitk.Cast(thresholdImage, sitk.sitkInt16) su.PushLabel(castedThresholdImage, calciumName) self.assignLabelLUT(calciumName) self.setLowerPaintThreshold()
def test_LabelObjectStatisticsLogic(self): self.delayDisplay("Starting test_LabelObjectStatisticsLogic") import SampleData sampleDataLogic = SampleData.SampleDataLogic() mrHead = sampleDataLogic.downloadMRHead() img = sitkUtils.PullFromSlicer(mrHead.GetName()) labelImg = sitk.OtsuMultipleThresholds(img, 3) labelNodeName = "OtsuMultipleThresholdLabelMap" sitkUtils.PushToSlicer(labelImg, "OtsuMultipleThresholdLabelMap", 2) mrHeadLabel = slicer.util.getNode(labelNodeName) logic = LabelObjectStatisticsLogic(mrHead, mrHeadLabel) print logic.keys print logic.labelStats logic.saveStats("test_LabelObjectStatisticsLogic.csv")
def runGradient(self, masterNode): global mean global std tempImage = sitkUtils.PullFromSlicer(masterNode.GetID()) ''' castIF = SimpleITK.CastImageFilter() castIF.SetOutputPixelType(SimpleITK.sitkFloat32) masterImage = castIF.Execute(tempImage) smoothIF = SimpleITK.GradientAnisotropicDiffusionImageFilter() spacing = masterImage.GetSpacing() min_spacing = numpy.min(numpy.array(spacing)) smoothIF.SetTimeStep(min_spacing/(math.pow(2, 4))) smoothIF.SetNumberOfIterations(10) smoothIF.SetConductanceParameter(10) smoothImage = smoothIF.Execute(masterImage) sitkUtils.PushToSlicer(smoothImage, 'smoothImage') print('Done smoothing') ''' smoothArray = SimpleITK.GetArrayFromImage(tempImage) gradientArray = SimpleITK.GetArrayFromImage( tempImage) # duplicate to modify this one for j in range(1, smoothArray.shape[1] - 2): # X for k in range(1, smoothArray.shape[2] - 2): # Y gradientArray[:, j, k] = numpy.sum(numpy.sum( numpy.abs(smoothArray[:, j - 2:j + 2, k - 2:k + 2] - mean), axis=2), axis=1) / 9 gradientImage = SimpleITK.GetImageFromArray(gradientArray) sitkUtils.PushToSlicer(gradientImage, 'gradientImage') print('Done sergio gradient')
def getRASFieldFromLPSField(self, displacementFieldPath, referenceNode): image = sitk.ReadImage(displacementFieldPath) arr = sitk.GetArrayFromImage(image) is2D = len(arr.shape) == 3 if is2D: arr = arr[:, :, None, :] # add z voxels axis zeros = np.zeros_like( arr[..., :1]) # add z component of the vectors arr = np.concatenate((arr, zeros), axis=3) arr[..., :2] *= -1 # RAS to LPS # Create new image referenceImage = su.PullFromSlicer(referenceNode.GetID()) newImage = sitk.GetImageFromArray(arr) newImage.SetOrigin(referenceImage.GetOrigin()) newImage.SetDirection(referenceImage.GetDirection()) newImage.SetSpacing(referenceImage.GetSpacing()) # TODO: convert the image directly into a transform to save space and time sitk.WriteImage(newImage, displacementFieldPath) transformNode = slicer.util.loadTransform(displacementFieldPath) return transformNode
def modelHandler(ImageFilePath, imageNode, labelNode, imgOutputDir, IDcurrPatient, Zind): """ imageBuffer = vtk.vtkImageData() label = growCut(imageNode.GetImageData(),labelNode.GetImageData(),imageBuffer) q = labelNode.GetImageData() q.DeepCopy(label) if labelNode.GetImageDataConnection(): labelNode.GetImageDataConnection().GetProducer().Update() if labelNode.GetImageData().GetPointData().GetScalars() != None: labelNode.GetImageData().GetPointData().GetScalars().Modified() labelNode.GetImageData().Modified() labelNode.Modified() pdb.set_trace() """ imageSeriesDescription = os.path.basename(ImageFilePath).replace( '.nrrd', '') imagePatientID = os.path.basename( os.path.dirname(os.path.dirname(os.path.dirname((ImageFilePath))))) imageStudyDate = os.path.basename( os.path.dirname(os.path.dirname((ImageFilePath)))) imagePatientID_StudyDate = imagePatientID + '_' + imageStudyDate inputImage = su.PullFromSlicer(imageNode.GetName()) inputLabel = su.PullFromSlicer(labelNode.GetName()) pixelID = inputImage.GetPixelIDValue() FlipYAxis = sitk.FlipImageFilter() FlipYAxis.SetFlipAxes([False, True, False]) sizeZ = list(inputImage.GetSize()) sizeZ[2] = 0 indexZ = [0, 0, Zind] ExtractorZ = sitk.ExtractImageFilter() ExtractorZ.SetSize(sizeZ) ExtractorZ.SetIndex(indexZ) sliceZImage = ExtractorZ.Execute(inputImage) sliceZLabel = ExtractorZ.Execute(inputLabel) imageName = 'Axial_Slice_Image' + IDcurrPatient labelName = 'Axial_Slice_Label' + IDcurrPatient su.PushToSlicer(sliceZImage, imageName) su.PushToSlicer(sliceZLabel, labelName) sliceZImageNode = slicer.util.getNode(imageName) sliceZLabelNode = slicer.util.getNode(labelName) volumesLogic = slicer.vtkSlicerVolumesLogic() volumesLogic.SetVolumeAsLabelMap(sliceZLabelNode, True) volumesLogic.SetVolumeAsLabelMap(labelNode, True) #sliceZLabelNode = binarizeLabelMapToValue(sliceZLabelNode, labelValue=296) #labelNode = binarizeLabelMapToValue(labelNode, labelValue=296) sliceZLabelNodeDisplay = sliceZLabelNode.GetDisplayNode() sliceZLabelNodeDisplay.SetAndObserveColorNodeID( 'vtkMRMLColorTableNodeFileGenericColors.txt') sliceZLabelNode.SetAndObserveDisplayNodeID(sliceZLabelNodeDisplay.GetID()) labelNodeDisplay = labelNode.GetDisplayNode() labelNodeDisplay.SetAndObserveColorNodeID( 'vtkMRMLColorTableNodeFileGenericColors.txt') labelNode.SetAndObserveDisplayNodeID(labelNodeDisplay.GetID()) ## appLogic = slicer.app.applicationLogic() selectionNode = appLogic.GetSelectionNode() selectionNode.SetReferenceActiveVolumeID(sliceZImageNode.GetID()) selectionNode.SetReferenceActiveLabelVolumeID(sliceZLabelNode.GetID()) appLogic.PropagateVolumeSelection() ## lm = slicer.app.layoutManager() lm.setLayout(slicer.vtkMRMLLayoutNode.SlicerLayoutFourUpView) redWidget = lm.sliceWidget('Red') redLogic = redWidget.sliceLogic() redView = redWidget.sliceView() #redLogic.SetBackgroundWindowLevel(*windowLevel) sln = slicer.util.getNode('vtkMRMLSliceNodeRed') dims = list(sliceZImageNode.GetImageData().GetDimensions()) # dims[0] is x, dims[1] is y, dims [2] is Z redWidget.setFixedSize(720, 660) slncw = redWidget.sliceController() slncw.showLabelOutline(1) slncw.fitSliceToBackground() #sln.SetFieldOfView(dims[0],dims[1],1) #sln.SetDimensions(dims[0],dims[1],1) sliceannotations = slicer.modules.DataProbeInstance.infoWidget.sliceAnnoations if sliceannotations.sliceViewAnnotationsCheckBox.checkState() == 2: sliceannotations.sliceViewAnnotationsCheckBox.click() slicer.app.processEvents() wti = vtk.vtkWindowToImageFilter() wti.SetInput(redView.renderWindow()) wti.Update() imgDataRedSlice = wti.GetOutput() modelMakerCLI(labelNode) imgData3D = GetModelSnapshot() append = vtk.vtkImageAppend() append.SetAppendAxis(0) append.AddInputData(imgDataRedSlice) append.AddInputData(imgData3D) append.Update() finalImage = append.GetOutput() #finalImagePath = str(os.path.join(imgOutputDir, IDcurrPatient + '_axial_sliceZ.png')) finalImagePath = str( os.path.join( imgOutputDir, imagePatientID_StudyDate + '_' + imageSeriesDescription + '.png')) writer = vtk.vtkPNGWriter() writer.SetFileName(finalImagePath) writer.SetInputData(finalImage) writer.Write()
def onloadSegFLAIRButtonClicked(self): label_sitk = su.PullFromSlicer(self.label_name) roi = sitk.GetArrayFromImage(label_sitk) roi = roi > 0 seedpointobj = AutoMRIBrainSegWizard.FastMarching_threshold_slicer() seedpoint = seedpointobj.computeCentroid_swap(roi) img_FLAIR = sitk.ReadImage(str(self.FLAIR_image_path), sitk.sitkFloat32) # Read in ATLAS atlas_T1 = sitk.ReadImage(self.atlas_T1_dir, sitk.sitkFloat32) labelatlas_T1 = sitk.ReadImage(self.atlas_label_T1_dir, sitk.sitkUInt8) # Apply ATLAS to FLAIR image img_FLAIRbrain, brainmask = AutoMRIBrainSegWizard.MRIBrainSegmentor( ).skullstrip(img_FLAIR, atlas_T1, labelatlas_T1) # write out skull stripped images sitk.WriteImage(img_FLAIRbrain, self.FLAIR_path + self.name_FLAIR_image) # Load registered and resampled FLAIR image img_FLAIRbrain = sitk.ReadImage( self.FLAIR_path + self.name_FLAIR_image, sitk.sitkFloat32) # smoothing with filter blurFilter = sitk.CurvatureFlowImageFilter() blurFilter.SetNumberOfIterations(5) blurFilter.SetTimeStep(0.1) blurredFLAIR = blurFilter.Execute(img_FLAIRbrain) # perform segmentation with thresholding #chan_filter = sitk.ScalarChanAndVeseSparseLevelSetImageFilter() # water_filter = sitk.MorphologicalWatershedImageFilter() # water_filter.SetLevel(600) # segFLAIR_raw = water_filter.Execute(blurredFLAIR) #water_filter.SetMarkWatershedLine(1) #water_filter.SetFullyConnected(1) # seed = (219,220,13) # seg = sitk.Image(blurredFLAIR.GetSize(), sitk.sitkUInt8) # seg.CopyInformation(blurredFLAIR) # seg[seed] = 1 #seg = sitk.BinaryDilate(blurredFLAIR, 3) #segFLAIR = sitk.ConnectedThreshold(blurredFLAIR, seedList=[seed], lower=200, upper=1200) segFLAIR = sitk.ConfidenceConnected(blurredFLAIR, seedList=[seedpoint], numberOfIterations=10, multiplier=3, initialNeighborhoodRadius=1, replaceValue=1) print('done') # Filling holes if any in ROI vectorRadius = (10, 10, 5) kernel = sitk.sitkBall segFLAIR = sitk.BinaryMorphologicalClosing(segFLAIR, vectorRadius, kernel) # b = np.array(semiauto) # white_pix = b.reshape(-1) nda = sitk.GetArrayFromImage(segFLAIR) white_pix = np.count_nonzero(nda) # n_white_pix = np.sum(semiauto == 1) print('Number of white pixels:', white_pix) # To check if the tumors are segmented out well if white_pix > 45000: segFLAIR = sitk.ConfidenceConnected(blurredFLAIR, seedList=[seedpoint], numberOfIterations=10, multiplier=2.75, initialNeighborhoodRadius=1, replaceValue=1) print('done') vectorRadius = (10, 10, 5) kernel = sitk.sitkBall segFLAIR = sitk.BinaryMorphologicalClosing(segFLAIR, vectorRadius, kernel) nda = sitk.GetArrayFromImage(segFLAIR) white_pix = np.count_nonzero(nda) print('Number of white pixels:', white_pix) if white_pix > 45000: segFLAIR = sitk.ConfidenceConnected( blurredFLAIR, seedList=[seedpoint], numberOfIterations=10, multiplier=2.5, initialNeighborhoodRadius=1, replaceValue=1) print('done') vectorRadius = (10, 10, 5) kernel = sitk.sitkBall segFLAIR = sitk.BinaryMorphologicalClosing( segFLAIR, vectorRadius, kernel) nda = sitk.GetArrayFromImage(segFLAIR) white_pix = np.count_nonzero(nda) print('Number of white pixels:', white_pix) if white_pix > 45000: segFLAIR = sitk.ConfidenceConnected( blurredFLAIR, seedList=[seedpoint], numberOfIterations=10, multiplier=2.35, initialNeighborhoodRadius=1, replaceValue=1) print('done') vectorRadius = (10, 10, 5) kernel = sitk.sitkBall segFLAIR = sitk.BinaryMorphologicalClosing( segFLAIR, vectorRadius, kernel) nda = sitk.GetArrayFromImage(segFLAIR) white_pix = np.count_nonzero(nda) print('Number of white pixels:', white_pix) # This will work for very small nodules if white_pix > 45000: segFLAIR = sitk.ConfidenceConnected( blurredFLAIR, seedList=[seedpoint], numberOfIterations=10, multiplier=2.15, initialNeighborhoodRadius=1, replaceValue=1) print('done') vectorRadius = (10, 10, 5) kernel = sitk.sitkBall segFLAIR = sitk.BinaryMorphologicalClosing( segFLAIR, vectorRadius, kernel) nda = sitk.GetArrayFromImage(segFLAIR) white_pix = np.count_nonzero(nda) print('Number of white pixels:', white_pix) # This will work for very small nodules hopefully (last resort) if white_pix > 45000: segFLAIR = sitk.ConfidenceConnected( blurredFLAIR, seedList=[seedpoint], numberOfIterations=10, multiplier=1.95, initialNeighborhoodRadius=1, replaceValue=1) print('done') vectorRadius = (10, 10, 5) kernel = sitk.sitkBall segFLAIR = sitk.BinaryMorphologicalClosing( segFLAIR, vectorRadius, kernel) nda = sitk.GetArrayFromImage(segFLAIR) white_pix = np.count_nonzero(nda) print('Number of white pixels:', white_pix) if white_pix > 45000: segFLAIR = sitk.ConfidenceConnected( blurredFLAIR, seedList=[seedpoint], numberOfIterations=10, multiplier=1.85, initialNeighborhoodRadius=1, replaceValue=1) print('done') vectorRadius = (10, 10, 5) kernel = sitk.sitkBall segFLAIR = sitk.BinaryMorphologicalClosing( segFLAIR, vectorRadius, kernel) nda = sitk.GetArrayFromImage(segFLAIR) white_pix = np.count_nonzero(nda) print('Number of white pixels:', white_pix) if white_pix > 45000: segFLAIR = sitk.ConfidenceConnected( blurredFLAIR, seedList=[seedpoint], numberOfIterations=10, multiplier=1.75, initialNeighborhoodRadius=1, replaceValue=1) print('done') vectorRadius = (10, 10, 5) kernel = sitk.sitkBall segFLAIR = sitk.BinaryMorphologicalClosing( segFLAIR, vectorRadius, kernel) nda = sitk.GetArrayFromImage(segFLAIR) white_pix = np.count_nonzero(nda) print('Number of white pixels:', white_pix) if white_pix > 45000: segFLAIR = sitk.ConfidenceConnected( blurredFLAIR, seedList=[seedpoint], numberOfIterations=10, multiplier=1.65, initialNeighborhoodRadius=1, replaceValue=1) print('done') vectorRadius = (10, 10, 5) kernel = sitk.sitkBall segFLAIR = sitk.BinaryMorphologicalClosing( segFLAIR, vectorRadius, kernel) nda = sitk.GetArrayFromImage(segFLAIR) white_pix = np.count_nonzero(nda) print('Number of white pixels:', white_pix) if white_pix > 45000: segFLAIR = sitk.ConfidenceConnected( blurredFLAIR, seedList=[seedpoint], numberOfIterations=10, multiplier=1.55, initialNeighborhoodRadius=1, replaceValue=1) print('done') vectorRadius = (10, 10, 5) kernel = sitk.sitkBall segFLAIR = sitk.BinaryMorphologicalClosing( segFLAIR, vectorRadius, kernel) nda = sitk.GetArrayFromImage( segFLAIR) white_pix = np.count_nonzero(nda) print('Number of white pixels:', white_pix) if white_pix > 45000: segFLAIR = sitk.ConfidenceConnected( blurredFLAIR, seedList=[seedpoint], numberOfIterations=10, multiplier=1.4, initialNeighborhoodRadius=1, replaceValue=1) print('done') vectorRadius = (10, 10, 5) kernel = sitk.sitkBall segFLAIR = sitk.BinaryMorphologicalClosing( segFLAIR, vectorRadius, kernel) nda = sitk.GetArrayFromImage( segFLAIR) white_pix = np.count_nonzero( nda) print( 'Number of white pixels:', white_pix) holefill = sitk.VotingBinaryIterativeHoleFillingImageFilter() holefill.SetMaximumNumberOfIterations(5) segFLAIR = holefill.Execute(segFLAIR) ### save resulting segmentation ### sitk.WriteImage(segFLAIR, self.FLAIR_path + self.name_FLAIR_label) FLAIR_label = slicer.util.loadVolume(self.FLAIR_path + self.name_FLAIR_label, properties={'labelmap': True}, returnNode=True) labelname = 'FLAIR_label' labelNode = slicer.util.getNode(pattern=labelname) self.labelNode = labelNode self.auto3DGen()
def test_SimpleITK_SlicerPushPull_Deprecated(self): """ Test with deprecated API to ensure backward compatibility """ """ Download the MRHead node """ import SampleData SampleData.downloadSample("MRHead") volumeNode1 = slicer.util.getNode('MRHead') self.assertEqual(volumeNode1.GetName(), "MRHead") """ Verify that pulling SimpleITK image from Slicer and then pushing it back creates an identical volume. """ sitkimage = su.PullFromSlicer(volumeNode1.GetName()) self.assertIsNotNone(sitkimage) su.PushToSlicer(sitkimage, 'MRHead', compositeView=0, overwrite=False) volumeNode1Copy = slicer.util.getNode('MRHead_1') """ Verify that image is not overwritten but a new one is created """ self.assertEqual(volumeNode1, slicer.util.getNode('MRHead'), 'Original volume is changed') self.assertNotEqual(volumeNode1, volumeNode1Copy, 'Copy of original volume is not created') """ Few modification of the image : Direction, Origin """ sitkimage.SetDirection((-1.0, 1.0, 0.0, 0.0, -1.0, 1.0, 1.0, 0.0, 1.0)) sitkimage.SetOrigin((100.0, 100.0, 100.0)) """ Few pixel changed """ size = sitkimage.GetSize() for x in xrange(0,size[0],(int)(size[0]/10)): for y in xrange(0,size[1],(int)(size[1]/10)): for z in xrange(0,size[2],(int)(size[2]/10)): sitkimage.SetPixel(x,y,z,0L) su.PushToSlicer(sitkimage, 'ImageChanged', compositeView=0, overwrite=False) volumeNode1Modified = slicer.util.getNode('ImageChanged') self.assertNotEqual(volumeNode1.GetMTime(), volumeNode1Modified.GetMTime(), 'Error Push Pull: Modify Time are the same') """ Test the consistency between sitkimage and volumeNode1Modified """ tmp = volumeNode1Modified.GetOrigin() valToCompare = (-tmp[0], -tmp[1], tmp[2]) self.assertEqual(valToCompare,sitkimage.GetOrigin(), 'Modified origin mismatch') """ Test push with all parameter combinations """ for compositeView in xrange(3): # background, foreground, label for overwrite in [False, True]: su.PushToSlicer(sitkimage, 'volumeNode'+str(compositeView)+str(overwrite), compositeView, overwrite) volumeNode = slicer.util.getNode('volumeNode'+str(compositeView)+str(overwrite)) print("compositeView : %s" %compositeView ) print("overwrite : %s " %overwrite ) #Check if it's a label if compositeView == 2: self.assertEqual(volumeNode.GetClassName(),'vtkMRMLLabelMapVolumeNode', 'Error Push Pull: Not a label Class Name') else: self.assertEqual(volumeNode.GetClassName(), 'vtkMRMLScalarVolumeNode', 'Error Push Pull: Not a back/foreground Class Name') slicer.mrmlScene.Clear(0)