def performLaplaceOfGaussian(self, image):
'''
'''
gaussian = vtk.vtkImageGaussianSmooth()
gaussian.SetInputData(image)
gaussian.Update()
laplacian = vtk.vtkImageLaplacian()
laplacian.SetInputData(gaussian.GetOutput())
laplacian.Update()
outImageData = vtk.vtkImageData()
outImageData.DeepCopy(laplacian.GetOutput())
return outImageData
def performLaplaceOfGaussian( self, image ):
'''
'''
gaussian = vtk.vtkImageGaussianSmooth()
gaussian.SetInputData( image )
gaussian.Update()
laplacian = vtk.vtkImageLaplacian()
laplacian.SetInputData( gaussian.GetOutput() )
laplacian.Update()
outImageData = vtk.vtkImageData()
outImageData.DeepCopy( laplacian.GetOutput() )
return outImageData
def filtro(self):
escenafiltro = slicer.mrmlScene
#Se recupera la escena cargada
volumen4Dfiltro = self.inputSelector3.currentNode()
imagenvtk4Dfiltro = volumen4Dfiltro.GetImageData()
numero_imagenes = volumen4Dfiltro.GetNumberOfFrames()
for i in range(0, numero_imagenes, 1):
#extraer la imagen movil
extract2 = vtk.vtkImageExtractComponents()
extract2.SetInputData(imagenvtk4Dfiltro)
extract2.SetComponents(i)
extract2.Update()
filtroGaussiano = vtk.vtkImageGaussianSmooth()
filtroGaussiano.SetStandardDeviation(1, 1, 1)
filtroGaussiano.SetInputData(extract2.GetOutput())
filtroGaussiano.Update()
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
volumen4Dfiltro.GetRASToIJKMatrix(ras2ijk)
volumen4Dfiltro.GetIJKToRASMatrix(ijk2ras)
volSalida = slicer.vtkMRMLScalarVolumeNode()
volSalida.SetAndObserveImageData(filtroGaussiano.GetOutput())
volSalida.SetRASToIJKMatrix(ras2ijk)
volSalida.SetIJKToRASMatrix(ijk2ras)
slicer.mrmlScene.AddNode(volSalida)
slicer.util.saveNode(
volSalida, 'filtrado' + str(i + 1) + '.nrrd'
) #se guarda el volumen registrado en la carpeta de documentos
print("ya filtre" + str(i))
def createSyntheticDose(self, doseVolumeNode, radius, value):
"""
Run the actual algorithm
"""
roiSphere = vtk.vtkSphere()
roiCenter = [0, 0, 0]
roiOrigin = [0, 0, 0]
roiSpacing = [1, 1, 1]
roiDimension = [100, 100, 100]
# roiDimension = refVolumeNode.GetImageData().GetDimensions()
roiCenter[0] = roiOrigin[0] + roiDimension[0] * roiSpacing[0] / 2
roiCenter[1] = roiOrigin[1] + roiDimension[1] * roiSpacing[1] / 2
roiCenter[2] = roiOrigin[2] + roiDimension[2] * roiSpacing[2] / 2
print "roiCenter", roiCenter
"""
ijkToRas = vtk.vtkMatrix4x4()
refVolumeNode.GetIJKToRASMatrix( ijkToRas )
roiPoint = [0,0,0,1];
roiPoint[0] = roiCenter[0]
roiPoint[1] = roiCenter[1]
roiPoint[2] = roiCenter[2]
roiPoint = ijkToRas.MultiplyPoint(roiPoint)
roiCenter[0] = roiPoint[0]
roiCenter[1] = roiPoint[1]
roiCenter[2] = roiPoint[2]
print "roiCenter", roiCenter
"""
roiSphere.SetCenter(roiCenter)
roiSphere.SetRadius(radius + 5)
# Determine the transform between the box and the image IJK coordinate systems
rasToSphere = vtk.vtkMatrix4x4()
# if roiNode.GetTransformNodeID() != None:
# roiSphereTransformNode = slicer.mrmlScene.GetNodeByID(roiNode.GetTransformNodeID())
# sphereToRas = vtk.vtkMatrix4x4()
# roiSphereTransformNode.GetMatrixTransformToWorld(sphereToRas)
# rasToSphere.DeepCopy(sphereToRas)
# rasToSphere.Invert()
"""
ijkToSphere = vtk.vtkMatrix4x4()
vtk.vtkMatrix4x4.Multiply4x4(rasToSphere,ijkToRas,ijkToSphere)
ijkToSphereTransform = vtk.vtkTransform()
ijkToSphereTransform.SetMatrix(ijkToSphere)
roiSphere.SetTransform(ijkToSphereTransform)
"""
# Use the stencil to fill the volume
# refImageData = refVolumeNode.GetImageData()
imageSource = vtk.vtkImageNoiseSource()
imageSource.SetMinimum(0)
imageSource.SetMaximum(0)
# extent = refImageData.GetWholeExtent()
imageSource.SetWholeExtent(0, roiDimension[0] - 1, 0,
roiDimension[1] - 1, 0, roiDimension[2] - 1)
imageSource.Update()
"""
changeInfo = vtk.vtkImageChangeInformation()
changeInfo.SetInputData(imageSource.GetOutput())
changeInfo.SetOutputOrigin(refImageData.GetOrigin())
changeInfo.SetOutputSpacing(refImageData.GetSpacing())
changeInfo.Update()
"""
# Convert the implicit function to a stencil
functionToStencil = vtk.vtkImplicitFunctionToImageStencil()
functionToStencil.SetInput(roiSphere)
functionToStencil.SetOutputOrigin(0, 0, 0)
functionToStencil.SetOutputSpacing(1, 1, 1)
functionToStencil.SetOutputWholeExtent(0, roiDimension[0] - 1, 0,
roiDimension[1] - 1, 0,
roiDimension[2] - 1)
functionToStencil.Update()
# Apply the stencil to the volume
stencilToImage = vtk.vtkImageStencil()
stencilToImage.SetInputData(imageSource.GetOutput())
stencilToImage.SetStencilData(functionToStencil.GetOutput())
stencilToImage.ReverseStencilOn()
stencilToImage.SetBackgroundValue(value)
stencilToImage.Update()
smooth = vtk.vtkImageGaussianSmooth()
smooth.SetInputData(stencilToImage.GetOutput())
smooth.SetStandardDeviations(2.8, 2.8,
2.8) # place to change gradient size.
smooth.SetRadiusFactors(3, 3, 3)
smooth.SetDimensionality(3)
smooth.Update()
"""
resample = vtk.vtkImageReslice()
resample.SetInputData(smooth.GetOutput())
resample.SetOutputOrigin(refImageData.GetOrigin())
resample.SetOutputSpacing(refImageData.GetSpacing()[0]/2, refImageData.GetSpacing()[1]/2, refImageData.GetSpacing()[2]/2 )
resample.SetOutputExtent(extent[0], (extent[1]-extent[0])*2-1,
extent[2], (extent[3]-extent[2])*2-1,
extent[4], (extent[5]-extent[4])*2-1)
resample.Update()
changeInfo2 = vtk.vtkImageChangeInformation()
changeInfo2.SetInputData(resample.GetOutput())
changeInfo2.SetOutputOrigin(refImageData.GetOrigin())
changeInfo2.SetOutputSpacing(refImageData.GetSpacing())
changeInfo2.Update()
"""
# Update the volume with the stencil operation result
doseVolumeNode.SetAndObserveImageData(smooth.GetOutput())
doseVolumeNode.SetOrigin(0, 0, 0)
doseVolumeNode.SetSpacing(1, 1, 1)
# doseVolumeNode.CopyOrientation(refVolumeNode)
doseVolumeNode.SetAttribute("DicomRtImport.DoseVolume", "1")
mgr = slicer.app.layoutManager()
mgr.sliceWidget(
'Red').sliceLogic().GetSliceCompositeNode().SetBackgroundVolumeID(
doseVolumeNode.GetID())
mgr.sliceWidget('Yellow').sliceLogic().GetSliceCompositeNode(
).SetBackgroundVolumeID(doseVolumeNode.GetID())
mgr.sliceWidget('Green').sliceLogic().GetSliceCompositeNode(
).SetBackgroundVolumeID(doseVolumeNode.GetID())
def runCaliper(self):
inputVolume = self.inputSelector.currentNode()
if not (inputVolume):
qt.QMessageBox.critical(
slicer.util.mainWindow(),
'Deploy Caliper', 'Input volume is required for calculation.')
return
# If coordinates modified, use for calculation
if self.coordinatesWidgetModified:
widgetPointsList = slicer.vtkMRMLMarkupsFiducialNode()
widgetPointsList.SetName('WPL')
# widgetNode = slicer.util.getNode('WPL')
slicer.mrmlScene.AddNode(widgetPointsList)
# Grab first widget coordinate and display
print "PointNum1 is: "
pointNum1Str = (str(self.c1Select.coordinates)).split(",")
pointNum1 = [float(i) for i in pointNum1Str]
print pointNum1
widgetPointsList.AddFiducial(pointNum1[0], pointNum1[1], pointNum1[2], 'WP-1')
# Grab second widget coordinate and display
print "PointNum2 is: "
pointNum2Str = (str(self.c2Select.coordinates)).split(",")
pointNum2 = [float(i) for i in pointNum2Str]
print pointNum2
widgetPointsList.AddFiducial(pointNum2[0], pointNum2[1], pointNum2[2], 'WP-2')
# Center the slices on Point 1
slicer.modules.markups.logic().JumpSlicesToLocation(pointNum1[0], pointNum1[1], pointNum1[2], True)
# Calculate distance in mm and print to console
distanceValue = math.sqrt( math.pow((pointNum1[0] - pointNum2[0]), 2) + math.pow((pointNum1[1] - pointNum2[1]), 2) + math.pow((pointNum1[2] - pointNum2[2]), 2))
self.distUpdate.setText("Distance: %.2f mm" % distanceValue)
# Add a ruler
rulerNode = slicer.vtkMRMLAnnotationRulerNode()
rulerNode.SetDistanceAnnotationVisibility(1)
rulerNode.SetPosition1(pointNum1[0], pointNum1[1], pointNum1[2])
rulerNode.SetPosition2(pointNum2[0], pointNum2[1], pointNum2[2])
rulerNode.SetName('Distance 1')
rulerNode.SetDistanceAnnotationVisibility(False)
rulerNode.Initialize(slicer.mrmlScene)
self.coordinatesWidgetModified = False
else:
# Get interactive coordinates, if any
intNode1 = slicer.util.getNode('IP1')
intNode2 = slicer.util.getNode('IP2')
if ((intNode1.GetNumberOfFiducials() == 1) and (intNode2.GetNumberOfFiducials() == 1)):
z3point1 = [0.0, 0.0, 0.0]
z3point2 = [0.0, 0.0, 0.0]
intNode1.GetNthFiducialPosition(0, z3point1)
intNode2.GetNthFiducialPosition(0, z3point2)
print "Interactive Point 1:"
print z3point1
print "Interactive Point 2:"
print z3point2
interactiveDistance = math.sqrt( math.pow((z3point1[0] - z3point2[0]), 2) + math.pow((z3point1[1] - z3point2[1]), 2) + math.pow((z3point1[2] - z3point2[2]), 2))
self.intDistUpdate.setText("Distance: %.2f mm" % interactiveDistance)
intRulerNode = slicer.vtkMRMLAnnotationRulerNode()
intRulerNode.SetDistanceAnnotationVisibility(1)
intRulerNode.SetPosition1(z3point1[0], z3point1[1], z3point1[2])
intRulerNode.SetPosition2(z3point2[0], z3point2[1], z3point2[2])
intRulerNode.SetName('Distance 2')
intRulerNode.SetDistanceAnnotationVisibility(False)
intRulerNode.Initialize(slicer.mrmlScene)
# Blur if checkbox is checked
if self.blur.isChecked():
gauss = vtk.vtkImageGaussianSmooth()
gauss.SetInputData(inputVolume.GetImageData())
gauss.SetDimensionality(3)
fwhmValue = .01 * distanceValue
gauss.SetStandardDeviation(fwhmValue)
gauss.Update()
ijkToRAS = vtk.vtkMatrix4x4()
inputVolume.GetIJKToRASMatrix(ijkToRAS)
inputVolume.SetAndObserveImageData(gauss.GetOutput())
