def run(self, fixed, moving, outputTrans, meanDistanceType,
landmarkTransformType, numberOfLandmarks, maxDistance,
numberOfIterations, matchCentroids, checkMeanDistance):
"""Run the actual algorithm"""
inputPolyData = moving.GetPolyData()
icp = vtk.vtkIterativeClosestPointTransform()
icp.SetSource(inputPolyData)
icp.SetTarget(fixed.GetPolyData())
if landmarkTransformType == "RigidBody":
icp.GetLandmarkTransform().SetModeToRigidBody()
elif landmarkTransformType == "Similarity":
icp.GetLandmarkTransform().SetModeToSimilarity()
elif landmarkTransformType == "Affine":
icp.GetLandmarkTransform().SetModeToAffine()
if meanDistanceType == "RMS":
icp.SetMeanDistanceModeToRMS()
elif meanDistanceType == "Absolute Value":
icp.SetMeanDistanceModeToAbsoluteValue()
icp.SetMaximumNumberOfIterations(numberOfIterations)
icp.SetMaximumMeanDistance(maxDistance)
icp.SetMaximumNumberOfLandmarks(numberOfLandmarks)
icp.SetCheckMeanDistance(int(checkMeanDistance))
icp.SetStartByMatchingCentroids(int(matchCentroids))
icp.Update()
outputMatrix = vtk.vtkMatrix4x4()
icp.GetMatrix(outputMatrix)
outputTrans.SetAndObserveMatrixTransformToParent(outputMatrix)
return
def checkForVolumeWarnings(self,master,merge):
"""Verify that volumes are compatible with label calculation
algorithm assumptions. Returns warning text of empty
string if none.
"""
warnings = ""
if not master:
warnings = "Missing master volume"
if merge:
if not master.GetImageData() or not merge.GetImageData():
return "Missing image data"
if master.GetImageData().GetDimensions() != merge.GetImageData().GetDimensions():
warnings += "Volume dimensions do not match\n"
if master.GetImageData().GetSpacing() != merge.GetImageData().GetSpacing():
warnings += "Volume spacings do not match\n"
if master.GetImageData().GetOrigin() != merge.GetImageData().GetOrigin():
warnings += "Volume spacings do not match\n"
if merge.GetImageData().GetScalarType() != vtk.VTK_SHORT:
warnings += "Label map must be of type Short (Use Cast Scalar Volume to fix)\n"
masterIJKToRAS = vtk.vtkMatrix4x4()
mergeIJKToRAS = vtk.vtkMatrix4x4()
master.GetIJKToRASMatrix(masterIJKToRAS)
merge.GetIJKToRASMatrix(mergeIJKToRAS)
for row in range(4):
for column in range(4):
if masterIJKToRAS.GetElement(row,column) != mergeIJKToRAS.GetElement(row,column):
warnings += "Volume geometry does not match (Resample to fix)\n"
break
return warnings
def recolorLabelMap(self, modelNode, labelMap, initialValue, outputValue):
import vtkSlicerRtCommonPython
if (modelNode != None and labelMap != None):
self.labelMapImgData = labelMap.GetImageData()
self.resectionPolyData = modelNode.GetPolyData()
# IJK -> RAS
ijkToRasMatrix = vtk.vtkMatrix4x4()
labelMap.GetIJKToRASMatrix(ijkToRasMatrix)
# RAS -> IJK
rasToIjkMatrix = vtk.vtkMatrix4x4()
labelMap.GetRASToIJKMatrix(rasToIjkMatrix)
rasToIjkTransform = vtk.vtkTransform()
rasToIjkTransform.SetMatrix(rasToIjkMatrix)
rasToIjkTransform.Update()
# Transform Resection model from RAS -> IJK
polyDataTransformFilter = vtk.vtkTransformPolyDataFilter()
if (vtk.VTK_MAJOR_VERSION <= 5):
polyDataTransformFilter.SetInput(self.resectionPolyData)
else:
polyDataTransformFilter.SetInputData(self.resectionPolyData)
polyDataTransformFilter.SetTransform(rasToIjkTransform)
polyDataTransformFilter.Update()
# Convert Resection model to label map
polyDataToLabelmapFilter = vtkSlicerRtCommonPython.vtkPolyDataToLabelmapFilter()
polyDataToLabelmapFilter.SetInputPolyData(polyDataTransformFilter.GetOutput())
polyDataToLabelmapFilter.SetReferenceImage(self.labelMapImgData)
polyDataToLabelmapFilter.UseReferenceValuesOn()
polyDataToLabelmapFilter.SetBackgroundValue(0)
polyDataToLabelmapFilter.SetLabelValue(outputValue)
polyDataToLabelmapFilter.Update()
# Cast resection label map to unsigned char for use with mask filter
castFilter = vtk.vtkImageCast()
if (vtk.VTK_MAJOR_VERSION <= 5):
castFilter.SetInput(polyDataToLabelmapFilter.GetOutput())
else:
castFilter.SetInputData(polyDataToLabelmapFilter.GetOutput())
castFilter.SetOutputScalarTypeToUnsignedChar()
castFilter.Update()
# Create mask for recoloring the original label map
maskFilter = vtk.vtkImageMask()
if (vtk.VTK_MAJOR_VERSION <= 5):
maskFilter.SetImageInput(self.labelMapImgData)
maskFilter.SetMaskInput(castFilter.GetOutput())
else:
maskFilter.SetImageInputData(self.labelMapImgData)
maskFilter.SetMaskInputData(castFilter.GetOutput())
maskFilter.SetMaskedOutputValue(outputValue)
maskFilter.NotMaskOn()
maskFilter.Update()
self.labelMapImgData = maskFilter.GetOutput()
self.labelMapImgData.Modified()
labelMap.SetAndObserveImageData(self.labelMapImgData)
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,referenceNode, inputNode, transformNode, outputNode):
"""
Run the actual algorithm
"""
dimensions = [1,1,1]
referenceNode.GetImageData().GetDimensions(dimensions)
inputIJK2RASMatrix = vtk.vtkMatrix4x4()
inputNode.GetIJKToRASMatrix(inputIJK2RASMatrix)
referenceRAS2IJKMatrix = vtk.vtkMatrix4x4()
referenceNode.GetRASToIJKMatrix(referenceRAS2IJKMatrix)
inputRAS2RASMatrix = transformNode.GetMatrixTransformToParent()
resampleTransform = vtk.vtkTransform()
resampleTransform.Identity()
resampleTransform.PostMultiply()
resampleTransform.SetMatrix(inputIJK2RASMatrix)
resampleTransform.Concatenate(inputRAS2RASMatrix)
resampleTransform.Concatenate(referenceRAS2IJKMatrix)
resampleTransform.Inverse()
resampler = vtk.vtkImageReslice()
resampler.SetInput(inputNode.GetImageData())
resampler.SetOutputOrigin(0,0,0)
resampler.SetOutputSpacing(1,1,1)
resampler.SetOutputExtent(0,dimensions[0],0,dimensions[1],0,dimensions[2])
resampler.SetResliceTransform(resampleTransform)
resampler.Update()
outputNode.CopyOrientation(referenceNode)
outputNode.SetAndObserveImageData(resampler.GetOutput())
return True
def checkForVolumeWarnings(self,master,merge):
"""Verify that volumes are compatible with label calculation
algorithm assumptions. Returns warning text of empty
string if none.
"""
warnings = ""
if not master:
warnings = "Missing master volume"
if merge:
if not master.GetImageData() or not merge.GetImageData():
return "Missing image data"
if master.GetImageData().GetDimensions() != merge.GetImageData().GetDimensions():
warnings += "Volume dimensions do not match\n"
if master.GetImageData().GetSpacing() != merge.GetImageData().GetSpacing():
warnings += "Volume spacings do not match\n"
if master.GetImageData().GetOrigin() != merge.GetImageData().GetOrigin():
warnings += "Volume spacings do not match\n"
# if merge.GetScalarType() != vtk.VTK_SHORT:
# warnings += "Label map must be of type Short (Use Cast Scalar Volume to fix)\n"
# if master.GetLabelMap():
# if master.GetImageData().GetScalarType() != vtk.VTK_SHORT:
# warnings += "Label map must be of type Short (Use Cast Scalar Volume to fix)\n"
masterIJKToRAS = vtk.vtkMatrix4x4()
mergeIJKToRAS = vtk.vtkMatrix4x4()
master.GetIJKToRASMatrix(masterIJKToRAS)
merge.GetIJKToRASMatrix(mergeIJKToRAS)
for row in range(4):
for column in range(4):
if masterIJKToRAS.GetElement(row,column) != mergeIJKToRAS.GetElement(row,column):
warnings += "Volume geometry does not match (Resample to fix)\n"
print("coor: " + str(row) + " " + str(column) + " " + str(masterIJKToRAS.GetElement(row,column)) + " " + str(mergeIJKToRAS.GetElement(row,column)))
break
else:
warnings += "Missing merge volume"
return warnings
def onOpticalTransformNodeModified(self,observer,eventid):
minimumTimeBetweenUpdatesSec = 0.1
currentTimeSec = vtk.vtkTimerLog.GetUniversalTime()
if (currentTimeSec<self.lastUpdateTimeSec+minimumTimeBetweenUpdatesSec):
# too close to last update
return
self.lastUpdateTimeSec = currentTimeSec
# Check to ensure you do not overstep the bounds of the array, if done creating arrays, start calculations
if self.numberDataPointsCollected >= self.numberOfDataPointsToCollect:
logging.debug("Finished data collection")
self.removeObservers()
self.calculateCalibrationOutput()
return
# Store the two transform matrices into their corresponding arrays for calculations
opPointerToOpRefVtkMatrix = vtk.vtkMatrix4x4()
self.opPointerToOpRefNode.GetMatrixTransformToParent(opPointerToOpRefVtkMatrix)
self.opPointerToOpRefTransformArray[self.numberDataPointsCollected] = self.arrayFromVtkMatrix(opPointerToOpRefVtkMatrix)
emPointerToEmTrackerVtkMatrix = vtk.vtkMatrix4x4()
self.emPointerToEmTrackerNode.GetMatrixTransformToParent(emPointerToEmTrackerVtkMatrix)
self.emPointerToEmTrackerTransformArray[self.numberDataPointsCollected] = self.arrayFromVtkMatrix(emPointerToEmTrackerVtkMatrix)
self.numberDataPointsCollected = self.numberDataPointsCollected + 1
if self.numberDataPointsCollected % 10 == 0: # report status after every 10th point to avoid too frequent screen updates
self.reportStatus(self.CALIBRATION_IN_PROGRESS,100*self.numberDataPointsCollected/self.numberOfDataPointsToCollect)
def stepSlice(self, volumeId, structureId, sliceStep):
""" Move the selected ruler up or down one slice.
:param volumeId:
:param structureId:
:param sliceStep: +1 or -1
:return: new slice in RAS format
"""
# Calculate the RAS coords of the slice where we should jump to
rulerNode, newNode = self.getRulerNodeForVolumeAndStructure(volumeId, structureId, createIfNotExist=False)
if not rulerNode:
# The ruler has not been created. This op doesn't make sense
return False
coords = [0, 0, 0, 0]
# Get current RAS coords
rulerNode.GetPositionWorldCoordinates1(coords)
# Get the transformation matrixes
rastoijk = vtk.vtkMatrix4x4()
ijktoras = vtk.vtkMatrix4x4()
scalarVolumeNode = slicer.mrmlScene.GetNodeByID(volumeId)
scalarVolumeNode.GetRASToIJKMatrix(rastoijk)
scalarVolumeNode.GetIJKToRASMatrix(ijktoras)
# Get the current slice (Z). It will be the same in both positions
ijkCoords = list(rastoijk.MultiplyPoint(coords))
# Add/substract the offset to Z
ijkCoords[2] += sliceStep
# Convert back to RAS, just replacing the Z
newSlice = ijktoras.MultiplyPoint(ijkCoords)[2]
self._placeRulerInSlice_(rulerNode, structureId, volumeId, newSlice)
return newSlice
def loadEigenArtemis3DUS(self, loadable):
name = slicer.util.toVTKString(loadable.name)
filePath = loadable.files[0]
fileList = vtk.vtkStringArray()
fileList.InsertNextValue(slicer.util.toVTKString(filePath))
volumesLogic = slicer.modules.volumes.logic()
outputVolume = volumesLogic.AddArchetypeScalarVolume(
filePath, name, 0, fileList)
outputVolume.SetSpacing(loadable.spacing, loadable.spacing,
loadable.spacing)
outputVolume.SetOrigin(loadable.origin[0], loadable.origin[1],
loadable.origin[2])
ijk2ras = vtk.vtkMatrix4x4()
outputVolume.GetIJKToRASMatrix(ijk2ras)
rot = vtk.vtkMatrix4x4()
rot.DeepCopy((0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1))
ijk2ras_updated = vtk.vtkMatrix4x4()
ijk2ras.Multiply4x4(rot, ijk2ras, ijk2ras_updated)
outputVolume.SetIJKToRASMatrix(ijk2ras_updated)
appLogic = slicer.app.applicationLogic()
selectionNode = appLogic.GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(outputVolume.GetID())
appLogic.PropagateVolumeSelection(0)
appLogic.FitSliceToAll()
return outputVolume
def renderArray(self, labelNodeArray, labelNode, imageNode, shape=(512,512,88), spacing=(1,1,1), origin=(0,0,0)):
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
imageNode.GetRASToIJKMatrix(ras2ijk)
imageNode.GetIJKToRASMatrix(ijk2ras)
labelNode.SetRASToIJKMatrix(ras2ijk)
labelNode.SetIJKToRASMatrix(ijk2ras)
labelNodeImageData = vtk.vtkImageData()
labelNodeImageData.DeepCopy(imageNode.GetImageData())
#labelNodeImageData.AllocateScalars(4,1)
#labelNodeImageData.SetDimensions(shape)
labelNodePointData = labelNodeImageData.GetPointData()
"""
# Numpy array is converted from signed int16 to signed vtkShortArray
scalarArray = vtk.vtkShortArray()
dims1D = labelNodeArray.size #labelNodePointData.GetScalars().GetSize()
flatArray = labelNodeArray.reshape(dims1D, order='C')
scalarArray = vtk.util.numpy_support.numpy_to_vtk(flatArray)
"""
scalarArray = vtk.vtkShortArray()
dims1D = labelNodePointData.GetScalars().GetSize() #labelNodePointData.GetScalars().GetSize()
flatArray = labelNodeArray.reshape(dims1D, order='F')
scalarArray = vtk.util.numpy_support.numpy_to_vtk(flatArray) # VTK Unsigned Char Array =3, short =4, uint = 7
labelNodePointData.SetScalars(scalarArray)
labelNodeImageData.Modified()
slicer.mrmlScene.AddNode(labelNode)
labelNode.SetAndObserveImageData(labelNodeImageData)
labelNode.SetSpacing(spacing)
labelNode.SetOrigin(origin)
return labelNode
def modelTipToToolCreatorByTransforms(self, originTransformNode, fromTransformNode, toTransformNode, outputTransformNode):
logging.info('INFO | modelTipToToolCreatorByTransforms')
originPoint = [0.0,0.0,0.0]
fromPoint = [0.0,0.0,0.0]
toPoint = [0.0,0.0,0.0]
m = vtk.vtkMatrix4x4()
originTransformNode.GetMatrixTransformToWorld(m)
originPoint[0] = m.GetElement(0, 3)
originPoint[1] = m.GetElement(1, 3)
originPoint[2] = m.GetElement(2, 3)
m.Identity()
fromTransformNode.GetMatrixTransformToWorld(m)
fromPoint[0] = m.GetElement(0, 3)
fromPoint[1] = m.GetElement(1, 3)
fromPoint[2] = m.GetElement(2, 3)
m.Identity()
toTransformNode.GetMatrixTransformToWorld(m)
toPoint[0] = m.GetElement(0, 3)
toPoint[1] = m.GetElement(1, 3)
toPoint[2] = m.GetElement(2, 3)
m = vtk.vtkMatrix4x4()
m = self.getRotMatAligningVecAtoVecB(originPoint, fromPoint, toPoint)
outputTransformNode.SetMatrixTransformToParent(m)
return True
def __init__(self,fixed=None,moving=None,transform=None):
self.interval = 20
self.timer = None
# parameter defaults
self.sampleSpacing = 3
self.gradientWindow = 1
self.stepSize = 1
# the parametricTransform
#self.parametricTransform = RegimaticTranslationTransform()
self.parametricTransform = RegimaticTranslateSRotatePATransform()
#self.parametricTransform = RegimaticRigidTransform() #TODO: fix quaternion
# slicer nodes set by the GUI
self.fixed = fixed
self.moving = moving
self.transform = transform
# optimizer state variables
self.iteration = 0
self.metric = 0
# helper objects
self.scratchMatrix = vtk.vtkMatrix4x4()
self.ijkToRAS = vtk.vtkMatrix4x4()
self.rasToIJK = vtk.vtkMatrix4x4()
self.matrixToParent = vtk.vtkMatrix4x4()
self.reslice = vtk.vtkImageReslice()
self.resliceTransform = vtk.vtkTransform()
self.viewer = None
def RegisterToBaseModel(self):
# ICP Registration
if self.booleanCheckBox.isChecked():
self.surfaceRegistration.inputFixedModelSelector.currentNodeID = self.transientModelSelector.currentNodeID
else:
self.surfaceRegistration.inputFixedModelSelector.currentNodeID = self.baseModelSelector.currentNodeID
self.surfaceRegistration.inputMovingModelSelector.currentNodeID = self.pointCloudSelector.currentNodeID
self.surfaceRegistration.outputTransformSelector.currentNodeID = self.transientTransformSelector.currentNodeID
#self.surfaceRegistration.landmarkTransformTypeButtonsSimilarity.checked = True
self.surfaceRegistration.numberOfIterations.setValue(
self.iterationsSpinBox.value)
self.surfaceRegistration.numberOfLandmarks.setValue(
self.landmarksSpinBox.value)
self.surfaceRegistration.onComputeButton()
# Add transient transform to total transform
transientMatrix = vtk.vtkMatrix4x4()
matrix = vtk.vtkMatrix4x4()
resultMatrix = vtk.vtkMatrix4x4()
self.transformSelector.currentNode().GetMatrixTransformToParent(matrix)
self.transientTransformSelector.currentNode(
).GetMatrixTransformToParent(transientMatrix)
vtk.vtkMatrix4x4.Multiply4x4(transientMatrix, matrix, resultMatrix)
self.transformSelector.currentNode().SetMatrixTransformToParent(
resultMatrix)
def renderLabelMap(self):
# Initializes a vtkMRMLScalarVolumeNode for the SegmentCAD Output and copies ijkToRAS matrix and Image data from nodeLabel
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.nodePre.GetRASToIJKMatrix(ras2ijk)
self.nodePre.GetIJKToRASMatrix(ijk2ras)
self.SegmentCADLabelMap.SetRASToIJKMatrix(ras2ijk)
self.SegmentCADLabelMap.SetIJKToRASMatrix(ijk2ras)
SegmentCADLabelMapImageData = vtk.vtkImageData()
SegmentCADLabelMapImageData.DeepCopy(self.nodePre.GetImageData())
SegmentCADLabelMapPointData = SegmentCADLabelMapImageData.GetPointData()
# Numpy array is converted from signed int16 to signed vtkShortArray
scalarArray = vtk.vtkShortArray()
dims1D = SegmentCADLabelMapPointData.GetScalars().GetSize()
self.nodeArraySegmentCADLabel = self.nodeArraySegmentCADLabel.reshape(dims1D, order='C') #use a flattening function
scalarArray = vtk.util.numpy_support.numpy_to_vtk(self.nodeArraySegmentCADLabel)
# PointData() of SegmentCAD label output pointed to new vtkShortArray for scalar values
if vtk.VTK_MAJOR_VERSION <= 5:
#SegmentCADLabelMapImageData.SetScalarTypeToShort()
SegmentCADLabelMapPointData.SetScalars(scalarArray)
SegmentCADLabelMapPointData.Update()
else:
#SegmentCADLabelMapImageData.SetScalarType(4)
SegmentCADLabelMapPointData.SetScalars(scalarArray)
SegmentCADLabelMapImageData.Modified()
self.SegmentCADLabelMap.SetAndObserveImageData(SegmentCADLabelMapImageData)
# Corresponding display node and color table nodes created for SegmentCAD label Output
self.SegmentCADLabelMapDisplay = slicer.vtkMRMLLabelMapVolumeDisplayNode()
self.SegmentCADLabelMapDisplay.SetScene(slicer.mrmlScene)
self.SegmentCADLabelMapDisplay.SetAndObserveColorNodeID('vtkMRMLColorTableNodeFileGenericColors.txt')
if vtk.VTK_MAJOR_VERSION <= 5:
self.SegmentCADLabelMapDisplay.SetInputImageData(self.SegmentCADLabelMap.GetImageData())
else:
self.SegmentCADLabelMapDisplay.SetInputImageDataConnection(self.SegmentCADLabelMap.GetImageDataConnection())
self.SegmentCADLabelMapDisplay.UpdateImageDataPipeline()
slicer.mrmlScene.AddNode(self.SegmentCADLabelMapDisplay)
self.SegmentCADLabelMap.SetAndObserveDisplayNodeID(self.SegmentCADLabelMapDisplay.GetID())
self.SegmentCADLabelMapDisplay.UpdateScene(slicer.mrmlScene)
#red_logic = slicer.app.layoutManager().sliceWidget("Red").sliceLogic()
#red_logic.GetSliceCompositeNode().SetLabelVolumeID(self.SegmentCADLabelMap.GetID())
#yellow_logic = slicer.app.layoutManager().sliceWidget("Yellow").sliceLogic()
#yellow_logic.GetSliceCompositeNode().SetLabelVolumeID(self.SegmentCADLabelMap.GetID())
#green_logic = slicer.app.layoutManager().sliceWidget("Green").sliceLogic()
#green_logic.GetSliceCompositeNode().SetLabelVolumeID(self.SegmentCADLabelMap.GetID())
appLogic = slicer.app.applicationLogic()
selectionNode = appLogic.GetSelectionNode()
#selectionNode.SetReferenceActiveVolumeID(self.nodePre.GetID())
selectionNode.SetReferenceActiveLabelVolumeID(self.SegmentCADLabelMap.GetID())
#selectionNode.SetReferenceSecondaryVolumeID(self.node1.GetID())
appLogic.PropagateVolumeSelection()
def clipping(self):
planeCollection = vtk.vtkPlaneCollection()
harden = slicer.vtkSlicerTransformLogic()
tempTransform = slicer.vtkMRMLLinearTransformNode()
tempTransform.HideFromEditorsOn()
slicer.mrmlScene.AddNode(tempTransform)
numNodes = slicer.mrmlScene.GetNumberOfNodesByClass("vtkMRMLModelNode")
dictionnaryModel = dict()
hardenModelIDdict = dict()
landmarkDescriptionDict = dict()
modelIDdict = dict()
for i in range(3, numNodes):
planeCollection.RemoveAllItems()
mh = slicer.mrmlScene.GetNthNodeByClass(i, "vtkMRMLModelNode")
if mh.GetDisplayVisibility() == 0:
continue
model = slicer.util.getNode(mh.GetName())
transform = model.GetParentTransformNode()
if transform:
tempTransform.Copy(transform)
harden.hardenTransform(tempTransform)
m = vtk.vtkMatrix4x4()
tempTransform.GetMatrixTransformToParent(m)
m.Invert(m, m)
else:
m = vtk.vtkMatrix4x4()
for key, planeDef in self.planeDict.iteritems():
hardenP = m.MultiplyPoint(planeDef.P)
hardenN = m.MultiplyPoint(planeDef.n)
if planeDef.boxState:
planeDef.vtkPlane.SetOrigin(hardenP[0], hardenP[1], hardenP[2])
if planeDef.negState:
planeDef.vtkPlane.SetNormal(-hardenN[0], -hardenN[1], -hardenN[2])
if planeDef.posState:
planeDef.vtkPlane.SetNormal(hardenN[0], hardenN[1], hardenN[2])
planeCollection.AddItem(planeDef.vtkPlane)
dictionnaryModel[model.GetID()]= model.GetPolyData()
polyData = model.GetPolyData()
clipper = vtk.vtkClipClosedSurface()
clipper.SetClippingPlanes(planeCollection)
clipper.SetInputData(polyData)
clipper.SetGenerateFaces(1)
clipper.SetScalarModeToLabels()
clipper.Update()
polyDataNew = clipper.GetOutput()
model.SetAndObservePolyData(polyDataNew)
# Checking if one ore more fiducial list are connected to this model
list = slicer.mrmlScene.GetNodesByClass("vtkMRMLMarkupsFiducialNode")
end = list.GetNumberOfItems()
for i in range(0,end):
fidList = list.GetItemAsObject(i)
if fidList.GetAttribute("connectedModelID"):
if fidList.GetAttribute("connectedModelID") == model.GetID():
modelIDdict[fidList.GetID()], hardenModelIDdict[fidList.GetID()], landmarkDescriptionDict[fidList.GetID()] = \
self.unprojectLandmarks(fidList)
return dictionnaryModel, modelIDdict, hardenModelIDdict, landmarkDescriptionDict
def onGroundTruthTransformNodeModified(self, observer, eventid):
mappedToWorldTransform = vtk.vtkMatrix4x4()
self.mappedTransformNode.GetMatrixTransformToWorld(mappedToWorldTransform)
mappedPos = [mappedToWorldTransform.GetElement(0,3), mappedToWorldTransform.GetElement(1,3), mappedToWorldTransform.GetElement(2,3)]
groundTruthToWorldTransform = vtk.vtkMatrix4x4()
self.groundTruthTransformNode.GetMatrixTransformToWorld(groundTruthToWorldTransform)
worldToMappedTransform = vtk.vtkMatrix4x4()
vtk.vtkMatrix4x4.Invert(mappedToWorldTransform, worldToMappedTransform)
groundTruthToMappedTransform = vtk.vtkMatrix4x4()
vtk.vtkMatrix4x4.Multiply4x4(worldToMappedTransform, groundTruthToWorldTransform, groundTruthToMappedTransform)
positionErrorX = groundTruthToMappedTransform.GetElement(0,3)
positionErrorY = groundTruthToMappedTransform.GetElement(1,3)
positionErrorZ = groundTruthToMappedTransform.GetElement(2,3)
positionErrorMagnitude = math.sqrt(positionErrorX*positionErrorX+positionErrorY*positionErrorY+positionErrorZ*positionErrorZ)
orientationErrorMagnitude = -1 # if negative it means the value is invalid
try:
angle, direc, point = self.rotation_from_matrix(self.orthonormalize(self.arrayFromVtkMatrix(groundTruthToMappedTransform)))
orientationErrorMagnitude = abs(angle) * 180/math.pi
except ValueError:
logging.warning("Failed to compute orientation error")
self.positionErrorMagnitudeList.append(positionErrorMagnitude)
self.orientationErrorMagnitudeList.append(orientationErrorMagnitude)
self.updateErrorDisplay(positionErrorMagnitude, orientationErrorMagnitude, positionErrorX, positionErrorY, positionErrorZ)
groundTruthPosition_World = [groundTruthToWorldTransform.GetElement(0,3), groundTruthToWorldTransform.GetElement(1,3), groundTruthToWorldTransform.GetElement(2,3)]
mappedPosition_World = [mappedToWorldTransform.GetElement(0,3), mappedToWorldTransform.GetElement(1,3), mappedToWorldTransform.GetElement(2,3)]
# return if did not move enough compared to the previous sampling position
if vtk.vtkMath.Distance2BetweenPoints(self.previousGroundTruthPosition_World,groundTruthPosition_World) < self.minimumSamplingDistance*self.minimumSamplingDistance:
return
self.previousGroundTruthPosition_World = groundTruthPosition_World
# Add a box at the visited point position
if self.outputVisitedPointsModelNode:
self.visitedPoints.InsertNextPoint(groundTruthPosition_World)
self.visitedPoints.Modified()
# Update transforms
if self.positionErrorTransformNode:
positionErrorVectorTransform=self.positionErrorTransformNode.GetTransformToParent()
positionErrorVectorTransform.GetSourceLandmarks().InsertNextPoint(groundTruthPosition_World)
positionErrorVectorTransform.GetTargetLandmarks().InsertNextPoint(mappedPosition_World)
self.positionErrorTransformNode.GetTransformToParent().Modified()
if self.orientationErrorTransformNode:
orientationErrorMagnitudeTransform=self.orientationErrorTransformNode.GetTransformToParent()
orientationErrorMagnitudeTransform.GetSourceLandmarks().InsertNextPoint(groundTruthPosition_World)
orientationErrorMagnitudeTransform.GetTargetLandmarks().InsertNextPoint(groundTruthPosition_World[0]+orientationErrorMagnitude, groundTruthPosition_World[1], groundTruthPosition_World[2])
self.orientationErrorTransformNode.GetTransformToParent().Modified()
def onHelloWorldButtonClicked(self):
print "Hello World !"
#frame volume sera el scalar volume de referencia#
self.__mvNode = self.mvSelector.currentNode()
#NODO REFERENCIA
frameVolume = slicer.vtkMRMLScalarVolumeNode()
frameVolume.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(frameVolume)
nComponents = self.__mvNode.GetNumberOfFrames()
f=int(self.__veInitial.value)
frameId = min(f,nComponents-1)
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.__mvNode.GetRASToIJKMatrix(ras2ijk)
self.__mvNode.GetIJKToRASMatrix(ijk2ras)
frameImage = frameVolume.GetImageData()
if frameImage == None:
frameVolume.SetRASToIJKMatrix(ras2ijk)
frameVolume.SetIJKToRASMatrix(ijk2ras)
mvImage = self.__mvNode.GetImageData()
for i in range(nComponents-1):
extract = vtk.vtkImageExtractComponents()
extract.SetInput(mvImage)
extract.SetComponents(i)
extract.Update()
if i == 0:
frameVolume.SetAndObserveImageData(extract.GetOutput())
elif i < frameId+1 :
s=vtk.vtkImageMathematics()
s.SetOperationToAdd()
s.SetInput1(frameVolume.GetImageData())
s.SetInput2(extract.GetOutput())
s.Update()
frameVolume.SetAndObserveImageData(s.GetOutput())
frameName = 'Holaaa'
frameVolume.SetName(frameName)
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(frameVolume.GetID())
slicer.app.applicationLogic().PropagateVolumeSelection(0)
def onGroundTruthTransformNodeModified(self, observer, eventid):
mappedToWorldTransform = vtk.vtkMatrix4x4()
self.mappedTransformNode.GetMatrixTransformToWorld(mappedToWorldTransform)
mappedPos = [mappedToWorldTransform.GetElement(0,3), mappedToWorldTransform.GetElement(1,3), mappedToWorldTransform.GetElement(2,3)]
groundTruthToWorldTransform = vtk.vtkMatrix4x4()
self.groundTruthTransformNode.GetMatrixTransformToWorld(groundTruthToWorldTransform)
worldToMappedTransform = vtk.vtkMatrix4x4()
vtk.vtkMatrix4x4.Invert(mappedToWorldTransform, worldToMappedTransform)
groundTruthToMappedTransform = vtk.vtkMatrix4x4()
vtk.vtkMatrix4x4.Multiply4x4(worldToMappedTransform, groundTruthToWorldTransform, groundTruthToMappedTransform)
positionErrorX = groundTruthToMappedTransform.GetElement(0,3)
positionErrorY = groundTruthToMappedTransform.GetElement(1,3)
positionErrorZ = groundTruthToMappedTransform.GetElement(2,3)
positionErrorMagnitude = math.sqrt(positionErrorX*positionErrorX+positionErrorY*positionErrorY+positionErrorZ*positionErrorZ)
orientationErrorMagnitude = -1 # if negative it means the value is invalid
try:
angle, direc, point = self.rotation_from_matrix(self.orthonormalize(self.arrayFromVtkMatrix(groundTruthToMappedTransform)))
orientationErrorMagnitude = abs(angle) * 180/math.pi
except ValueError:
logging.warning("Failed to compute orientation error")
self.positionErrorMagnitudeList.append(positionErrorMagnitude)
self.orientationErrorMagnitudeList.append(orientationErrorMagnitude)
self.updateErrorDisplay(positionErrorMagnitude, orientationErrorMagnitude, positionErrorX, positionErrorY, positionErrorZ)
groundTruthPosition_World = [groundTruthToWorldTransform.GetElement(0,3), groundTruthToWorldTransform.GetElement(1,3), groundTruthToWorldTransform.GetElement(2,3)]
mappedPosition_World = [mappedToWorldTransform.GetElement(0,3), mappedToWorldTransform.GetElement(1,3), mappedToWorldTransform.GetElement(2,3)]
# return if did not move enough compared to the previous sampling position
if vtk.vtkMath.Distance2BetweenPoints(self.previousGroundTruthPosition_World,groundTruthPosition_World) < self.minimumSamplingDistance*self.minimumSamplingDistance:
return
self.previousGroundTruthPosition_World = groundTruthPosition_World
# Add a box at the visited point position
if self.outputVisitedPointsModelNode:
self.visitedPoints.InsertNextPoint(groundTruthPosition_World)
self.visitedPoints.Modified()
# Update transforms
if self.positionErrorTransformNode:
positionErrorVectorTransform=self.positionErrorTransformNode.GetTransformToParent()
positionErrorVectorTransform.GetSourceLandmarks().InsertNextPoint(groundTruthPosition_World)
positionErrorVectorTransform.GetTargetLandmarks().InsertNextPoint(mappedPosition_World)
self.positionErrorTransformNode.GetTransformToParent().Modified()
if self.orientationErrorTransformNode:
orientationErrorMagnitudeTransform=self.orientationErrorTransformNode.GetTransformToParent()
orientationErrorMagnitudeTransform.GetSourceLandmarks().InsertNextPoint(groundTruthPosition_World)
orientationErrorMagnitudeTransform.GetTargetLandmarks().InsertNextPoint(groundTruthPosition_World[0]+orientationErrorMagnitude, groundTruthPosition_World[1], groundTruthPosition_World[2])
self.orientationErrorTransformNode.GetTransformToParent().Modified()
def maskVolume(self, volumeIn, roiNode, inPlace=False):
# Clone input volume, unless inPlace
inPlace = False # TODO: make this work
nameout = volumeIn.GetName()
if not "masked" in nameout:
nameout += " masked"
if inPlace:
outData = vtk.vtkImageData()
volumeIn.SetName(volumeIn.GetName() + " masked")
else:
volumeOut = slicer.modules.volumes.logic().CloneVolume(volumeIn, nameout)
outData = volumeOut.GetImageData()
# Get transform into image space
IJKtoRAS = vtk.vtkMatrix4x4()
volumeIn.GetIJKToRASMatrix(IJKtoRAS)
# Get ROI to image transform
ROItoImage = vtk.vtkMatrix4x4()
ROItoImage.Identity()
parentNode = roiNode.GetParentTransformNode()
if parentNode is None and volumeIn.GetParentTransformNode():
volumeIn.GetParentTransformNode().GetMatrixTransformToWorld(ROItoImage)
# don't invert here, this is already the proper direction.
if parentNode is not None:
parentNode.GetMatrixTransformToNode(volumeIn.GetParentTransformNode(), ROItoImage)
ROItoImage.Invert()
# Transformations
tfm = vtk.vtkTransform()
tfm.SetMatrix(IJKtoRAS)
tfm.PostMultiply()
tfm.Concatenate(ROItoImage)
# Get planes and apply transform
planes = vtk.vtkPlanes()
roiNode.GetTransformedPlanes(planes)
planes.SetTransform(tfm)
# Blot out selected region
tostencil = vtk.vtkImplicitFunctionToImageStencil()
tostencil.SetInput(planes)
imgstencil = vtk.vtkImageStencil()
imgstencil.SetInput(volumeIn.GetImageData())
imgstencil.SetStencil(tostencil.GetOutput())
imgstencil.SetBackgroundValue(0)
imgstencil.ReverseStencilOn()
# Write the changes
imgstencil.SetOutput(outData)
imgstencil.Update()
def onSliderChanged(self, newValue):
value = self.__mdSlider.value
if self.__mvNode != None:
mvDisplayNode = self.__mvNode.GetDisplayNode()
mvDisplayNode.SetFrameComponent(newValue)
else:
return
if self.extractFrame == True:
frameVolume = self.__vfSelector.currentNode()
if frameVolume == None:
mvNodeFrameCopy = slicer.vtkMRMLScalarVolumeNode()
mvNodeFrameCopy.SetName(self.__mvNode.GetName() + ' frame')
mvNodeFrameCopy.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(mvNodeFrameCopy)
self.__vfSelector.setCurrentNode(mvNodeFrameCopy)
frameVolume = self.__vfSelector.currentNode()
mvImage = self.__mvNode.GetImageData()
frameId = newValue
extract = vtk.vtkImageExtractComponents()
extract.SetInput(mvImage)
extract.SetComponents(frameId)
extract.Update()
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.__mvNode.GetRASToIJKMatrix(ras2ijk)
self.__mvNode.GetIJKToRASMatrix(ijk2ras)
frameImage = frameVolume.GetImageData()
if frameImage == None:
frameVolume.SetRASToIJKMatrix(ras2ijk)
frameVolume.SetIJKToRASMatrix(ijk2ras)
frameVolume.SetAndObserveImageData(extract.GetOutput())
displayNode = frameVolume.GetDisplayNode()
if displayNode == None:
displayNode = slicer.mrmlScene.CreateNodeByClass(
'vtkMRMLScalarVolumeDisplayNode')
displayNode.SetReferenceCount(1)
displayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(displayNode)
displayNode.SetDefaultColorMap()
frameVolume.SetAndObserveDisplayNodeID(displayNode.GetID())
frameName = '%s frame %d' % (self.__mvNode.GetName(), frameId)
frameVolume.SetName(frameName)
def __init__(self): self.skullModel=None self.skullMarkersModel=None self.pointerModel=None self.skull = slicer.vtkMRMLModelNode() self.skullMarkers = slicer.vtkMRMLModelNode() self.pointer = slicer.vtkMRMLModelNode() # self.pointerToTrackerTransform=None # self.rigidBodyToTrackerTransform=None # self.trackerToRigidBodyTransform=None self.matrixPointerToTrackerTransform=vtk.vtkMatrix4x4() self.matrixRigidBodyToTrackerTransform=vtk.vtkMatrix4x4() self.matrixTrackerToRigidBodyTransform=vtk.vtkMatrix4x4()
def onSliderChanged(self, newValue):
value = self.__mdSlider.value
if self.__mvNode != None:
mvDisplayNode = self.__mvNode.GetDisplayNode()
mvDisplayNode.SetFrameComponent(newValue)
else:
return
if self.extractFrame == True:
frameVolume = self.__vfSelector.currentNode()
if frameVolume == None:
mvNodeFrameCopy = slicer.vtkMRMLScalarVolumeNode()
mvNodeFrameCopy.SetName(self.__mvNode.GetName()+' frame')
mvNodeFrameCopy.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(mvNodeFrameCopy)
self.__vfSelector.setCurrentNode(mvNodeFrameCopy)
frameVolume = self.__vfSelector.currentNode()
mvImage = self.__mvNode.GetImageData()
frameId = newValue
extract = vtk.vtkImageExtractComponents()
extract.SetInput(mvImage)
extract.SetComponents(frameId)
extract.Update()
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.__mvNode.GetRASToIJKMatrix(ras2ijk)
self.__mvNode.GetIJKToRASMatrix(ijk2ras)
frameImage = frameVolume.GetImageData()
if frameImage == None:
frameVolume.SetRASToIJKMatrix(ras2ijk)
frameVolume.SetIJKToRASMatrix(ijk2ras)
frameVolume.SetAndObserveImageData(extract.GetOutput())
displayNode = frameVolume.GetDisplayNode()
if displayNode == None:
displayNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLScalarVolumeDisplayNode')
displayNode.SetReferenceCount(1)
displayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(displayNode)
displayNode.SetDefaultColorMap()
frameVolume.SetAndObserveDisplayNodeID(displayNode.GetID())
frameName = '%s frame %d' % (self.__mvNode.GetName(), frameId)
frameVolume.SetName(frameName)
def onSliderChanged(self, newValue):
value = self.__mdSlider.value
if self.__dwvNode != None:
dwvDisplayNode = self.__dwvNode.GetDisplayNode()
dwvDisplayNode.SetDiffusionComponent(newValue)
if self.extractFrame == True:
frameVolume = self.__vfSelector.currentNode()
if frameVolume == None or self.__dwvNode == None:
return
dwvImage = self.__dwvNode.GetImageData()
frameId = newValue
extract = vtk.vtkImageExtractComponents()
cast = vtk.vtkImageCast()
extract.SetInput(dwvImage)
extract.SetComponents(frameId)
cast.SetInput(extract.GetOutput())
cast.SetOutputScalarTypeToShort()
cast.Update()
frame = cast.GetOutput()
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.__dwvNode.GetRASToIJKMatrix(ras2ijk)
self.__dwvNode.GetIJKToRASMatrix(ijk2ras)
frameImage = frameVolume.GetImageData()
if frameImage == None:
frameVolume.SetAndObserveImageData(frame)
frameVolume.SetRASToIJKMatrix(ras2ijk)
frameVolume.SetIJKToRASMatrix(ijk2ras)
frameImage = frame
frameImage.DeepCopy(frame)
displayNode = frameVolume.GetDisplayNode()
if displayNode == None:
displayNode = slicer.mrmlScene.CreateNodeByClass('vtkMRMLScalarVolumeDisplayNode')
displayNode.SetReferenceCount(1)
displayNode.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(displayNode)
displayNode.SetDefaultColorMap()
frameVolume.SetAndObserveDisplayNodeID(displayNode.GetID())
frameName = '%s frame %d' % (self.__dwvNode.GetName(), frameId)
frameVolume.SetName(frameName)
def onHelloWorldButtonClicked(self):
print "Hello World !"
#frame volume sera el scalar volume de referencia#
self.__mvNode = self.mvSelector.currentNode()
#NODO REFERENCIA
frameVolume = slicer.vtkMRMLScalarVolumeNode()
frameVolume.SetScene(slicer.mrmlScene)
slicer.mrmlScene.AddNode(frameVolume)
nComponents = self.__mvNode.GetNumberOfFrames()
f = int(self.__veInitial.value)
frameId = min(f, nComponents - 1)
ras2ijk = vtk.vtkMatrix4x4()
ijk2ras = vtk.vtkMatrix4x4()
self.__mvNode.GetRASToIJKMatrix(ras2ijk)
self.__mvNode.GetIJKToRASMatrix(ijk2ras)
frameImage = frameVolume.GetImageData()
if frameImage == None:
frameVolume.SetRASToIJKMatrix(ras2ijk)
frameVolume.SetIJKToRASMatrix(ijk2ras)
mvImage = self.__mvNode.GetImageData()
for i in range(nComponents - 1):
extract = vtk.vtkImageExtractComponents()
extract.SetInput(mvImage)
extract.SetComponents(i)
extract.Update()
if i == 0:
frameVolume.SetAndObserveImageData(extract.GetOutput())
elif i < frameId + 1:
s = vtk.vtkImageMathematics()
s.SetOperationToAdd()
s.SetInput1(frameVolume.GetImageData())
s.SetInput2(extract.GetOutput())
s.Update()
frameVolume.SetAndObserveImageData(s.GetOutput())
frameName = 'Holaaa'
frameVolume.SetName(frameName)
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(frameVolume.GetID())
slicer.app.applicationLogic().PropagateVolumeSelection(0)
def pasteFromMainToCroppedLabelVolume(mainLblVolume, croppedLblVolume, colorID):
pasted = False
if (mainLblVolume != None) & (croppedLblVolume != None):
mainImageData = mainLblVolume.GetImageData()
croppedImgData = croppedLblVolume.GetImageData()
if (mainImageData != None) & (croppedImgData != None):
rastoijk = vtk.vtkMatrix4x4()
mainLblVolume.GetRASToIJKMatrix(rastoijk)
croppedLblRASOrigin = croppedLblVolume.GetOrigin()
croppedLblRASOrigin = [croppedLblRASOrigin[0],croppedLblRASOrigin[1],croppedLblRASOrigin[2],1.0]
croppedLblIJKShiftedOrigin = rastoijk.MultiplyDoublePoint(croppedLblRASOrigin)
croppedLblIJKShiftedOrigin = [ int(croppedLblIJKShiftedOrigin[0] + 0.5), int(croppedLblIJKShiftedOrigin[1] + 0.5), int(croppedLblIJKShiftedOrigin[2] + 0.5)]
dims = croppedImgData.GetDimensions()
for x in range(0,dims[0],1):
for y in range(0,dims[1],1):
for z in range(0,dims[2],1):
p = mainImageData.GetScalarComponentAsDouble(x+croppedLblIJKShiftedOrigin[0],y+croppedLblIJKShiftedOrigin[1],z+croppedLblIJKShiftedOrigin[2],0)
if p == colorID:
croppedImgData.SetScalarComponentFromDouble(x,y,z,0,p)
if pasted == False:
pasted = True
return pasted
def MR_translate(self, movingMRIModel, fixedUSModel, *MRIinputs):
""" Translates MRI capsule and T2 imaging volume to roughly align with US capsule model so T2 prostate is within ARFI image
"""
# Print to Slicer CLI
print('Translating MRI inputs to U/S capsule...'),
start_time = time.time()
# Find out coordinates of models to be used for translation matrix
moving_bounds = movingMRIModel.GetPolyData().GetBounds()
fixed_bounds = fixedUSModel.GetPolyData().GetBounds()
# Define transform matrix
translate_transform = vtk.vtkMatrix4x4()
translate_transform.SetElement(2,3,fixed_bounds[5] - moving_bounds[5]) # lines up base of prostate
translate_transform.SetElement(1,3,fixed_bounds[2] - moving_bounds[2]) # lines up posterior of prostate
translate_transform.SetElement(0,3,fixed_bounds[0] - moving_bounds[0]) # lines up right side of prostate
# OPTIONAL: print transform to Python CLI
print translate_transform
# Apply transform to all MRI inputs
for MRIinput in MRIinputs:
MRIinput.ApplyTransformMatrix(translate_transform)
# print to Slicer CLI
end_time = time.time()
print('done (%0.2f s)') % float(end_time-start_time)
def setTransformNode(self, newTransformNode):
"""Allow to set the current Transform node.
Connected to signal 'currentNodeChanged()' emitted by Transform node selector."""
# Remove previous observer
if self.transformNode and self.transformNodeObserverTag:
self.transformNode.RemoveObserver(self.transformNodeObserverTag)
if self.transform and self.transformObserverTag:
self.transform.RemoveObserver(self.transformObserverTag)
newTransform = None
if newTransformNode:
# newTransform = newTransformNode.GetMatrixTransformToParent()
newTransform = vtk.vtkMatrix4x4()
newTransformNode.GetMatrixTransformToWorld(newTransform)
# Add TransformNode ModifiedEvent observer
self.TransformNodeObserverTag = newTransformNode.AddObserver(
slicer.vtkMRMLTransformNode.TransformModifiedEvent,
self.onTransformNodeModified)
# Add Transform ModifiedEvent observer
self.transformObserverTag = newTransform.AddObserver(
slicer.vtkMRMLTransformNode.TransformModifiedEvent,
self.onTransformNodeModified)
self.transformObserverTag = newTransform.AddObserver(
'TransformModifiedEvent', self.onTransformModified)
self.transformNode = newTransformNode
self.transform = newTransform
# Update UI
self.updateWidgetFromMRML()
def __init__(self, sliceWidget):
super(PaintEffectTool, self).__init__(sliceWidget)
# configuration variables
self.radius = 5
self.smudge = 0
self.delayedPaint = 1
# interaction state variables
self.position = [0, 0, 0]
self.paintCoordinates = []
self.feedbackActors = []
self.lastRadius = 0
# scratch variables
self.rasToXY = vtk.vtkMatrix4x4()
# initialization
self.brush = vtk.vtkPolyData()
self.createGlyph(self.brush)
self.mapper = vtk.vtkPolyDataMapper2D()
self.actor = vtk.vtkActor2D()
self.mapper.SetInput(self.brush)
self.actor.SetMapper(self.mapper)
self.actor.VisibilityOff()
self.renderer.AddActor2D(self.actor)
self.actors.append(self.actor)
self.processEvent()
def onCentrar(self):
volumenCentrar = self.imagenSelector.currentNode()
lm = slicer.app.layoutManager()
origenVolumen = volumenCentrar.GetOrigin()
volumeLogic = slicer.vtkSlicerVolumesLogic()
origenCentro = [0, 0, 0]
volumeLogic.GetVolumeCenteredOrigin(volumenCentrar, origenCentro)
traslacion = [0, 0, 0]
volumenCentrar.SetOrigin(origenCentro)
lm.resetSliceViews()
for i in range(3):
traslacion[i] = origenCentro[i] - origenVolumen[i]
T = slicer.vtkMRMLTransformNode()
I = slicer.vtkMRMLTransformNode()
transmatrix = vtk.vtkMatrix4x4()
transform = vtk.vtkTransform()
T.SetAndObserveTransformToParent(transform)
T.SetName('centrarTransformacionSeeg')
I.SetName('CentrarTInversaSeeg')
transmatrix.DeepCopy((1, 0, 0, traslacion[0], 0, 1, 0, traslacion[1],
0, 0, 1, traslacion[2], 0, 0, 0, 1))
transform.SetMatrix(transmatrix)
inv = transform.GetInverse()
I.SetAndObserveTransformToParent(inv)
slicer.mrmlScene.AddNode(T)
slicer.mrmlScene.AddNode(I)
def onApply(self):
inputVolume = self.inputSelector.currentNode()
outputVolume = self.outputSelector.currentNode()
if not (inputVolume and outputVolume):
qt.QMessageBox.critical(
slicer.util.mainWindow(), 'Sharpen',
'Input and output volumes are required for Laplacian')
return
# run the filter
laplacian = vtk.vtkImageLaplacian()
laplacian.SetInput(inputVolume.GetImageData())
laplacian.SetDimensionality(3)
laplacian.GetOutput().Update()
ijkToRAS = vtk.vtkMatrix4x4()
inputVolume.GetIJKToRASMatrix(ijkToRAS)
outputVolume.SetIJKToRASMatrix(ijkToRAS)
outputVolume.SetAndObserveImageData(laplacian.GetOutput())
# Section B - add code here
# (be sure to match indentation)
# optionally subtract laplacian from original image
if self.sharpen.checked:
parameters = {}
parameters['inputVolume1'] = inputVolume.GetID()
parameters['inputVolume2'] = outputVolume.GetID()
parameters['outputVolume'] = outputVolume.GetID()
slicer.cli.run(slicer.modules.subtractscalarvolumes,
None,
parameters,
wait_for_completion=True)
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(outputVolume.GetID())
slicer.app.applicationLogic().PropagateVolumeSelection(0)
def renderLabelMap(self):
# Initializes a vtkMRMLScalarVolumeNode for the SegmentCAD Output and copies ijkToRAS matrix and Image data from nodeLabel
ijkToRASMatrix = vtk.vtkMatrix4x4()
self.volumePre.GetIJKToRASMatrix(ijkToRASMatrix)
self.SegmentCADLabelMap.SetIJKToRASMatrix(ijkToRASMatrix)
SegmentCADLabelMapImageData = vtk.vtkImageData()
SegmentCADLabelMapImageData.DeepCopy(self.volumePre.GetImageData())
SegmentCADLabelMapPointData = SegmentCADLabelMapImageData.GetPointData()
# Numpy array is converted from signed int16 to signed vtkShortArray
scalarArray = vtk.vtkShortArray()
dims1D = SegmentCADLabelMapPointData.GetScalars().GetSize()
self.nodeArraySegmentCADLabel = self.nodeArraySegmentCADLabel.reshape(dims1D, order='C')
scalarArray = vtk.util.numpy_support.numpy_to_vtk(self.nodeArraySegmentCADLabel)
# PointData() of SegmentCAD label output pointed to new vtkShortArray for scalar values
SegmentCADLabelMapImageData.SetScalarTypeToShort()
SegmentCADLabelMapPointData.SetScalars(scalarArray)
SegmentCADLabelMapPointData.Update()
SegmentCADLabelMapImageData.Update()
self.SegmentCADLabelMap.SetAndObserveImageData(SegmentCADLabelMapImageData)
# Corresponding display node and color table nodes created for SegmentCAD label Output
self.SegmentCADLabelMapDisplay = slicer.vtkMRMLLabelMapVolumeDisplayNode()
self.SegmentCADLabelMapDisplay.SetScene(slicer.mrmlScene)
self.SegmentCADLabelMapDisplay.SetAndObserveColorNodeID('vtkMRMLColorTableNodeFileGenericColors.txt')
self.SegmentCADLabelMapDisplay.SetInputImageData(SegmentCADLabelMapImageData)
self.SegmentCADLabelMapDisplay.UpdateImageDataPipeline()
slicer.mrmlScene.AddNode(self.SegmentCADLabelMapDisplay)
self.SegmentCADLabelMap.SetAndObserveDisplayNodeID(self.SegmentCADLabelMapDisplay.GetID())
self.SegmentCADLabelMapDisplay.UpdateScene(slicer.mrmlScene)
def setTransformNode(self, newTransformNode):
"""Allow to set the current Transform node.
Connected to signal 'currentNodeChanged()' emitted by Transform node selector."""
# Remove previous observer
if self.transformNode and self.transformNodeObserverTag:
self.transformNode.RemoveObserver(self.transformNodeObserverTag)
if self.transform and self.transformObserverTag:
self.transform.RemoveObserver(self.transformObserverTag)
newTransform = None
if newTransformNode:
newTransform = vtk.vtkMatrix4x4()
newTransformNode.GetMatrixTransformToWorld(newTransform)
# Add TransformNode ModifiedEvent observer
self.TransformNodeObserverTag = newTransformNode.AddObserver(slicer.vtkMRMLTransformNode.TransformModifiedEvent , self.onTransformNodeModified)
# Add Transform ModifiedEvent observer
self.transformObserverTag = newTransform.AddObserver(slicer.vtkMRMLTransformNode.TransformModifiedEvent, self.onTransformNodeModified)
self.transformObserverTag = newTransform.AddObserver('TransformModifiedEvent', self.onTransformModified)
self.transformNode = newTransformNode
self.transform = newTransform
# Update UI
self.updateWidgetFromMRML()
def UpdateMetrics( allMetrics, transformNode, absTime, metricsTable ):
if ( PythonMetricsCalculatorLogic.GetMRMLScene() == None ):
return
# The assumption is that the scene is already appropriately updated
matrix = vtk.vtkMatrix4x4()
matrix.Identity()
transformNode.GetMatrixTransformToWorld( matrix )
point = [ matrix.GetElement( 0, 3 ), matrix.GetElement( 1, 3 ), matrix.GetElement( 2, 3 ), matrix.GetElement( 3, 3 ) ]
for metricInstanceID in allMetrics:
metric = allMetrics[ metricInstanceID ]
metricInstanceNode = PythonMetricsCalculatorLogic.GetMRMLScene().GetNodeByID( metricInstanceID )
for role in metric.GetAcceptedTransformRoles():
if ( metricInstanceNode.GetRoleID( role, metricInstanceNode.TransformRole ) == transformNode.GetID() ):
try:
metric.AddTimestamp( absTime, matrix, point, role )
except TypeError: # Only look if there is an issue with the number of arguments
metric.AddTimestamp( absTime, matrix, point ) # TODO: Keep this for backwards compatibility with Python Metrics?
# Output the results to the metrics table node
# TODO: Do we have to clear it all and re-write it all?
if ( metricsTable != None ):
self.OutputAllMetricsToMetricsTable( metricsTable, allMetrics )
def initializeNewLabel(newLabel, sourceVolume):
displayNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLLabelMapVolumeDisplayNode())
threshold = vtk.vtkImageThreshold()
threshold.ReplaceInOn()
threshold.ReplaceOutOn()
threshold.SetInValue(0)
threshold.SetOutValue(0)
threshold.SetOutputScalarTypeToUnsignedShort()
threshold.SetInput(sourceVolume.GetImageData())
threshold.Update()
labelImage = vtk.vtkImageData()
labelImage.DeepCopy(threshold.GetOutput())
newLabel.SetAndObserveStorageNodeID(None)
newLabel.SetLabelMap(1)
newLabel.CopyOrientation(sourceVolume)
ras2ijk = vtk.vtkMatrix4x4()
sourceVolume.GetRASToIJKMatrix(ras2ijk)
newLabel.SetRASToIJKMatrix(ras2ijk)
newLabel.SetAttribute('ReportingReportNodeID', sourceVolume.GetAttribute('ReportingReportNodeID'))
newLabel.SetAttribute('AssociatedNodeID', sourceVolume.GetID())
newLabel.SetAndObserveDisplayNodeID(displayNode.GetID())
newLabel.SetAndObserveImageData(labelImage)
def updateTemplateVectors(self):
print 'updateTemplateVectors()'
mnode = slicer.mrmlScene.GetNodeByID(self.templateModelNodeID)
if mnode is None:
return 0
tnode = mnode.GetParentTransformNode()
trans = vtk.vtkMatrix4x4()
if tnode is not None:
tnode.GetMatrixTransformToWorld(trans)
else:
trans.Identity()
# Calculate offset
zero = [0.0, 0.0, 0.0, 1.0]
offset = []
offset = trans.MultiplyDoublePoint(zero)
self.pathOrigins = []
self.pathVectors = []
i = 0
for orig in self.templatePathOrigins:
torig = trans.MultiplyDoublePoint(orig)
self.pathOrigins.append(numpy.array(torig[0:3]))
vec = self.templatePathVectors[i]
tvec = trans.MultiplyDoublePoint(vec)
self.pathVectors.append(numpy.array([tvec[0]-offset[0], tvec[1]-offset[1], tvec[2]-offset[2]]))
i += 1
def probeVolume(self, volumeNode, rulerNode, numOfPoints):
#get ruler end points in RAS coordinates system
p0ras = rulerNode.GetPolyData().GetPoint(0) + (1,)
p1ras = rulerNode.GetPolyData().GetPoint(1) + (1,)
import math, numpy
lineLength = math.sqrt((p0ras[0]-p1ras[0])*(p0ras[0]-p1ras[0]) + (p0ras[1]-p1ras[1])*(p0ras[1]-p1ras[1]) + (p0ras[2]-p1ras[2])*(p0ras[2]-p1ras[2]))
distanceArray = [0]
if (numOfPoints > 1):
distanceArray = numpy.linspace(0,lineLength,numOfPoints)
#The transformation matrix from RAS to IJK coordinates systems
ras2ijk = vtk.vtkMatrix4x4()
volumeNode.GetRASToIJKMatrix(ras2ijk)
p0ijk = [int(round(c)) for c in ras2ijk.MultiplyPoint(p0ras)[:3]]
p1ijk = [int(round(c)) for c in ras2ijk.MultiplyPoint(p1ras)[:3]]
#Create the VTK sampling line
line = vtk.vtkLineSource()
line.SetResolution(numOfPoints)
line.SetPoint1(p0ijk[0], p0ijk[1], p0ijk[2])
line.SetPoint2(p1ijk[0], p1ijk[1], p1ijk[2])
#Creat the VTK probe filter
probe = vtk.vtkProbeFilter()
probe.SetInputConnection(line.GetOutputPort())
probe.SetSourceData(volumeNode.GetImageData())
probe.Update()
# return the sampled array
return probe.GetOutput().GetPointData().GetArray('ImageScalars'), distanceArray
def initializeNewLabel(newLabel, sourceVolume):
displayNode = slicer.mrmlScene.AddNode(
slicer.vtkMRMLLabelMapVolumeDisplayNode())
threshold = vtk.vtkImageThreshold()
threshold.ReplaceInOn()
threshold.ReplaceOutOn()
threshold.SetInValue(0)
threshold.SetOutValue(0)
threshold.SetOutputScalarTypeToUnsignedShort()
threshold.SetInput(sourceVolume.GetImageData())
threshold.Update()
labelImage = vtk.vtkImageData()
labelImage.DeepCopy(threshold.GetOutput())
newLabel.SetAndObserveStorageNodeID(None)
newLabel.SetLabelMap(1)
newLabel.CopyOrientation(sourceVolume)
ras2ijk = vtk.vtkMatrix4x4()
sourceVolume.GetRASToIJKMatrix(ras2ijk)
newLabel.SetRASToIJKMatrix(ras2ijk)
newLabel.SetAttribute('AssociatedNodeID', sourceVolume.GetID())
newLabel.SetAndObserveDisplayNodeID(displayNode.GetID())
newLabel.SetAndObserveImageData(labelImage)
def updateTemplateVectors(self):
print 'updateTemplateVectors()'
mnode = slicer.mrmlScene.GetNodeByID(self.templateModelNodeID)
if mnode == None:
return 0
tnode = mnode.GetParentTransformNode()
trans = vtk.vtkMatrix4x4()
if tnode != None:
tnode.GetMatrixTransformToWorld(trans);
else:
trans.Identity()
# Calculate offset
zero = [0.0, 0.0, 0.0, 1.0]
offset = []
offset = trans.MultiplyDoublePoint(zero)
self.pathOrigins = []
self.pathVectors = []
i = 0
for orig in self.templatePathOrigins:
torig = trans.MultiplyDoublePoint(orig)
self.pathOrigins.append(numpy.array(torig[0:3]))
vec = self.templatePathVectors[i]
tvec = trans.MultiplyDoublePoint(vec)
self.pathVectors.append(numpy.array([tvec[0]-offset[0], tvec[1]-offset[1], tvec[2]-offset[2]]))
i = i + 1
def estimateDim(Pz, Pa, volumeName="baselineROI", minThread=150):
volume_node = slicer.util.getNode(volumeName)
voxels = slicer.util.arrayFromVolume(volume_node)
VVList = []
seg = 12
for ii in range(20):
i = 2 + ii * .5
cylName = "Cyl{}".format(str(i))
cyl = Helper.p2pCyl(Pa, Pz, i, cylName, 1 - np.linalg.norm(Pz - Pa), Seg=seg)
pzP = Helper.Pcoord(cylName)[2]
Helper.delNode(cylName)
for j in range(seg):
P = pzP[j * 2]
volumeRasToIjk = vtk.vtkMatrix4x4()
volume_node.GetRASToIJKMatrix(volumeRasToIjk)
point_Ijk = [0, 0, 0, 1]
volumeRasToIjk.MultiplyPoint(np.append(P, 1.0), point_Ijk)
point_Ijk = [int(round(c)) for c in point_Ijk[0:3]]
voxelValue = voxels[point_Ijk[2], point_Ijk[1], point_Ijk[0]]
# print(voxelValue)
# if voxelValue<150:
# AddPoint(P)
if j == 0:
VVlist = np.array([voxelValue])
else:
VVlist = np.append(VVlist, voxelValue)
VVList.append(VVlist)
arrayV = np.array(VVList).mean(0)
return np.argmax(arrayV) * .5
def createMatrixFromString(self, transformMatrixString):
transformMatrix = vtk.vtkMatrix4x4()
transformMatrixArray = map(float, transformMatrixString.split(' '))
for r in xrange(4):
for c in xrange(4):
transformMatrix.SetElement(r,c, transformMatrixArray[r*4+c])
return transformMatrix
def fixVolumes(self):
""" The current DICOM import does not load the z spacing correctly for SPECT images.
This function copies x size to z size and also corrects an orientation issue.
"""
self.updateActiveVolumes()
self.labelStats = {}
self.labelStats['Labels'] = []
self.totalCounts = 0
self.currentView = self.getActiveSpects()[0]
self.computedMean = 0.0
layoutManager = slicer.app.layoutManager()
for timePoint in self.colonData:
if self.colonData[timePoint]['SP']['Active']:
volumeNode = slicer.util.getNode(self.colonData[timePoint]['SP']['ID'])
mymat = vtk.vtkMatrix4x4()
(sx,sy,sz) = volumeNode.GetSpacing()
sz = sx
volumeNode.SetSpacing(sx,sy,sz)
volumeNode.GetIJKToRASDirectionMatrix(mymat)
mymat.SetElement(2,2,-1.0)
volumeNode.SetIJKToRASDirectionMatrix(mymat)
self.volumesLogic.CenterVolume(volumeNode)
self.setSpectColours()
self.setCTWindow()
layoutManager.setLayout(slicer.vtkMRMLLayoutNode.SlicerLayoutFourUpView)
def updateCurrentPosition(self):
matrixSourceToTarget = vtk.vtkMatrix4x4()
self.transformSourceNode.GetMatrixTransformToNode(
self.transformTargetNode, matrixSourceToTarget)
transformSourceToTarget = vtk.vtkTransform()
transformSourceToTarget.SetMatrix(matrixSourceToTarget)
transformSourceToTarget.GetPosition(self.currentPositionMm)
# determine self.currentDistanceFromPointNMinus2Mm
if (self.markupsFiducialNode.GetNumberOfFiducials() >= 2):
pointNMinus2Mm = [0, 0, 0]
self.markupsFiducialNode.GetNthFiducialPosition(
self.markupsFiducialNode.GetNumberOfFiducials() - 2,
pointNMinus2Mm)
positionRelativeToPointNMinus2Mm = [0, 0, 0]
vtk.vtkMath.Subtract(self.currentPositionMm, pointNMinus2Mm,
positionRelativeToPointNMinus2Mm)
self.currentDistanceFromPointNMinus2Mm = vtk.vtkMath.Norm(
positionRelativeToPointNMinus2Mm)
else:
self.currentDistanceFromPointNMinus2Mm = 0
# determine self.currentDistanceFromPointNMinus3Mm
if (self.markupsFiducialNode.GetNumberOfFiducials() >= 3):
pointNMinus3Mm = [0, 0, 0] # second last point
self.markupsFiducialNode.GetNthFiducialPosition(
self.markupsFiducialNode.GetNumberOfFiducials() - 3,
pointNMinus3Mm)
positionRelativeToPointNMinus3Mm = [0, 0, 0]
vtk.vtkMath.Subtract(self.currentPositionMm, pointNMinus3Mm,
positionRelativeToPointNMinus3Mm)
self.currentDistanceFromPointNMinus3Mm = vtk.vtkMath.Norm(
positionRelativeToPointNMinus3Mm)
else:
self.currentDistanceFromPointNMinus3Mm = 0
def onStopPivotCalibration(self): #lumpnav
self.pivotCalibrationLogic.SetRecordingState(False)
self.needlePivotButton.setEnabled(True)
self.cauteryPivotButton.setEnabled(True)
self.pivotCalibrationLogic.ComputePivotCalibration()
if (self.pivotCalibrationLogic.GetPivotRMSE() >= float(
self.parameterNode.GetParameter(
'PivotCalibrationErrorThresholdMm'))):
self.countdownLabel.setText(
"Calibration failed, error = %f mm, please calibrate again!" %
self.pivotCalibrationLogic.GetPivotRMSE())
self.pivotCalibrationLogic.ClearToolToReferenceMatrices()
return
tooltipToToolMatrix = vtk.vtkMatrix4x4()
self.pivotCalibrationLogic.GetToolTipToToolMatrix(tooltipToToolMatrix)
self.pivotCalibrationLogic.ClearToolToReferenceMatrices()
self.pivotCalibrationResultTargetNode.SetMatrixTransformToParent(
tooltipToToolMatrix)
self.writeTransformToSettings(self.pivotCalibrationResultTargetName,
tooltipToToolMatrix)
self.countdownLabel.setText("Calibration completed, error = %f mm" %
self.pivotCalibrationLogic.GetPivotRMSE())
logging.debug(
"Pivot calibration completed. Tool: {0}. RMSE = {1} mm".format(
self.pivotCalibrationResultTargetNode.GetName(),
self.pivotCalibrationLogic.GetPivotRMSE()))
def runLabelWise(self, targetLabelNode, obstacleModelNode, skinModelNode):
"""
Run label-wise analysis
"""
poly = skinModelNode.GetPolyData()
polyDataNormals = vtk.vtkPolyDataNormals()
polyDataNormals.SetInput(poly)
polyDataNormals.ComputeCellNormalsOn()
polyDataNormals.Update()
polyData = polyDataNormals.GetOutput()
bspTree = vtk.vtkModifiedBSPTree()
bspTree.SetDataSet(obstacleModelNode.GetPolyData())
bspTree.BuildLocator()
trans = vtk.vtkMatrix4x4()
targetLabelNode.GetIJKToRASMatrix(trans)
pos = [0.0, 0.0, 0.0, 0.0]
imageData = targetLabelNode.GetImageData()
(x0, x1, y0, y1, z0, z1) = imageData.GetExtent()
for z in range(z0, z1 + 1):
for y in range(y0, y1 + 1):
for x in range(x0, x1 + 1):
if imageData.GetScalarComponentAsDouble(x, y, z, 0) > 0:
trans.MultiplyPoint([x, y, z, 1.0], pos)
(score, mind, mindp) = self.calcApproachScore(
pos[0:3], polyData, bspTree, None)
imageData.SetScalarComponentFromDouble(
x, y, z, 0, score * 100.0 + 1.0)
#print ("Index(%f, %f, %f) -> RAS(%f, %f, %f)" % (x, y, z, pos[0], pos[1], pos[2]))
#print ("Approach Score (<accessible area> / (<accessible area> + <inaccessible area>)) = %f" % (score))
return True
def computeDifference(self, fieldA, fieldB, roi, differenceVolume):
referenceVolume = self.createVectorVolumeFromRoi(
roi, self.ReferenceVolumeSpacingMm)
referenceVolume.SetName('ReferenceVolume')
slicer.mrmlScene.AddNode(referenceVolume)
resampledFieldA = self.resampleVolume(fieldA, referenceVolume)
resampledFieldB = self.resampleVolume(fieldB, referenceVolume)
subtractor = vtk.vtkImageMathematics()
subtractor.SetOperationToSubtract()
subtractor.SetInput1Data(resampledFieldA.GetImageData())
subtractor.SetInput2Data(resampledFieldB.GetImageData())
differenceVolume.SetImageDataConnection(subtractor.GetOutputPort())
ijkToRasMatrix = vtk.vtkMatrix4x4()
referenceVolume.GetIJKToRASMatrix(ijkToRasMatrix)
differenceVolume.SetIJKToRASMatrix(ijkToRasMatrix)
differenceVolumeDisplayNode = slicer.vtkMRMLVectorVolumeDisplayNode()
slicer.mrmlScene.AddNode(differenceVolumeDisplayNode)
differenceVolumeDisplayNode.SetAndObserveColorNodeID(
"vtkMRMLColorTableNodeRainbow")
differenceVolume.SetAndObserveNthDisplayNodeID(
0, differenceVolumeDisplayNode.GetID())
slicer.mrmlScene.RemoveNode(resampledFieldA)
slicer.mrmlScene.RemoveNode(resampledFieldB)
slicer.mrmlScene.RemoveNode(referenceVolume)
def loadImageData(self, filePath, grayscale, volumeNode):
import vtkITK
if grayscale:
reader = vtkITK.vtkITKArchetypeImageSeriesScalarReader()
else:
reader = vtkITK.vtkITKArchetypeImageSeriesVectorReaderFile()
reader.SetArchetype(filePath)
reader.AddFileName(filePath)
reader.SetSingleFile(True)
reader.SetOutputScalarTypeToNative()
reader.SetDesiredCoordinateOrientationToNative()
reader.SetUseNativeOriginOn()
# GDCM is not particularly better in this than DCMTK, we just select one explicitly
# so that we know which one is used
reader.SetDICOMImageIOApproachToGDCM()
reader.Update()
if reader.GetErrorCode() != vtk.vtkErrorCode.NoError:
errorString = vtk.vtkErrorCode.GetStringFromErrorCode(
reader.GetErrorCode())
raise ValueError(
f"Could not read image {loadable.name} from file {filePath}. Error is: {errorString}"
)
rasToIjk = reader.GetRasToIjkMatrix()
ijkToRas = vtk.vtkMatrix4x4()
vtk.vtkMatrix4x4.Invert(rasToIjk, ijkToRas)
return reader.GetOutput(), ijkToRas
def runLabelWise(self, targetLabelNode, obstacleModelNode, skinModelNode):
"""
Run label-wise analysis
"""
poly = skinModelNode.GetPolyData()
polyDataNormals = vtk.vtkPolyDataNormals()
polyDataNormals.SetInput(poly)
polyDataNormals.ComputeCellNormalsOn()
polyDataNormals.Update()
polyData = polyDataNormals.GetOutput()
bspTree = vtk.vtkModifiedBSPTree()
bspTree.SetDataSet(obstacleModelNode.GetPolyData())
bspTree.BuildLocator()
trans = vtk.vtkMatrix4x4()
targetLabelNode.GetIJKToRASMatrix(trans)
pos = [0.0, 0.0, 0.0, 0.0]
imageData = targetLabelNode.GetImageData()
(x0, x1, y0, y1, z0, z1) = imageData.GetExtent()
for z in range(z0, z1+1):
for y in range(y0, y1+1):
for x in range(x0, x1+1):
if imageData.GetScalarComponentAsDouble(x, y, z, 0) > 0:
trans.MultiplyPoint([x, y, z, 1.0], pos);
(score, mind, mindp) = self.calcApproachScore(pos[0:3], polyData, bspTree, None)
imageData.SetScalarComponentFromDouble(x, y, z, 0, score*100.0+1.0)
#print ("Index(%f, %f, %f) -> RAS(%f, %f, %f)" % (x, y, z, pos[0], pos[1], pos[2]))
#print ("Approach Score (<accessible area> / (<accessible area> + <inaccessible area>)) = %f" % (score))
return True
def startDataCollection(self, numberOfDataPointsToCollect, emPointerToEmTrackerNode, opPointerToOpRefNode, initialEmTrackerToOpRefTransformNode, \
emTrackerToOpRefNode, emPointerToOpPointerNode):
self.removeObservers()
self.opPointerToOpRefNode = opPointerToOpRefNode
self.emPointerToEmTrackerNode = emPointerToEmTrackerNode
self.numberOfDataPointsToCollect = numberOfDataPointsToCollect
self.outputEmTrackerToOpRefNode = emTrackerToOpRefNode
self.outputEmPointerToOpPointerNode = emPointerToOpPointerNode
initialEmTrackerToOpRefVtkMatrix = vtk.vtkMatrix4x4()
initialEmTrackerToOpRefTransformNode.GetMatrixTransformToParent(
initialEmTrackerToOpRefVtkMatrix)
self.initialEmTrackerToOpRefTransform = self.arrayFromVtkMatrix(
initialEmTrackerToOpRefVtkMatrix)
logging.debug("initialEmTrackerToOpRefTransformNode = {0}".format(
self.initialEmTrackerToOpRefTransform))
self.numberDataPointsCollected = 0
self.opPointerToOpRefTransformArray = np.zeros(
(self.numberOfDataPointsToCollect, 4, 4))
self.emPointerToEmTrackerTransformArray = np.zeros(
(self.numberOfDataPointsToCollect, 4, 4))
self.addObservers()
self.reportStatus(self.CALIBRATION_IN_PROGRESS, 0)
def resetOrientation(self):
self.transformSlider1.setValue(0)
self.transformSlider2.reset()
collectionT = slicer.mrmlScene.GetNodesByName('Transform-%s' % self.currentFidLabel)
transformFid = collectionT.GetItemAsObject(0)
matrixScrew = vtk.vtkMatrix4x4()
matrixScrew = transformFid.GetMatrixTransformToParent()
matrixScrew.SetElement(0,0,1)
matrixScrew.SetElement(0,1,0)
matrixScrew.SetElement(0,2,0)
matrixScrew.SetElement(1,0,0)
matrixScrew.SetElement(1,1,-1)
matrixScrew.SetElement(1,2,0)
matrixScrew.SetElement(2,0,0)
matrixScrew.SetElement(2,1,0)
matrixScrew.SetElement(2,2,-1)
matrixScrew.SetElement(0,3,self.coords[0])
matrixScrew.SetElement(1,3,self.coords[1])
matrixScrew.SetElement(2,3,self.coords[2])
transformFid.UpdateScene(slicer.mrmlScene)
self.backoutScrewButton.enabled = False
self.insertScrewButton.enabled = True
self.transformSlider1.enabled = True
self.transformSlider2.enabled = True
self.b.enabled = True
def __init__(self, sliceWidget):
super(PaintEffectTool,self).__init__(sliceWidget)
# create a logic instance to do the non-gui work
self.logic = PaintEffectLogic(self.sliceWidget.sliceLogic())
# configuration variables
self.delayedPaint = True
self.parameterNode = self.editUtil.getParameterNode()
self.sphere = not (0 == int(self.parameterNode.GetParameter("PaintEffect,sphere")))
self.smudge = not (0 == int(self.parameterNode.GetParameter("PaintEffect,smudge")))
self.pixelMode = not (0 == int(self.parameterNode.GetParameter("PaintEffect,pixelMode")))
self.radius = float(self.parameterNode.GetParameter("PaintEffect,radius"))
# interaction state variables
self.position = [0, 0, 0]
self.paintCoordinates = []
self.feedbackActors = []
self.lastRadius = 0
# scratch variables
self.rasToXY = vtk.vtkMatrix4x4()
# initialization
self.brush = vtk.vtkPolyData()
self.createGlyph(self.brush)
self.mapper = vtk.vtkPolyDataMapper2D()
self.actor = vtk.vtkActor2D()
self.mapper.SetInput(self.brush)
self.actor.SetMapper(self.mapper)
self.actor.VisibilityOff()
self.renderer.AddActor2D(self.actor)
self.actors.append(self.actor)
self.processEvent()
def __init__( self, stepid ):
self.initialize( stepid )
self.setName( '5. Place Screws' )
self.setDescription( 'Load screw models and change orientation using sliders' )
self.screwPath = None
self.screwName = None
self.coords = [0,0,0]
self.matrix1 = vtk.vtkMatrix3x3()
self.matrix2 = vtk.vtkMatrix3x3()
self.matrix3 = vtk.vtkMatrix3x3()
self.matrixScrew = vtk.vtkMatrix4x4()
self.fiduciallist = []
self.screwSummary = []
self.screwList = []
self.currentFidIndex = 0
self.currentFidLabel = None
self.fidNode = slicer.vtkMRMLMarkupsFiducialNode()
self.valueTemp1 = 0
self.valueTemp2 = 0
self.driveTemp = 0
self.__loadScrewButton = None
self.__parent = super( ScrewStep, self )
self.timer = qt.QTimer()
self.timer.setInterval(2)
self.timer.connect('timeout()', self.driveScrew)
self.timer2 = qt.QTimer()
self.timer2.setInterval(2)
self.timer2.connect('timeout()', self.reverseScrew)
self.screwInsert = 0.0
def cameraTransform(self):
"""Create the transform and the observer for the camera
"""
transformName = 'Camera-To-RAS'
transformNode = slicer.util.getNode(transformName)
if not transformNode:
# Create transform node
transformNode = slicer.vtkMRMLLinearTransformNode()
transformNode.SetName(transformName)
slicer.mrmlScene.AddNode(transformNode)
camera = self.cameraNode().GetCamera()
import numpy
position = numpy.array(camera.GetPosition())
focalPoint = numpy.array(camera.GetFocalPoint())
viewUp = numpy.array(camera.GetViewUp())
viewPlaneNormal = numpy.array(camera.GetViewPlaneNormal())
viewAngle = camera.GetViewAngle()
viewRight = numpy.cross(viewUp, viewPlaneNormal)
viewDistance = numpy.linalg.norm(focalPoint - position)
cameraToRAS = vtk.vtkMatrix4x4()
for row in xrange(3):
cameraToRAS.SetElement(row, 0, viewRight[row])
cameraToRAS.SetElement(row, 1, viewUp[row])
cameraToRAS.SetElement(row, 2, viewPlaneNormal[row])
cameraToRAS.SetElement(row, 3, position[row])
transformNode.GetMatrixTransformToParent().DeepCopy(cameraToRAS)
return transformNode, viewDistance
def cameraTransform(self):
"""Create the transform and the observer for the camera
"""
transformName = 'Camera-To-RAS'
transformNode = slicer.util.getNode(transformName)
if not transformNode:
# Create transform node
transformNode = slicer.vtkMRMLLinearTransformNode()
transformNode.SetName(transformName)
slicer.mrmlScene.AddNode(transformNode)
camera = self.cameraNode().GetCamera()
import numpy
position = numpy.array(camera.GetPosition())
focalPoint = numpy.array(camera.GetFocalPoint())
viewUp = numpy.array(camera.GetViewUp())
viewPlaneNormal = numpy.array(camera.GetViewPlaneNormal())
viewAngle = camera.GetViewAngle()
viewRight = numpy.cross(viewUp,viewPlaneNormal)
viewDistance = numpy.linalg.norm(focalPoint - position)
cameraToRAS = vtk.vtkMatrix4x4()
for row in xrange(3):
cameraToRAS.SetElement(row, 0, viewRight[row])
cameraToRAS.SetElement(row, 1, viewUp[row])
cameraToRAS.SetElement(row, 2, viewPlaneNormal[row])
cameraToRAS.SetElement(row, 3, position[row])
transformNode.GetMatrixTransformToParent().DeepCopy(cameraToRAS)
return transformNode,viewDistance
def rasToXY(self, rasPoint, sliceLogic): sliceNode = sliceLogic.GetSliceNode() rasToXY = vtk.vtkMatrix4x4() rasToXY.DeepCopy(sliceNode.GetXYToRAS()) rasToXY.Invert() xyzw = rasToXY.MultiplyPoint(rasPoint + (1,)) return (int(round(xyzw[0])), int(round(xyzw[1])))
def onApply(self):
inputVolume = self.inputSelector.currentNode()
outputVolume = self.outputSelector.currentNode()
# check for input data
if not (inputVolume and outputVolume):
qt.QMessageBox.critical(
slicer.util.mainWindow(), 'Luminance',
'Input and output volumes are required for conversion')
return
# check that data has enough components
inputImage = inputVolume.GetImageData()
if not inputImage or inputImage.GetNumberOfScalarComponents() < 3:
qt.QMessageBox.critical(
slicer.util.mainWindow(), 'Vector to Scalar Volume',
'Input does not have enough components for conversion')
return
# run the filter
# - extract the RGB portions
extract = vtk.vtkImageExtractComponents()
extract.SetComponents(0, 1, 2)
extract.SetInput(inputVolume.GetImageData())
luminance = vtk.vtkImageLuminance()
luminance.SetInput(extract.GetOutput())
luminance.GetOutput().Update()
ijkToRAS = vtk.vtkMatrix4x4()
inputVolume.GetIJKToRASMatrix(ijkToRAS)
outputVolume.SetIJKToRASMatrix(ijkToRAS)
outputVolume.SetAndObserveImageData(luminance.GetOutput())
# make the output volume appear in all the slice views
selectionNode = slicer.app.applicationLogic().GetSelectionNode()
selectionNode.SetReferenceActiveVolumeID(outputVolume.GetID())
slicer.app.applicationLogic().PropagateVolumeSelection(0)
def convRAS2IJK(self, caller, event):
nodes = slicer.util.getNodesByClass('vtkMRMLMarkupsFiducialNode')
isInputImage = True
for f in nodes:
if (f.GetName() == "CochleaLocation"):
inputFiducial = self.inputFiducialNode
inputVolume = self.inputSelectorCoBx.currentNode()
print
# Get RAS-to-IJK-conversion matrix of the volume node associated with the Fiducial
RasToIjkMatrix = vtk.vtkMatrix4x4()
inputVolume.GetRASToIJKMatrix(RasToIjkMatrix)
# Call function to calculate IJK coordinates
world = [0, 0, 0, 0]
inputFiducial.GetNthFiducialWorldCoordinates(0, world)
ijkDoubleCoordinates = RasToIjkMatrix.MultiplyDoublePoint(world)
ijkIntCoordinates = [0, 0, 0]
for i in range(0, 3):
ijkIntCoordinates[i] = int(ijkDoubleCoordinates[i])
# Save IJK coordinates in corresponding point variable and display them
self.CPos = world
if isInputImage:
self.inputPoint = ijkIntCoordinates
self.inputPointEdt.setText(str(ijkIntCoordinates))
self.inputFiducialBtn.setStyleSheet(
"QPushButton{ background-color: White }")
print(" ..... cochlea location RAS: " + str(world))
print(" ..... cochlea location in the fixed image set to: " +
str(ijkIntCoordinates))
def ptsIJK2RAS(self, ptsIJK, inputImg): # input a markup points set
# Convert thepoints from IJK to RAS
ijk2rasM = vtk.vtkMatrix4x4()
inputImg.GetIJKToRASMatrix(ijk2rasM)
ptsRAS = np.zeros((len(ptsIJK), 3))
NoPts = len(ptsIJK)
PtsLength = 0
for i in range(0, NoPts):
ijk = ptsIJK[i][:]
ijkv = [ijk[0], ijk[1], ijk[2], 1]
rasPts = ijk2rasM.MultiplyDoublePoint(ijkv)
ptsRAS[i] = rasPts[0:3]
if (i > 0):
x1 = ptsRAS[i - 1][0]
y1 = ptsRAS[i - 1][1]
z1 = ptsRAS[i - 1][2]
x2 = rasPts[0]
y2 = rasPts[1]
z2 = rasPts[2]
PtsLength = PtsLength + math.sqrt((x2 - x1)**2 + (y2 - y1)**2 +
(z2 - z1)**2)
#print("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
self.StLength = PtsLength
print(" length = " + str(PtsLength))
#print("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx")
return ptsRAS
def run(self, referenceSequenceNode, inputNode, transformSequenceNode,
outputSequenceNode):
"""
Run the actual algorithm
"""
if outputSequenceNode:
outputSequenceNode.RemoveAllDataNodes()
numOfImageNodes = referenceSequenceNode.GetNumberOfDataNodes()
for i in xrange(numOfImageNodes):
referenceNode = referenceSequenceNode.GetNthDataNode(i)
referenceNodeIndexValue = referenceSequenceNode.GetNthIndexValue(i)
dimensions = [1, 1, 1]
referenceNode.GetImageData().GetDimensions(dimensions)
transformNode = transformSequenceNode.GetNthDataNode(i)
inputIJK2RASMatrix = vtk.vtkMatrix4x4()
inputNode.GetIJKToRASMatrix(inputIJK2RASMatrix)
referenceRAS2IJKMatrix = vtk.vtkMatrix4x4()
referenceNode.GetRASToIJKMatrix(referenceRAS2IJKMatrix)
inputRAS2RASMatrix = transformNode.GetTransformToParent()
resampleTransform = vtk.vtkGeneralTransform()
resampleTransform.Identity()
resampleTransform.PostMultiply()
resampleTransform.Concatenate(inputIJK2RASMatrix)
resampleTransform.Concatenate(inputRAS2RASMatrix)
resampleTransform.Concatenate(referenceRAS2IJKMatrix)
resampleTransform.Inverse()
resampler = vtk.vtkImageReslice()
resampler.SetInput(inputNode.GetImageData())
resampler.SetOutputOrigin(0, 0, 0)
resampler.SetOutputSpacing(1, 1, 1)
resampler.SetOutputExtent(0, dimensions[0], 0, dimensions[1], 0,
dimensions[2])
resampler.SetResliceTransform(resampleTransform)
resampler.Update()
outputNode = slicer.vtkMRMLScalarVolumeNode()
outputNode.CopyOrientation(referenceNode)
outputNode.SetAndObserveImageData(resampler.GetOutput())
outputSequenceNode.SetDataNodeAtValue(outputNode,
referenceNodeIndexValue)
return True
def run(self, baseFiducial, inputVolume, logPath=None):
"""
Run the actual algorithm
"""
if logPath:
self.logFilePath = logPath
self.logFile = open(logPath, 'a')
srcMatrix = vtk.vtkMatrix4x4()
xRange = [-50.0, 50.0]
yRange = [-50.0, 50.0]
zRange = [-50.0, 50.0]
for n in range(1, 2):
testFiducialVolumeNode = slicer.mrmlScene.CreateNodeByClass(
"vtkMRMLScalarVolumeNode")
testFiducialNode = slicer.mrmlScene.CreateNodeByClass(
"vtkMRMLMarkupsFiducialNode")
slicer.mrmlScene.AddNode(testFiducialVolumeNode)
slicer.mrmlScene.AddNode(testFiducialNode)
testFiducialNode.RemoveAllMarkups()
nFid = baseFiducial.GetNumberOfFiducials()
for m in range(0, nFid):
pos = [0.0, 0.0, 0.0]
baseFiducial.GetNthFiducialPosition(m, pos)
lb = baseFiducial.GetNthFiducialLabel(m)
testFiducialNode.AddFiducialFromArray(pos, lb)
testFiducialNode.SetName("TestFiducial-%d" % n)
testFiducialVolumeNode.SetName("TestImage-%d" % n)
self.generateRandomTransform(xRange, yRange, zRange, srcMatrix)
randomTransform = slicer.mrmlScene.CreateNodeByClass(
"vtkMRMLLinearTransformNode")
randomTransform.SetMatrixTransformToParent(srcMatrix)
slicer.mrmlScene.AddNode(randomTransform)
randomTransform.SetName("TestRandomTransform-%d" % n)
testFiducialNode.ApplyTransformMatrix(srcMatrix)
self.generateFiducialImage(inputVolume, testFiducialVolumeNode,
testFiducialNode)
self.printMatrixInLine("Reference", srcMatrix)
self.runRegistration(baseFiducial, testFiducialVolumeNode,
testFiducialNode)
#slicer.mrmlScene.RemoveNode(randomTransform)
#slicer.mrmlScene.RemoveNode(testFiducialVolumeNode)
#slicer.mrmlScene.RemoveNode(testFiducialNode)
if self.logFile:
self.logFile.close()
return True
