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 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