class QMeshViewer(QtWidgets.QFrame): def __init__(self, parent): super(QMeshViewer, self).__init__(parent) self.platformModel: vtk.vtkCubeSource = None self.platformGrid: vtk.vtkPolyData = None self.platformModelActor: vtk.vtkActor = None self.platformGridActor: vtk.vtkActor = None self.platformWidth: float = 200.0 self.platformDepth: float = 200.0 self.platformThickness: float = 2.0 self.gridBottomHeight: float = 0.15 self.gridSize: np.uint16 = 10 # Make the actual QtWidget a child so that it can be re_parented self.interactor = QVTKRenderWindowInteractor(self) self.layout = QtWidgets.QHBoxLayout() self.layout.addWidget(self.interactor) self.layout.setContentsMargins(0, 0, 0, 0) self.setLayout(self.layout) self.initScene() self.initPlatform() self.initAxes() self.resetCamera() self.style = vtk.vtkInteractorStyleTrackballCamera() self.style.SetDefaultRenderer(self.renderer) self.interactor.SetInteractorStyle(self.style) def resetCamera(self): m_camPositionX = -237.885 m_camPositionY = -392.348 m_camPositionZ = 369.477 self.renderer.GetActiveCamera().SetPosition(m_camPositionX, m_camPositionY, m_camPositionZ) self.renderer.GetActiveCamera().SetFocalPoint(0.0, 0.0, 0.0) self.renderer.GetActiveCamera().SetViewUp(0.0, 0.0, 1.0) self.renderer.ResetCameraClippingRange() def initScene(self): qDebug('initScene()') self.renderer = vtk.vtkOpenGLRenderer() self.render_window = self.interactor.GetRenderWindow() self.render_window.AddRenderer(self.renderer) self.cellPicker = vtk.vtkCellPicker() self.cellPicker.SetTolerance(30.0) self.interactor.SetPicker(self.cellPicker) #* Top background color bg_t = np.ones(3) * 245.0 / 255.0 #* Bottom background color bg_b = np.ones(3) * 170.0 / 255.0 self.renderer.SetBackground(bg_t) self.renderer.SetBackground2(bg_b) self.renderer.GradientBackgroundOn() def createNewActor(self): axes = vtk.vtkAxesActor() axes_length = 50.0 axes_label_font_size = np.int16(20) axes.SetTotalLength(axes_length, axes_length, axes_length) axes.SetCylinderRadius(0.01) axes.SetShaftTypeToCylinder() axes.GetXAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone() axes.GetYAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone() axes.GetZAxisCaptionActor2D().GetTextActor().SetTextScaleModeToNone() axes.GetXAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize( axes_label_font_size) axes.GetYAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize( axes_label_font_size) axes.GetZAxisCaptionActor2D().GetCaptionTextProperty().SetFontSize( axes_label_font_size) axes.PickableOn() return axes def initAxes(self): # #* Axes axes = self.createNewActor() self.axes = axes self.renderer.AddActor(self.axes) def initPlatform(self): qDebug('initPlatform()') #* Platform Model platformModelMapper = vtk.vtkPolyDataMapper() self.platformModel = vtk.vtkCubeSource() platformModelMapper.SetInputConnection( self.platformModel.GetOutputPort()) self.platformModelActor = vtk.vtkActor() self.platformModelActor.SetMapper(platformModelMapper) self.platformModelActor.GetProperty().SetColor(1, 1, 1) self.platformModelActor.GetProperty().LightingOn() self.platformModelActor.GetProperty().SetOpacity(1) self.platformModelActor.GetProperty().SetAmbient(0.45) self.platformModelActor.GetProperty().SetDiffuse(0.4) self.platformModelActor.PickableOff() self.renderer.AddActor(self.platformModelActor) #* Platform Grid self.platformGrid = vtk.vtkPolyData() platformGridMapper = vtk.vtkPolyDataMapper() platformGridMapper.SetInputData(self.platformGrid) self.platformGridActor = vtk.vtkActor() self.platformGridActor.SetMapper(platformGridMapper) self.platformGridActor.GetProperty().LightingOff() self.platformGridActor.GetProperty().SetColor(0.45, 0.45, 0.45) self.platformGridActor.GetProperty().SetOpacity(1) self.platformGridActor.PickableOff() self.renderer.AddActor(self.platformGridActor) self.updatePlatform() def updatePlatform(self): qDebug('updatePlatform()') #* Platform Model if self.platformModel: self.platformModel.SetXLength(self.platformWidth) self.platformModel.SetYLength(self.platformDepth) self.platformModel.SetZLength(self.platformThickness) self.platformModel.SetCenter(0.0, 0.0, -self.platformThickness / 2) #* Platform Grid gridPoints = vtk.vtkPoints() gridCells = vtk.vtkCellArray() i = -self.platformWidth / 2 while i <= self.platformWidth / 2: self.createLine(i, -self.platformDepth / 2, self.gridBottomHeight, i, self.platformDepth / 2, self.gridBottomHeight, gridPoints, gridCells) i += self.gridSize i = -self.platformDepth / 2 while i <= self.platformDepth / 2: self.createLine(-self.platformWidth / 2, i, self.gridBottomHeight, self.platformWidth / 2, i, self.gridBottomHeight, gridPoints, gridCells) i += self.gridSize self.platformGrid.SetPoints(gridPoints) self.platformGrid.SetLines(gridCells) def createLine(self, x1: float, y1: float, z1: float, x2: float, y2: float, z2: float, points: vtk.vtkPoints, cells: vtk.vtkCellArray): line = vtk.vtkPolyLine() line.GetPointIds().SetNumberOfIds(2) id_1 = points.InsertNextPoint(x1, y1, z1) # vtkIdType id_2 = points.InsertNextPoint(x2, y2, z2) # vtkIdType line.GetPointIds().SetId(0, id_1) line.GetPointIds().SetId(1, id_2) cells.InsertNextCell(line) def start(self): self.interactor.Initialize() # If a big Qt application, call app.exec instead of having two GUI threads self.interactor.Start() def moveAxes(self, axes, aff): self.interactor.Disable() # Axes transform = vtk.vtkTransform() mat = vtk.vtkMatrix4x4() for i in range(4): for j in range(4): mat.SetElement(i, j, aff[i, j]) transform.SetMatrix(mat) axes.SetUserTransform(transform) self.interactor.Enable() self.render_window.Render() def removeActor(self, actor): self.interactor.Disable() self.renderer.RemoveActor(actor) self.interactor.Enable() self.render_window.Render() def addActor(self, actor): self.interactor.Disable() self.renderer.AddActor(actor) self.interactor.Enable() self.render_window.Render()
class QLiverViewer(QtWidgets.QFrame): colors = vtk.vtkNamedColors() widgetMoved = Signal(object, object, object) #float) widgetRegistered = Signal(object, object, object) def __init__(self, parent): super(QLiverViewer, self).__init__(parent) # Make the actual QtWidget a child so that it can be re_parented self.interactor = QVTKRenderWindowInteractor(self) self.layout = QtWidgets.QHBoxLayout() self.layout.addWidget(self.interactor) self.layout.setContentsMargins(0, 0, 0, 0) self.setLayout(self.layout) self.imgWidth: float = 50.0 # mm self.worldScale: float = 0.05 self.worldScale: float = 1.0 self.brighter25: bool = True self.opacity: float = 0.35 self.showReferencePlane = False self.nReferences = 2 self.refplanes = [] # Displayed reference planes self.planeWidgets = [] # Widgets for manipulation self.contours = [] # Contours clipped to reference plane self.fullcontours = [] # Full contour data self.planeSources = [] self.userAttempts = [] self.contourResults = self.nReferences * [None] self.vessels = None self.liver = None self.initScene() self.initLiver() self.initVessels() # Must be before planeWidgets self.lastPositions = dict({ 'origin': self.nReferences * [None], 'normal': self.nReferences * [None], 'axis1': self.nReferences * [None], 'reset': self.nReferences * [None] }) self.lastIndex = None self.initPlaneWidgets(0) if not IOUSFAN: self.initPlaneWidgets(1) self.resetCamera() self.style = vtk.vtkInteractorStyleTrackballCamera() self.style.SetDefaultRenderer(self.renderer) self.interactor.SetInteractorStyle(self.style) self.interactor.AddObserver('KeyPressEvent', self.KeyPress, 1.0) def KeyPress(self, obj, ev): key = obj.GetKeySym() index = self.lastIndex if self.lastIndex is None: return userAttempt = self.userAttempts[index] planeWidget = self.planeWidgets[index] refActor = self.refplanes[index] resetPositions = self.lastPositions['reset'][index] planeSource = self.planeSources[index] contourActor = self.contours[index] if key == 'c': print('Reset') userAttempt.SetUserTransform(None) userAttempt.Modified() # Reset planeWidget planeWidget.SetEnabled(0) planeWidget.SetOrigin(resetPositions[0]) planeWidget.SetPoint1(resetPositions[1]) planeWidget.SetPoint2(resetPositions[2]) planeWidget.Modified() planeWidget.SetEnabled(1) lastNormal = planeWidget.GetNormal() lastAxis1 = vtk.vtkVector3d() vtk.vtkMath.Subtract(planeWidget.GetPoint1(), planeWidget.GetOrigin(), lastAxis1) lastOrigin = planeWidget.GetCenter() self.lastPositions['origin'][index] = lastOrigin self.lastPositions['normal'][index] = lastNormal self.lastPositions['axis1'][index] = lastAxis1 if self.contourResults[index] is not None: self.renderer.RemoveActor(self.contourResults[index]) self.contourResults[index] = None self.render_window.Render() elif key == 's': print('Registration') # ============ run ICP ============== icp = vtk.vtkIterativeClosestPointTransform() # Transform contours tfpdf0 = vtk.vtkTransformPolyDataFilter() tfpdf0.SetInputData(self.fullcontours[index]) tfpdf0.SetTransform(userAttempt.GetUserTransform()) tfpdf0.Update() wrongContours = tfpdf0.GetOutput() icp.SetSource(wrongContours) icp.SetTarget(self.vesselPolyData) icp.GetLandmarkTransform().SetModeToRigidBody() icp.DebugOn() icp.SetMaximumNumberOfIterations(10) icp.StartByMatchingCentroidsOff() icp.SetCheckMeanDistance(1) # Experiment #icp.SetMeanDistanceModeToAbsoluteValue() # Original icp.SetMeanDistanceModeToRMS() # Default #print(icp.GetLandmarkTransform()) #sys.stdout.write("Before: ") #print(icp.GetMeanDistance()) from vtkUtils import CloudMeanDist dist0 = CloudMeanDist(wrongContours, self.vesselPolyData) print(dist0) icp.Modified() icp.Update() #print(icp) # Shows mean distance #print(icp.GetLandmarkTransform()) icpTransformFilter = vtk.vtkTransformPolyDataFilter() icpTransformFilter.SetInputData(wrongContours) icpTransformFilter.SetTransform(icp) icpTransformFilter.Update() correctedContours = icpTransformFilter.GetOutput() dist1 = CloudMeanDist(correctedContours, self.vesselPolyData) print(dist1) #sys.stdout.write("After: ") #print(icp.GetMeanDistance()) tubes = vtk.vtkTubeFilter() tubes.SetInputData(correctedContours) tubes.CappingOn() tubes.SidesShareVerticesOff() tubes.SetNumberOfSides(12) tubes.SetRadius(1.0) edgeMapper = vtk.vtkPolyDataMapper() edgeMapper.ScalarVisibilityOff() edgeMapper.SetInputConnection(tubes.GetOutputPort()) if self.contourResults[index] is not None: self.renderer.RemoveActor(self.contourResults[index]) testActor = vtk.vtkActor() testActor.SetMapper(edgeMapper) prop = testActor.GetProperty() prop.SetColor(yellow) prop.SetLineWidth(3) self.renderer.AddActor(testActor) self.contourResults[index] = testActor # Concatenate and get transform (w,x,y,z) userAttempt.GetUserTransform().Concatenate(icp.GetMatrix()) userAttempt.GetUserTransform().Update() (deg, x, y, z) = userAttempt.GetUserTransform().GetOrientationWXYZ() resetPositions = self.lastPositions['reset'][index] # Not correct!!! positionError = np.array( userAttempt.GetUserTransform().GetPosition()) positionError = np.array( userAttempt.GetUserTransform().TransformPoint( resetPositions[3])) - np.array(resetPositions[3]) # Reset afterwards userAttempt.SetUserTransform(None) userAttempt.Modified() # Reset planeWidget. planeWidget.SetEnabled(0) planeWidget.SetOrigin(resetPositions[0]) planeWidget.SetPoint1(resetPositions[1]) planeWidget.SetPoint2(resetPositions[2]) planeWidget.Modified() planeWidget.SetEnabled(1) lastNormal = planeWidget.GetNormal() lastAxis1 = vtk.vtkVector3d() vtk.vtkMath.Subtract(planeWidget.GetPoint1(), planeWidget.GetOrigin(), lastAxis1) lastOrigin = planeWidget.GetCenter() self.lastPositions['origin'][index] = lastOrigin self.lastPositions['normal'][index] = lastNormal self.lastPositions['axis1'][index] = lastAxis1 self.render_window.Render() originalNormal = resetPositions[4] originalNormal = originalNormal / np.sqrt(np.sum(originalNormal** 2)) self.widgetRegistered.emit((deg, np.r_[x, y, z]), originalNormal, positionError) elif key == 'm': # Move a reference print('Moving reference') showReferencePlane = False # Remove old reference plane if refActor is not None: self.removeActor(refActor) refActor = None showReferencePlane = True # Move reference plane planeSource.SetOrigin(planeWidget.GetOrigin()) planeSource.SetPoint1(planeWidget.GetPoint1()) planeSource.SetPoint2(planeWidget.GetPoint2()) # mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(planeSource.GetOutputPort()) # New reference actor if showReferencePlane: refActor = vtk.vtkActor() refActor.SetMapper(mapper) prop = refActor.GetProperty() prop.SetColor(blue) prop.SetOpacity(self.opacity) self.refplanes[index] = refActor self.renderer.AddActor(refActor) self.removeActor(contourActor) tubes, oldContours = self.computeContoursAndTubes(planeSource) edgeMapper = vtk.vtkPolyDataMapper() edgeMapper.ScalarVisibilityOff() edgeMapper.SetInputConnection(tubes.GetOutputPort()) planes = self.computeClippingPlanes(planeSource) edgeMapper.SetClippingPlanes(planes) actor = vtk.vtkActor() actor.SetMapper(edgeMapper) prop = actor.GetProperty() prop.SetColor(green) prop.SetLineWidth(3) self.contours[index] = actor self.renderer.AddActor(actor) # User attempt self.removeActor(userAttempt) attempt = vtk.vtkActor() transform = vtk.vtkTransform() trans = vtk.vtkMatrix4x4() trans.Identity() transform.SetMatrix(trans) transform.PostMultiply() attempt.SetUserTransform(transform) self.fullcontours[index] = oldContours mapper = vtk.vtkPolyDataMapper() mapper.ScalarVisibilityOff() mapper.SetInputData(oldContours) attempt.SetMapper(mapper) attempt.GetProperty().SetColor(red) self.userAttempts[index] = attempt self.renderer.AddActor(attempt) # Update reset positions of plane widget self.lastPositions['reset'][index] = [ planeWidget.GetOrigin(), planeWidget.GetPoint1(), planeWidget.GetPoint2(), planeWidget.GetCenter(), np.array(planeWidget.GetNormal()) ] # Redundant sys.stdout.write('Plane origin: ') print(planeWidget.GetOrigin()) sys.stdout.write('Plane point1: ') print(planeWidget.GetPoint1()) sys.stdout.write('Plane point2: ') print(planeWidget.GetPoint2()) print( "To make the app start at this location, insert these points near the tag\n 'FIXED PLANE POSITION AND ORIENTATION' in LiverView.py" ) self.render_window.Render() def removeActor(self, actor): self.interactor.Disable() self.renderer.RemoveActor(actor) self.interactor.Enable() # self.render_window.Render() def scale(self, polyData): if self.worldScale == 1.0: return polyData else: transform = vtk.vtkTransform() transform.Scale(self.worldScale, self.worldScale, self.worldScale) transformFilter = vtk.vtkTransformPolyDataFilter() transformFilter.SetInputData(polyData) transformFilter.SetTransform(transform) transformFilter.Update() return transformFilter.GetOutput() def getReferencePosition(self, index): """ Dumped from slicer program """ refplanes = [] centers = [] if IOUSFAN: refplanes.append( np.array([[1, 0, 0, -191.357], [0, 0, -1, 17.9393], [0, 1, 0, 192.499], [0, 0, 0, 1]])) centers.append(np.r_[117.54695990115218, 103.95861040356766, 127.81653778974703]) else: refplanes.append( np.array([[ 0.99722, -0.00658366270883304, 0.0741938205770847, -321.64 ], [0.07419, 0.17584, -0.98162, -227.46], [-0.0065837, 0.98440, 0.17584, -563.67], [0, 0, 0, 1.0]])) centers.append(np.r_[-75.696, -149.42, -231.76]) refplanes.append( np.array([[ 0.9824507428729312, -0.028608856565971154, 0.1843151408713164, -221.425151769367 ], [ 0.18431514087131629, 0.3004711475787132, -0.935812491003576, -325.6553959586223 ], [ -0.028608856565971223, 0.9533617481306448, 0.3004711475787133, -547.1574253306663 ], [0, 0, 0, 1]])) centers.append(np.r_[-31.317285034663634, -174.62449255285645, -193.39018826551072]) return centers[index], refplanes[index] def resetCamera(self): qDebug('resetCamera') self.renderer.ResetCamera() def initScene(self): qDebug('initScene()') self.renderer = vtk.vtkOpenGLRenderer() self.render_window = self.interactor.GetRenderWindow() self.render_window.AddRenderer(self.renderer) self.cellPicker = vtk.vtkCellPicker() self.cellPicker.SetTolerance(30.0) self.interactor.SetPicker(self.cellPicker) #* Top background color bg_t = np.ones(3) * 245.0 / 255.0 #* Bottom background color bg_b = np.ones(3) * 170.0 / 255.0 self.renderer.SetBackground(bg_t) self.renderer.SetBackground2(bg_b) self.renderer.GradientBackgroundOn() def computeClippingPlanes(self, source): # Clipping planes planes = vtk.vtkPlaneCollection() axis1 = np.array(source.GetPoint1()) - np.array(source.GetOrigin()) axis2 = np.array(source.GetPoint2()) - np.array(source.GetOrigin()) # Okay plane1 = vtk.vtkPlane() plane1.SetOrigin(source.GetOrigin()) plane1.SetNormal(axis2) plane2 = vtk.vtkPlane() plane2.SetOrigin(source.GetOrigin()) plane2.SetNormal(axis1) tmp = axis2 + np.array(source.GetPoint1()) plane3 = vtk.vtkPlane() plane3.SetOrigin(tmp) plane3.SetNormal(-axis2) plane4 = vtk.vtkPlane() plane4.SetOrigin(tmp) plane4.SetNormal(-axis1) planes.AddItem(plane1) planes.AddItem(plane2) planes.AddItem(plane3) planes.AddItem(plane4) return planes def computeContoursAndTubes(self, source): # Plane for intersection plane = vtk.vtkPlane() plane.SetOrigin(source.GetOrigin()) plane.SetNormal(source.GetNormal()) cutEdges = vtk.vtkCutter() cutEdges.SetInputConnection(self.vesselNormals.GetOutputPort()) cutEdges.SetCutFunction(plane) cutEdges.GenerateCutScalarsOff() # Was on cutEdges.SetValue(0, 0.5) cutEdges.Update() cutStrips = vtk.vtkStripper() cutStrips.SetInputConnection(cutEdges.GetOutputPort()) cutStrips.Update() oldContours = cutStrips.GetOutput() tubes = vtk.vtkTubeFilter() tubes.SetInputConnection(cutStrips.GetOutputPort()) tubes.CappingOn() tubes.SidesShareVerticesOff() tubes.SetNumberOfSides(12) tubes.SetRadius(self.worldScale * 1.0) return tubes, oldContours def initPlaneWidgets(self, index): qDebug('initPlaneWidgets()') center, htrans = self.getReferencePosition(index) hw = self.imgWidth shw = self.worldScale * hw source = vtk.vtkPlaneSource() source.SetOrigin(0, 0, 0) source.SetPoint1(shw, 0, 0) source.SetPoint2(0, shw, 0) transform = vtk.vtkTransform() mat = vtk.vtkMatrix4x4() for i in range(4): for j in range(4): mat.SetElement(i, j, htrans[i, j]) # Should transformation also be scaled?? for i in range(3): mat.SetElement(i, 3, self.worldScale * mat.GetElement(i, 3)) transform.SetMatrix(mat) transform.Update() origin = source.GetOrigin() origin = transform.TransformPoint(origin) source.SetOrigin(origin) p1 = source.GetPoint1() p1 = transform.TransformPoint(p1) source.SetPoint1(p1) p2 = source.GetPoint2() p2 = transform.TransformPoint(p2) source.SetPoint2(p2) source.Update() source.SetCenter(self.worldScale * center) source.Update() # Test position good for slice 17 (HACK) if (IOUSFAN): source.SetOrigin(-36.00039424299387, 58.447421532729656, 116.93018531955384) source.SetPoint1(13.731795848152041, 54.203001711976306, 119.87877296847647) source.SetPoint2(-40.18599847580337, 8.635225461941415, 115.82300881527104) source.Update() self.planeSources.append(source) ##################################### # Blue reference plane ##################################### # mapper if self.showReferencePlane: mapper0 = vtk.vtkPolyDataMapper() mapper0.SetInputConnection(source.GetOutputPort()) # actor refActor = vtk.vtkActor() refActor.SetMapper(mapper0) prop = refActor.GetProperty() prop.SetColor(blue) prop.SetOpacity(self.opacity) self.refplanes.append(refActor) self.renderer.AddActor(refActor) else: self.refplanes.append(None) ##################################### # Compute contours, tubes and clipping ##################################### tubes, oldContours = self.computeContoursAndTubes(source) edgeMapper = vtk.vtkPolyDataMapper() edgeMapper.ScalarVisibilityOff() edgeMapper.SetInputConnection(tubes.GetOutputPort()) planes = self.computeClippingPlanes(source) edgeMapper.SetClippingPlanes(planes) actor = vtk.vtkActor() actor.SetMapper(edgeMapper) prop = actor.GetProperty() prop.SetColor(green) prop.SetLineWidth(3) self.contours.append(actor) self.renderer.AddActor(actor) ################################################### # Plane widget for interaction ################################################### planeWidget = vtk.vtkPlaneWidget() planeWidget.SetInteractor(self.interactor) planeWidget.SetOrigin(source.GetOrigin()) planeWidget.SetPoint1(source.GetPoint1()) planeWidget.SetPoint2(source.GetPoint2()) prop = planeWidget.GetHandleProperty() prop.SetColor(QLiverViewer.colors.GetColor3d("Red")) prop = planeWidget.GetPlaneProperty() prop.SetColor(QLiverViewer.colors.GetColor3d("Red")) # Original position and orientation of reference plane self.lastPositions['reset'][index] = [ planeWidget.GetOrigin(), planeWidget.GetPoint1(), planeWidget.GetPoint2(), planeWidget.GetCenter(), np.array(planeWidget.GetNormal()) ] # Redundant print('normal') print(planeWidget.GetNormal()) planeWidget.SetEnabled(1) planeWidget.AddObserver(vtk.vtkCommand.EndInteractionEvent, self.onWidgetMoved, 1.0) attempt = vtk.vtkActor() self.fullcontours.append(oldContours) mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(oldContours) attempt.SetMapper(mapper) attempt.GetProperty().SetColor(red) self.userAttempts.append(attempt) self.renderer.AddActor(attempt) lastNormal = planeWidget.GetNormal() lastAxis1 = vtk.vtkVector3d() vtk.vtkMath.Subtract(planeWidget.GetPoint1(), planeWidget.GetOrigin(), lastAxis1) lastOrigin = planeWidget.GetCenter() self.lastPositions['origin'][index] = lastOrigin self.lastPositions['normal'][index] = lastNormal self.lastPositions['axis1'][index] = lastAxis1 self.planeWidgets.append(planeWidget) self.render_window.Render() def onWidgetMoved(self, obj, ev): if (obj in self.planeWidgets): index = self.planeWidgets.index(obj) self.lastIndex = index normal0 = self.lastPositions['normal'][index] first0 = self.lastPositions['axis1'][index] origin0 = self.lastPositions['origin'][index] normal1 = np.array(obj.GetNormal()) first1 = np.array(obj.GetPoint1()) - np.array(obj.GetOrigin()) origin1 = obj.GetCenter() trans = AxesToTransform(normal0, first0, origin0, normal1, first1, origin1) if self.userAttempts[index].GetUserTransform() is not None: self.userAttempts[index].GetUserTransform().Concatenate(trans) else: transform = vtk.vtkTransform() transform.SetMatrix(trans) transform.PostMultiply() self.userAttempts[index].SetUserTransform(transform) (deg, x, y, z) = self.userAttempts[index].GetUserTransform( ).GetOrientationWXYZ() self.lastPositions['origin'][index] = obj.GetCenter() lastAxis1 = [first1[0], first1[1], first1[2]] lastNormal = (normal1[0], normal1[1], normal1[2]) self.lastPositions['axis1'][index] = lastAxis1 self.lastPositions['normal'][index] = lastNormal self.userAttempts[index].Modified() self.render_window.Render() print("center") print('wtf') originalNormal = self.lastPositions['reset'][index][4] originalNormal = originalNormal / np.sqrt(np.sum(originalNormal** 2)) self.widgetMoved.emit( (deg, np.r_[x, y, z]), originalNormal, np.array(obj.GetCenter()) - np.array(self.lastPositions['reset'][index][3])) #print(ev) def initVessels(self): qDebug('initVessels()') if os.name == 'nt': filename = os.path.join(filedir, '../../data/Abdomen/Connected.vtp') if IOUSFAN: #filename = 'e:/analogic/TrialVTK/data/VesselMeshData.vtk' filename = 'e:/analogic/TrialVTK/data/LiverVesselMeshData.vtk' else: filename = '/home/jmh/bkmedical/data/CT/Connected.vtp' # read data if IOUSFAN: reader = vtk.vtkGenericDataObjectReader() else: reader = vtk.vtkXMLPolyDataReader() reader.SetFileName(filename) reader.Update() connectFilter = vtk.vtkPolyDataConnectivityFilter() connectFilter.SetInputConnection(reader.GetOutputPort()) connectFilter.SetExtractionModeToLargestRegion() connectFilter.Update() self.vesselPolyData = self.scale(connectFilter.GetOutput()) # compute normals self.vesselNormals = vtk.vtkPolyDataNormals() self.vesselNormals.SetInputData(self.vesselPolyData) # mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(self.vesselNormals.GetOutputPort()) # actor for vessels self.vessels = vtk.vtkActor() self.vessels.SetMapper(mapper) prop = self.vessels.GetProperty() if self.brighter25: prop.SetColor(vtk.vtkColor3d(hexCol("#517487"))) # 25% lighter else: prop.SetColor(vtk.vtkColor3d(hexCol("#415d6c"))) # assign actor to the renderer self.renderer.AddActor(self.vessels) def initLiver(self): qDebug('initLiver()') if os.name == 'nt': filename = os.path.join( filedir, '../../data/Abdomen/Liver_3D-interpolation.vtp') if IOUSFAN: filename = 'e:/analogic/TrialVTK/data/segmented_liver_ITK_snap.vtk' else: filename = '/home/jmh/bkmedical/data/CT/Liver_3D-interpolation.vtp' if IOUSFAN: reader = vtk.vtkGenericDataObjectReader() else: reader = vtk.vtkXMLPolyDataReader() reader.SetFileName(filename) reader.Update() connectFilter = vtk.vtkPolyDataConnectivityFilter() connectFilter.SetInputConnection(reader.GetOutputPort()) connectFilter.SetExtractionModeToLargestRegion() connectFilter.Update() surfNormals = vtk.vtkPolyDataNormals() surfNormals.SetInputData(self.scale(connectFilter.GetOutput())) #Create a mapper and actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(surfNormals.GetOutputPort()) # was reader self.liver = vtk.vtkActor() self.liver.SetMapper(mapper) prop = self.liver.GetProperty() if self.brighter25: prop.SetColor(vtk.vtkColor3d(hexCol("#873927"))) else: prop.SetColor(vtk.vtkColor3d(hexCol("#6c2e1f"))) prop.SetOpacity(self.opacity) self.renderer.AddActor(self.liver) def start(self): self.interactor.Initialize()