def computeFemoralLandMarkMatrix(txtPath: str): ''' 计算将solidWorks中的假体平移和旋转到原点附近 ''' pSourcePoints = vtk.vtkPoints() pSourcePoints.InsertPoint(0, -73.292, 1.468, -186.725) pSourcePoints.InsertPoint(1, -73.6702, 0.964468, -171.738) pSourcePoints.InsertPoint(2, -73.292, 1.468, -156.725) # pSourcePoints.InsertPoint(3, 57.6515, 29.5704 , -171.2451) # pSourcePoints.InsertPoint(4, 115.8690, 3.24210 , -160.804) pTargetPoints = vtk.vtkPoints() pTargetPoints.InsertPoint(0, -73.292, 1.468, -186.725) pTargetPoints.InsertPoint(1, -73.292, 1.468, -171.725) pTargetPoints.InsertPoint(2, -73.292, 1.468, -156.725) # -y 横向的 后端切平面的法线 # pTargetPoints.InsertPoint(3, -48.651500, 21.57049, -208.7548) # pTargetPoints.InsertPoint(4, -106.8690, -4.7579, -219.1959) # -z 轴向的 远端切平面的法线 landmarkTransform = vtk.vtkLandmarkTransform() landmarkTransform.SetSourceLandmarks(pSourcePoints) landmarkTransform.SetTargetLandmarks(pTargetPoints) landmarkTransform.SetModeToRigidBody() landmarkTransform.Update() matrix = landmarkTransform.GetMatrix() nparray = arrayFromVTKMatrix(matrix) for i in range(4): for j in range(4): print("{:10.2f}".format(matrix.GetElement(i, j)), end=", ") print("") np.set_printoptions(precision=3) np.savetxt(txtPath, nparray, fmt='%1.3f')
def __init__(self, module_manager): ModuleBase.__init__(self, module_manager) self._input_points = [None, None] self._source_landmarks = None self._target_landmarks = None self._config.mode = 'Rigid' configList = [('Transformation mode:', 'mode', 'base:str', 'choice', 'Rigid: rotation + translation;\n' 'Similarity: rigid + isotropic scaling\n' 'Affine: rigid + scaling + shear', ('Rigid', 'Similarity', 'Affine'))] self._landmark_transform = vtk.vtkLandmarkTransform() ScriptedConfigModuleMixin.__init__( self, configList, { 'Module (self)': self, 'vtkLandmarkTransform': self._landmark_transform }) self.sync_module_logic_with_config()
def getRigidTransform(fix, mov): # In real resolution LandmarkTransform = vtk.vtkLandmarkTransform() LandmarkTransform.SetModeToRigidBody() n = fix.shape[0] fix_point = vtk.vtkPoints() fix_point.SetNumberOfPoints(n) mov_point = vtk.vtkPoints() mov_point.SetNumberOfPoints(n) for i in range(n): fix_point.SetPoint(i, fix[i, 0], fix[i, 1], fix[i, 2]) mov_point.SetPoint(i, mov[i, 0], mov[i, 1], mov[i, 2]) LandmarkTransform.SetSourceLandmarks(mov_point) LandmarkTransform.SetTargetLandmarks(fix_point) LandmarkTransform.Update() matrix = LandmarkTransform.GetMatrix() T = ml.zeros([4, 4], dtype = npy.float32) for i in range(4): for j in range(4): T[i, j] = matrix.GetElement(j, i) p1 = mov[0, :].tolist() p2 = [0.0, 0, 0] LandmarkTransform.InternalTransformPoint(p1, p2) return T, npy.array(p2)
def computeTibiaTrayLandMarkMatrix(txtPath: str): ''' 计算将solidWorks中的假体平移和旋转到原点附近 ''' pSourcePoints = vtk.vtkPoints() pSourcePoints.InsertPoint(0, 0, 0, 0) pSourcePoints.InsertPoint(1, 0.5, 0, 0) pSourcePoints.InsertPoint(2, 1.0, 0, 0) pSourcePoints.InsertPoint(3, 0, 0.5, 0) pSourcePoints.InsertPoint(4, 0, 1.0, 0) pTargetPoints = vtk.vtkPoints() pTargetPoints.InsertPoint(0, 0, 0, 0) pTargetPoints.InsertPoint(1, -0.5, 0, 0) pTargetPoints.InsertPoint(2, -1.0, 0, 0) pTargetPoints.InsertPoint(3, 0, 0.5, 0) pTargetPoints.InsertPoint(4, 0, 1.0, 0) landmarkTransform = vtk.vtkLandmarkTransform() landmarkTransform.SetSourceLandmarks(pSourcePoints) landmarkTransform.SetTargetLandmarks(pTargetPoints) landmarkTransform.SetModeToRigidBody() landmarkTransform.Update() matrix = landmarkTransform.GetMatrix() nparray = arrayFromVTKMatrix(matrix) for i in range(4): for j in range(4): print("{:10.2f}".format(matrix.GetElement(i, j)), end=", ") print("") np.set_printoptions(precision=3) np.savetxt(txtPath, nparray, fmt='%1.3f')
def getRigidTransform(fix, mov): # In real resolution LandmarkTransform = vtk.vtkLandmarkTransform() LandmarkTransform.SetModeToRigidBody() n = fix.shape[0] fix_point = vtk.vtkPoints() fix_point.SetNumberOfPoints(n) mov_point = vtk.vtkPoints() mov_point.SetNumberOfPoints(n) for i in range(n): fix_point.SetPoint(i, fix[i, 0], fix[i, 1], fix[i, 2]) mov_point.SetPoint(i, mov[i, 0], mov[i, 1], mov[i, 2]) LandmarkTransform.SetSourceLandmarks(mov_point) LandmarkTransform.SetTargetLandmarks(fix_point) LandmarkTransform.Update() matrix = LandmarkTransform.GetMatrix() T = ml.zeros([4, 4], dtype=npy.float32) for i in range(4): for j in range(4): T[i, j] = matrix.GetElement(j, i) p1 = mov[0, :].tolist() p2 = [0.0, 0, 0] LandmarkTransform.InternalTransformPoint(p1, p2) return T, npy.array(p2)
def onLandmarkMoved_NOT(self,state): """Perform the linear transform using the vtkLandmarkTransform class""" if state.transformed.GetTransformNodeID() != state.linearTransform.GetID(): state.transformed.SetAndObserveTransformNodeID(state.linearTransform.GetID()) self.linearMode = "Rigid" # try to use user selection, but fall back if not enough points are available landmarkTransform = vtk.vtkLandmarkTransform() if self.linearMode == 'Rigid': landmarkTransform.SetModeToRigidBody() if self.linearMode == 'Similarity': landmarkTransform.SetModeToSimilarity() if self.linearMode == 'Affine': landmarkTransform.SetModeToAffine() if state.fixedFiducials.GetNumberOfFiducials() < 3: landmarkTransform.SetModeToRigidBody() points = {} point = [0,]*3 for volumeNode in (state.fixed,state.moving): points[volumeNode] = vtk.vtkPoints() indices = range(state.fixedFiducials.GetNumberOfFiducials()) fiducialLists = (state.fixedFiducials,state.movingFiducials) volumeNodes = (state.fixed,state.moving) for fiducials,volumeNode in zip(fiducialLists,volumeNodes): for index in indices: fiducials.GetNthFiducialPosition(index,point) points[volumeNode].InsertNextPoint(point) landmarkTransform.SetSourceLandmarks(points[state.moving]) landmarkTransform.SetTargetLandmarks(points[state.fixed]) landmarkTransform.Update() t = state.linearTransform t.SetAndObserveMatrixTransformToParent(landmarkTransform.GetMatrix())
def onLandmarkMoved(self,state): """Perform the linear transform using the vtkLandmarkTransform class""" if state.transformed: if state.transformed.GetTransformNodeID() != state.transform.GetID(): state.transformed.SetAndObserveTransformNodeID(state.transform.GetID()) if not state.fixedFiducials or not state.movingFiducials: return # try to use user selection, but fall back if not enough points are available landmarkTransform = vtk.vtkLandmarkTransform() if self.linearMode == 'Rigid': landmarkTransform.SetModeToRigidBody() if self.linearMode == 'Similarity': landmarkTransform.SetModeToSimilarity() if self.linearMode == 'Affine': landmarkTransform.SetModeToAffine() if state.fixedFiducials.GetNumberOfFiducials() < 3: landmarkTransform.SetModeToRigidBody() volumeNodes = (state.fixed, state.moving) fiducialNodes = (state.fixedFiducials,state.movingFiducials) points = state.logic.vtkPointsForVolumes( volumeNodes, fiducialNodes ) landmarkTransform.SetSourceLandmarks(points[state.moving]) landmarkTransform.SetTargetLandmarks(points[state.fixed]) landmarkTransform.Update() state.transform.SetAndObserveTransformToParent(landmarkTransform)
def onLandmarkMoved(self, state): """Perform the linear transform using the vtkLandmarkTransform class""" if state.transformed: if state.transformed.GetTransformNodeID() != state.transform.GetID( ): state.transformed.SetAndObserveTransformNodeID( state.transform.GetID()) if not state.fixedFiducials or not state.movingFiducials: return # try to use user selection, but fall back if not enough points are available landmarkTransform = vtk.vtkLandmarkTransform() if self.linearMode == 'Rigid': landmarkTransform.SetModeToRigidBody() if self.linearMode == 'Similarity': landmarkTransform.SetModeToSimilarity() if self.linearMode == 'Affine': landmarkTransform.SetModeToAffine() if state.fixedFiducials.GetNumberOfFiducials() < 3: landmarkTransform.SetModeToRigidBody() volumeNodes = (state.fixed, state.moving) fiducialNodes = (state.fixedFiducials, state.movingFiducials) points = state.logic.vtkPointsForVolumes(volumeNodes, fiducialNodes) landmarkTransform.SetSourceLandmarks(points[state.moving]) landmarkTransform.SetTargetLandmarks(points[state.fixed]) landmarkTransform.Update() state.transform.SetAndObserveTransformToParent(landmarkTransform)
def performLandmarkRegistion(self, fromFiducialsNode, toFiducialsNode, outputTransformNode): fromPoints = vtk.vtkPoints() toPoints = vtk.vtkPoints() nFrom = fromFiducialsNode.GetNumberOfFiducials() nTo = toFiducialsNode.GetNumberOfFiducials() if nFrom != nTo: logging.error('Number of fiducials in lists are not equal.') return for i in range(nFrom): p = [0, 0, 0] fromFiducialsNode.GetNthFiducialPosition(i, p) fromPoints.InsertNextPoint( p ) toFiducialsNode.GetNthFiducialPosition(i, p) toPoints.InsertNextPoint( p ) lt = vtk.vtkLandmarkTransform() lt.SetSourceLandmarks(fromPoints) lt.SetTargetLandmarks(toPoints) lt.SetModeToRigidBody() lt.Update() m = vtk.vtkMatrix4x4() lt.GetMatrix(m) #Check for stability of registration det = m.Determinant() if det < 1e-8: logging.error('Unstable registration. Check input for collinear points.') return outputTransformNode.SetMatrixTransformToParent(m)
def LandmarkSimilitudRegistration(fix, mov): """ landmarks registration from two vtkPoints """ transform = vtk.vtkLandmarkTransform() transform.SetSourceLandmarks(mov) transform.SetTargetLandmarks(fix) transform.SetModeToSimilarity() transform.Update() return transform
def onCalculateButtonClicked(self): self.landmarkTransform = vtk.vtkLandmarkTransform() self.landmarkTransform.SetSourceLandmarks(self.collectedPoints) self.landmarkTransform.SetTargetLandmarks(self.points) self.landmarkTransform.SetModeToRigidBody() self.landmarkTransform.Update() self.outputMatrix = vtk.vtkMatrix4x4() self.landmarkTransform.GetMatrix(self.outputMatrix) self.transformTable.setItem( 0, 0, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(0, 0)))) self.transformTable.setItem( 0, 1, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(0, 1)))) self.transformTable.setItem( 0, 2, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(0, 2)))) self.transformTable.setItem( 0, 3, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(0, 3)))) self.transformTable.setItem( 1, 0, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(1, 0)))) self.transformTable.setItem( 1, 1, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(1, 1)))) self.transformTable.setItem( 1, 2, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(1, 2)))) self.transformTable.setItem( 1, 3, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(1, 3)))) self.transformTable.setItem( 2, 0, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(2, 0)))) self.transformTable.setItem( 2, 1, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(2, 1)))) self.transformTable.setItem( 2, 2, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(2, 2)))) self.transformTable.setItem( 2, 3, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(2, 3)))) self.transformTable.setItem( 3, 0, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(3, 0)))) self.transformTable.setItem( 3, 1, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(3, 1)))) self.transformTable.setItem( 3, 2, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(3, 2)))) self.transformTable.setItem( 3, 3, qt.QTableWidgetItem(str(self.outputMatrix.GetElement(3, 3)))) self.transformTable.resizeColumnToContents(0) self.transformTable.resizeColumnToContents(1) self.transformTable.resizeColumnToContents(2) self.transformTable.resizeColumnToContents(3) self.calNode = slicer.mrmlScene.AddNewNodeByClass( 'vtkMRMLLinearTransformNode', 'JigSensorToJig') self.calNode.SetMatrixTransformToParent(self.outputMatrix) self.collectionNode.SetAndObserveTransformNodeID(self.calNode.GetID()) self.array = np.ones(4) self.transformedArray = np.array( [[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]], np.float64()) for i in range(0, 6): self.collectionNode.GetMarkupPointWorld(i, 0, self.array) self.transformedArray[i] = self.array[0:3] self.error = np.linalg.norm(self.jigArray - self.transformedArray) self.errorString.text = "RMSE: " + str(self.error)
def MRIXRayRegistration(self, mriLMReader, wrlLMReader, mriReader): Transrigid = vtk.vtkLandmarkTransform() Transrigid.SetSourceLandmarks(mriLMReader.points) Transrigid.SetTargetLandmarks(wrlLMReader.vertebrae_points) Transrigid.SetModeToRigidBody() Transrigid.Update() mriReader.actor.SetUserTransform(Transrigid) mriLMReader.actor.SetUserTransform(Transrigid) print("-----Performance Metrics of MRI to X-Ray using Rigid Registration-----") self.getMetrics(mriLMReader, wrlLMReader, Transrigid)
def landmark_registration(src, tgt): ''' src: moving points tgt: fix points ''' reg = vtk.vtkLandmarkTransform() reg.SetSourceLandmarks(src.GetPoints()) reg.SetTargetLandmarks(tgt.GetPoints()) reg.SetModeToRigidBody() reg.Update() return reg.GetMatrix()
def vtk_ellipsoid_topomesh(ellipsoid_radius=50.0, ellipsoid_scales=[1,1,1], ellipsoid_axes=np.diag(np.ones(3)), ellipsoid_center=np.zeros(3)): """ """ import vtk from openalea.cellcomplex.property_topomesh.utils.image_tools import vtk_polydata_to_triangular_mesh ico = vtk.vtkPlatonicSolidSource() ico.SetSolidTypeToIcosahedron() ico.Update() subdivide = vtk.vtkLoopSubdivisionFilter() subdivide.SetNumberOfSubdivisions(3) subdivide.SetInputConnection(ico.GetOutputPort()) subdivide.Update() scale_transform = vtk.vtkTransform() scale_factor = ellipsoid_radius/(np.sqrt(2)/2.) scale_transform.Scale(scale_factor,scale_factor,scale_factor) ellipsoid_sphere = vtk.vtkTransformPolyDataFilter() ellipsoid_sphere.SetInput(subdivide.GetOutput()) ellipsoid_sphere.SetTransform(scale_transform) ellipsoid_sphere.Update() ellipsoid_transform = vtk.vtkTransform() axes_transform = vtk.vtkLandmarkTransform() source_points = vtk.vtkPoints() source_points.InsertNextPoint([1,0,0]) source_points.InsertNextPoint([0,1,0]) source_points.InsertNextPoint([0,0,1]) target_points = vtk.vtkPoints() target_points.InsertNextPoint(ellipsoid_axes[0]) target_points.InsertNextPoint(ellipsoid_axes[1]) target_points.InsertNextPoint(ellipsoid_axes[2]) axes_transform.SetSourceLandmarks(source_points) axes_transform.SetTargetLandmarks(target_points) axes_transform.SetModeToRigidBody() axes_transform.Update() ellipsoid_transform.SetMatrix(axes_transform.GetMatrix()) ellipsoid_transform.Scale(ellipsoid_scales[0],ellipsoid_scales[1],ellipsoid_scales[2]) center_transform = vtk.vtkTransform() center_transform.Translate(ellipsoid_center[0],ellipsoid_center[1],ellipsoid_center[2]) center_transform.Concatenate(ellipsoid_transform) ellipsoid_ellipsoid = vtk.vtkTransformPolyDataFilter() ellipsoid_ellipsoid.SetInput(ellipsoid_sphere.GetOutput()) ellipsoid_ellipsoid.SetTransform(center_transform) ellipsoid_ellipsoid.Update() ellipsoid_mesh = vtk_polydata_to_triangular_mesh(ellipsoid_ellipsoid.GetOutput()) topomesh = triangle_topomesh(ellipsoid_mesh.triangles.values(),ellipsoid_mesh.points) return topomesh
def ICPSimilitudRegistration(fix, mov, fix_ldm=None, mov_ldm=None, do_rigid=False): """ IterativeClosestPoint registration between two vtkPolyData return the vtkTransform can be initialized using landmarks (then return a composed vtkTransform instead of a vtkIterativeClosestPointTransform) """ transform = vtk.vtkIterativeClosestPointTransform() if do_rigid: transform.GetLandmarkTransform().SetModeToRigidBody() else: transform.GetLandmarkTransform().SetModeToSimilarity() transform.SetTarget(fix) #transform.SetMaximumNumberOfIterations(10) #transform.SetMaximumNumberOfLandmarks(100) # initialize using landmarks if fix_ldm is not None and mov_ldm is not None: ldm_transform = vtk.vtkLandmarkTransform() ldm_transform.SetSourceLandmarks(mov_ldm) ldm_transform.SetTargetLandmarks(fix_ldm) if do_rigid: ldm_transform.SetModeToRigidBody() else: ldm_transform.SetModeToSimilarity() ldm_transform.Update() warper = vtk.vtkTransformPolyDataFilter() warper.SetTransform(ldm_transform) warper.SetInputData(mov) warper.Update() # ICP registration transform.SetSource(warper.GetOutput()) transform.Update() composed = vtk.vtkTransform() composed.SetInput(transform) composed.PreMultiply() composed.Concatenate(ldm_transform) return composed else: transform.SetStartByMatchingCentroids(True) # ICP registration transform.SetSource(mov) transform.Update() return transform
def constraint(self, x_current): # Make sure the optimizer is searching in a reasonable region. # aim to preserve volume using the determinant of the overall affine transform affine_part = vtk.vtkLandmarkTransform() source_landmarks = convert_numpy_array_to_vtk_points(x_current) target_landmarks = convert_numpy_array_to_vtk_points(self.target_landmarks) affine_part.SetSourceLandmarks(source_landmarks) affine_part.SetTargetLandmarks(target_landmarks) affine_part.SetModeToAffine() affine_part.Update() det = affine_part.GetMatrix().Determinant() penalty = -100 * (1 - det) return penalty
def BestBoundingBox(axis, target, source, targetLandmarks, sourceLandmarks, bestDistance, bestPoints): distance = vtk.vtkHausdorffDistancePointSetFilter() testTransform = vtk.vtkTransform() testTransformPD = vtk.vtkTransformPolyDataFilter() lmTransform = vtk.vtkLandmarkTransform() lmTransformPD = vtk.vtkTransformPolyDataFilter() lmTransform.SetModeToSimilarity() lmTransform.SetTargetLandmarks(targetLandmarks.GetPoints()) sourceCenter = sourceLandmarks.GetCenter() delta = 90.0 for i in range(0, 4): angle = delta * i # Rotate about center testTransform.Identity() testTransform.Translate(sourceCenter[0], sourceCenter[1], sourceCenter[2]) if axis == "X": testTransform.RotateX(angle) elif axis == "Y": testTransform.RotateY(angle) else: testTransform.RotateZ(angle) testTransform.Translate(-sourceCenter[0], -sourceCenter[1], -sourceCenter[2]) testTransformPD.SetTransform(testTransform) testTransformPD.SetInputData(sourceLandmarks) testTransformPD.Update() lmTransform.SetSourceLandmarks(testTransformPD.GetOutput().GetPoints()) lmTransform.Modified() lmTransformPD.SetInputData(source) lmTransformPD.SetTransform(lmTransform) lmTransformPD.Update() distance.SetInputData(0, target) distance.SetInputData(1, lmTransformPD.GetOutput()) distance.Update() testDistance = distance.GetOutput(0).GetFieldData().GetArray( "HausdorffDistance").GetComponent(0, 0) if testDistance < bestDistance: bestDistance = testDistance bestPoints.DeepCopy(testTransformPD.GetOutput().GetPoints()) return bestDistance
def computeRegistration(referenceToRas, alphaPoints, betaPoints): landmarkTransform = vtk.vtkLandmarkTransform() landmarkTransform.SetSourceLandmarks(alphaPoints) landmarkTransform.SetTargetLandmarks(betaPoints) landmarkTransform.SetModeToRigidBody() landmarkTransform.Update() alphaToBetaMatrix = vtk.vtkMatrix4x4() landmarkTransform.GetMatrix(alphaToBetaMatrix) det = alphaToBetaMatrix.Determinant() if det < 1e-8: print 'Unstable registration. Check input for collinear points.' referenceToRas.SetMatrixTransformToParent(alphaToBetaMatrix) return alphaToBetaMatrix
def transform_lmk(sourcepoints,targetpoints,surface,similarityon=False): lmktransform = vtk.vtkLandmarkTransform() lmktransform.SetSourceLandmarks(sourcepoints) lmktransform.SetTargetLandmarks(targetpoints) if similarityon: lmktransform.SetModeToSimilarity() else: lmktransform.SetModeToAffine() lmktransform.Update() transformfilter = vtk.vtkTransformPolyDataFilter() transformfilter.SetInputData(surface) transformfilter.SetTransform(lmktransform) transformfilter.Update() return transformfilter.GetOutput()
def SurfaceXRayRegistration(self, szeLMReader, wrlLMReader, szeReader): # Rotate surface becsause it is not aligned with landmarks self.AlignSurfaceLM(szeReader) # find the rigid registration using correspondences Transrigid = vtk.vtkLandmarkTransform() Transrigid.SetSourceLandmarks(szeLMReader.points) Transrigid.SetTargetLandmarks(wrlLMReader.capteurs_points) Transrigid.SetModeToRigidBody() Transrigid.Update() # Apply transformation to landmarks self.ApplyTransform(szeLMReader.actor, Transrigid) print("-----Performance Metrics of Surface Topography to X-Ray using Rigid Registration-----") self.getMetrics(szeLMReader, wrlLMReader, Transrigid) # Apply transformation to surface self.ApplyTransform(szeReader.actorCopy, Transrigid) self.ApplyTransform(szeReader.actor, Transrigid)
def _updateTransform(self): """ Update the landmark transform """ if PointsSetsIsEmpty(self.landmarkPointSets): return numberOfSets = NumberOfSets(self.landmarkPointSets) fixedPoints = vtkPoints() movingPoints = vtkPoints() fixedPoints.SetNumberOfPoints(numberOfSets) movingPoints.SetNumberOfPoints(numberOfSets) pointsetIndex = 0 for index in range(len(self.landmarkPointSets)): pointset = self.landmarkPointSets[index] if pointset[0] and pointset[1]: fixedPoint = pointset[0] movingPoint = pointset[1] # Transform the point from the moving landmark with the original transform transPoint = self.originalTransform.TransformPoint(movingPoint) fixedPoints.SetPoint(pointsetIndex, fixedPoint) movingPoints.SetPoint(pointsetIndex, transPoint) pointsetIndex += 1 landmarkTransform = vtkLandmarkTransform() if self.landmarkTransformType == 0: landmarkTransform.SetModeToRigidBody() elif self.landmarkTransformType == 1: landmarkTransform.SetModeToSimilarity() elif self.landmarkTransformType == 2: landmarkTransform.SetModeToAffine() landmarkTransform.SetSourceLandmarks(fixedPoints) landmarkTransform.SetTargetLandmarks(movingPoints) landmarkTransform.Update() transform = TransformWithMatrix(landmarkTransform.GetMatrix()) transform.Inverse() transformation = self.multiWidget.transformations[-1] assert transformation.transformType == Transformation.TypeLandmark transformation.transform = transform self.multiWidget.transformations[-1] = transformation self._updateLandmarkTransforms()
def AlignBoundingBoxes(source, target): # Use OBBTree to create an oriented bounding box for target and source sourceOBBTree = vtk.vtkOBBTree() sourceOBBTree.SetDataSet(source) sourceOBBTree.SetMaxLevel(1) sourceOBBTree.BuildLocator() targetOBBTree = vtk.vtkOBBTree() targetOBBTree.SetDataSet(target) targetOBBTree.SetMaxLevel(1) targetOBBTree.BuildLocator() sourceLandmarks = vtk.vtkPolyData() sourceOBBTree.GenerateRepresentation(0, sourceLandmarks) targetLandmarks = vtk.vtkPolyData() targetOBBTree.GenerateRepresentation(0, targetLandmarks) lmTransform = vtk.vtkLandmarkTransform() lmTransform.SetModeToSimilarity() lmTransform.SetTargetLandmarks(targetLandmarks.GetPoints()) # lmTransformPD = vtk.vtkTransformPolyDataFilter() bestDistance = vtk.VTK_DOUBLE_MAX bestPoints = vtk.vtkPoints() bestDistance = BestBoundingBox("X", target, source, targetLandmarks, sourceLandmarks, bestDistance, bestPoints) bestDistance = BestBoundingBox("Y", target, source, targetLandmarks, sourceLandmarks, bestDistance, bestPoints) bestDistance = BestBoundingBox("Z", target, source, targetLandmarks, sourceLandmarks, bestDistance, bestPoints) lmTransform.SetSourceLandmarks(bestPoints) lmTransform.Modified() transformPD = vtk.vtkTransformPolyDataFilter() transformPD.SetInputData(source) transformPD.SetTransform(lmTransform) transformPD.Update() source.DeepCopy(transformPD.GetOutput()) return
def landmarkRegistration(self, fromMarkupsNode, toMarkupsNode, outputTransformNode): logging.debug('landmarkRegistration') fromPoints = vtk.vtkPoints() toPoints = vtk.vtkPoints() nFromPoints = fromMarkupsNode.GetNumberOfFiducials() nToPoints = toMarkupsNode.GetNumberOfFiducials() if nFromPoints != nToPoints: return 'Number of points in markups nodes are not equal. Error {0:.2f}', 1 if nFromPoints < 3: return 'Insufficient number of points in markups nodes. Error {0:.2f}', 2 for i in range(nFromPoints): p = [0, 0, 0] fromMarkupsNode.GetNthControlPointPositionWorld(i, p) fromPoints.InsertNextPoint(p) toMarkupsNode.GetNthControlPointPositionWorld(i, p) toPoints.InsertNextPoint(p) lt = vtk.vtkLandmarkTransform() lt.SetSourceLandmarks(fromPoints) lt.SetTargetLandmarks(toPoints) lt.SetModeToSimilarity() lt.Update() resultsMatrix = vtk.vtkMatrix4x4() lt.GetMatrix(resultsMatrix) det = resultsMatrix.Determinant() if det < 1e-8: return 'Unstable registration. Check input for collinear points. Error {0:.2f}', 3 outputTransformNode.SetMatrixTransformToParent(resultsMatrix) return self.calculateRMSE(nFromPoints, fromPoints, toPoints, resultsMatrix)
def matrixError(self, pre, post): pSourcePoints = vtk.vtkPoints() pTargetPoints = vtk.vtkPoints() # 求取术前空间到术后空间的转换矩阵 for i in range(5): pTargetPoints.InsertPoint(i, post[i][0], post[i][1], post[i][2]) pSourcePoints.InsertPoint(i, pre[i][0], pre[i][1], pre[i][2]) landmarkTransform = vtk.vtkLandmarkTransform() landmarkTransform.SetSourceLandmarks(pSourcePoints) landmarkTransform.SetTargetLandmarks(pTargetPoints) landmarkTransform.SetModeToRigidBody() landmarkTransform.Update() matrix = landmarkTransform.GetMatrix() matrix_np = self.arrayFromVTKMatrix(matrix) temp_five = np.ones([5, 3], dtype=float) temp_dist = [] for i in range(5): post_temp = np.array([pre[i][0], pre[i][1], pre[i][2], 1]) post_temp_transform = np.matmul(matrix_np, post_temp) temp_five[i] = post_temp_transform[0:3] dist = np.linalg.norm(post[i] - post_temp_transform[0:3]) temp_dist.append(dist) # print("post ", post) # print("temp_five ", temp_five) # print("temp_dist ", temp_dist) temp_dist = np.array(temp_dist) # print("max error ", np.max(temp_dist)) # 返回最大的偏差 return np.max(temp_dist), matrix_np
def applyLandmarkTransform(self): if (self.in2_pipe != None): in1_pts = self.pickerstyle.getNumberOfPoints("in1_pipeline") in2_pts = self.pickerstyle.getNumberOfPoints("in2_pipeline") if (in1_pts == in2_pts and in1_pts >= 3): lm = vtk.vtkLandmarkTransform() lm.SetTargetLandmarks( self.pickerstyle.getPoints("in1_pipeline")) lm.SetSourceLandmarks( self.pickerstyle.getPoints("in2_pipeline")) lm.SetModeToRigidBody() lm.Update() mat = lm.GetMatrix() self.in2_pipe.setRigidBodyTransformConcatenateMatrix(mat) self.pickerstyle.removePoints("in1_pipeline") self.pickerstyle.removePoints("in2_pipeline") self.refreshRenderWindow() self.updateGUI() self.statusBar().showMessage( f"Landmark transform complete based on {in1_pts}", 4000) else: self.statusBar().showMessage( "ERROR: Landmark transform could not be executed", 4000)
def affine_alignment(source_mesh, source_landmarks, target_landmarks): """ Applies an affine transformation to the source mesh and landmarks :param source_mesh: vtkPolyData to be transformed :param source_landmarks: array of shape [n,3] :param target_landmarks: array of shape [n,3] :return: (transformed source_mesh, transformed source_landmarks) """ tar = utils.np_to_vtkPoints(target_landmarks) src = utils.np_to_vtkPoints(source_landmarks) src_poly = vtk.vtkPolyData() src_poly.SetPoints(src) affine = vtk.vtkLandmarkTransform() affine.SetSourceLandmarks(src) affine.SetTargetLandmarks(tar) affine.SetModeToAffine() affine.Update() transform_mesh = vtk.vtkTransformPolyDataFilter() transform_mesh.SetTransform(affine) transform_mesh.SetInputData(source_mesh) transform_mesh.Update() transformed_mesh = transform_mesh.GetOutput() transform_landmarks = vtk.vtkTransformPolyDataFilter() transform_landmarks.SetTransform(affine) transform_landmarks.SetInputData(src_poly) transform_landmarks.Update() transformed_landmarks = utils.vtkPoints_to_np( transform_landmarks.GetOutput().GetPoints()) return (transformed_mesh, transformed_landmarks)
def __init__(self, master=None): if master is None: master = Toplevel() master.wm_title("Registration") Frame.__init__(self, master) self.pack(fill='both', expand='true') else: Frame.__init__(self, master) # the lists of landmarks self._SourceLandmarks = [] self._TargetLandmarks = [] # the index of the current landmark self._CurrentLandmark = 0 # the transformation that matches the landmarks self._SourcePoints = vtk.vtkPoints() self._TargetPoints = vtk.vtkPoints() self._Transform = vtk.vtkLandmarkTransform() # self._Transform.SetModeToRigidBody() self._Transform.SetSourceLandmarks(self._SourcePoints) self._Transform.SetTargetLandmarks(self._TargetPoints) # the FiducialMarkerFactory draws the annotations on the image self._FiducialMarkerFactory = None # the OrthoPlanesFactory acts as the cursor for Source points self._OrthoPlanesFactory = None # the TrackedPointer acts as the cursor for Target points self._TrackedPointer = None # a list of 2D panes: whenever a point is chosen, these will # be adjusted to ensure that the point is visible self._Panes = [] # build the user interface mframe = Frame(self) lframe = Frame(mframe) self._Scrollbar = Scrollbar(lframe, relief='sunken', bd=2) self._Listbox = Listbox( lframe, yscrollcommand=self._Scrollbar.set, # selectmode='multiple', exportselection='false', font='courier', width=len(toanatomic(0, 0, 0)) + 6) self._Listbox.bind("<ButtonRelease-1>", self._Select) self._Listbox.bind("<KeyRelease>", self._SelectKey) # self._Listbox.bind("<KeyRelease-KP_Delete>", # lambda e,f=self._Delete: f()) self._Listbox.bind("<KeyRelease-Delete>", lambda e, f=self._Delete: f()) # self._Listbox.bind("<KeyRelease-KP_Enter>", # lambda e,f=self._Add: f()) self._Listbox.bind("<KeyRelease-Return>", lambda e, f=self._Add: f()) self._Scrollbar.config(command=self._Listbox.yview) self._Listbox.pack(side='left', fill='both', expand='true') self._Scrollbar.pack(side='left', fill='y') lframe.pack(side='left', fill='both', expand='true') bframe1 = Frame(mframe, bd=1) bframe = Frame(bframe1, relief='sunken', bd=1) self._AddB = Button(bframe, text='Add', command=self._Add) self._NextB = Button(bframe, text='Next', command=self._Next) self._SetB = Button(bframe, text='Set', command=self._Set) self._PrevB = Button(bframe, text='Prev', command=self._Prev) self._DeleteB = Button(bframe, text='Delete', command=self._Delete) self._AddB.pack(side='top', fill='both', expand='true') self._NextB.pack(side='top', fill='both', expand='true') self._SetB.pack(side='top', fill='both', expand='true') self._PrevB.pack(side='top', fill='both', expand='true') self._DeleteB.pack(side='top', fill='both', expand='true') bframe.pack(side='left', fill='both', expand='true') bframe1.pack(side='left', fill='both', expand='true') mframe.pack(side='top', fill='both', expand='true') self._StdDevLabel = Label( self, text='Standard Deviation: --- mm (0 Points)') self._StdDevLabel.pack(side='top', fill='y', expand='true')
def register(self, fixedData, movingData, index = -1, discard = False, delta = 0, fov = 9999999.0, down_fix = 1, down_mov = 1, occ = 9999999.0, op = False, useMask = False, isTime = False, MaxRate = 0.2, aug = False, distance_fix = 0.3, distance_mov = 0.1, w_wrong = 1.5, truth_mov = None): time1 = time.time() if index == -1: index = self.gui.getDataIndex({'Contour': 0, 'Centerline': 1}, 'Select the object') if index is None: return None, None, None if index == 0: fixed_points = fixedData.getPointSet('Contour').copy() moving_points = movingData.getPointSet('Contour').copy() else: fixed_points = fixedData.getPointSet('Centerline').copy() moving_points = movingData.getPointSet('Centerline').copy() if truth_mov is None: truth_mov = moving_points.copy() fixed_bif = db.getBifurcation(fixed_points) moving_bif = db.getBifurcation(moving_points) if useMask: mask_points = movingData.getPointSet('Mask') for point in mask_points: moving_points = npy.delete(moving_points, npy.where((npy.abs(moving_points[:, 2] - point[2]) < 0.0001) & (npy.round(moving_points[:, -1]) == point[3])), axis = 0) fixed_res = fixedData.getResolution().tolist() moving_res = movingData.getResolution().tolist() fixed_points = fixed_points[npy.where(fixed_points[:, 0] >= 0)] moving_points = moving_points[npy.where(moving_points[:, 0] >= 0)] # Use the bifurcation as the initial position if (fixed_bif < 0) or (moving_bif < 0): fixed_min = 0 # Augmentation of pointset fixed = fixed_points.copy() moving = moving_points.copy() if index == 1 and aug: fixed = util.augmentCenterline(fixed, 1, 10) moving = util.augmentCenterline(moving, 1, 10) fix_dis = util.getAxisSin(fixed, 3 / fixed_res[2]) * distance_fix mov_dis = util.getAxisSin(moving, 3 / moving_res[2]) * distance_mov fixed = util.resampleCenterline(fixed, fix_dis / fixed_res[2]) moving = util.resampleCenterline(moving, mov_dis / moving_res[2]) fixed = fixed[npy.cast[npy.int32](npy.abs(fixed[:, 2] - fixed_bif)) % down_fix == 0] moving = moving[npy.cast[npy.int32](npy.abs(moving[:, 2] - moving_bif)) % down_mov == 0] fixed[:, :3] *= fixed_res[:3] moving[:, :3] *= moving_res[:3] new_trans_points = truth_mov result_center_points = movingData.getPointSet('Centerline').copy() new_trans_points = new_trans_points[new_trans_points[:, 3] >= 0] result_center_points = result_center_points[result_center_points[:, 3] >= 0] new_trans_points[:, :3] *= moving_res[:3] result_center_points[:, :3] *= moving_res[:3] if (fixed_bif >= 0) and (moving_bif >= 0): fixed[:, 2] -= (fixed_bif * fixed_res[2] - moving_bif * moving_res[2] + delta) # Prepare for ICP MaxIterNum = 50 #MaxNum = 600 MaxNum = int(MaxRate * moving.shape[0] + 0.5) targetPoints = [vtk.vtkPoints(), vtk.vtkPoints(), vtk.vtkPoints()] targetVertices = [vtk.vtkCellArray(), vtk.vtkCellArray(), vtk.vtkCellArray()] target = [vtk.vtkPolyData(), vtk.vtkPolyData(), vtk.vtkPolyData()] Locator = [vtk.vtkCellLocator(), vtk.vtkCellLocator(), vtk.vtkCellLocator()] for i in range(3): for x in fixed[npy.round(fixed[:, 3]) == i]: id = targetPoints[i].InsertNextPoint(x[0], x[1], x[2]) targetVertices[i].InsertNextCell(1) targetVertices[i].InsertCellPoint(id) target[i].SetPoints(targetPoints[i]) target[i].SetVerts(targetVertices[i]) Locator[i].SetDataSet(target[i]) Locator[i].SetNumberOfCellsPerBucket(1) Locator[i].BuildLocator() step = 1 if moving.shape[0] > MaxNum: ind = moving[:, 2].argsort() moving = moving[ind, :] step = moving.shape[0] / MaxNum nb_points = moving.shape[0] / step points1 = vtk.vtkPoints() points1.SetNumberOfPoints(nb_points) label = npy.zeros([MaxNum * 2], dtype = npy.int8) j = 0 for i in range(nb_points): points1.SetPoint(i, moving[j][0], moving[j][1], moving[j][2]) label[i] = moving[j][3] j += step closestp = vtk.vtkPoints() closestp.SetNumberOfPoints(nb_points) points2 = vtk.vtkPoints() points2.SetNumberOfPoints(nb_points) id1 = id2 = vtk.mutable(0) dist = vtk.mutable(0.0) outPoint = [0.0, 0.0, 0.0] p1 = [0.0, 0.0, 0.0] p2 = [0.0, 0.0, 0.0] iternum = 0 a = points1 b = points2 if (op and index == 0) or (not op and index == 1): w_mat = [[1, w_wrong, w_wrong], [w_wrong, 1, 99999999], [w_wrong, 99999999, 1]] else: w_mat = [[1, 1, 1], [1, 1, 1], [1, 1, 1]] accumulate = vtk.vtkTransform() accumulate.PostMultiply() LandmarkTransform = vtk.vtkLandmarkTransform() LandmarkTransform.SetModeToRigidBody() while True: for i in range(nb_points): min_dist = 99999999 min_outPoint = [0.0, 0.0, 0.0] for j in range(3): Locator[j].FindClosestPoint(a.GetPoint(i), outPoint, id1, id2, dist) dis = npy.sqrt(npy.sum((npy.array(outPoint) - a.GetPoint(i)) ** 2)) if dis * w_mat[label[i]][j] < min_dist: min_dist = dis * w_mat[label[i]][j] min_outPoint = copy.deepcopy(outPoint) closestp.SetPoint(i, min_outPoint) LandmarkTransform.SetSourceLandmarks(a) LandmarkTransform.SetTargetLandmarks(closestp) LandmarkTransform.Update() accumulate.Concatenate(LandmarkTransform.GetMatrix()) iternum += 1 for i in range(nb_points): a.GetPoint(i, p1) LandmarkTransform.InternalTransformPoint(p1, p2) b.SetPoint(i, p2) b, a = a, b if iternum >= MaxIterNum: break matrix = accumulate.GetMatrix() T = ml.mat([matrix.GetElement(0, 3), matrix.GetElement(1, 3), matrix.GetElement(2, 3)]).T R = ml.mat([[matrix.GetElement(0, 0), matrix.GetElement(0, 1), matrix.GetElement(0, 2)], [matrix.GetElement(1, 0), matrix.GetElement(1, 1), matrix.GetElement(1, 2)], [matrix.GetElement(2, 0), matrix.GetElement(2, 1), matrix.GetElement(2, 2)]]).I result_center_points[:, :3] = util.applyTransformForPoints(result_center_points[:, :3], npy.array([1.0, 1, 1]), npy.array([1.0, 1, 1]), R, T, ml.zeros([3, 1], dtype = npy.float32)) new_trans_points[:, :3] = util.applyTransformForPoints(new_trans_points[:, :3], npy.array([1.0, 1, 1]), npy.array([1.0, 1, 1]), R, T, ml.zeros([3, 1], dtype = npy.float32)) LandmarkTransform = vtk.vtkThinPlateSplineTransform() LandmarkTransform.SetBasisToR() iternum = 0 # Non-rigid while True: for i in range(nb_points): min_dist = 99999999 min_outPoint = [0.0, 0.0, 0.0] for j in range(3): Locator[j].FindClosestPoint(a.GetPoint(i), outPoint, id1, id2, dist) dis = npy.sqrt(npy.sum((npy.array(outPoint) - a.GetPoint(i)) ** 2)) if dis * w_mat[label[i]][j] < min_dist: min_dist = dis * w_mat[label[i]][j] min_outPoint = copy.deepcopy(outPoint) closestp.SetPoint(i, min_outPoint) LandmarkTransform.SetSourceLandmarks(a) LandmarkTransform.SetTargetLandmarks(closestp) LandmarkTransform.Update() ''' for i in range(result_center_points.shape[0]): LandmarkTransform.InternalTransformPoint([result_center_points[i, 0], result_center_points[i, 1], result_center_points[i, 2]], p2) result_center_points[i, :3] = p2 ''' for i in range(new_trans_points.shape[0]): LandmarkTransform.InternalTransformPoint([new_trans_points[i, 0], new_trans_points[i, 1], new_trans_points[i, 2]], p2) new_trans_points[i, :3] = p2 iternum += 1 if iternum >= 1: break for i in range(nb_points): a.GetPoint(i, p1) LandmarkTransform.InternalTransformPoint(p1, p2) b.SetPoint(i, p2) b, a = a, b time2 = time.time() if (fixed_bif >= 0) and (moving_bif >= 0): new_trans_points[:, 2] += (fixed_bif * fixed_res[2] - moving_bif * moving_res[2] + delta) result_center_points[:, 2] += (fixed_bif * fixed_res[2] - moving_bif * moving_res[2] + delta) new_trans_points[:, :3] /= fixed_res[:3] result_center_points[:, :3] /= fixed_res[:3] resultImage = movingData.getData().copy() sa = SurfaceErrorAnalysis(None) dataset = db.BasicData(npy.array([[[0]]]), fixedData.getInfo(), {'Contour': new_trans_points, 'Centerline': result_center_points}) mean_dis, mean_whole, max_dis, max_whole = sa.analysis(dataset, point_data_fix = fixedData.getPointSet('Contour').copy(), useResult = True) del dataset print mean_dis print mean_whole if isTime: return resultImage, {'Contour': new_trans_points, 'Centerline': result_center_points}, [mean_dis, mean_whole], time2 - time1 return resultImage, {'Contour': new_trans_points, 'Centerline': result_center_points}, [mean_dis, mean_whole]
# read source landmarks SourceLMReader = vtk.vtkPolyDataReader() SourceLMReader.SetFileName("DefaultLandmarks.vtk"); SourceLMReader.Update() #print SourceLMReader.GetOutput().GetPoints() # read target landmarks TargetLMReader = vtk.vtkPolyDataReader() TargetLMReader.SetFileName("TargetLandmarks.vtk"); TargetLMReader.Update() #print TargetLMReader.GetOutput().GetPoints() # create transformation LandmarkTransform = vtk.vtkLandmarkTransform() LandmarkTransform.SetSourceLandmarks(SourceLMReader.GetOutput().GetPoints() ) LandmarkTransform.SetTargetLandmarks(TargetLMReader.GetOutput().GetPoints() ) LandmarkTransform.SetModeToRigidBody() LandmarkTransform.Update() print LandmarkTransform.GetMatrix() # apply transform transformFilter = vtk.vtkTransformFilter() #transformFilter.SetInput(vtkCylinder.GetOutput() ) transformFilter.SetInput(trianglefilter.GetOutput() ) transformFilter.SetTransform( LandmarkTransform) transformFilter.Update() # write model modelWriter = vtk.vtkDataSetWriter()
def __init__(self, master=None): if master is None: master = Toplevel() master.wm_title("Registration") Frame.__init__(self, master) self.pack(fill='both', expand='true') else: Frame.__init__(self, master) # the lists of landmarks self._SourceLandmarks = [] self._TargetLandmarks = [] # the index of the current landmark self._CurrentLandmark = 0 # the transformation that matches the landmarks self._SourcePoints = vtk.vtkPoints() self._TargetPoints = vtk.vtkPoints() self._Transform = vtk.vtkLandmarkTransform() # self._Transform.SetModeToRigidBody() self._Transform.SetSourceLandmarks(self._SourcePoints) self._Transform.SetTargetLandmarks(self._TargetPoints) # the FiducialMarkerFactory draws the annotations on the image self._FiducialMarkerFactory = None # the OrthoPlanesFactory acts as the cursor for Source points self._OrthoPlanesFactory = None # the TrackedPointer acts as the cursor for Target points self._TrackedPointer = None # a list of 2D panes: whenever a point is chosen, these will # be adjusted to ensure that the point is visible self._Panes = [] # build the user interface mframe = Frame(self) lframe = Frame(mframe) self._Scrollbar = Scrollbar(lframe, relief='sunken', bd=2) self._Listbox = Listbox(lframe, yscrollcommand=self._Scrollbar.set, # selectmode='multiple', exportselection='false', font='courier', width=len(toanatomic(0, 0, 0)) + 6) self._Listbox.bind("<ButtonRelease-1>", self._Select) self._Listbox.bind("<KeyRelease>", self._SelectKey) # self._Listbox.bind("<KeyRelease-KP_Delete>", # lambda e,f=self._Delete: f()) self._Listbox.bind("<KeyRelease-Delete>", lambda e, f=self._Delete: f()) # self._Listbox.bind("<KeyRelease-KP_Enter>", # lambda e,f=self._Add: f()) self._Listbox.bind("<KeyRelease-Return>", lambda e, f=self._Add: f()) self._Scrollbar.config(command=self._Listbox.yview) self._Listbox.pack(side='left', fill='both', expand='true') self._Scrollbar.pack(side='left', fill='y') lframe.pack(side='left', fill='both', expand='true') bframe1 = Frame(mframe, bd=1) bframe = Frame(bframe1, relief='sunken', bd=1) self._AddB = Button(bframe, text='Add', command=self._Add) self._NextB = Button(bframe, text='Next', command=self._Next) self._SetB = Button(bframe, text='Set', command=self._Set) self._PrevB = Button(bframe, text='Prev', command=self._Prev) self._DeleteB = Button(bframe, text='Delete', command=self._Delete) self._AddB.pack(side='top', fill='both', expand='true') self._NextB.pack(side='top', fill='both', expand='true') self._SetB.pack(side='top', fill='both', expand='true') self._PrevB.pack(side='top', fill='both', expand='true') self._DeleteB.pack(side='top', fill='both', expand='true') bframe.pack(side='left', fill='both', expand='true') bframe1.pack(side='left', fill='both', expand='true') mframe.pack(side='top', fill='both', expand='true') self._StdDevLabel = Label(self, text='Standard Deviation: --- mm (0 Points)') self._StdDevLabel.pack(side='top', fill='y', expand='true')
def register(self, fixedData, movingData, index=-1, discard=False, delta=0, fov=9999999.0, down_fix=1, down_mov=1, occ=9999999.0, useMask=False, isTime=False, MaxRate=0.2, aug=False, distance_fix=0.3, distance_mov=0.1, w_wrong=1.5): time1 = time.time() if index == -1: index = self.gui.getDataIndex({ 'Contour': 0, 'Centerline': 1 }, 'Select the object') if index is None: return None, None, None if index == 0: fixed_points = fixedData.getPointSet('Contour').copy() moving_points = movingData.getPointSet('Contour').copy() else: fixed_points = fixedData.getPointSet('Centerline').copy() moving_points = movingData.getPointSet('Centerline').copy() fixed_bif = db.getBifurcation(fixed_points) moving_bif = db.getBifurcation(moving_points) if useMask: mask_points = movingData.getPointSet('Mask') for point in mask_points: moving_points = npy.delete( moving_points, npy.where( (npy.abs(moving_points[:, 2] - point[2]) < 0.0001) & (npy.round(moving_points[:, -1]) == point[3])), axis=0) fixed_res = fixedData.getResolution().tolist() moving_res = movingData.getResolution().tolist() fixed_points = fixed_points[npy.where(fixed_points[:, 0] >= 0)] moving_points = moving_points[npy.where(moving_points[:, 0] >= 0)] # Use the bifurcation as the initial position if (fixed_bif < 0) or (moving_bif < 0): fixed_min = 0 # Augmentation of pointset fixed = fixed_points.copy() moving = moving_points.copy() if index == 1 and aug: fixed = util.augmentCenterline(fixed, 1, 10) moving = util.augmentCenterline(moving, 1, 10) fix_dis = util.getAxisSin(fixed, 3 / fixed_res[2]) * distance_fix mov_dis = util.getAxisSin(moving, 3 / moving_res[2]) * distance_mov fixed = util.resampleCenterline(fixed, fix_dis / fixed_res[2]) moving = util.resampleCenterline(moving, mov_dis / moving_res[2]) fixed = fixed[npy.cast[npy.int32](npy.abs(fixed[:, 2] - fixed_bif)) % down_fix == 0] moving = moving[npy.cast[npy.int32](npy.abs(moving[:, 2] - moving_bif)) % down_mov == 0] fixed[:, :3] *= fixed_res[:3] moving[:, :3] *= moving_res[:3] if (fixed_bif >= 0) and (moving_bif >= 0): fixed[:, 2] -= (fixed_bif * fixed_res[2] - moving_bif * moving_res[2] + delta) # Prepare for ICP LandmarkTransform = vtk.vtkLandmarkTransform() LandmarkTransform.SetModeToRigidBody() MaxIterNum = 50 #MaxNum = 600 MaxNum = int(MaxRate * moving.shape[0] + 0.5) targetPoints = [vtk.vtkPoints(), vtk.vtkPoints(), vtk.vtkPoints()] targetVertices = [ vtk.vtkCellArray(), vtk.vtkCellArray(), vtk.vtkCellArray() ] target = [vtk.vtkPolyData(), vtk.vtkPolyData(), vtk.vtkPolyData()] Locator = [ vtk.vtkCellLocator(), vtk.vtkCellLocator(), vtk.vtkCellLocator() ] for i in range(3): for x in fixed[npy.round(fixed[:, 3]) == i]: id = targetPoints[i].InsertNextPoint(x[0], x[1], x[2]) targetVertices[i].InsertNextCell(1) targetVertices[i].InsertCellPoint(id) target[i].SetPoints(targetPoints[i]) target[i].SetVerts(targetVertices[i]) Locator[i].SetDataSet(target[i]) Locator[i].SetNumberOfCellsPerBucket(1) Locator[i].BuildLocator() step = 1 if moving.shape[0] > MaxNum: ind = moving[:, 2].argsort() moving = moving[ind, :] step = moving.shape[0] / MaxNum nb_points = moving.shape[0] / step accumulate = vtk.vtkTransform() accumulate.PostMultiply() points1 = vtk.vtkPoints() points1.SetNumberOfPoints(nb_points) label = npy.zeros([MaxNum * 2], dtype=npy.int8) j = 0 for i in range(nb_points): points1.SetPoint(i, moving[j][0], moving[j][1], moving[j][2]) label[i] = moving[j][3] j += step closestp = vtk.vtkPoints() closestp.SetNumberOfPoints(nb_points) points2 = vtk.vtkPoints() points2.SetNumberOfPoints(nb_points) id1 = id2 = vtk.mutable(0) dist = vtk.mutable(0.0) outPoint = [0.0, 0.0, 0.0] p1 = [0.0, 0.0, 0.0] p2 = [0.0, 0.0, 0.0] iternum = 0 a = points1 b = points2 w_mat = [[1, w_wrong, w_wrong], [w_wrong, 1, 99999999], [w_wrong, 99999999, 1]] while True: for i in range(nb_points): min_dist = 99999999 min_outPoint = [0.0, 0.0, 0.0] for j in range(3): Locator[j].FindClosestPoint(a.GetPoint(i), outPoint, id1, id2, dist) dis = npy.sqrt( npy.sum((npy.array(outPoint) - a.GetPoint(i))**2)) if dis * w_mat[label[i]][j] < min_dist: min_dist = dis * w_mat[label[i]][j] min_outPoint = copy.deepcopy(outPoint) closestp.SetPoint(i, min_outPoint) LandmarkTransform.SetSourceLandmarks(a) LandmarkTransform.SetTargetLandmarks(closestp) LandmarkTransform.Update() accumulate.Concatenate(LandmarkTransform.GetMatrix()) iternum += 1 if iternum >= MaxIterNum: break for i in range(nb_points): a.GetPoint(i, p1) LandmarkTransform.InternalTransformPoint(p1, p2) b.SetPoint(i, p2) b, a = a, b time2 = time.time() # Get the result transformation parameters matrix = accumulate.GetMatrix() T = ml.mat([ matrix.GetElement(0, 3), matrix.GetElement(1, 3), matrix.GetElement(2, 3) ]).T R = ml.mat([[ matrix.GetElement(0, 0), matrix.GetElement(0, 1), matrix.GetElement(0, 2) ], [ matrix.GetElement(1, 0), matrix.GetElement(1, 1), matrix.GetElement(1, 2) ], [ matrix.GetElement(2, 0), matrix.GetElement(2, 1), matrix.GetElement(2, 2) ]]).I if (fixed_bif >= 0) and (moving_bif >= 0): T[2] += (fixed_bif * fixed_res[2] - moving_bif * moving_res[2] + delta) # Resample the moving contour moving_points = movingData.getPointSet('Contour').copy() moving_center = movingData.getPointSet('Centerline').copy() new_trans_points, result_center_points = moving_points, moving_center result_center_points[:, :3] = util.applyTransformForPoints( result_center_points[:, :3], moving_res, fixed_res, R, T, ml.zeros([3, 1], dtype=npy.float32)) new_trans_points[:, :3] = util.applyTransformForPoints( new_trans_points[:, :3], moving_res, fixed_res, R, T, ml.zeros([3, 1], dtype=npy.float32)) T = -T T = R * T transform = sitk.Transform(3, sitk.sitkAffine) para = R.reshape(1, -1).tolist()[0] + T.T.tolist()[0] transform.SetParameters(para) movingImage = movingData.getSimpleITKImage() fixedImage = fixedData.getSimpleITKImage() resultImage = sitk.Resample(movingImage, fixedImage, transform, sitk.sitkLinear, 0, sitk.sitkFloat32) if isTime: return sitk.GetArrayFromImage(resultImage), { 'Contour': new_trans_points, 'Centerline': result_center_points }, para + [0, 0, 0], time2 - time1 return sitk.GetArrayFromImage(resultImage), { 'Contour': new_trans_points, 'Centerline': result_center_points }, para + [0, 0, 0]
def __init__(self, comedi, config_dict): """ @param comedi: Instance of comedi that will be used to update GUI and views. @param config_dict: This dict, part of the main module config, will be kept up to date throughout. """ self._comedi = comedi self._cfg = config_dict # if we get an empty config dict, configure! if 'data1_landmarks' not in self._cfg: self._cfg['data1_landmarks'] = {} # do the list cp = comedi._view_frame.pane_controls.window r1 = comedi._data1_slice_viewer.renderer self._data1_landmarks = \ LandmarkList( self._cfg['data1_landmarks'], cp.data1_landmarks_olv, r1) if 'data2_landmarks' not in self._cfg: self._cfg['data2_landmarks'] = {} r2 = comedi._data2_slice_viewer.renderer self._data2_landmarks = \ LandmarkList( self._cfg['data2_landmarks'], cp.data2_landmarks_olv, r2) self._setup_ui() self._bind_events() # we'll use this to store a binding to the current output self._output = None # and this to store a binding to the current confidence self._confidence = None # remember, this turns out to be the transform itself self._landmark = vtk.vtkLandmarkTransform() # and this guy is going to do the work self._trfm = vtk.vtkImageReslice() self._trfm.SetInterpolationModeToLinear() # setup a progress message: module_utils.setup_vtk_object_progress( self._comedi, self._trfm, 'Transforming Data 2') # distance field will be calculated up to this distance, # saving you time and money! if KEY_MAX_DISTANCE not in self._cfg: self._cfg[KEY_MAX_DISTANCE] = 43 md = self._cfg[KEY_MAX_DISTANCE] print "sslm starting itk init" # use itk fast marching to generate confidence field self._fm = itk.FastMarchingImageFilter.IF3IF3.New() self._fm.SetStoppingValue(md) self._fm.SetSpeedConstant(1.0) # setup a progress message print "sslm fm progress start" itk_kit.utils.setup_itk_object_progress( self, self._fm, 'itkFastMarchingImageFilter', 'Propagating confidence front.', None, comedi._module_manager) print "sslm fm progress end" # and a threshold to clip off the really high values that fast # marching inserts after its max distance self._thresh = t = itk.ThresholdImageFilter.IF3.New() t.SetOutsideValue(md) # values equal to or greater than this are set to outside value t.ThresholdAbove(md) itk_kit.utils.setup_itk_object_progress( self, self._thresh, 'itkThresholdImageFilter', 'Clipping high values in confidence field.', None, comedi._module_manager) t.SetInput(self._fm.GetOutput()) # and a little something to convert it back to VTK world self._itk2vtk = itk.ImageToVTKImageFilter.IF3.New() self._itk2vtk.SetInput(t.GetOutput()) print "sslm mm init end"
## delny.Update() # read source landmarks SourceLMReader = vtk.vtkPolyDataReader() SourceLMReader.SetFileName("DefaultLandmarks.vtk") SourceLMReader.Update() #print SourceLMReader.GetOutput().GetPoints() # read target landmarks TargetLMReader = vtk.vtkPolyDataReader() TargetLMReader.SetFileName("TargetLandmarks.vtk") TargetLMReader.Update() #print TargetLMReader.GetOutput().GetPoints() # create transformation LandmarkTransform = vtk.vtkLandmarkTransform() LandmarkTransform.SetSourceLandmarks(SourceLMReader.GetOutput().GetPoints()) LandmarkTransform.SetTargetLandmarks(TargetLMReader.GetOutput().GetPoints()) LandmarkTransform.SetModeToRigidBody() LandmarkTransform.Update() print LandmarkTransform.GetMatrix() # apply transform transformFilter = vtk.vtkTransformFilter() #transformFilter.SetInput(vtkCylinder.GetOutput() ) transformFilter.SetInput(trianglefilter.GetOutput()) transformFilter.SetTransform(LandmarkTransform) transformFilter.Update() # write model modelWriter = vtk.vtkDataSetWriter()
def distanceAndAngleCompute(self, num=7): pSourcePoints = vtk.vtkPoints() pTargetPoints = vtk.vtkPoints() # 求取术后空间到术前空间的转换矩阵 for i in range(num): pTargetPoints.InsertPoint(i, self.preoperative[i][0], self.preoperative[i][1], self.preoperative[i][2]) pSourcePoints.InsertPoint(i, self.postoperative[i][0], self.postoperative[i][1], self.postoperative[i][2]) # 将种植体的植入点和跟尖点加入 pSourcePoints.InsertPoint(num, self.ImplantPosition[0][3], self.ImplantPosition[0][4], self.ImplantPosition[0][5]) pSourcePoints.InsertPoint(num + 1, self.ImplantPosition[1][3], self.ImplantPosition[1][4], self.ImplantPosition[1][5]) pTargetPoints.InsertPoint(num, self.ImplantPosition[0][0], self.ImplantPosition[0][1], self.ImplantPosition[0][2]) pTargetPoints.InsertPoint(num + 1, self.ImplantPosition[1][0], self.ImplantPosition[1][1], self.ImplantPosition[1][2]) landmarkTransform = vtk.vtkLandmarkTransform() landmarkTransform.SetSourceLandmarks(pSourcePoints) landmarkTransform.SetTargetLandmarks(pTargetPoints) landmarkTransform.SetModeToRigidBody() landmarkTransform.Update() matrix = landmarkTransform.GetMatrix() matrix_np = self.arrayFromVTKMatrix(matrix) for i in range(4): for j in range(4): print("{:10.7f}".format(matrix.GetElement(i, j)), end=", ") print("") post_root = np.array([ self.ImplantPosition[1][3], self.ImplantPosition[1][4], self.ImplantPosition[1][5], 1 ]) post_implant = np.array([ self.ImplantPosition[0][3], self.ImplantPosition[0][4], self.ImplantPosition[0][5], 1 ]) # print("术后植入点 ", post_implant) # print("术后跟尖点 ", post_root) post_implant = np.matmul(matrix_np, post_implant) post_root = np.matmul(matrix_np, post_root) post_implant = post_implant[0:3] post_root = post_root[0:3] pre_root = np.array([ self.ImplantPosition[1][0], self.ImplantPosition[1][1], self.ImplantPosition[1][2] ]) pre_implant = np.array([ self.ImplantPosition[0][0], self.ImplantPosition[0][1], self.ImplantPosition[0][2] ]) print("术前植入点 ", pre_implant) print("术前跟尖点 ", pre_root) print("术后植入点 ", post_implant) print("术后跟尖点 ", post_root) print("植入点之间的距离偏差 ", np.linalg.norm(pre_implant - post_implant)) print("根尖点之间的距离偏差 ", np.linalg.norm(pre_root - post_root)) angle = vtk.vtkMath().AngleBetweenVectors(pre_root - pre_implant, post_root - post_implant) print("角度偏差 ", math.degrees(angle)) print(Style.RESET_ALL)
def performAffineAndThinPlateRegistration(self, state, landmarks): """Perform Affine registration first, use the transformed result as the input of the thin plate transform""" # if state.transformed: # if state.transformed.GetTransformNodeID() != state.transform.GetID(): # state.transformed.SetAndObserveTransformNodeID(state.transform.GetID()) volumeNodes = (state.fixed, state.moving) fiducialNodes = (state.fixedFiducials,state.movingFiducials) points = state.logic.vtkPointsForVolumes( volumeNodes, fiducialNodes ) #yingli debug #print 'self.linearMode',self.linearMode if not self.landmarkTransform: self.landmarkTransform = vtk.vtkLandmarkTransform() if self.linearMode == 'Rigid': self.landmarkTransform.SetModeToRigidBody() if self.linearMode == 'Similarity': self.landmarkTransform.SetModeToSimilarity() if self.linearMode == 'Affine': self.landmarkTransform.SetModeToAffine() if state.fixedFiducials.GetNumberOfFiducials() < 3: self.landmarkTransform.SetModeToRigidBody() self.landmarkTransform.SetSourceLandmarks(points[state.moving]) self.landmarkTransform.SetTargetLandmarks(points[state.fixed]) self.landmarkTransform.Update() #transform moving landmarks affine_transformed_moving_points = vtk.vtkPoints() self.landmarkTransform.TransformPoints(points[state.moving],affine_transformed_moving_points) #yingli debug #print self.landmarkTransform.GetMatrix() #print 'old moving', points[state.moving].GetPoint(0) #print 'new moving', affine_transformed_moving_points.GetPoint(0) # do thin plate, use affine transformed result as the input # since this is a resample transform, source is the fixed (resampling target) space # and moving is the target space if not self.thinPlateTransform: self.thinPlateTransform = vtk.vtkThinPlateSplineTransform() self.thinPlateTransform.SetBasisToR() # for 3D transform self.thinPlateTransform.SetSourceLandmarks(affine_transformed_moving_points) self.thinPlateTransform.SetTargetLandmarks(points[state.fixed]) self.thinPlateTransform.Update() if points[state.moving].GetNumberOfPoints() != points[state.fixed].GetNumberOfPoints(): raise hell #add nesting transfrom: order matters! transformSelector = slicer.qMRMLNodeComboBox() transformSelector.nodeTypes = ( ("vtkMRMLTransformNode"), "" ) transformSelector.selectNodeUponCreation = True transformSelector.addEnabled = True transformSelector.removeEnabled = True transformSelector.noneEnabled = True transformSelector.showHidden = False transformSelector.showChildNodeTypes = False transformSelector.setMRMLScene( slicer.mrmlScene ) transformSelector.setToolTip( "The transform for linear registration" ) transformSelector.enabled = False # concatenate transfroms: method 1: add nesting transfrom: order matters! # note: this method will keep each transform(not ideal) # landmarkTransformNode = slicer.util.getNode('Affine-Transform') # if not landmarkTransformNode: # landmarkTransformNode=transformSelector.addNode() # landmarkTransformNode.SetName('Affine-Transform') # state.transform.SetAndObserveTransformNodeID(landmarkTransformNode.GetID()) # landmarkTransformNode.ApplyTransform(self.landmarkTransform) # thinPlateTransformNode = slicer.util.getNode('ThinPlate-Transform') # if not thinPlateTransformNode: # thinPlateTransformNode=transformSelector.addNode() # thinPlateTransformNode.SetName('ThinPlate-Transform') # landmarkTransformNode.SetAndObserveTransformNodeID(thinPlateTransformNode.GetID()) # # thinPlateTransformNode.ApplyTransform(self.thinPlateTransform) #state.transform.SetAndObserveTransformToParent(self.landmarkTransform) # #state.transform.SetAndObserveTransformToParent(self.thinPlateTransform) # stateTransformNodeNode = slicer.util.getNode('Transform') # stateTransformNodeNode.SetAndObserveTransformToParent(self.thinPlateTransform) #test vtk concatenate #self.landmarkTransform.Concatenate(self.landmarkTransform) #state.transform.SetAndObserveTransformToParent(self.thinPlateTransform) #concatenate transfroms: method 2: use vtkGeneralTransform to concatenate transfroms. transform = vtk.vtkGeneralTransform() transform.Concatenate(self.thinPlateTransform) transform.Concatenate(self.landmarkTransform) state.transform.SetAndObserveTransformToParent(transform)
def ComputeCalibration(self, usCalibrationNode, listNode, eventid): #Ignore listnode and eventid if (usCalibrationNode is None): return markedPointsList = usCalibrationNode.GetNodeReference( ImagelessUSCalibrationWidget.MARKED_POINTS_ROLE) unmarkedPointsList = usCalibrationNode.GetNodeReference( ImagelessUSCalibrationWidget.UNMARKED_POINTS_ROLE) if (markedPointsList is None or unmarkedPointsList is None): return if (markedPointsList.GetNumberOfFiducials() < 2): usCalibrationNode.SetAttribute( ImagelessUSCalibrationWidget.OUTPUT_MESSAGE_ROLE, "Insufficient number of marked corner points selected.") return if (unmarkedPointsList.GetNumberOfFiducials() < 2): usCalibrationNode.SetAttribute( ImagelessUSCalibrationWidget.OUTPUT_MESSAGE_ROLE, "Insufficient number of unmarked corner points selected.") return # Assume the ordering of points is: # Unmarked near, marked near, unmarked far, marked far # Find the points in the probe coordinate system markedCorner1 = [0, 0, 0] markedPointsList.GetNthFiducialPosition(0, markedCorner1) markedCorner2 = [0, 0, 0] markedPointsList.GetNthFiducialPosition(1, markedCorner2) unmarkedCorner1 = [0, 0, 0] unmarkedPointsList.GetNthFiducialPosition(0, unmarkedCorner1) unmarkedCorner2 = [0, 0, 0] unmarkedPointsList.GetNthFiducialPosition(1, unmarkedCorner2) # Find the near points markedNearPoint = [0, 0, 0] vtk.vtkMath.Add(markedCorner1, markedCorner2, markedNearPoint) vtk.vtkMath.MultiplyScalar(markedNearPoint, 0.5) unmarkedNearPoint = [0, 0, 0] vtk.vtkMath.Add(unmarkedCorner1, unmarkedCorner2, unmarkedNearPoint) vtk.vtkMath.MultiplyScalar(unmarkedNearPoint, 0.5) # Find the vector required for computing the far points markedUnmarkedVector = [0, 0, 0] vtk.vtkMath.Subtract(unmarkedNearPoint, markedNearPoint, markedUnmarkedVector) markedCornerVector = [0, 0, 0] vtk.vtkMath.Subtract(markedCorner2, markedCorner1, markedCornerVector) unmarkedCornerVector = [0, 0, 0] vtk.vtkMath.Subtract(unmarkedCorner2, unmarkedCorner1, unmarkedCornerVector) markedFarVector = [0, 0, 0] vtk.vtkMath.Cross(markedUnmarkedVector, markedCornerVector, markedFarVector) vtk.vtkMath.Normalize(markedFarVector) unmarkedFarVector = [0, 0, 0] vtk.vtkMath.Cross(markedUnmarkedVector, unmarkedCornerVector, unmarkedFarVector) vtk.vtkMath.Normalize(unmarkedFarVector) # Compute the far points try: depth = float( usCalibrationNode.GetAttribute( ImagelessUSCalibrationWidget.DEPTH_ROLE)) except TypeError: usCalibrationNode.SetAttribute( ImagelessUSCalibrationWidget.OUTPUT_MESSAGE_ROLE, "Depth improperly specified.") return vtk.vtkMath.MultiplyScalar(markedFarVector, depth) markedFarPoint = [0, 0, 0] vtk.vtkMath.Add(markedNearPoint, markedFarVector, markedFarPoint) vtk.vtkMath.MultiplyScalar(unmarkedFarVector, depth) unmarkedFarPoint = [0, 0, 0] vtk.vtkMath.Add(unmarkedNearPoint, unmarkedFarVector, unmarkedFarPoint) # Now, we can assemble the probe points probePoints = vtk.vtkPoints() probePoints.InsertNextPoint(unmarkedNearPoint) probePoints.InsertNextPoint(markedNearPoint) probePoints.InsertNextPoint(unmarkedFarPoint) probePoints.InsertNextPoint(markedFarPoint) # Compute the scaling factor usImageNode = usCalibrationNode.GetNodeReference( ImagelessUSCalibrationWidget.ULTRASOUND_IMAGE_ROLE) if (usImageNode is None or usImageNode.GetImageData() is None): usCalibrationNode.SetAttribute( ImagelessUSCalibrationWidget.OUTPUT_MESSAGE_ROLE, "No ultrasound image is selected.") return # The scale is the ratio of depth to y pixels usImageDimensions = [0, 0, 0] usImageNode.GetImageData().GetDimensions(usImageDimensions) pixelsToMmScale = depth / usImageDimensions[1] # y dimension imagePixelToImageMm = vtk.vtkTransform() imagePixelToImageMm.Scale( [pixelsToMmScale, pixelsToMmScale, pixelsToMmScale]) # Uniform scaling - similarity transform print pixelsToMmScale # Next, we can assembla the image points imagePoints_ImageMm = vtk.vtkPoints() imagePoints_ImageMm.InsertNextPoint([0, 0, 0]) imagePoints_ImageMm.InsertNextPoint( [usImageDimensions[0] * pixelsToMmScale, 0, 0]) imagePoints_ImageMm.InsertNextPoint([0, depth, 0]) imagePoints_ImageMm.InsertNextPoint( [usImageDimensions[0] * pixelsToMmScale, depth, 0]) # Compute the transform (without the scaling) imageToProbeTransformNode = usCalibrationNode.GetNodeReference( ImagelessUSCalibrationWidget.IMAGE_TO_PROBE_TRANSFORM_ROLE) if (imageToProbeTransformNode is None): usCalibrationNode.SetAttribute( ImagelessUSCalibrationWidget.OUTPUT_MESSAGE_ROLE, "No output ImageToProbe transform specified.") return imageMmToProbe = vtk.vtkLandmarkTransform() imageMmToProbe.SetSourceLandmarks(imagePoints_ImageMm) imageMmToProbe.SetTargetLandmarks(probePoints) imageMmToProbe.SetModeToRigidBody() imageMmToProbe.Update() # The overall ImageToProbe = ImageMmToProbe * ImagePixelToImageMm imageToProbeTransform = vtk.vtkTransform() imageToProbeTransform.PreMultiply() imageToProbeTransform.Concatenate(imageMmToProbe) imageToProbeTransform.Concatenate(imagePixelToImageMm) imageToProbeMatrix = vtk.vtkMatrix4x4() imageToProbeTransform.GetMatrix(imageToProbeMatrix) imageToProbeTransformNode.SetMatrixTransformToParent( imageToProbeMatrix) usCalibrationNode.SetAttribute( ImagelessUSCalibrationWidget.OUTPUT_MESSAGE_ROLE, "Success!")
def GetApplicatorTransform(pointtip,pointentry,SourceLandmarkFileName, TargetLandmarkFileName ): ApplicatorTipLength = .011 #m # template applicator center at coordinate (0, 0., 0. ) m # template applicator distal ends at coordinates (0, 0.,+/- ApplicatorTipLength/2. ) m originalOrientation = vtk.vtkPoints() originalOrientation.SetNumberOfPoints(2) originalOrientation.SetPoint(0,0.,0., 0. ) originalOrientation.SetPoint(1,0.,0., ApplicatorTipLength/2.) slicerLength = numpy.linalg.norm( numpy.array(pointentry) - numpy.array(pointtip) ) unitdirection = 1./slicerLength * (numpy.array(pointentry) - numpy.array(pointtip) ) pointscaled = pointtip + ApplicatorTipLength/2. * unitdirection print "points", pointentry, pointtip, pointscaled, slicerLength, numpy.linalg.norm( unitdirection ), numpy.linalg.norm( pointscaled - pointtip ) slicerOrientation = vtk.vtkPoints() slicerOrientation.SetNumberOfPoints(2) slicerOrientation.SetPoint(0,pointscaled[0],pointscaled[1],pointscaled[2] ) slicerOrientation.SetPoint(1,pointtip[ 0],pointtip[ 1],pointtip[ 2] ) # write landmarks to file WriteVTKPoints(originalOrientation,SourceLandmarkFileName) WriteVTKPoints(slicerOrientation ,TargetLandmarkFileName) ApplicatorLineTransform = vtk.vtkLandmarkTransform() ApplicatorLineTransform.SetModeToRigidBody() ApplicatorLineTransform.SetSourceLandmarks(originalOrientation) ApplicatorLineTransform.SetTargetLandmarks(slicerOrientation ) ApplicatorLineTransform.Update() print ApplicatorLineTransform.GetMatrix() # create model of applicator ApplicatorLength = .10 #m vtkCylinder = vtk.vtkCylinderSource() vtkCylinder.SetHeight( ApplicatorLength ); vtkCylinder.SetRadius( .00075 ); vtkCylinder.SetCenter(0.0, 0.0, 0.0 ); vtkCylinder.SetResolution(16); vtkCylinder.SetCapping(1); # model orientation modelOrientation = vtk.vtkPoints() modelOrientation.SetNumberOfPoints(2) modelOrientation.SetPoint(0, 0., 0. ,0. ) modelOrientation.SetPoint(1, 0.,-ApplicatorLength/2.,0. ) ModelLineTransform = vtk.vtkLandmarkTransform() ModelLineTransform.SetModeToRigidBody() ModelLineTransform.SetSourceLandmarks(modelOrientation ) ModelLineTransform.SetTargetLandmarks(slicerOrientation ) ModelLineTransform.Update() print ModelLineTransform.GetMatrix() # transform slicertransformFilter = vtk.vtkTransformFilter() slicertransformFilter.SetInput(vtkCylinder.GetOutput() ) slicertransformFilter.SetTransform( ModelLineTransform ) slicertransformFilter.Update() apppolyData=slicertransformFilter.GetOutput(); # write model to file vtkModelWriter = vtk.vtkDataSetWriter() vtkModelWriter.SetInput(apppolyData) vtkModelWriter.SetFileName("applicator.vtk") vtkModelWriter.SetFileTypeToBinary() vtkModelWriter.Write() # return transform return ApplicatorLineTransform
def ICP(args): # This method takes one source surface files and ICP align it to a set of target surfaces. targetNameList = args[0] # List of target names sourceSurfaceFile = args[1] # name and full path of the source surface. dirSurface = args[2] # Path of the surface files. dirOutputSurface = args[3] # Output path the aligned source surfaces. dirLandmark = args[4] #Path of the landmark files sourceLandmarkFile = args[5] dirOutputLandmarks = args[6] sourceName = sourceSurfaceFile.split('\\')[-1][:-4] #sourceSurfaceFile = os.path.join(dirSurface,sourceName + '.vtk') targetSurfaceFile = os.path.join(dirSurface, targetNameList + '.vtk') filename = os.path.join(dirOutputSurface, targetNameList + '.vtk') # Reading surfaces reader = vtk.vtkPolyDataReader() reader.SetFileName(sourceSurfaceFile) reader.Update() sourceSurface = reader.GetOutput() reader = vtk.vtkPolyDataReader() reader.SetFileName(targetSurfaceFile) reader.Update() targetSurface = reader.GetOutput() if targetSurface.GetNumberOfPoints() < 1: print('Could not read', targetSurfaceFile) return #------------------------------------------------------------------------------------------------ # Reading landmarks targetLandmarkFile = os.path.join(dirLandmark, targetNameList + '.txt') targetLandmarks = ((np.loadtxt(targetLandmarkFile, skiprows=2))) if not os.path.isfile(sourceLandmarkFile): print('\nSource Surface: %s has no landmarks file' % sourceName) return np.float64(), np.float64() sourceLandmarks = ((np.loadtxt(sourceLandmarkFile, skiprows=2))) numberOfLandmarks = np.size(targetLandmarks, 0) # Set points in vtk sourcePoints = vtk.vtkPoints() for point in sourceLandmarks: sourcePoints.InsertNextPoint(point) source = vtk.vtkPolyData() source.SetPoints(sourcePoints) targetPoints = vtk.vtkPoints() for point in targetLandmarks: targetPoints.InsertNextPoint(point) target = vtk.vtkPolyData() target.SetPoints(targetPoints) #------------------------------------------------------------------------------------------------ # Find landmark transformation landmarkTransform = vtk.vtkLandmarkTransform() landmarkTransform.SetSourceLandmarks(sourcePoints) landmarkTransform.SetTargetLandmarks(targetPoints) landmarkTransform.SetModeToSimilarity() landmarkTransform.Update() # Apply landmarks transformation to source surface TransformFilter = vtk.vtkTransformPolyDataFilter() TransformFilter.SetInputData(sourceSurface) TransformFilter.SetTransform(landmarkTransform) TransformFilter.Update() transformedSourceSurface = TransformFilter.GetOutput() # Apply landmarks transformation to source landmarks TransformFilter = vtk.vtkTransformPolyDataFilter() TransformFilter.SetInputData(source) TransformFilter.SetTransform(landmarkTransform) TransformFilter.Update() transformedSourceLandmarks = TransformFilter.GetOutput() #------------------------------------------------------------------------------------------------ # Find icp transformation icp = vtk.vtkIterativeClosestPointTransform() icp.SetSource(transformedSourceSurface) icp.SetTarget(targetSurface) icp.GetLandmarkTransform().SetModeToRigidBody() icp.Modified() icp.Update() #------------------------------------------------------------------------------------------------ # Apply icp transformation to transformed source surface TransformFilter = vtk.vtkTransformPolyDataFilter() TransformFilter.SetInputData(transformedSourceSurface) TransformFilter.SetTransform(icp) TransformFilter.Update() icptransformedSourceSurface = TransformFilter.GetOutput() # Apply icp transformation to transformed source landmarks TransformFilter = vtk.vtkTransformPolyDataFilter() TransformFilter.SetInputData(transformedSourceLandmarks) TransformFilter.SetTransform(icp) TransformFilter.Update() icptransformedSourceLandmarks = TransformFilter.GetOutput() #=========================================================================== # RMS_transformedSurface = Metrics.RMS(icptransformedSourceSurface,targetSurface,VTKobj=True) # RMS_SourceTarget = Metrics.RMS(sourceSurface,targetSurface,VTKobj=True) #=========================================================================== #------------------------------------------------------------------------------------------------ # Write transformed source surface to .vtk file writer = vtk.vtkPolyDataWriter() writer.SetInputData(icptransformedSourceSurface) #writer.SetInputData(transformedSourceSurface) writer.SetFileName(filename) writer.Write() # Write transformed landmarks to .txt file readable by elastix npTranformedLandmarks = np.zeros([numberOfLandmarks, 3]) for index in range(numberOfLandmarks): point = [0, 0, 0] icptransformedSourceLandmarks.GetPoint(index, point) #transformedSourceLandmarks.GetPoint(index, point) npTranformedLandmarks[index, :] = point filename = os.path.join(dirOutputLandmarks, targetNameList + '.txt') with open(filename, 'w+') as f: f.write('point\n') f.write(str(numberOfLandmarks)) for idx in range(numberOfLandmarks): f.write('\n' + str(npTranformedLandmarks[idx, 0]) + ' ') for Val in npTranformedLandmarks[idx, 1:]: f.write(str(Val) + ' ')
def register(self, fixedData, movingData, index = -1, discard = False, delta = 0, fov = 9999999.0, down_fix = 1, down_mov = 1, occ = 9999999.0, op = False, useMask = False, isTime = False, MaxRate = 0.2, aug = False, distance_fix = 0.3, distance_mov = 0.1): time1 = time.time() if index == -1: index = self.gui.getDataIndex({'Contour': 0, 'Centerline': 1}, 'Select the object') if index is None: return None, None, None if index == 0: fixed_points = fixedData.getPointSet('Contour').copy() moving_points = movingData.getPointSet('Contour').copy() else: fixed_points = fixedData.getPointSet('Centerline').copy() moving_points = movingData.getPointSet('Centerline').copy() fixed_bif = db.getBifurcation(fixed_points) moving_bif = db.getBifurcation(moving_points) if useMask: mask_points = movingData.getPointSet('Mask') for point in mask_points: moving_points = npy.delete(moving_points, npy.where((npy.abs(moving_points[:, 2] - point[2]) < 0.0001) & (npy.round(moving_points[:, -1]) == point[3])), axis = 0) fixed_res = fixedData.getResolution().tolist() moving_res = movingData.getResolution().tolist() fixed_points = fixed_points[npy.where(fixed_points[:, 0] >= 0)] moving_points = moving_points[npy.where(moving_points[:, 0] >= 0)] # Use the bifurcation as the initial position if (fixed_bif < 0) or (moving_bif < 0): fixed_min = 0 # Augmentation of pointset fixed = fixed_points.copy() moving = moving_points.copy() if index == 1 and aug: fixed = util.augmentCenterline(fixed, 1, 10) moving = util.augmentCenterline(moving, 1, 10) fix_dis = util.getAxisSin(fixed, 3 / fixed_res[2]) * distance_fix mov_dis = util.getAxisSin(moving, 3 / moving_res[2]) * distance_mov fixed = util.resampleCenterline(fixed, fix_dis / fixed_res[2]) moving = util.resampleCenterline(moving, mov_dis / moving_res[2]) fixed = fixed[npy.cast[npy.int32](npy.abs(fixed[:, 2] - fixed_bif)) % down_fix == 0] moving = moving[npy.cast[npy.int32](npy.abs(moving[:, 2] - moving_bif)) % down_mov == 0] fixed[:, :3] *= fixed_res[:3] moving[:, :3] *= moving_res[:3] if (fixed_bif >= 0) and (moving_bif >= 0): fixed[:, 2] -= (fixed_bif * fixed_res[2] - moving_bif * moving_res[2] + delta) # Prepare for ICP LandmarkTransform = vtk.vtkLandmarkTransform() LandmarkTransform.SetModeToRigidBody() MaxIterNum = 50 #MaxNum = 600 MaxNum = int(MaxRate * moving.shape[0] + 0.5) targetPoints = [vtk.vtkPoints(), vtk.vtkPoints(), vtk.vtkPoints()] targetVertices = [vtk.vtkCellArray(), vtk.vtkCellArray(), vtk.vtkCellArray()] target = [vtk.vtkPolyData(), vtk.vtkPolyData(), vtk.vtkPolyData()] Locator = [vtk.vtkCellLocator(), vtk.vtkCellLocator(), vtk.vtkCellLocator()] if index == 0: if not op: label_dis = [3, 3, 3] else: label_dis = [3, 2, 1] else: if op: label_dis = [3, 3, 3] else: label_dis = [3, 2, 1] for i in range(3): for x in fixed[npy.round(fixed[:, 3]) != label_dis[i]]: id = targetPoints[i].InsertNextPoint(x[0], x[1], x[2]) targetVertices[i].InsertNextCell(1) targetVertices[i].InsertCellPoint(id) target[i].SetPoints(targetPoints[i]) target[i].SetVerts(targetVertices[i]) Locator[i].SetDataSet(target[i]) Locator[i].SetNumberOfCellsPerBucket(1) Locator[i].BuildLocator() step = 1 if moving.shape[0] > MaxNum: ind = moving[:, 2].argsort() moving = moving[ind, :] step = moving.shape[0] / MaxNum nb_points = moving.shape[0] / step accumulate = vtk.vtkTransform() accumulate.PostMultiply() points1 = vtk.vtkPoints() points1.SetNumberOfPoints(nb_points) label = npy.zeros([MaxNum * 2], dtype = npy.int8) j = 0 for i in range(nb_points): points1.SetPoint(i, moving[j][0], moving[j][1], moving[j][2]) label[i] = moving[j][3] j += step closestp = vtk.vtkPoints() closestp.SetNumberOfPoints(nb_points) points2 = vtk.vtkPoints() points2.SetNumberOfPoints(nb_points) id1 = id2 = vtk.mutable(0) dist = vtk.mutable(0.0) outPoint = [0.0, 0.0, 0.0] p1 = [0.0, 0.0, 0.0] p2 = [0.0, 0.0, 0.0] iternum = 0 a = points1 b = points2 ''' path = sys.argv[0] if os.path.isfile(path): path = os.path.dirname(path) path += '/Data/Transform' wfile = open("%s/transform.txt" % path, 'w') matrix = accumulate.GetMatrix() T = ml.mat([matrix.GetElement(0, 3), matrix.GetElement(1, 3), matrix.GetElement(2, 3)]).T; R = ml.mat([[matrix.GetElement(0, 0), matrix.GetElement(0, 1), matrix.GetElement(0, 2)], [matrix.GetElement(1, 0), matrix.GetElement(1, 1), matrix.GetElement(1, 2)], [matrix.GetElement(2, 0), matrix.GetElement(2, 1), matrix.GetElement(2, 2)]]).I if (fixed_bif >= 0) and (moving_bif >= 0): T[2] += (fixed_bif * fixed_res[2] - moving_bif * moving_res[2] + delta) saveTransform(wfile, T, R) ''' while True: for i in range(nb_points): Locator[label[i]].FindClosestPoint(a.GetPoint(i), outPoint, id1, id2, dist) closestp.SetPoint(i, outPoint) LandmarkTransform.SetSourceLandmarks(a) LandmarkTransform.SetTargetLandmarks(closestp) LandmarkTransform.Update() accumulate.Concatenate(LandmarkTransform.GetMatrix()) iternum += 1 if iternum >= MaxIterNum: break dist_err = 0 for i in range(nb_points): a.GetPoint(i, p1) LandmarkTransform.InternalTransformPoint(p1, p2) b.SetPoint(i, p2) dist_err += npy.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2 + (p1[2] - p2[2]) ** 2) dist_err /= nb_points print "iter = %d: %f" % (iternum, dist_err) ''' matrix = accumulate.GetMatrix() T = ml.mat([matrix.GetElement(0, 3), matrix.GetElement(1, 3), matrix.GetElement(2, 3)]).T; R = ml.mat([[matrix.GetElement(0, 0), matrix.GetElement(0, 1), matrix.GetElement(0, 2)], [matrix.GetElement(1, 0), matrix.GetElement(1, 1), matrix.GetElement(1, 2)], [matrix.GetElement(2, 0), matrix.GetElement(2, 1), matrix.GetElement(2, 2)]]).I; if (fixed_bif >= 0) and (moving_bif >= 0): T[2] += (fixed_bif * fixed_res[2] - moving_bif * moving_res[2]) saveTransform(wfile, T, R) ''' b, a = a, b time2 = time.time() #wfile.close() # Get the result transformation parameters matrix = accumulate.GetMatrix() T = ml.mat([matrix.GetElement(0, 3), matrix.GetElement(1, 3), matrix.GetElement(2, 3)]).T R = ml.mat([[matrix.GetElement(0, 0), matrix.GetElement(0, 1), matrix.GetElement(0, 2)], [matrix.GetElement(1, 0), matrix.GetElement(1, 1), matrix.GetElement(1, 2)], [matrix.GetElement(2, 0), matrix.GetElement(2, 1), matrix.GetElement(2, 2)]]).I #T = ml.mat([0, 0, 0]).T #R = ml.mat([[1, 0, 0], [0, 1, 0], [0, 0, 1]]).T if (fixed_bif >= 0) and (moving_bif >= 0): T[2] += (fixed_bif * fixed_res[2] - moving_bif * moving_res[2] + delta) # Resample the moving contour moving_points = movingData.getPointSet('Contour').copy() moving_center = movingData.getPointSet('Centerline').copy() #new_trans_points, result_center_points = util.resliceTheResultPoints(moving_points, moving_center, 20, moving_res, fixed_res, discard, R, T) new_trans_points, result_center_points = moving_points, moving_center result_center_points[:, :3] = util.applyTransformForPoints(result_center_points[:, :3], moving_res, fixed_res, R, T, ml.zeros([3, 1], dtype = npy.float32)) new_trans_points[:, :3] = util.applyTransformForPoints(new_trans_points[:, :3], moving_res, fixed_res, R, T, ml.zeros([3, 1], dtype = npy.float32)) T = -T T = R * T transform = sitk.Transform(3, sitk.sitkAffine) para = R.reshape(1, -1).tolist()[0] + T.T.tolist()[0] transform.SetParameters(para) movingImage = movingData.getSimpleITKImage() fixedImage = fixedData.getSimpleITKImage() resultImage = sitk.Resample(movingImage, fixedImage, transform, sitk.sitkLinear, 0, sitk.sitkFloat32) if isTime: return sitk.GetArrayFromImage(resultImage), {'Contour': new_trans_points, 'Centerline': result_center_points}, para + [0, 0, 0], time2 - time1 return sitk.GetArrayFromImage(resultImage), {'Contour': new_trans_points, 'Centerline': result_center_points}, para + [0, 0, 0]
def createMorph(selectedImages,selectedPMs): """ Translates and rotate the bitmaps based on the shapedefining landmarks (selectedPMs) of the associated image to the target image (first image). Morphs the result so that the bitmap overlay on the first image is valid for the first image. """ #save the temporary results here later: os_temp_path = tempfile.gettempdir() #get the measurements for the first image (our targets) mainImage = OriginalImage.objects.all().get(id=selectedImages[0]) potentialids = [] #now get the associated measurements measures = Measurement.objects.all().filter(id__in=selectedPMs[0]).filter(mogelijkemeting__shapedefining=True) measures = [j for j in measures] measures.sort(key=lambda x: x.mogelijkemeting.name) coordsx = [] coordsy = [] for k, measurement in enumerate(measures): coordsx.append(float(measurement.x)) coordsy.append(float(measurement.y)) potentialids.append(measurement.mogelijkemeting.id) r1 = vtk.vtkJPEGReader() r1.SetFileName(settings.DATADIR + mainImage.id + ".jpg") r1.Update() # flip y coord (VTK has opposite convention), create 3-d coords (z=0) ydim = r1.GetOutput().GetDimensions()[1] coords = [(x, ydim - y, 0) for (x,y) in zip(coordsx, coordsy)] # convert everything to vtkPoints lmt = vtk.vtkPoints() lmt.SetNumberOfPoints(len(coords)) for i, coord in enumerate(coords): lmt.SetPoint(i,coord) #The target is clear, let's get to work, get the source images... images = [] #we don't need the first image or its measures anymore, because they don't need to be transformed or morphed selectedImages.pop(0) selectedPMs.pop(0) for id in selectedImages: images.append(OriginalImage.objects.all().get(id=id)) transformations = [] morphtransformations = [] #Create a new database object for the target image to associate the bitmaps with img = OriginalImage(project=mainImage.project, name='MorphedImage') img.save() imp = Image.open(settings.DATADIR + mainImage.id + '.jpg') imp.save(settings.DATADIR + img.id + '.jpg', 'JPEG') orig_bitmaps = Bitmap.objects.all().filter(image=mainImage) for bm in orig_bitmaps: #store bitmaps of mainImage as sub of img bitmap = Bitmap(project=img.project, name='warpedbitmap', image=img, mogelijkemeting=bm.mogelijkemeting, imagewidth=bm.imagewidth, imageheight=bm.imageheight, minx=bm.minx, miny=bm.miny, maxx=bm.maxx, maxy=bm.maxy) bitmap.save() bitmap_image = Image.open(settings.DATADIR + bm.id + '.gif') bitmap_image = bitmap_image.convert("RGBA") bitmap_image.save(settings.DATADIR + bitmap.id + '.gif', transparency=0) #now get the other images and perform our transformations for i in range(len(images)): measures = Measurement.objects.all().filter(id__in=selectedPMs[i]).filter(mogelijkemeting__shapedefining=True)#get measurements measures = [j for j in measures] measures.sort(key=lambda x: x.mogelijkemeting.name) coordsx = [] coordsy = [] for k, measurement in enumerate(measures): coordsx.append(float(measurement.x)) coordsy.append(float(measurement.y)) if potentialids[k] != measurement.mogelijkemeting.id: #the potentialmeasurements do not match up to the ones in the target image return img, 0 r = vtk.vtkJPEGReader() r.SetFileName(settings.DATADIR + images[i].id + ".jpg") r.Update() ydim = r.GetOutput().GetDimensions()[1] coordso = [(x, ydim - y, 0) for (x,y) in zip(coordsx, coordsy)] lms = vtk.vtkPoints() lms.SetNumberOfPoints(len(coordso)) for k, coord in enumerate(coordso): lms.SetPoint(k,coord) transformation = vtk.vtkLandmarkTransform() transformation.SetTargetLandmarks(lmt) lmt.Modified() transformation.SetSourceLandmarks(lms) lms.Modified() #size matters, so set the mode to Rigid Body (also known as do not scale please) transformation.SetModeToRigidBody() transformation.Inverse() transformation.Update() out = vtk.vtkPoints()#this will be the source of our morph transform transformation.TransformPoints(lms,out) transformations.append(transformation) ir = vtk.vtkImageReslice() # we're not using linear, because we want to improve the quality of the bitmaps ir.SetInterpolationModeToNearestNeighbor() ir.SetResliceTransform(transformation) ir.SetInput(r.GetOutput()) ir.SetInformationInput(r1.GetOutput()) w = vtk.vtkJPEGWriter() w.SetFileName(os_temp_path+'/translated'+images[i].id+'.jpg') w.SetInput(ir.GetOutput()) w.Write() r2 = vtk.vtkJPEGReader() r2.SetFileName(os_temp_path+'/translated'+images[i].id+'.jpg') r2.Update() # the mighty morphing ThinPlateSplineTransform morphtransform = vtk.vtkThinPlateSplineTransform() morphtransform.SetBasisToR2LogR() morphtransform.SetSourceLandmarks(lms) lms.Modified() morphtransform.SetTargetLandmarks(lmt) lmt.Modified() morphtransform.Inverse() morphtransform.Update() morphtransformations.append(morphtransform) #ir.SetInput(r2.GetOutput()) #ir.SetInformationInput(r1.GetOutput()) bitmaps = Bitmap.objects.all().filter(image=images[i]) #now perform the total transformation on all bitmaps for bm in bitmaps: location = settings.DATADIR + bm.id + ".gif" im = Image.open(location) im = im.convert("RGBA") im.save(settings.DATADIR + bm.id + ".png", "PNG") r3 = vtk.vtkPNGReader() r3.SetFileName(settings.DATADIR + bm.id + '.png') r3.Update() ir2 = vtk.vtkImageReslice() ir2.SetInterpolationModeToNearestNeighbor() ir2.SetResliceTransform(morphtransform) ir2.SetInput(r3.GetOutput()) ir2.SetInformationInput(r2.GetOutput()) w3 = vtk.vtkPNGWriter() w3.SetFileName(os_temp_path+'/morphed'+bm.id+'.png') w3.SetInput(ir2.GetOutput()) w3.Write() bitmap = Bitmap(project=img.project, name='warpedbitmap', image=img, mogelijkemeting=bm.mogelijkemeting, imagewidth=bm.imagewidth, imageheight=bm.imageheight, minx=bm.minx, miny=bm.miny, maxx=bm.maxx, maxy=bm.maxy) bitmap.save() im = Image.open(os_temp_path+'/morphed'+bm.id+'.png') im = im.convert("RGBA") im.save(settings.DATADIR + bitmap.id + '.gif', transparency=0) return img, 1
LandmarkDistanceList = np.array(LandmarkDistanceList) SubjectList = np.array(SubjectList) LabelList = np.array(LabelList) distArrInd = LandmarkDistanceList.argsort() sortedDistList = LandmarkDistanceList[distArrInd[::-1]] sortedSubjectList = SubjectList[distArrInd[::-1]] sortedLabelList = LabelList[distArrInd[::-1]] sortedCMRepSurfaceList = CMRepSurfaceList[distArrInd[::-1]] cntFlip = 0 for i in range(len(sortedCMRepSurfaceList)): dataTest = sortedCMRepSurfaceList[i] landmarktransformCheck = vtk.vtkLandmarkTransform() landmarktransformCheck.SetSourceLandmarks(dataTest.GetPoints()) landmarktransformCheck.SetTargetLandmarks(mu.GetPoints()) landmarktransformCheck.SetModeToRigidBody() landmarktransformCheck.Update() transformCheck = vtk.vtkTransform() transformCheck.SetMatrix(landmarktransformCheck.GetMatrix()) transformCheck.Update() if np.abs(transformCheck.GetOrientation()[0]) >= 90: print(sortedSubjectList[i]) cntFlip += 1 if np.abs(transformCheck.GetOrientation()[1]) >= 90: print(sortedSubjectList[i]) cntFlip += 1