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)
