def add_stud(prev, x, y): cylA = create_cylinder(r=2.5, h=2.) trA = vtk.vtkTransform() trA.Translate(x, y, 10.6) trA.RotateX(90) tfA = vtk.vtkTransformPolyDataFilter() tfA.SetTransform(trA) tfA.SetInputConnection(cylA.GetOutputPort()) bA = vtkboolPython.vtkPolyDataBooleanFilter() bA.SetInputConnection(prev.GetOutputPort()) bA.SetInputConnection(1, tfA.GetOutputPort()) bA.SetOperModeToUnion() bA.DecPolysOff() cylB = create_cylinder(r=1.5, h=1.) trB = vtk.vtkTransform() trB.Translate(x, y, 9.1) trB.RotateX(90) tfB = vtk.vtkTransformPolyDataFilter() tfB.SetTransform(trB) tfB.SetInputConnection(cylB.GetOutputPort()) bB = vtkboolPython.vtkPolyDataBooleanFilter() bB.SetInputConnection(bA.GetOutputPort()) bB.SetInputConnection(1, tfB.GetOutputPort()) bB.SetOperModeToDifference() bB.DecPolysOff() return bB
def Merge5 (): reader = vtk.vtkPolyDataReader() reader.SetFileName('test10.vtk') reader2 = vtk.vtkPolyDataReader() reader2.SetFileName('test12.vtk') reader3 = vtk.vtkPolyDataReader() reader3.SetFileName('test13.vtk') app = vtk.vtkAppendPolyData() app.AddInputConnection(reader.GetOutputPort()) tr = vtk.vtkTransform() tr.Translate(-50.916666, -1.083333, 0) tr.RotateZ(90) tp = vtk.vtkTransformPolyDataFilter() tp.SetTransform(tr) tp.SetInputConnection(reader2.GetOutputPort()) app.AddInputConnection(tp.GetOutputPort()) tr2 = vtk.vtkTransform() tr2.Translate(-50.916666, -1.083333, 0) tp2 = vtk.vtkTransformPolyDataFilter() tp2.SetTransform(tr2) tp2.SetInputConnection(reader3.GetOutputPort()) app.AddInputConnection(tp2.GetOutputPort()) return app
def __init__(self): EventHandler.EventHandler.__init__(self) # default name is the class name, minus the "Factory" self._Name = self.__class__.__name__ if self._Name[-7:] == 'Factory': self._Name = self._Name[0:-7] # Store the modified time self._MTime = vtk.vtkObject() self._RenderTime = vtk.vtkObject() # list of renderers the actors are displayed in self._Renderers = [] # dictionary of actors for each renderer self._ActorDict = {} # ActorFactories which are children of this one self._Children = [] # the transform for all of the actors self._Transform = vtk.vtkTransform() # this transform is used as a spare self._DummyTransform = vtk.vtkTransform()
def __init__(self): # ODE initialization self.world = ode.World() self.world.setGravity(GRAVITY) self.world.setERP(ERP) self.world.setCFM(CFM) self.space = ode.Space() self.floor = ode.GeomPlane(self.space, (0.0,1.0,0.0), 0.0) self.jointGroup = ode.JointGroup() self.time = 0.0 # VTK initialization self.renderer = vtk.vtkRenderer() self.renderer.SetBackground(102.0/255.0,204/255.0,1.0) self.window = vtk.vtkRenderWindow() self.window.SetSize(WINDOW_WIDTH,WINDOW_HEIGHT) self.window.AddRenderer(self.renderer) self.interactor = vtk.vtkRenderWindowInteractor() self.interactor.SetRenderWindow(self.window) self.axes = vtk.vtkAxesActor() self.axes.SetAxisLabels(0) transform = vtk.vtkTransform() transform.Scale(0.1,0.1,0.1) self.axes.SetUserTransform(transform) self.renderer.AddActor(self.axes) # Create ground plane visualization self.floorVisual = vtk.vtkPlaneSource() self.floorVisual.SetNormal((0.0,1.0,0.0)) self.floorVisual.SetResolution(10,10) self.floorReader = vtk.vtkJPEGReader() self.floorReader.SetFileName(FLOOR_IMAGE) self.floorTexture = vtk.vtkTexture() transform = vtk.vtkTransform() transform.Scale(50.0,50.0,50.0) self.floorTexture.SetTransform(transform) self.floorTexture.SetInput(self.floorReader.GetOutput()) self.floorMap = vtk.vtkTextureMapToPlane() self.floorMap.SetInput(self.floorVisual.GetOutput()) self.floorMapper = vtk.vtkPolyDataMapper() self.floorMapper.SetInput(self.floorMap.GetOutput()) self.floorActor = vtk.vtkActor() transform = vtk.vtkTransform() transform.Scale(100.0,100.0,100.0) self.floorActor.SetUserTransform(transform) self.floorActor.SetMapper(self.floorMapper) self.floorActor.SetTexture(self.floorTexture) self.renderer.AddActor(self.floorActor) # VTK camera setup self.camera = vtk.vtkCamera() self.renderer.SetActiveCamera(self.camera) self.cameraFocus = [0.0, 0.0, 0.0] self.cameraPos = [4.0, 2.5, 1.5] self.cameraOffset = [0.0,1.0,3.0] self.cameraRoll = 0.0 # Keep track of the simulated bodies and robots self.bodies = [] self.robots = [] self.controllers = []
def __init__(self): super(RenderWidget, self).__init__() # Default volume renderer self.renderer = vtkRenderer() self.renderer.SetBackground2(0.4, 0.4, 0.4) self.renderer.SetBackground(0.1, 0.1, 0.1) self.renderer.SetGradientBackground(True) self.renderer.SetLayer(0) # Overlay renderer which is synced with the default renderer self.rendererOverlay = vtkRenderer() self.rendererOverlay.SetLayer(1) self.rendererOverlay.SetInteractive(0) self.renderer.GetActiveCamera().AddObserver("ModifiedEvent", self._syncCameras) self.rwi = QVTKRenderWindowInteractor(parent=self) self.rwi.SetInteractorStyle(vtkInteractorStyleTrackballCamera()) self.rwi.GetRenderWindow().AddRenderer(self.renderer) self.rwi.GetRenderWindow().AddRenderer(self.rendererOverlay) self.rwi.GetRenderWindow().SetNumberOfLayers(2) self.rwi.SetDesiredUpdateRate(0) self.imagePlaneWidgets = [vtkImagePlaneWidget() for i in range(3)] for index in range(3): self.imagePlaneWidgets[index].DisplayTextOn() self.imagePlaneWidgets[index].SetInteractor(self.rwi) # Disable the margin for free rotation self.imagePlaneWidgets[index].SetMarginSizeX(0.0) self.imagePlaneWidgets[index].SetMarginSizeY(0.0) self.mapper = vtkOpenGLGPUVolumeRayCastMapper() self.mapper.SetAutoAdjustSampleDistances(1) self.volume = None self.imageData = None self.VolumeVisualization = None self.shouldResetCamera = False self.gridItems = [] self.orientationGridItems = [] self.clippingBox = ClippingBox() self.clippingBox.setWidget(self) # Keep track of the base and user transforms self.baseTransform = vtkTransform() self.userTransform = vtkTransform() self.setMinimumWidth(340) self.setMinimumHeight(340) layout = QGridLayout(self) layout.setSpacing(0) layout.setContentsMargins(0, 0, 0, 0) layout.addWidget(self.rwi, 0, 0) self.setLayout(layout)
def DeformSurface(self): # interpolate and sample the displacement norms over the surface rbf = vtkvmtkcontrib.vtkvmtkRBFInterpolation2() rbf.SetSource(self.SourceSpheres) rbf.SetRBFTypeToBiharmonic() rbf.ComputeCoefficients() sampler = vtkvmtkcontrib.vtkvmtkPolyDataSampleFunction() sampler.SetInput(self.Surface) sampler.SetImplicitFunction(rbf) sampler.SetSampleArrayName("DisplacementNorms") sampler.Update() sampArray = sampler.GetOutput().GetPointData().GetArray("DisplacementNorms") ##Clamp the negative values to 0 and the positive values to one in a weight array calculator = vtk.vtkArrayCalculator() calculator.SetInput(sampler.GetOutput()) calculator.AddScalarArrayName("DisplacementNorms") calculator.SetFunction("if( DisplacementNorms > 0 , iHat, jHat)") calculator.SetResultArrayName("Weights") calculator.SetResultArrayType(vtk.VTK_FLOAT) calculator.Update() # Create the transform thinPlateSplineTransform = vtk.vtkThinPlateSplineTransform() thinPlateSplineTransform.SetBasisToR() thinPlateSplineTransform.SetSourceLandmarks(self.SourcePoints) thinPlateSplineTransform.SetTargetLandmarks(self.TargetPoints) transform = vtk.vtkTransform() transform.Identity() transform2 = vtk.vtkTransform() transform2.Identity() # Apply weighted transform transformFilter = vtk.vtkWeightedTransformFilter() transformFilter.SetInput(calculator.GetOutput()) transformFilter.SetNumberOfTransforms(3) transformFilter.SetWeightArray("Weights") transformFilter.SetTransform(thinPlateSplineTransform, 0) transformFilter.SetTransform(transform, 1) transformFilter.SetTransform(transform2, 2) transformFilter.Update() normalsFilter = vtk.vtkPolyDataNormals() normalsFilter.SetInput(transformFilter.GetOutput()) normalsFilter.Update() # FIXME: the normal filter apparently introduced some holes in some meshes (wtf?). This filter cleans the mesh cleanFilter = vtk.vtkCleanPolyData() cleanFilter.SetInput(normalsFilter.GetOutput()) cleanFilter.Update() self.DeformedSurface = cleanFilter.GetOutput()
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 get_cylinder(upper, height, radius, direction, resolution=10): src = vtk.vtkCylinderSource() src.SetCenter((0, height/2, 0)) src.SetHeight(height + radius/2.0) src.SetRadius(radius) src.SetResolution(resolution) rot1 = vtk.vtkTransform() fi = nm.arccos(direction[1]) rot1.RotateWXYZ(-nm.rad2deg(fi), 0.0, 0.0, 1.0) u = nm.abs(nm.sin(fi)) rot2 = vtk.vtkTransform() if u > 1.0e-6: # sometimes d[0]/u little bit is over 1 d0_over_u = direction[0] / u if d0_over_u > 1: psi = 0 elif d0_over_u < -1: psi = 2 * nm.pi else: psi = nm.arccos(direction[0] / u) logger.debug('d0 '+str(direction[0])+' u '+str(u)+' psi '+str(psi)) if direction[2] < 0: psi = 2 * nm.pi - psi rot2.RotateWXYZ(-nm.rad2deg(psi), 0.0, 1.0, 0.0) tl = vtk.vtkTransform() tl.Translate(upper) tr1a = vtk.vtkTransformFilter() tr1a.SetInput(src.GetOutput()) tr1a.SetTransform(rot1) tr1b = vtk.vtkTransformFilter() tr1b.SetInput(tr1a.GetOutput()) tr1b.SetTransform(rot2) tr2 = vtk.vtkTransformFilter() tr2.SetInput(tr1b.GetOutput()) tr2.SetTransform(tl) tr2.Update() return tr2.GetOutput()
def test_Segmentation(self): """ Test the GetRASBounds & GetBounds method on a segmentation. """ #self.delayDisplay("Starting test_Segmentation") cubeSource = vtk.vtkCubeSource() cubeSource.SetXLength(500) cubeSource.SetYLength(200) cubeSource.SetZLength(300) cubeSource.SetCenter(10, -85, 0.7) rotation = vtk.vtkTransform() rotation.RotateX(15.0) rotation.RotateZ(78) applyTransform = vtk.vtkTransformPolyDataFilter() applyTransform.SetTransform(rotation) applyTransform.SetInputConnection(cubeSource.GetOutputPort()) applyTransform.Update() modelNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLModelNode()) modelNode.SetPolyDataConnection(applyTransform.GetOutputPort()) segmentationNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLSegmentationNode()) segmentationLogic = slicer.modules.segmentations.logic() segmentationLogic.ImportModelToSegmentationNode(modelNode, segmentationNode) # Testing bounds = range(6) segmentationNode.GetRASBounds(bounds) untransformedBounds = [-65.0710220336914, 235.9289779663086, -304.413391113281, 288.586608886719, -216.427032470703, 213.572967529297] self.assertListAlmostEquals(bounds, untransformedBounds) segmentationNode.GetBounds(bounds) self.assertListAlmostEquals(bounds, untransformedBounds) transform = vtk.vtkTransform() transform.Translate([-5.0, +42.0, -0.1]) transform.RotateWXYZ(41, 0.7, 0.6, 75) transform.Scale(2, 3, 10) transformNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLTransformNode()) transformNode.ApplyTransform(transform) segmentationNode.SetAndObserveTransformNodeID(transformNode.GetID()) transformedBounds = [-200.70776329131795, 479.54290966330126, -723.6172978253361, 996.0765602877555, -2171.2883672792996, 2141.1537548033725] segmentationNode.GetRASBounds(bounds) self.assertListAlmostEquals(bounds, transformedBounds) segmentationNode.GetBounds(bounds) self.assertListAlmostEquals(bounds, untransformedBounds)
def test_Segmentation(self): """ Test the GetRASBounds & GetBounds method on a segmentation. """ #self.delayDisplay("Starting test_Segmentation") cubeSource = vtk.vtkCubeSource() cubeSource.SetXLength(500) cubeSource.SetYLength(200) cubeSource.SetZLength(300) cubeSource.SetCenter(10, -85, 0.7) rotation = vtk.vtkTransform() rotation.RotateX(15.0) rotation.RotateZ(78) applyTransform = vtk.vtkTransformPolyDataFilter() applyTransform.SetTransform(rotation) applyTransform.SetInputConnection(cubeSource.GetOutputPort()) applyTransform.Update() modelNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLModelNode()) modelNode.SetPolyDataConnection(applyTransform.GetOutputPort()) segmentationNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLSegmentationNode()) segmentationLogic = slicer.modules.segmentations.logic() segmentationLogic.ImportModelToSegmentationNode(modelNode, segmentationNode) # Testing bounds = range(6) segmentationNode.GetRASBounds(bounds) untransformedBounds = [-65.4164152220677, 237.23434621664234, -305.4495706784099, 289.7072339384947, -217.46321203583187, 213.68731403607347] self.assertListAlmostEquals(bounds, untransformedBounds) segmentationNode.GetBounds(bounds) self.assertListAlmostEquals(bounds, untransformedBounds) transform = vtk.vtkTransform() transform.Translate([-5.0, +42.0, -0.1]) transform.RotateWXYZ(41, 0.7, 0.6, 75) transform.Scale(2, 3, 10) transformNode = slicer.mrmlScene.AddNode(slicer.vtkMRMLTransformNode()) transformNode.ApplyTransform(transform) segmentationNode.SetAndObserveTransformNodeID(transformNode.GetID()) transformedBounds = [-690.2701685073098, 970.3186946284741, -744.3124542486084, 1018.260811721817, -2183.4639807718822, 2144.107746300856] segmentationNode.GetRASBounds(bounds) self.assertListAlmostEquals(bounds, transformedBounds) segmentationNode.GetBounds(bounds) self.assertListAlmostEquals(bounds, untransformedBounds)
def drawFrameInCamera(self, t, frameName='new frame',visible=True): imageView = self.cameraView.views[self.imageViewName] v = imageView.view q = self.cameraView.imageManager.queue localToCameraT = vtk.vtkTransform() q.getTransform('local', self.imageViewName, localToCameraT) res = vis.showFrame( vtk.vtkTransform() , 'temp', view=v, visible=True, scale = 0.2) om.removeFromObjectModel(res) pd = res.polyData pd = filterUtils.transformPolyData(pd, t) pd = filterUtils.transformPolyData(pd, localToCameraT) q.projectPoints(self.imageViewName, pd ) vis.showPolyData(pd, ('overlay ' + frameName), view=v, colorByName='Axes',parent='camera overlay',visible=visible)
def colladaGeometryToPolyData(geometry, transform): polyDataList = [] for primitives in geometry.primitives: if type(primitives) != collada.triangleset.TriangleSet: print 'warning, unhandled primitive type:', type(primitives) continue polyData = colladaTriangleSetToPolyData(primitives) if not polyData: continue addTextureMetaData(polyData, primitives.material) t = vtk.vtkTransform() t.PostMultiply() t.Scale(0.0254, 0.0254, 0.0254) t.RotateX(-90) polyData = transformPolyData(polyData, t) polyData = transformPolyData(polyData, transform) polyDataList.append(polyData) return polyDataList
def __init__(self, renderers, radius = 2.0, height = 8.0, rotationXYZ = [0, 0, 0], offsetXYZ = [0, 0, 0]): ''' Initialize the cylinder. ''' # Call the parent constructor super(Cylinder,self).__init__(renderers) cylinderSource = vtk.vtkCylinderSource() cylinderSource.SetCenter(0.0, 0.0, 0.0) cylinderSource.SetRadius(radius) cylinderSource.SetHeight(height) # Make it a little more defined cylinderSource.SetResolution(24) # Transform scale it to the right size trans = vtk.vtkTransform() trans.Scale(1, 1, 1) trans.Translate(offsetXYZ[0], offsetXYZ[1], offsetXYZ[2]) trans.RotateZ(rotationXYZ[2]) trans.RotateX(rotationXYZ[0]) trans.RotateY(rotationXYZ[1]) transF = vtk.vtkTransformPolyDataFilter() transF.SetInputConnection(cylinderSource.GetOutputPort()) transF.SetTransform(trans) cylinderMapper = vtk.vtkPolyDataMapper() cylinderMapper.SetInputConnection(transF.GetOutputPort()) self.vtkActor.SetMapper(cylinderMapper) # Change it to a red sphere self.vtkActor.GetProperty().SetColor(0.8, 0.8, 0.3)
def WriteVTSXMLVolumeFile(self): if (self.OutputFileName == ''): self.PrintError('Error: no OutputFileName.') self.PrintLog('Writing VTS XML grid file.') if self.ApplyTransform == 0: origin = self.Image.GetOrigin() spacing = self.Image.GetSpacing() matrix = vtk.vtkMatrix4x4() matrix.DeepCopy((1/spacing[0], 0, 0, - origin[0]/spacing[0], 0, 1/spacing[1], 0, - origin[1]/spacing[1], 0, 0, 1/spacing[2], - origin[2]/spacing[2], 0, 0, 0, 1)) #LPI convention with correct origin and spacing else: if self.RasToIjkMatrixCoefficients == None: self.PrintError('Error: no RasToIjkMatrixCoefficients.') matrix = vtk.vtkMatrix4x4() matrix.DeepCopy(self.RasToIjkMatrixCoefficients) trans = vtk.vtkTransform() trans.SetMatrix(matrix) trans_filt = vtk.vtkTransformFilter() trans_filt.SetTransform(trans) trans_filt.SetInputData(self.Image) trans_filt.Update() writer = vtk.vtkXMLStructuredGridWriter() writer.SetInputConnection(trans_filt.GetOutputPort()) writer.SetFileName(self.OutputFileName) writer.Write()
def addContourObject(self, contourObject, prop3D): """Activate contouring for the contourObject. The contourObject is usually a tdObject and specifically a vtkPolyData. We also need the prop3D that represents this polydata in the 3d scene. """ if self._contourObjectsDict.has_key(contourObject): # we already have this, thanks return try: contourable = contourObject.IsA('vtkPolyData') except: contourable = False if contourable: # we need a cutter to calculate the contours and then a stripper # to string them all together cutter = vtk.vtkCutter() plane = vtk.vtkPlane() cutter.SetCutFunction(plane) trfm = vtk.vtkTransform() trfm.SetMatrix(prop3D.GetMatrix()) trfmFilter = vtk.vtkTransformPolyDataFilter() trfmFilter.SetTransform(trfm) trfmFilter.SetInput(contourObject) cutter.SetInput(trfmFilter.GetOutput()) stripper = vtk.vtkStripper() stripper.SetInput(cutter.GetOutput()) # #tubef = vtk.vtkTubeFilter() #tubef.SetNumberOfSides(12) #tubef.SetRadius(0.5) #tubef.SetInput(stripper.GetOutput()) # and create the overlay at least for the 3d renderer mapper = vtk.vtkPolyDataMapper() mapper.SetInput(stripper.GetOutput()) mapper.ScalarVisibilityOff() actor = vtk.vtkActor() actor.SetMapper(mapper) c = self.sliceDirections.slice3dVWR._tdObjects.getObjectColour( contourObject) actor.GetProperty().SetColor(c) actor.GetProperty().SetInterpolationToFlat() # add it to the renderer self.sliceDirections.slice3dVWR._threedRenderer.AddActor(actor) # add all necessary metadata to our dict contourDict = {'contourObject' : contourObject, 'contourObjectProp' : prop3D, 'trfmFilter' : trfmFilter, 'cutter' : cutter, 'tdActor' : actor} self._contourObjectsDict[contourObject] = contourDict # now sync the bugger self.syncContourToObject(contourObject)
def rotateMesh(mesh, axis=1, angle=0): try: print("Rotating surface: axis=", axis, "angle=", angle) matrix = vtk.vtkTransform() if axis == 0: matrix.RotateX(angle) if axis == 1: matrix.RotateY(angle) if axis == 2: matrix.RotateZ(angle) tfilter = vtk.vtkTransformPolyDataFilter() tfilter.SetTransform(matrix) if vtk.vtkVersion.GetVTKMajorVersion() >= 6: tfilter.SetInputData(mesh) else: tfilter.SetInput(mesh) tfilter.Update() mesh2 = tfilter.GetOutput() return mesh2 except: print("Surface rotating failed") exc_type, exc_value, exc_traceback = sys.exc_info() traceback.print_exception( exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout) return None
def Execute(self): if (self.Mesh == None): self.PrintError('Error: no Mesh.') if not self.Matrix4x4: self.Matrix4x4 = vtk.vtkMatrix4x4() if self.MatrixCoefficients != []: self.PrintLog('Setting up transform matrix using specified coefficients') self.Matrix4x4.DeepCopy(self.MatrixCoefficients) elif self.Translation != [0.0,0.0,0.0] or self.Rotation != [0.0,0.0,0.0] or self.Scaling != [1.0,1.0,1.0]: self.PrintLog('Setting up transform matrix using specified translation, rotation and/or scaling') transform = vtk.vtkTransform() transform.RotateX(self.Rotation[0]) transform.RotateY(self.Rotation[1]) transform.RotateZ(self.Rotation[2]) transform.Translate(self.Translation[0], self.Translation[1], self.Translation[2]) transform.Scale(self.Scaling[0], self.Scaling[1], self.Scaling[2]) self.Matrix4x4.DeepCopy(transform.GetMatrix()) if self.InvertMatrix: self.Matrix4x4.Invert() transform = vtk.vtkMatrixToLinearTransform() transform.SetInput(self.Matrix4x4) transformFilter = vtk.vtkTransformFilter() transformFilter.SetInputData(self.Mesh) transformFilter.SetTransform(transform) transformFilter.Update() self.Mesh = transformFilter.GetOutput()
def select_point_cloud(self): if not self.scene.get_active_point_cloud(): return self.unselect_point_cloud() transform = vtk.vtkTransform() transform.SetMatrix(self.actor.GetMatrix()) transform_filter = vtk.vtkTransformPolyDataFilter() transform_filter.SetInputConnection(self.src.GetOutputPort()) transform_filter.SetTransform(transform) enclosed_pts = vtk.vtkSelectEnclosedPoints() if USING_VTK6: enclosed_pts.SetInputData(self.scene.get_active_point_cloud().polydata) enclosed_pts.SetSurfaceConnection(transform_filter.GetOutputPort()) else: enclosed_pts.SetInput(self.scene.get_active_point_cloud().polydata) enclosed_pts.SetSurface(transform_filter.GetOutput()) enclosed_pts.Update() inside_arr = enclosed_pts.GetOutput().GetPointData().\ GetArray('SelectedPoints') self.selected_pts = [] for i in range(inside_arr.GetNumberOfTuples()): if inside_arr.GetComponent(i, 0): self.scene.get_active_point_cloud().colors.\ SetTuple3(i, *name_to_rgb('blue')) self.selected_pts.append(i) self.scene.get_active_point_cloud().selected_pts[i] += 1 self.scene.get_active_point_cloud().colors.Modified() self.frame.ren_win.Render()
def SetInlet(self, inlet): """Create a vtkTransform which will rotate the coordinates such that inlet.Normal is oriented in the z-direction and origin is inlet.Centre """ n = inlet.Normal n = np.array([n.x, n.y, n.z]) minInd = n.argsort()[0] axis = np.zeros(3) axis[minInd] = 1 transmat = np.eye(4) transmat[0, 0:3] = np.cross(n, axis) transmat[0, 0:3] /= np.sqrt(np.sum(transmat[0, 0:3]**2)) transmat[1, 0:3] = np.cross(n, transmat[0, 0:3]) transmat[2, 0:3] = n trans = vtkTransform() trans.Scale(1., 1., 0.) trans.Concatenate(transmat.flatten()) r = inlet.Centre trans.Translate(r.x, r.y, r.z) self.trans = trans self.transformer.SetTransform(self.trans) return
def __init__(self, renderers, name): ''' Initialize the bot model. ''' # Call the parent constructor super(RoverBot,self).__init__(renderers) filename = "../scene/media/rover.stl" self.__name = name reader = vtk.vtkSTLReader() reader.SetFileName(filename) # Do the internal transforms to make it look along unit-z, do it with a quick transform trans = vtk.vtkTransform() trans.Scale(0.05, 0.05, 0.05) trans.RotateX(-90) transF = vtk.vtkTransformPolyDataFilter() transF.SetInputConnection(reader.GetOutputPort()) transF.SetTransform(trans) self.__mapper = vtk.vtkPolyDataMapper() #if vtk.VTK_MAJOR_VERSION <= 5: # self.__mapper.SetInput(reader.GetOutput()) #else: self.__mapper.SetInputConnection(transF.GetOutputPort()) self.vtkActor.SetMapper(self.__mapper) # Set up all the children for this model self.__setupChildren(renderers) # Set it to [0,0,0] so that it updates all the children self.SetSceneObjectPosition([0, 0, 0])
def test_3D_interactionDefaults(self): """ Test that the interaction widget exists in the 3D view. """ logic = SlicerTransformInteractionTest1Logic() #self.delayDisplay("Starting test_3D_interactionDefaults") logic = SlicerTransformInteractionTest1Logic() tNode, tdNode = logic.addTransform() self.assertFalse(tdNode.GetEditorVisibility()) self.assertFalse(tdNode.GetEditorSliceIntersectionVisibility()) slicer.app.layoutManager().layout = slicer.vtkMRMLLayoutNode.SlicerLayoutOneUp3DView manager = logic.getModel3DDisplayableManager() self.assertIsNotNone(manager) # Check when nothing is on widget = manager.GetWidget(tdNode) self.assertFalse(widget.GetEnabled()) # Check when interactive is on tdNode.SetEditorVisibility(True) self.assertTrue(widget.GetEnabled()) # Check default widget tranform values representation = widget.GetRepresentation() defaultTransform = vtk.vtkTransform() representation.GetTransform(defaultTransform) expectedDefaultTransform = [ [100.0, 0.0, 0.0, 0.0], [0.0, 100.0, 0.0, 0.0], [0.0, 0.0, 100.0, 0.0], [0.0, 0.0, 0.0, 1.0], ] self.assertTransform(defaultTransform, expectedDefaultTransform)
def RotateBond(self, angle, mode="up"): trans = vtk.vtkTransform() trans.PostMultiply() if mode == "down": pos = self.bond_atoms[1].pos.copy() v = self.bond_atoms[0].pos - self.bond_atoms[1].pos self.Translate(-1 * pos) trans.RotateWXYZ(angle, v[0], v[1], v[2]) for atom in self: atom.ApplyTransform(trans) if atom is self.bond_atoms[0]: atom.ApplyTransform(trans) break elif mode == "up": pos = self.bond_atoms[0].pos.copy() v = self.bond_atoms[1].pos - self.bond_atoms[0].pos self.Translate(-1 * pos) trans.RotateWXYZ(angle, v[0], v[1], v[2]) aux_flag = False for atom in self: if aux_flag: atom.ApplyTransform(trans) elif atom is self.bond_atoms[0]: aux_flag = True self.Translate(pos)
def RandomizeLocation(self, vec): """Randomiztion of location respecting to the vec. """ trans = vtk.vtkTransform() random_vector = [vec[0] * rand.random(), vec[1] * rand.random(), vec[2] * rand.random()] trans.Translate(random_vector) self.ApplyTransform(trans)
def create_glyphs (self, poly): if self.glyph_type == 'sphere': glyph = vtk.vtkSphereSource() glyph.SetRadius(1) glyph.SetPhiResolution(8) glyph.SetThetaResolution(8) elif self.glyph_type == 'cylinder': glyph = vtk.vtkCylinderSource() glyph.SetHeight(self.height) glyph.SetRadius(self.radius) glyph.SetCenter(0,0,0) glyph.SetResolution(10) glyph.CappingOn() tt = vtk.vtkTransform() tt.RotateZ(90) tf = vtk.vtkTransformPolyDataFilter() tf.SetInput(glyph.GetOutput()) tf.SetTransform(tt) tf.Update() glypher = vtk.vtkGlyph3D() glypher.SetInput(poly) glypher.SetSource(tf.GetOutput()) glypher.SetVectorModeToUseNormal() glypher.SetScaleModeToScaleByScalar() glypher.SetScaleFactor(self.glyph_scale_factor) glypher.Update() return glypher
def GetLineFromWidget(self, obj, event): if self.Type == "freehand": path = vtk.vtkPolyData() obj.GetPath(path) elif self.Type == "contour": path = self.ImageTracerWidget.GetRepresentation().GetContourRepresentationAsPolyData() spacing = self.Image.GetSpacing() translation = [0.0, 0.0, 0.0] translation[self.Axis] = self.SliceVOI[self.Axis * 2] * spacing[self.Axis] transform = vtk.vtkTransform() transform.Translate(translation) pathTransform = vtk.vtkTransformPolyDataFilter() pathTransform.SetInput(path) pathTransform.SetTransform(transform) pathTransform.Update() self.Line = pathTransform.GetOutput() if self.Line.GetSource(): self.Line.GetSource().UnRegisterAllOutputs()
def __init__(self,center=(0,-2,0) , radius=0.5, height=2, color=(0,1,1), rotXYZ=(0,0,0), resolution=50 ): """ cylinder """ self.src = vtk.vtkCylinderSource() self.src.SetCenter(0,0,0) self.src.SetHeight(height) self.src.SetRadius(radius) self.src.SetResolution(resolution) # SetResolution # SetCapping(int) # CappingOn() CappingOff() # this transform rotates the cylinder so it is vertical # and then translates the lower tip to the center point transform = vtk.vtkTransform() transform.Translate(center[0], center[1], center[2]+height/2) transform.RotateX(rotXYZ[0]) transformFilter=vtk.vtkTransformPolyDataFilter() transformFilter.SetTransform(transform) transformFilter.SetInputConnection(self.src.GetOutputPort()) transformFilter.Update() self.mapper = vtk.vtkPolyDataMapper() #self.mapper.SetInput(self.src.GetOutput()) self.mapper.SetInput( transformFilter.GetOutput() ) self.SetMapper(self.mapper) self.SetColor(color)
def CreateTorus(point1, point2, axe): """ Creates a torus that has point1 as center point2 defines a point on the torus. """ direction = map(lambda x, y: x - y, point2, point1) length = math.sqrt(sum(map(lambda x: x ** 2, direction))) torus = vtkParametricTorus() torus.SetRingRadius(length / 1.5) torus.SetCrossSectionRadius(length / 30.0) torusSource = vtkParametricFunctionSource() torusSource.SetParametricFunction(torus) torusSource.SetScalarModeToPhase() torusSource.Update() transform = vtkTransform() if axe == 0: transform.RotateY(90) elif axe == 1: transform.RotateX(90) transformFilter = vtkTransformFilter() transformFilter.SetInputConnection(torusSource.GetOutputPort()) transformFilter.SetTransform(transform) transformFilter.Update() torusMapper = vtkPolyDataMapper() torusMapper.SetInputConnection(transformFilter.GetOutputPort()) torusActor = vtkActor() torusActor.SetMapper(torusMapper) return torusActor, transformFilter.GetOutput()
def __init__(self, center=(-2,0,0), radius = 1, angle=45, height=0.4, color=(1,1,0) , resolution=60): """ cone""" self.src = vtk.vtkConeSource() self.src.SetResolution(resolution) self.src.SetRadius( radius ) #self.src.SetAngle( angle ) self.src.SetHeight( height ) #self.src.SetCenter(center) transform = vtk.vtkTransform() transform.Translate(center[0], center[1], center[2] - self.src.GetHeight()/2) #transform.RotateX(rotXYZ[0]) transform.RotateY( -90 ) #transform.RotateZ(rotXYZ[2]) transformFilter=vtk.vtkTransformPolyDataFilter() transformFilter.SetTransform(transform) transformFilter.SetInputConnection(self.src.GetOutputPort()) transformFilter.Update() self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetInput(transformFilter.GetOutput()) #self.mapper = vtk.vtkPolyDataMapper() #self.mapper.SetInput(self.src.GetOutput()) self.SetMapper(self.mapper) self.SetColor(color)
def transform_back(self,pt,pd): #The reconstructed surface is transformed back to where the #original points are. (Hopefully) it is only a similarity #transformation. #1. Get bounding box of pt, get its minimum corner (left, bottom, least-z), at c0, pt_bounds #2. Get bounding box of surface pd, get its minimum corner (left, bottom, least-z), at c1, pd_bounds #3. compute scale as: # scale = (pt_bounds[1] - pt_bounds[0])/(pd_bounds[1] - pd_bounds[0]); #4. transform the surface by T := T(pt_bounds[0], [2], [4]).S(scale).T(-pd_bounds[0], -[2], -[4]) pt_bounds=pt.GetBounds() pd_bounds=pd.GetBounds() scale = (pt_bounds[1] - pt_bounds[0])/(pd_bounds[1] - pd_bounds[0]); transp = vtk.vtkTransform() transp.Translate(pt_bounds[0], pt_bounds[2], pt_bounds[4]); transp.Scale(scale, scale, scale); transp.Translate(- pd_bounds[0], - pd_bounds[2], - pd_bounds[4]); tpd = vtk.vtkTransformPolyDataFilter(); tpd.SetInput(pd); tpd.SetTransform(transp); tpd.Update(); return tpd.GetOutput();
def __init__(self, color=(1,1,1), center=(0,0,0), text="hello", scale=1, camera=[]): """ create text """ self.src = vtk.vtkVectorText() self.SetText(text) #self.SetCamera(camera) transform = vtk.vtkTransform() transform.Translate(center[0], center[1], center[2]) transform.Scale(scale, scale, scale) #transform.RotateY(90) #transform2 = vtk.vtkTransform() #transform.Concatenate(transform2) #transformFilter=vtk.vtkTransformPolyDataFilter() #transformFilter.SetTransform(transform) #transformFilter.SetInputConnection(self.src.GetOutputPort()) #transformFilter.Update() #follower = vtk.vtkFollower() #follower.SetMapper self.SetUserTransform(transform) self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetInputConnection(self.src.GetOutputPort()) self.SetMapper(self.mapper) self.SetColor(color)
def GetTransform(rotationAngle, rotationVector): transform = vtk.vtkTransform() transform.RotateWXYZ(rotationAngle, rotationVector[0], rotationVector[1], rotationVector[2]) return transform
def myCallback(widget, event_string): t = vtk.vtkTransform() boxWidget.GetTransform(t) boxWidget.GetProp3D().SetUserTransform(t)
faceColors.InsertComponent(2,1,255) faceColors.InsertComponent(2,2,0) faceColors.InsertComponent(3,0,0) faceColors.InsertComponent(3,1,0) faceColors.InsertComponent(3,2,255) faceColors.InsertComponent(4,0,255) faceColors.InsertComponent(4,1,0) faceColors.InsertComponent(4,2,255) faceColors.InsertComponent(5,0,0) faceColors.InsertComponent(5,1,255) faceColors.InsertComponent(5,2,255) cube = vtk.vtkPolyData() cube.SetPoints(pts) cube.SetPolys(faces) cube.GetCellData().SetScalars(faceColors) t1 = vtk.vtkTransform() t1.Translate(1,2,3) t1.RotateX(15) t1.Scale(4,2,1) tpdf1 = vtk.vtkTransformPolyDataFilter() tpdf1.SetInputData(cube) tpdf1.SetTransform(t1) cube1Mapper = vtk.vtkPolyDataMapper() cube1Mapper.SetInputConnection(tpdf1.GetOutputPort()) cube1 = vtk.vtkActor() cube1.SetMapper(cube1Mapper) t2 = vtk.vtkTransform() t2.Translate(5,10,15) t2.RotateX(22.5) t2.RotateY(15) t2.RotateZ(85)
f22.SetInputConnection(ap.GetOutputPort()) f22.SetTransform(t2.GetInverse()) m22 = vtk.vtkDataSetMapper() m22.SetInputConnection(f22.GetOutputPort()) a22 = vtk.vtkActor() a22.SetMapper(m22) a22.GetProperty().SetColor(0.9, 0.9, 0) a22.GetProperty().SetRepresentationToWireframe() ren22 = vtk.vtkRenderer() ren22.SetViewport(0.25, 0.0, 0.50, 0.5) ren22.ResetCamera(-0.5, 0.5, -0.5, 0.5, -1, 1) ren22.AddActor(a22) renWin.AddRenderer(ren22) #-------------------------- # linear concatenation - should end up with identity here t3 = vtk.vtkTransform() t3.Concatenate(t1) t3.Concatenate(t1.GetInverse()) f31 = vtk.vtkTransformPolyDataFilter() f31.SetInputConnection(ap.GetOutputPort()) f31.SetTransform(t3) m31 = vtk.vtkDataSetMapper() m31.SetInputConnection(f31.GetOutputPort()) a31 = vtk.vtkActor() a31.SetMapper(m31) a31.GetProperty().SetColor(1, 0, 0) a31.GetProperty().SetRepresentationToWireframe() ren31 = vtk.vtkRenderer() ren31.SetViewport(0.50, 0.5, 0.75, 1.0) ren31.ResetCamera(-0.5, 0.5, -0.5, 0.5, -1, 1) ren31.AddActor(a31)
import vtk from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # this script tests vtkImageReslice with different interpolation modes, # with the wrap-pad feature turned on and with a rotation # Image pipeline reader = vtk.vtkImageReader() reader.ReleaseDataFlagOff() reader.SetDataByteOrderToLittleEndian() reader.SetDataExtent(0, 63, 0, 63, 1, 93) reader.SetDataSpacing(3.2, 3.2, 1.5) reader.SetFilePrefix("" + str(VTK_DATA_ROOT) + "/Data/headsq/quarter") reader.SetDataMask(0x7fff) transform = vtk.vtkTransform() # rotate about the center of the image transform.Translate(+100.8, +100.8, +69.0) transform.RotateWXYZ(100, 0.1, 0.1, 1) transform.Translate(-100.8, -100.8, -69.0) reslice1 = vtk.vtkImageReslice() reslice1.SetInputConnection(reader.GetOutputPort()) reslice1.MirrorOn() reslice1.SetResliceTransform(transform) reslice1.SetInterpolationModeToCubic() reslice1.SetOutputSpacing(2.0, 2.0, 1.5) reslice1.SetOutputOrigin(-32, -32, 40) reslice1.SetOutputExtent(0, 127, 0, 127, 0, 0) reslice2 = vtk.vtkImageReslice() reslice2.SetInputConnection(reader.GetOutputPort()) reslice2.MirrorOn()
def createMeshFromSegmentationCleaver(self, inputSegmentation, outputMeshNode, additionalParameters="--scale 0.2 --multiplier 2 --grading 5"): self.abortRequested = False tempDir = self.createTempDirectory() self.addLog('Mesh generation using Cleaver is started in working directory: '+tempDir) inputParamsCleaver = [] # Write inputs qt.QDir().mkpath(tempDir) labelmapVolumeNode = slicer.mrmlScene.AddNewNodeByClass('vtkMRMLLabelMapVolumeNode') slicer.modules.segmentations.logic().ExportAllSegmentsToLabelmapNode(inputSegmentation, labelmapVolumeNode) inputLabelmapVolumeFilePath = os.path.join(tempDir, "inputLabelmap.nrrd") slicer.util.saveNode(labelmapVolumeNode, inputLabelmapVolumeFilePath, {"useCompression": False}) inputParamsCleaver.extend(["--input_files", inputLabelmapVolumeFilePath]) inputParamsCleaver.append("--segmentation") # Keep IJK to RAS matrix, we'll need it later unscaledIjkToRasMatrix = vtk.vtkMatrix4x4() labelmapVolumeNode.GetIJKToRASDirectionMatrix(unscaledIjkToRasMatrix) origin = labelmapVolumeNode.GetOrigin() for i in range(3): unscaledIjkToRasMatrix.SetElement(i,3, origin[i]) # Keep color node, we'll need it later colorTableNode = labelmapVolumeNode.GetDisplayNode().GetColorNode() # Background color is transparent by default which is not ideal for 3D display colorTableNode.SetColor(0,0.6,0.6,0.6,1.0) slicer.mrmlScene.RemoveNode(labelmapVolumeNode) slicer.mrmlScene.RemoveNode(colorTableNode) # Set up output format inputParamsCleaver.extend(["--output_path", tempDir+"/"]) inputParamsCleaver.extend(["--output_format", "vtkUSG"]) # VTK unstructed grid inputParamsCleaver.append("--fix_tet_windup") # prevent inside-out tets inputParamsCleaver.append("--strip_exterior") # remove temporary elements that are added to make the volume cubic inputParamsCleaver.append("--verbose") # Quality inputParamsCleaver.extend(slicer.util.toVTKString(additionalParameters).split(' ')) # Run Cleaver ep = self.startMesher(inputParamsCleaver, self.getCleaverPath()) self.logProcessOutput(ep, self.cleaverFilename) # Read results if not self.abortRequested: outputVolumetricMeshPath = os.path.join(tempDir, "output.vtk") outputReader = vtk.vtkUnstructuredGridReader() outputReader.SetFileName(outputVolumetricMeshPath) outputReader.ReadAllScalarsOn() outputReader.ReadAllVectorsOn() outputReader.ReadAllNormalsOn() outputReader.ReadAllTensorsOn() outputReader.ReadAllColorScalarsOn() outputReader.ReadAllTCoordsOn() outputReader.ReadAllFieldsOn() outputReader.Update() # Cleaver returns the mesh in voxel coordinates, need to transform to RAS space transformer = vtk.vtkTransformFilter() transformer.SetInputData(outputReader.GetOutput()) ijkToRasTransform = vtk.vtkTransform() ijkToRasTransform.SetMatrix(unscaledIjkToRasMatrix) transformer.SetTransform(ijkToRasTransform) outputMeshNode.SetUnstructuredGridConnection(transformer.GetOutputPort()) outputMeshDisplayNode = outputMeshNode.GetDisplayNode() if not outputMeshDisplayNode: # Initial setup of display node outputMeshNode.CreateDefaultDisplayNodes() outputMeshDisplayNode = outputMeshNode.GetDisplayNode() outputMeshDisplayNode.SetEdgeVisibility(True) outputMeshDisplayNode.SetClipping(True) colorTableNode = slicer.mrmlScene.AddNode(colorTableNode) outputMeshDisplayNode.SetAndObserveColorNodeID(colorTableNode.GetID()) outputMeshDisplayNode.ScalarVisibilityOn() outputMeshDisplayNode.SetActiveScalarName('labels') outputMeshDisplayNode.SetActiveAttributeLocation(vtk.vtkAssignAttribute.CELL_DATA); outputMeshDisplayNode.SetSliceIntersectionVisibility(True) outputMeshDisplayNode.SetSliceIntersectionOpacity(0.5) else: currentColorNode = outputMeshDisplayNode.GetColorNode() if currentColorNode.GetType() == currentColorNode.User and currentColorNode.IsA("vtkMRMLColorTableNode"): # current color table node can be overwritten currentColorNode.Copy(colorTableNode) else: colorTableNode = slicer.mrmlScene.AddNode(colorTableNode) outputMeshDisplayNode.SetAndObserveColorNodeID(colorTableNode.GetID()) # Clean up if self.deleteTemporaryFiles: import shutil shutil.rmtree(tempDir) self.addLog("Model generation is completed")
def obs_to_world(self, pnt): if not self.hasData: return spacing = self.imageData.GetSpacing() transform = vtk.vtkTransform() transform.Scale(spacing) return transform.TransformPoint(pnt)
def plot(self, color='w', show_edges=True, **kwargs): """Plot the full rotor geometry. Parameters ---------- color : string or 3 item list, optional, defaults to white Either a string, rgb list, or hex color string. For example: ``color='white'`` ``color='w'`` ``color=[1, 1, 1]`` ``color='#FFFFFF'`` Color will be overridden when scalars are input. show_edges : bool, optional Shows the edges of a mesh. Does not apply to a wireframe representation. style : string, optional Visualization style of the vtk mesh. One for the following: ``style='surface'`` ``style='wireframe'`` ``style='points'`` Defaults to 'surface' off_screen : bool Plots off screen when True. Helpful for saving screenshots without a window popping up. full_screen : bool, optional Opens window in full screen. When enabled, ignores window_size. Default False. screenshot : str or bool, optional Saves screenshot to file when enabled. See: help(pyvista.Plotter.screenshot). Default disabled. When True, takes screenshot and returns numpy array of image. window_size : list, optional Window size in pixels. Defaults to [1024, 768] show_bounds : bool, optional Shows mesh bounds when True. Default False. Alias ``show_grid`` also accepted. show_axes : bool, optional Shows a vtk axes widget. Enabled by default. Returns ------- cpos : list List of camera position, focal point, and view up. """ cs_cord = self.resultheader['csCord'] if cs_cord > 1: matrix = self.cs_4x4(cs_cord, as_vtk_matrix=True) i_matrix = self.cs_4x4(cs_cord, as_vtk_matrix=True) i_matrix.Invert() else: matrix = vtk.vtkMatrix4x4() i_matrix = vtk.vtkMatrix4x4() off_screen = kwargs.pop('off_screen', None) window_size = kwargs.pop('window_size', None) plotter = pv.Plotter(off_screen, window_size) rang = 360.0 / self.n_sector for i in range(self.n_sector): actor = plotter.add_mesh(self.grid.copy(False), color=color, show_edges=show_edges, **kwargs) # transform to standard position, rotate about Z axis, # transform back transform = vtk.vtkTransform() transform.RotateZ(rang*i) transform.Update() rot_matrix = transform.GetMatrix() if cs_cord > 1: temp_matrix = vtk.vtkMatrix4x4() rot_matrix.Multiply4x4(i_matrix, rot_matrix, temp_matrix) rot_matrix.Multiply4x4(temp_matrix, matrix, rot_matrix) transform.SetMatrix(rot_matrix) actor.SetUserTransform(transform) cpos = kwargs.pop('cpos', None) if cpos is None: cpos = plotter.get_default_cam_pos() plotter.camera_position = cpos plotter.camera_set = False else: plotter.camera_position = cpos return plotter.plot()
def TestSection_03_qMRMLSegmentationGeometryWidget(self): logging.info('Test section 2: qMRMLSegmentationGeometryWidget') binaryLabelmapReprName = slicer.vtkSegmentationConverter.GetBinaryLabelmapRepresentationName( ) closedSurfaceReprName = slicer.vtkSegmentationConverter.GetClosedSurfaceRepresentationName( ) # Use MRHead and Tinypatient for testing import SampleData mrVolumeNode = SampleData.downloadSample("MRHead") [tinyVolumeNode, tinySegmentationNode] = SampleData.downloadSamples('TinyPatient') # Convert MRHead to oriented image data import vtkSlicerSegmentationsModuleLogicPython as vtkSlicerSegmentationsModuleLogic mrOrientedImageData = vtkSlicerSegmentationsModuleLogic.vtkSlicerSegmentationsModuleLogic.CreateOrientedImageDataFromVolumeNode( mrVolumeNode) mrOrientedImageData.UnRegister(None) # Create segmentation node with binary labelmap master and one segment with MRHead geometry segmentationNode = slicer.mrmlScene.AddNewNodeByClass( 'vtkMRMLSegmentationNode') segmentationNode.GetSegmentation().SetMasterRepresentationName( binaryLabelmapReprName) geometryStr = slicer.vtkSegmentationConverter.SerializeImageGeometry( mrOrientedImageData) segmentationNode.GetSegmentation().SetConversionParameter( slicer.vtkSegmentationConverter. GetReferenceImageGeometryParameterName(), geometryStr) threshold = vtk.vtkImageThreshold() threshold.SetInputData(mrOrientedImageData) threshold.ThresholdByUpper(16.0) threshold.SetInValue(1) threshold.SetOutValue(0) threshold.SetOutputScalarType(vtk.VTK_UNSIGNED_CHAR) threshold.Update() segmentOrientedImageData = slicer.vtkOrientedImageData() segmentOrientedImageData.DeepCopy(threshold.GetOutput()) mrImageToWorldMatrix = vtk.vtkMatrix4x4() mrOrientedImageData.GetImageToWorldMatrix(mrImageToWorldMatrix) segmentOrientedImageData.SetImageToWorldMatrix(mrImageToWorldMatrix) segment = slicer.vtkSegment() segment.SetName('Brain') segment.SetColor(0.0, 0.0, 1.0) segment.AddRepresentation(binaryLabelmapReprName, segmentOrientedImageData) segmentationNode.GetSegmentation().AddSegment(segment) # Create geometry widget geometryWidget = slicer.qMRMLSegmentationGeometryWidget() geometryWidget.setSegmentationNode(segmentationNode) geometryWidget.editEnabled = True geometryImageData = slicer.vtkOrientedImageData( ) # To contain the output later # Volume source with no transforms geometryWidget.setSourceNode(tinyVolumeNode) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (49, 49, 23), (248.8439, 248.2890, -123.75), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 92) # Transformed volume source translationTransformMatrix = vtk.vtkMatrix4x4() translationTransformMatrix.SetElement(0, 3, 24.5) translationTransformMatrix.SetElement(1, 3, 24.5) translationTransformMatrix.SetElement(2, 3, 11.5) translationTransformNode = slicer.vtkMRMLLinearTransformNode() translationTransformNode.SetName('TestTranslation') slicer.mrmlScene.AddNode(translationTransformNode) translationTransformNode.SetMatrixTransformToParent( translationTransformMatrix) tinyVolumeNode.SetAndObserveTransformNodeID( translationTransformNode.GetID()) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (49, 49, 23), (273.3439, 272.7890, -112.25), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 94) # Volume source with isotropic spacing tinyVolumeNode.SetAndObserveTransformNodeID(None) geometryWidget.setIsotropicSpacing(True) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (23, 23, 23), (248.8439, 248.2890, -123.75), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 414) # Volume source with oversampling geometryWidget.setIsotropicSpacing(False) geometryWidget.setOversamplingFactor(2.0) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (24.5, 24.5, 11.5), (261.0939, 260.5390, -129.5), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 751) slicer.util.delayDisplay('Volume source cases - OK') # Segmentation source with binary labelmap master geometryWidget.setOversamplingFactor(1.0) geometryWidget.setSourceNode(tinySegmentationNode) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (49, 49, 23), (248.8439, 248.2890, -123.75), [[-1.0, 0.0, 0.0], [0.0, -1.0, 0.0], [0.0, 0.0, 1.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 92) # Segmentation source with closed surface master tinySegmentationNode.GetSegmentation().SetConversionParameter( 'Smoothing factor', '0.0') self.assertTrue( tinySegmentationNode.GetSegmentation().CreateRepresentation( closedSurfaceReprName)) tinySegmentationNode.GetSegmentation().SetMasterRepresentationName( closedSurfaceReprName) tinySegmentationNode.Modified( ) # Trigger re-calculation of geometry (only generic Modified event is observed) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (1, 1, 1), (-86.645, 133.929, 116.786), # current origin of the segmentation is kept [[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5223040) slicer.util.delayDisplay('Segmentation source cases - OK') # Model source with no transform shNode = slicer.vtkMRMLSubjectHierarchyNode.GetSubjectHierarchyNode( slicer.mrmlScene) outputFolderId = shNode.CreateFolderItem(shNode.GetSceneItemID(), 'ModelsFolder') success = vtkSlicerSegmentationsModuleLogic.vtkSlicerSegmentationsModuleLogic.ExportVisibleSegmentsToModels( tinySegmentationNode, outputFolderId) self.assertTrue(success) modelNode = slicer.util.getNode('Body_Contour') geometryWidget.setSourceNode(modelNode) geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (1, 1, 1), (-86.645, 133.929, 116.786), # current origin of the segmentation is kept [[0.0, 0.0, 1.0], [-1.0, 0.0, 0.0], [0.0, -1.0, 0.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5223040) slicer.util.delayDisplay('Model source - OK') # Transformed model source rotationTransform = vtk.vtkTransform() rotationTransform.RotateX(45) rotationTransformMatrix = vtk.vtkMatrix4x4() rotationTransform.GetMatrix(rotationTransformMatrix) rotationTransformNode = slicer.vtkMRMLLinearTransformNode() rotationTransformNode.SetName('TestRotation') slicer.mrmlScene.AddNode(rotationTransformNode) rotationTransformNode.SetMatrixTransformToParent( rotationTransformMatrix) modelNode.SetAndObserveTransformNodeID(rotationTransformNode.GetID()) modelNode.Modified() geometryWidget.geometryImageData(geometryImageData) self.assertTrue( self.compareOutputGeometry( geometryImageData, (1, 1, 1), (-86.645, 177.282, -12.122), [[0.0, 0.0, 1.0], [-0.7071, -0.7071, 0.0], [0.7071, -0.7071, 0.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5229164) slicer.util.delayDisplay('Transformed model source - OK') # ROI source roiNode = slicer.mrmlScene.AddNewNodeByClass("vtkMRMLMarkupsROINode", 'SourceROI') rasDimensions = [0.0, 0.0, 0.0] rasCenter = [0.0, 0.0, 0.0] slicer.vtkMRMLSliceLogic.GetVolumeRASBox(tinyVolumeNode, rasDimensions, rasCenter) print(f"rasDimensions={rasDimensions}, rasCenter={rasCenter}") rasRadius = [x / 2.0 for x in rasDimensions] roiNode.SetCenter(rasCenter) roiNode.SetRadiusXYZ(rasRadius) geometryWidget.setSourceNode(roiNode) geometryWidget.geometryImageData(geometryImageData) print(f"geometryImageData: {geometryImageData}") self.assertTrue( self.compareOutputGeometry( geometryImageData, (1, 1, 1), (28.344, 27.789, -20.25), [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]])) slicer.vtkOrientedImageDataResample.ResampleOrientedImageToReferenceOrientedImage( segmentOrientedImageData, geometryImageData, geometryImageData, False, True) self.assertEqual(self.getForegroundVoxelCount(geometryImageData), 5223040) slicer.util.delayDisplay('ROI source - OK') slicer.util.delayDisplay('Segmentation geometry widget test passed')
def plot_point_scalars(self, scalars, rnum=None, stitle='', flip_scalars=None, screenshot=None, cpos=None, off_screen=None, grid=None, add_text=True, **kwargs): """ Plot point scalars on active mesh. Parameters ---------- scalars : np.ndarray Node scalars to plot. rnum : int, optional Cumulative result number. Used for adding informative text. stitle : str, optional Title of the scalar bar. flip_scalars : bool, optional Reverses the direction of the cmap. screenshot : str, optional When a filename, saves screenshot to disk. cpos : list, optional 3x3 list describing the camera position. Obtain it by getting the output of plot_point_scalars first. interactive : bool, optional Allows user to interact with the plot when True. Default True. grid : pyvista.PolyData or pyvista.UnstructuredGrid, optional Uses self.grid by default. When specified, uses this grid instead. add_text : bool, optional Adds information about the result when rnum is given. kwargs : keyword arguments Additional keyword arguments. See help(pyvista.plot) Returns ------- cpos : list Camera position. """ if grid is None: grid = self.mas_grid window_size = kwargs.pop('window_size', None) full_screen = kwargs.pop('full_screen', False) cmap = kwargs.pop('cmap', 'jet') # Plot off screen when not interactive plotter = pv.Plotter(off_screen=off_screen) if 'show_axes' in kwargs: plotter.add_axes() # set background plotter.background_color = kwargs.pop('background', None) rng = [np.nanmin(scalars), np.nanmax(scalars)] cs_cord = self.resultheader['csCord'] if cs_cord > 1: matrix = self.cs_4x4(cs_cord, as_vtk_matrix=True) i_matrix = self.cs_4x4(cs_cord, as_vtk_matrix=True) i_matrix.Invert() else: matrix = vtk.vtkMatrix4x4() i_matrix = vtk.vtkMatrix4x4() rang = 360.0 / self.n_sector for i in range(self.n_sector): actor = plotter.add_mesh(grid.copy(False), scalars=scalars[i], stitle=stitle, cmap=cmap, flip_scalars=flip_scalars, interpolate_before_map=True, rng=rng, **kwargs) # for transparency issues # plotter.renderers[0].SetUseDepthPeeling(1) # NAN/missing data are white plotter.mapper.GetLookupTable().SetNanColor(1, 1, 1, 1) # transform to standard position, rotate about Z axis, # transform back transform = vtk.vtkTransform() transform.RotateZ(rang*i) transform.Update() rot_matrix = transform.GetMatrix() if cs_cord > 1: temp_matrix = vtk.vtkMatrix4x4() rot_matrix.Multiply4x4(i_matrix, rot_matrix, temp_matrix) rot_matrix.Multiply4x4(temp_matrix, matrix, rot_matrix) transform.SetMatrix(rot_matrix) actor.SetUserTransform(transform) if cpos: plotter.camera_position = cpos # add table if add_text and rnum is not None: plotter.add_text(self.text_result_table(rnum), font_size=20, position=[0, 0]) if screenshot: cpos = plotter.show(auto_close=False, interactive=interactive, window_size=window_size, full_screen=full_screen) if screenshot is True: img = plotter.screenshot() else: plotter.screenshot(screenshot) plotter.close() else: cpos = plotter.plot(window_size=window_size, full_screen=full_screen) if screenshot is True: return cpos, img else: return cpos
def quiver3d(self, x, y, z, u, v, w, color, scale, mode, resolution=8, glyph_height=None, glyph_center=None, glyph_resolution=None, opacity=1.0, scale_mode='none', scalars=None, backface_culling=False, line_width=2., name=None): with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=FutureWarning) factor = scale vectors = np.c_[u, v, w] points = np.vstack(np.c_[x, y, z]) n_points = len(points) offset = np.arange(n_points) * 3 cell_type = np.full(n_points, vtk.VTK_VERTEX) cells = np.c_[np.full(n_points, 1), range(n_points)] grid = UnstructuredGrid(offset, cells, cell_type, points) grid.point_arrays['vec'] = vectors if scale_mode == 'scalar': grid.point_arrays['mag'] = np.array(scalars) scale = 'mag' else: scale = False if mode == '2darrow': return _arrow_glyph(grid, factor) elif mode == 'arrow' or mode == '3darrow': self.plotter.add_mesh(grid.glyph(orient='vec', scale=scale, factor=factor), color=color, opacity=opacity, backface_culling=backface_culling) elif mode == 'cone': cone = vtk.vtkConeSource() if glyph_height is not None: cone.SetHeight(glyph_height) if glyph_center is not None: cone.SetCenter(glyph_center) if glyph_resolution is not None: cone.SetResolution(glyph_resolution) cone.Update() geom = cone.GetOutput() self.plotter.add_mesh(grid.glyph(orient='vec', scale=scale, factor=factor, geom=geom), color=color, opacity=opacity, backface_culling=backface_culling) elif mode == 'cylinder': cylinder = vtk.vtkCylinderSource() cylinder.SetHeight(glyph_height) cylinder.SetRadius(0.15) cylinder.SetCenter(glyph_center) cylinder.SetResolution(glyph_resolution) cylinder.Update() # fix orientation tr = vtk.vtkTransform() tr.RotateWXYZ(90, 0, 0, 1) trp = vtk.vtkTransformPolyDataFilter() trp.SetInputData(cylinder.GetOutput()) trp.SetTransform(tr) trp.Update() geom = trp.GetOutput() self.plotter.add_mesh(grid.glyph(orient='vec', scale=scale, factor=factor, geom=geom), color=color, opacity=opacity, backface_culling=backface_culling)
def main(): # Basic stuff setup # Set up the renderer, window, and interactor colors = vtk.vtkNamedColors() ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetSize(640, 480) iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin) # Create a cone with an elliptical base whose major axis is in the # X-direction. coneSource = vtk.vtkConeSource() coneSource.SetCenter(0.0, 0.0, 0.0) coneSource.SetRadius(5.0) coneSource.SetHeight(15.0) coneSource.SetDirection(0, 1, 0) coneSource.SetResolution(60) coneSource.Update() transform = vtk.vtkTransform() transform.Scale(1.0, 1.0, 0.75) transF = vtk.vtkTransformPolyDataFilter() transF.SetInputConnection(coneSource.GetOutputPort()) transF.SetTransform(transform) bounds = transF.GetOutput().GetBounds() elevation = vtk.vtkElevationFilter() elevation.SetInputConnection(transF.GetOutputPort()) elevation.SetLowPoint(0, bounds[2], 0) elevation.SetHighPoint(0, bounds[3], 0) bandedContours = vtk.vtkBandedPolyDataContourFilter() bandedContours.SetInputConnection(elevation.GetOutputPort()) bandedContours.SetScalarModeToValue() bandedContours.GenerateContourEdgesOn() bandedContours.GenerateValues(11, elevation.GetScalarRange()) # Make a lookup table using a color series. colorSeries = vtk.vtkColorSeries() colorSeries.SetColorScheme(vtk.vtkColorSeries.BREWER_DIVERGING_SPECTRAL_11) lut = vtk.vtkLookupTable() colorSeries.BuildLookupTable(lut, vtk.vtkColorSeries.ORDINAL) coneMapper = vtk.vtkPolyDataMapper() coneMapper.SetInputConnection(bandedContours.GetOutputPort()) coneMapper.SetScalarRange(elevation.GetScalarRange()) coneMapper.SetLookupTable(lut) coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) # Contouring contourLineMapper = vtk.vtkPolyDataMapper() contourLineMapper.SetInputData(bandedContours.GetContourEdgesOutput()) contourLineMapper.SetScalarRange(elevation.GetScalarRange()) contourLineMapper.SetResolveCoincidentTopologyToPolygonOffset() contourLineActor = vtk.vtkActor() contourLineActor.SetMapper(contourLineMapper) contourLineActor.GetProperty().SetColor(colors.GetColor3d('DimGray')) # Set up the Orientation Marker Widget. prop_assembly = MakeAnnotatedCubeActor(colors) om1 = vtk.vtkOrientationMarkerWidget() om1.SetOrientationMarker(prop_assembly) om1.SetInteractor(iRen) om1.SetDefaultRenderer(ren) om1.On() om1.InteractiveOn() xyzLabels = ['X', 'Y', 'Z'] scale = [1.0, 1.0, 1.0] axes = MakeAxesActor(scale, xyzLabels) om2 = vtk.vtkOrientationMarkerWidget() om2.SetOrientationMarker(axes) # Position lower right in the viewport. om2.SetViewport(0.8, 0, 1.0, 0.2) om2.SetInteractor(iRen) om2.EnabledOn() om2.InteractiveOn() ren.AddActor(coneActor) ren.AddActor(contourLineActor) ren.SetBackground2(colors.GetColor3d('RoyalBlue')) ren.SetBackground(colors.GetColor3d('MistyRose')) ren.GradientBackgroundOn() ren.GetActiveCamera().Azimuth(45) ren.GetActiveCamera().Pitch(-22.5) ren.ResetCamera() renWin.SetSize(600, 600) renWin.Render() renWin.SetWindowName('ColoredAnnotatedCube') renWin.Render() iRen.Start()
from vtk.util.misc import vtkGetDataRoot VTK_DATA_ROOT = vtkGetDataRoot() # create pipeline # pl3d = vtk.vtkMultiBlockPLOT3DReader() pl3d.SetXYZFileName("" + str(VTK_DATA_ROOT) + "/Data/combxyz.bin") pl3d.SetQFileName("" + str(VTK_DATA_ROOT) + "/Data/combq.bin") pl3d.SetScalarFunctionNumber(100) pl3d.SetVectorFunctionNumber(202) pl3d.Update() output = pl3d.GetOutput().GetBlock(0) # create three line probes line = vtk.vtkLineSource() line.SetResolution(30) transL1 = vtk.vtkTransform() transL1.Translate(3.7, 0.0, 28.37) transL1.Scale(5, 5, 5) transL1.RotateY(90) tf = vtk.vtkTransformPolyDataFilter() tf.SetInputConnection(line.GetOutputPort()) tf.SetTransform(transL1) probe = vtk.vtkProbeFilter() probe.SetInputConnection(tf.GetOutputPort()) probe.SetSourceData(output) probe.Update() transL2 = vtk.vtkTransform() transL2.Translate(9.2, 0.0, 31.20) transL2.Scale(5, 5, 5) transL2.RotateY(90) tf2 = vtk.vtkTransformPolyDataFilter()
def createModelBaseOnVolume(self, holefilledImageNode, outputModelNode): if holefilledImageNode: holefilledImageData = holefilledImageNode.GetImageData() cast = vtk.vtkImageCast() cast.SetInputData(holefilledImageData) cast.SetOutputScalarTypeToUnsignedChar() cast.Update() labelVolumeNode = slicer.mrmlScene.CreateNodeByClass("vtkMRMLLabelMapVolumeNode") slicer.mrmlScene.AddNode(labelVolumeNode) labelVolumeNode.SetName("Threshold") labelVolumeNode.SetSpacing(holefilledImageData.GetSpacing()) labelVolumeNode.SetOrigin(holefilledImageData.GetOrigin()) matrix = vtk.vtkMatrix4x4() holefilledImageNode.GetIJKToRASMatrix(matrix) labelVolumeNode.SetIJKToRASMatrix(matrix) labelImage = cast.GetOutput() labelVolumeNode.SetAndObserveImageData(labelImage) transformIJKtoRAS = vtk.vtkTransform() matrix = vtk.vtkMatrix4x4() labelVolumeNode.GetRASToIJKMatrix(matrix) transformIJKtoRAS.SetMatrix(matrix) transformIJKtoRAS.Inverse() padder = vtk.vtkImageConstantPad() padder.SetInputData(labelImage) padder.SetConstant(0) extent = labelImage.GetExtent() padder.SetOutputWholeExtent(extent[0], extent[1] + 2, extent[2], extent[3] + 2, extent[4], extent[5] + 2) cubes = vtk.vtkDiscreteMarchingCubes() cubes.SetInputConnection(padder.GetOutputPort()) cubes.GenerateValues(1, 1, 1) cubes.Update() smoother = vtk.vtkWindowedSincPolyDataFilter() smoother.SetInputConnection(cubes.GetOutputPort()) smoother.SetNumberOfIterations(10) smoother.BoundarySmoothingOn() smoother.FeatureEdgeSmoothingOff() smoother.SetFeatureAngle(120.0) smoother.SetPassBand(0.001) smoother.NonManifoldSmoothingOn() smoother.NormalizeCoordinatesOn() smoother.Update() pthreshold = vtk.vtkThreshold() pthreshold.SetInputConnection(smoother.GetOutputPort()) pthreshold.ThresholdBetween(1, 1) ## Label 1 pthreshold.ReleaseDataFlagOn() geometryFilter = vtk.vtkGeometryFilter() geometryFilter.SetInputConnection(pthreshold.GetOutputPort()) geometryFilter.ReleaseDataFlagOn() decimator = vtk.vtkDecimatePro() decimator.SetInputConnection(geometryFilter.GetOutputPort()) decimator.SetFeatureAngle(60) decimator.SplittingOff() decimator.PreserveTopologyOn() decimator.SetMaximumError(1) decimator.SetTargetReduction(0.5) #0.001 only reduce the points by 0.1%, 0.5 is 50% off decimator.ReleaseDataFlagOff() decimator.Update() smootherPoly = vtk.vtkSmoothPolyDataFilter() smootherPoly.SetRelaxationFactor(0.33) smootherPoly.SetFeatureAngle(60) smootherPoly.SetConvergence(0) if transformIJKtoRAS.GetMatrix().Determinant() < 0: reverser = vtk.vtkReverseSense() reverser.SetInputConnection(decimator.GetOutputPort()) reverser.ReverseNormalsOn() reverser.ReleaseDataFlagOn() smootherPoly.SetInputConnection(reverser.GetOutputPort()) else: smootherPoly.SetInputConnection(decimator.GetOutputPort()) Smooth = 10 smootherPoly.SetNumberOfIterations(Smooth) smootherPoly.FeatureEdgeSmoothingOff() smootherPoly.BoundarySmoothingOff() smootherPoly.ReleaseDataFlagOn() smootherPoly.Update() transformer = vtk.vtkTransformPolyDataFilter() transformer.SetInputConnection(smootherPoly.GetOutputPort()) transformer.SetTransform(transformIJKtoRAS) transformer.ReleaseDataFlagOn() transformer.Update() normals = vtk.vtkPolyDataNormals() normals.SetInputConnection(transformer.GetOutputPort()) normals.SetFeatureAngle(60) normals.SetSplitting(True) normals.ReleaseDataFlagOn() stripper = vtk.vtkStripper() stripper.SetInputConnection(normals.GetOutputPort()) stripper.ReleaseDataFlagOff() stripper.Update() outputModel = stripper.GetOutput() outputModelNode.SetAndObservePolyData(outputModel) outputModelNode.SetAttribute("vtkMRMLModelNode.modelCreated","True") outputModelNode.GetDisplayNode().SetVisibility(1) slicer.mrmlScene.RemoveNode(labelVolumeNode) pass
def main(): filename = get_program_parameters() # Create the reader for the data. reader = vtk.vtkUnstructuredGridReader() reader.SetFileName(filename) reader.Update() bounds = reader.GetOutput().GetBounds() center = reader.GetOutput().GetCenter() colors = vtk.vtkNamedColors() renderer = vtk.vtkRenderer() renderer.SetBackground(colors.GetColor3d('Wheat')) renderer.UseHiddenLineRemovalOn() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.SetSize(640, 480) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) xnorm = [-1.0, -1.0, 1.0] clipPlane = vtk.vtkPlane() clipPlane.SetOrigin(reader.GetOutput().GetCenter()) clipPlane.SetNormal(xnorm) clipper = vtk.vtkClipDataSet() clipper.SetClipFunction(clipPlane) clipper.SetInputData(reader.GetOutput()) clipper.SetValue(0.0) clipper.GenerateClippedOutputOn() clipper.Update() insideMapper = vtk.vtkDataSetMapper() insideMapper.SetInputData(clipper.GetOutput()) insideMapper.ScalarVisibilityOff() insideActor = vtk.vtkActor() insideActor.SetMapper(insideMapper) insideActor.GetProperty().SetDiffuseColor(colors.GetColor3d('banana')) insideActor.GetProperty().SetAmbient(.3) insideActor.GetProperty().EdgeVisibilityOn() clippedMapper = vtk.vtkDataSetMapper() clippedMapper.SetInputData(clipper.GetClippedOutput()) clippedMapper.ScalarVisibilityOff() clippedActor = vtk.vtkActor() clippedActor.SetMapper(clippedMapper) clippedActor.GetProperty().SetDiffuseColor(colors.GetColor3d('tomato')) insideActor.GetProperty().SetAmbient(.3) clippedActor.GetProperty().EdgeVisibilityOn() # Create transforms to make a better visualization insideTransform = vtk.vtkTransform() insideTransform.Translate(-(bounds[1] - bounds[0]) * 0.75, 0, 0) insideTransform.Translate(center[0], center[1], center[2]) insideTransform.RotateY(-120.0) insideTransform.Translate(-center[0], -center[1], -center[2]) insideActor.SetUserTransform(insideTransform) clippedTransform = vtk.vtkTransform() clippedTransform.Translate((bounds[1] - bounds[0]) * 0.75, 0, 0) clippedTransform.Translate(center[0], center[1], center[2]) clippedTransform.RotateY(60.0) clippedTransform.Translate(-center[0], -center[1], -center[2]) clippedActor.SetUserTransform(clippedTransform) renderer.AddViewProp(clippedActor) renderer.AddViewProp(insideActor) renderer.ResetCamera() renderer.GetActiveCamera().Dolly(1.4) renderer.ResetCameraClippingRange() renderWindow.Render() renderWindow.SetWindowName('ClipUnstructuredGridWithPlane2') renderWindow.Render() interactor.Start() # Generate a report numberOfCells = clipper.GetOutput().GetNumberOfCells() print('------------------------') print('The inside dataset contains a \n', clipper.GetOutput().GetClassName(), ' that has ', numberOfCells, ' cells') cellMap = dict() for i in range(0, numberOfCells): cellMap.setdefault(clipper.GetOutput().GetCellType(i), 0) cellMap[clipper.GetOutput().GetCellType(i)] += 1 # Sort by key and put into an OrderedDict. # An OrderedDict remembers the order in which the keys have been inserted. for k, v in collections.OrderedDict(sorted(cellMap.items())).items(): print('\tCell type ', vtk.vtkCellTypes.GetClassNameFromTypeId(k), ' occurs ', v, ' times.') numberOfCells = clipper.GetClippedOutput().GetNumberOfCells() print('------------------------') print('The clipped dataset contains a \n', clipper.GetClippedOutput().GetClassName(), ' that has ', numberOfCells, ' cells') outsideCellMap = dict() for i in range(0, numberOfCells): outsideCellMap.setdefault(clipper.GetClippedOutput().GetCellType(i), 0) outsideCellMap[clipper.GetClippedOutput().GetCellType(i)] += 1 for k, v in collections.OrderedDict(sorted( outsideCellMap.items())).items(): print('\tCell type ', vtk.vtkCellTypes.GetClassNameFromTypeId(k), ' occurs ', v, ' times.')
import vtk '''<Reader>''' reader = vtk.vtkStructuredGridReader() reader.SetFileName('files/output.vtk') reader.Update() # 'Active' Scalar 지정 또는 변경(이미 default로 되어있는 경우) varName = reader.GetOutput().GetPointData().GetArrayName(1) reader.GetOutput().GetPointData().SetActiveScalars(varName) rangeStart, rangeEnd = reader.GetOutput().GetScalarRange() '''<Filter 1>''' transformation = vtk.vtkTransform() transformation.Scale(1, 1, 0.001) Filter1 = vtk.vtkTransformFilter() Filter1.SetInputConnection(reader.GetOutputPort()) Filter1.SetTransform(transformation) '''<Filter 2>''' Filter2 = vtk.vtkThreshold() Filter2.ThresholdBetween(rangeStart, rangeEnd) Filter2.SetInputConnection(Filter1.GetOutputPort()) '''<Mapper>''' mapper = vtk.vtkDataSetMapper() mapper.SetInputConnection(Filter2.GetOutputPort()) mapper.SetScalarRange(reader.GetOutput().GetScalarRange()) '''<Actor>''' actor = vtk.vtkActor() actor.SetMapper(mapper) '''<Renderer>''' renderer = vtk.vtkRenderer() renderer.AddActor(actor) renderer.SetBackground(1, 1, 1)
def gen_surface(tomo, lbl=1, mask=True, purge_ratio=1, field=False, mode_2d=False, verbose=False): """ Generates a VTK PolyData surface from a segmented tomogram. Args: tomo (numpy.ndarray or str): the input segmentation as numpy ndarray or the file name in MRC, EM or VTI format lbl (int, optional): label for the foreground, default 1 mask (boolean, optional): if True (default), the input segmentation is used as mask for the surface purge_ratio (int, optional): if greater than 1 (default), then 1 every purge_ratio points of the segmentation are randomly deleted field (boolean, optional): if True (default False), additionally returns the polarity distance scalar field mode_2d (boolean, optional): needed for polarity distance calculation (if field is True), if True (default False), ... verbose (boolean, optional): if True (default False), prints out messages for checking the progress Returns: - output surface (vtk.vtkPolyData) - polarity distance scalar field (np.ndarray), if field is True """ # Check input format if isinstance(tomo, str): fname, fext = os.path.splitext(tomo) # if fext == '.fits': # tomo = pyfits.getdata(tomo) if fext == '.mrc': hold = ImageIO() hold.readMRC(file=tomo) tomo = hold.data elif fext == '.em': hold = ImageIO() hold.readEM(file=tomo) tomo = hold.data elif fext == '.vti': reader = vtk.vtkXMLImageDataReader() reader.SetFileName(tomo) reader.Update() tomo = vti_to_numpy(reader.GetOutput()) else: error_msg = 'Format %s not readable.' % fext raise pexceptions.PySegInputError(expr='gen_surface', msg=error_msg) elif not isinstance(tomo, np.ndarray): error_msg = 'Input must be either a file name or a ndarray.' raise pexceptions.PySegInputError(expr='gen_surface', msg=error_msg) # Load file with the cloud of points nx, ny, nz = tomo.shape cloud = vtk.vtkPolyData() points = vtk.vtkPoints() cloud.SetPoints(points) if purge_ratio <= 1: for x in range(nx): for y in range(ny): for z in range(nz): if tomo[x, y, z] == lbl: points.InsertNextPoint(x, y, z) else: count = 0 mx_value = purge_ratio - 1 purge = np.random.randint(0, purge_ratio+1, nx*ny*nz) for x in range(nx): for y in range(ny): for z in range(nz): if purge[count] == mx_value: if tomo[x, y, z] == lbl: points.InsertNextPoint(x, y, z) count += 1 if verbose: print 'Cloud of points loaded...' # Creating the isosurface surf = vtk.vtkSurfaceReconstructionFilter() # surf.SetSampleSpacing(2) surf.SetSampleSpacing(purge_ratio) # surf.SetNeighborhoodSize(10) surf.SetInputData(cloud) contf = vtk.vtkContourFilter() contf.SetInputConnection(surf.GetOutputPort()) # if thick is None: contf.SetValue(0, 0) # else: # contf.SetValue(0, thick) # Sometimes the contouring algorithm can create a volume whose gradient # vector and ordering of polygon (using the right hand rule) are # inconsistent. vtkReverseSense cures this problem. reverse = vtk.vtkReverseSense() reverse.SetInputConnection(contf.GetOutputPort()) reverse.ReverseCellsOn() reverse.ReverseNormalsOn() reverse.Update() rsurf = reverse.GetOutput() if verbose: print 'Isosurfaces generated...' # Translate and scale to the proper positions cloud.ComputeBounds() rsurf.ComputeBounds() xmin, xmax, ymin, ymax, zmin, zmax = cloud.GetBounds() rxmin, rxmax, rymin, rymax, rzmin, rzmax = rsurf.GetBounds() scale_x = (xmax-xmin) / (rxmax-rxmin) scale_y = (ymax-ymin) / (rymax-rymin) denom = rzmax - rzmin num = zmax - xmin if (denom == 0) or (num == 0): scale_z = 1 else: scale_z = (zmax-zmin) / (rzmax-rzmin) transp = vtk.vtkTransform() transp.Translate(xmin, ymin, zmin) transp.Scale(scale_x, scale_y, scale_z) transp.Translate(-rxmin, -rymin, -rzmin) tpd = vtk.vtkTransformPolyDataFilter() tpd.SetInputData(rsurf) tpd.SetTransform(transp) tpd.Update() tsurf = tpd.GetOutput() if verbose: print 'Rescaled and translated...' # Masking according to distance to the original segmentation if mask: tomod = scipy.ndimage.morphology.distance_transform_edt( np.invert(tomo == lbl)) for i in range(tsurf.GetNumberOfCells()): # Check if all points which made up the polygon are in the mask points_cell = tsurf.GetCell(i).GetPoints() count = 0 for j in range(0, points_cell.GetNumberOfPoints()): x, y, z = points_cell.GetPoint(j) if (tomod[int(round(x)), int(round(y)), int(round(z))] > MAX_DIST_SURF): count += 1 if count > 0: tsurf.DeleteCell(i) # Release free memory tsurf.RemoveDeletedCells() if verbose: print 'Mask applied...' # Field distance if field: # Get normal attributes norm_flt = vtk.vtkPolyDataNormals() norm_flt.SetInputData(tsurf) norm_flt.ComputeCellNormalsOn() norm_flt.AutoOrientNormalsOn() norm_flt.ConsistencyOn() norm_flt.Update() tsurf = norm_flt.GetOutput() # for i in range(tsurf.GetPointData().GetNumberOfArrays()): # array = tsurf.GetPointData().GetArray(i) # if array.GetNumberOfComponents() == 3: # break array = tsurf.GetCellData().GetNormals() # Build membrane mask tomoh = np.ones(shape=tomo.shape, dtype=np.bool) tomon = np.ones(shape=(tomo.shape[0], tomo.shape[1], tomo.shape[2], 3), dtype=TypesConverter().vtk_to_numpy(array)) # for i in range(tsurf.GetNumberOfCells()): # points_cell = tsurf.GetCell(i).GetPoints() # for j in range(0, points_cell.GetNumberOfPoints()): # x, y, z = points_cell.GetPoint(j) # # print x, y, z, array.GetTuple(j) # x, y, z = int(round(x)), int(round(y)), int(round(z)) # tomo[x, y, z] = False # tomon[x, y, z, :] = array.GetTuple(j) for i in range(tsurf.GetNumberOfCells()): points_cell = tsurf.GetCell(i).GetPoints() for j in range(0, points_cell.GetNumberOfPoints()): x, y, z = points_cell.GetPoint(j) # print x, y, z, array.GetTuple(j) x, y, z = int(round(x)), int(round(y)), int(round(z)) if tomo[x, y, z] == lbl: tomoh[x, y, z] = False tomon[x, y, z, :] = array.GetTuple(i) # Distance transform tomod, ids = scipy.ndimage.morphology.distance_transform_edt( tomoh, return_indices=True) # Compute polarity if mode_2d: for x in range(nx): for y in range(ny): for z in range(nz): i_x, i_y, i_z = (ids[0, x, y, z], ids[1, x, y, z], ids[2, x, y, z]) norm = tomon[i_x, i_y, i_z] norm[2] = 0 pnorm = (i_x, i_y, 0) p = (x, y, 0) dprod = dot_norm(np.asarray(p, dtype=np.float), np.asarray(pnorm, dtype=np.float), np.asarray(norm, dtype=np.float)) tomod[x, y, z] = tomod[x, y, z] * np.sign(dprod) else: for x in range(nx): for y in range(ny): for z in range(nz): i_x, i_y, i_z = (ids[0, x, y, z], ids[1, x, y, z], ids[2, x, y, z]) hold_norm = tomon[i_x, i_y, i_z] norm = hold_norm # norm[0] = (-1) * hold_norm[1] # norm[1] = hold_norm[0] # norm[2] = hold_norm[2] pnorm = (i_x, i_y, i_z) p = (x, y, z) dprod = dot_norm(np.asarray(pnorm, dtype=np.float), np.asarray(p, dtype=np.float), np.asarray(norm, dtype=np.float)) tomod[x, y, z] = tomod[x, y, z] * np.sign(dprod) if verbose: print 'Distance field generated...' return tsurf, tomod if verbose: print 'Finished!' return tsurf
def main(): colors = vtk.vtkNamedColors() # Set the colors. colors.SetColor("AzimuthArrowColor", [255, 77, 77, 255]) colors.SetColor("ElevationArrowColor", [77, 255, 77, 255]) colors.SetColor("RollArrowColor", [255, 255, 77, 255]) colors.SetColor("SpikeColor", [255, 77, 255, 255]) colors.SetColor("BkgColor", [26, 51, 102, 255]) # Create a rendering window, renderer and interactor. ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # Create a camera model. camCS = vtk.vtkConeSource() camCS.SetHeight(1.5) camCS.SetResolution(12) camCS.SetRadius(0.4) camCBS = vtk.vtkCubeSource() camCBS.SetXLength(1.5) camCBS.SetZLength(0.8) camCBS.SetCenter(0.4, 0, 0) camAPD = vtk.vtkAppendFilter() camAPD.AddInputConnection(camCBS.GetOutputPort()) camAPD.AddInputConnection(camCS.GetOutputPort()) camMapper = vtk.vtkPolyDataMapper() camMapper.SetInputConnection(camAPD.GetOutputPort()) camActor = vtk.vtkLODActor() camActor.SetMapper(camMapper) camActor.SetScale(2, 2, 2) # Draw the arrows. pd = vtk.vtkPolyData() ca = vtk.vtkCellArray() fp = vtk.vtkPoints() fp.InsertNextPoint(0, 1, 0) fp.InsertNextPoint(8, 1, 0) fp.InsertNextPoint(8, 2, 0) fp.InsertNextPoint(10, 0.01, 0) fp.InsertNextPoint(8, -2, 0) fp.InsertNextPoint(8, -1, 0) fp.InsertNextPoint(0, -1, 0) ca.InsertNextCell(7) ca.InsertCellPoint(0) ca.InsertCellPoint(1) ca.InsertCellPoint(2) ca.InsertCellPoint(3) ca.InsertCellPoint(4) ca.InsertCellPoint(5) ca.InsertCellPoint(6) pd.SetPoints(fp) pd.SetPolys(ca) pd2 = vtk.vtkPolyData() ca2 = vtk.vtkCellArray() fp2 = vtk.vtkPoints() fp2.InsertNextPoint(0, 1, 0) fp2.InsertNextPoint(8, 1, 0) fp2.InsertNextPoint(8, 2, 0) fp2.InsertNextPoint(10, 0.01, 0) ca2.InsertNextCell(4) ca2.InsertCellPoint(0) ca2.InsertCellPoint(1) ca2.InsertCellPoint(2) ca2.InsertCellPoint(3) pd2.SetPoints(fp2) pd2.SetLines(ca2) arrowIM = vtk.vtkImplicitModeller() arrowIM.SetInputData(pd) arrowIM.SetSampleDimensions(50, 20, 8) arrowCF = vtk.vtkContourFilter() arrowCF.SetInputConnection(arrowIM.GetOutputPort()) arrowCF.SetValue(0, 0.2) arrowWT = vtk.vtkWarpTo() arrowWT.SetInputConnection(arrowCF.GetOutputPort()) arrowWT.SetPosition(5, 0, 5) arrowWT.SetScaleFactor(0.85) arrowWT.AbsoluteOn() arrowT = vtk.vtkTransform() arrowT.RotateY(60) arrowT.Translate(-1.33198, 0, -1.479) arrowT.Scale(1, 0.5, 1) arrowTF = vtk.vtkTransformFilter() arrowTF.SetInputConnection(arrowWT.GetOutputPort()) arrowTF.SetTransform(arrowT) arrowMapper = vtk.vtkDataSetMapper() arrowMapper.SetInputConnection(arrowTF.GetOutputPort()) arrowMapper.ScalarVisibilityOff() # Draw the azimuth arrows. a1Actor = vtk.vtkLODActor() a1Actor.SetMapper(arrowMapper) a1Actor.RotateZ(180) a1Actor.SetPosition(1, 0, -1) a1Actor.GetProperty().SetColor(colors.GetColor3d("AzimuthArrowColor")) a1Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) a1Actor.GetProperty().SetSpecular(0.3) a1Actor.GetProperty().SetSpecularPower(20) a1Actor.GetProperty().SetAmbient(0.2) a1Actor.GetProperty().SetDiffuse(0.8) a2Actor = vtk.vtkLODActor() a2Actor.SetMapper(arrowMapper) a2Actor.RotateZ(180) a2Actor.RotateX(180) a2Actor.SetPosition(1, 0, 1) a2Actor.GetProperty().SetColor(colors.GetColor3d("AzimuthArrowColor")) a2Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) a2Actor.GetProperty().SetSpecular(0.3) a2Actor.GetProperty().SetSpecularPower(20) a2Actor.GetProperty().SetAmbient(0.2) a2Actor.GetProperty().SetDiffuse(0.8) # Draw the elevation arrows. a3Actor = vtk.vtkLODActor() a3Actor.SetMapper(arrowMapper) a3Actor.RotateZ(180) a3Actor.RotateX(90) a3Actor.SetPosition(1, -1, 0) a3Actor.GetProperty().SetColor(colors.GetColor3d("ElevationArrowColor")) a3Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) a3Actor.GetProperty().SetSpecular(0.3) a3Actor.GetProperty().SetSpecularPower(20) a3Actor.GetProperty().SetAmbient(0.2) a3Actor.GetProperty().SetDiffuse(0.8) a4Actor = vtk.vtkLODActor() a4Actor.SetMapper(arrowMapper) a4Actor.RotateZ(180) a4Actor.RotateX(-90) a4Actor.SetPosition(1, 1, 0) a4Actor.GetProperty().SetColor(colors.GetColor3d("ElevationArrowColor")) a4Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) a4Actor.GetProperty().SetSpecular(0.3) a4Actor.GetProperty().SetSpecularPower(20) a4Actor.GetProperty().SetAmbient(0.2) a4Actor.GetProperty().SetDiffuse(0.8) # Draw the DOP. arrowT2 = vtk.vtkTransform() arrowT2.Scale(1, 0.6, 1) arrowT2.RotateY(90) arrowTF2 = vtk.vtkTransformPolyDataFilter() arrowTF2.SetInputData(pd2) arrowTF2.SetTransform(arrowT2) arrowREF = vtk.vtkRotationalExtrusionFilter() arrowREF.SetInputConnection(arrowTF2.GetOutputPort()) arrowREF.CappingOff() arrowREF.SetResolution(30) spikeMapper = vtk.vtkPolyDataMapper() spikeMapper.SetInputConnection(arrowREF.GetOutputPort()) a5Actor = vtk.vtkLODActor() a5Actor.SetMapper(spikeMapper) a5Actor.SetScale(.3, .3, .6) a5Actor.RotateY(90) a5Actor.SetPosition(-2, 0, 0) a5Actor.GetProperty().SetColor(colors.GetColor3d("SpikeColor")) a5Actor.GetProperty().SetAmbient(0.2) a5Actor.GetProperty().SetDiffuse(0.8) # Focal point. fps = vtk.vtkSphereSource() fps.SetRadius(0.5) fpMapper = vtk.vtkPolyDataMapper() fpMapper.SetInputConnection(fps.GetOutputPort()) fpActor = vtk.vtkLODActor() fpActor.SetMapper(fpMapper) fpActor.SetPosition(-9, 0, 0) fpActor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) fpActor.GetProperty().SetSpecular(0.3) fpActor.GetProperty().SetAmbient(0.2) fpActor.GetProperty().SetDiffuse(0.8) fpActor.GetProperty().SetSpecularPower(20) # Create the roll arrows. arrowWT2 = vtk.vtkWarpTo() arrowWT2.SetInputConnection(arrowCF.GetOutputPort()) arrowWT2.SetPosition(5, 0, 2.5) arrowWT2.SetScaleFactor(0.95) arrowWT2.AbsoluteOn() arrowT3 = vtk.vtkTransform() arrowT3.Translate(-2.50358, 0, -1.70408) arrowT3.Scale(0.5, 0.3, 1) arrowTF3 = vtk.vtkTransformFilter() arrowTF3.SetInputConnection(arrowWT2.GetOutputPort()) arrowTF3.SetTransform(arrowT3) arrowMapper2 = vtk.vtkDataSetMapper() arrowMapper2.SetInputConnection(arrowTF3.GetOutputPort()) arrowMapper2.ScalarVisibilityOff() # Draw the roll arrows. a6Actor = vtk.vtkLODActor() a6Actor.SetMapper(arrowMapper2) a6Actor.RotateZ(90) a6Actor.SetPosition(-4, 0, 0) a6Actor.SetScale(1.5, 1.5, 1.5) a6Actor.GetProperty().SetColor(colors.GetColor3d("RollArrowColor")) a6Actor.GetProperty().SetSpecularColor(colors.GetColor3d("White")) a6Actor.GetProperty().SetSpecular(0.3) a6Actor.GetProperty().SetSpecularPower(20) a6Actor.GetProperty().SetAmbient(0.2) a6Actor.GetProperty().SetDiffuse(0.8) # Add the actors to the renderer, set the background and size. ren.AddActor(camActor) ren.AddActor(a1Actor) ren.AddActor(a2Actor) ren.AddActor(a3Actor) ren.AddActor(a4Actor) ren.AddActor(a5Actor) ren.AddActor(a6Actor) ren.AddActor(fpActor) ren.SetBackground(colors.GetColor3d("BkgColor")) ren.SetBackground(colors.GetColor3d("SlateGray")) renWin.SetSize(640, 480) # Render the image. cam1 = (ren.GetActiveCamera()) ren.ResetCamera() cam1.Azimuth(150) cam1.Elevation(30) cam1.Dolly(1.5) ren.ResetCameraClippingRange() # Create a TextActor for azimuth (a1 and a2 actor's color). text = vtk.vtkTextActor() text.SetInput("Azimuth") tprop = text.GetTextProperty() tprop.SetFontFamilyToArial() tprop.ShadowOff() tprop.SetLineSpacing(1.0) tprop.SetFontSize(36) tprop.SetColor(a1Actor.GetProperty().GetColor()) text.SetDisplayPosition(20, 50) ren.AddActor2D(text) # Create a TextActor for elevation (a3 and a4 actor's color). text2 = vtk.vtkTextActor() text2.SetInput("Elevation") tprop = text2.GetTextProperty() tprop.SetFontFamilyToArial() tprop.ShadowOff() tprop.SetLineSpacing(1.0) tprop.SetFontSize(36) tprop.SetColor(a3Actor.GetProperty().GetColor()) text2.SetDisplayPosition(20, 100) ren.AddActor2D(text2) # Create a TextActor for roll (a6 actor's color). text3 = vtk.vtkTextActor() text3.SetInput("Roll") tprop = text3.GetTextProperty() tprop.SetFontFamilyToArial() tprop.ShadowOff() tprop.SetLineSpacing(1.0) tprop.SetFontSize(36) tprop.SetColor(a6Actor.GetProperty().GetColor()) text3.SetDisplayPosition(20, 150) ren.AddActor2D(text3) iren.Initialize() iren.Start()
if len(args) != 3: p.print_help() sys.exit(1) (in_file, grid_file, out_file) = args # work out readers and writers to use if in_file.endswith(".vtu"): old_mesh_reader = vtk.vtkXMLUnstructuredGridReader() elif in_file.endswith(".vtp"): old_mesh_reader = vtk.vtkXMLPolyDataReader() else: print "Program not yet configured for type of input file", in_file sys.exit(2) # to get rid of z values flattener = vtk.vtkTransform() flattener.Scale(1.0, 1.0, 0.0) # read the input and the source if opts.verbose: print "Reading", in_file old_mesh_reader.SetFileName(in_file) old_mesh_reader.Update() data = old_mesh_reader.GetOutput() data_flat = vtk.vtkTransformFilter() data_flat.SetInput(data) data_flat.SetTransform(flattener) data_flat.Update() data_flat = data_flat.GetOutput() if opts.verbose: print "Reading mesh" rect_grid_reader = vtk.vtkXMLRectilinearGridReader()
def quiver3d(self, x, y, z, u, v, w, color, scale, mode, resolution=8, glyph_height=None, glyph_center=None, glyph_resolution=None, opacity=1.0, scale_mode='none', scalars=None, backface_culling=False, line_width=2., name=None, glyph_width=None, glyph_depth=None, solid_transform=None): _check_option('mode', mode, ALLOWED_QUIVER_MODES) with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=FutureWarning) factor = scale vectors = np.c_[u, v, w] points = np.vstack(np.c_[x, y, z]) n_points = len(points) cell_type = np.full(n_points, vtk.VTK_VERTEX) cells = np.c_[np.full(n_points, 1), range(n_points)] args = (cells, cell_type, points) if not VTK9: args = (np.arange(n_points) * 3, ) + args grid = UnstructuredGrid(*args) _point_data(grid)['vec'] = vectors if scale_mode == 'scalar': _point_data(grid)['mag'] = np.array(scalars) scale = 'mag' else: scale = False if mode == '2darrow': return _arrow_glyph(grid, factor), grid elif mode == 'arrow': alg = _glyph(grid, orient='vec', scalars=scale, factor=factor) mesh = pyvista.wrap(alg.GetOutput()) else: tr = None if mode == 'cone': glyph = vtk.vtkConeSource() glyph.SetCenter(0.5, 0, 0) glyph.SetRadius(0.15) elif mode == 'cylinder': glyph = vtk.vtkCylinderSource() glyph.SetRadius(0.15) elif mode == 'oct': glyph = vtk.vtkPlatonicSolidSource() glyph.SetSolidTypeToOctahedron() else: assert mode == 'sphere', mode # guaranteed above glyph = vtk.vtkSphereSource() if mode == 'cylinder': if glyph_height is not None: glyph.SetHeight(glyph_height) if glyph_center is not None: glyph.SetCenter(glyph_center) if glyph_resolution is not None: glyph.SetResolution(glyph_resolution) tr = vtk.vtkTransform() tr.RotateWXYZ(90, 0, 0, 1) elif mode == 'oct': if solid_transform is not None: assert solid_transform.shape == (4, 4) tr = vtk.vtkTransform() tr.SetMatrix( solid_transform.astype(np.float64).ravel()) if tr is not None: # fix orientation glyph.Update() trp = vtk.vtkTransformPolyDataFilter() trp.SetInputData(glyph.GetOutput()) trp.SetTransform(tr) glyph = trp glyph.Update() geom = glyph.GetOutput() mesh = grid.glyph(orient='vec', scale=scale, factor=factor, geom=geom) actor = _add_mesh(self.plotter, mesh=mesh, color=color, opacity=opacity, backface_culling=backface_culling) return actor, mesh
def CreateSurface9076(): # Coordinate transformations # Sensor from STL sensorFromSTL = vtk.vtkTransform()
def marching_cubes(mcCases): color = vtk.vtkNamedColors() renWin = vtk.vtkRenderWindow() renWin.SetSize(640, 480) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) renderers = list() gridSize = ((len(mcCases) + 3) // 4) * 4 if len(mcCases) < 4: gridSize = len(mcCases) print("gridSize:", gridSize) for i in range(0, gridSize): # Create the Renderer renderer = vtk.vtkRenderer() renderers.append(renderer) renWin.AddRenderer(renderer) for i in range(0, len(mcCases)): # Define a Single Cube Scalars = vtk.vtkFloatArray() Scalars.InsertNextValue(1.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(1.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(0.0) Scalars.InsertNextValue(0.0) Points = vtk.vtkPoints() Points.InsertNextPoint(0, 0, 0) Points.InsertNextPoint(1, 0, 0) Points.InsertNextPoint(1, 1, 0) Points.InsertNextPoint(0, 1, 0) Points.InsertNextPoint(0, 0, 1) Points.InsertNextPoint(1, 0, 1) Points.InsertNextPoint(1, 1, 1) Points.InsertNextPoint(0, 1, 1) Ids = vtk.vtkIdList() Ids.InsertNextId(0) Ids.InsertNextId(1) Ids.InsertNextId(2) Ids.InsertNextId(3) Ids.InsertNextId(4) Ids.InsertNextId(5) Ids.InsertNextId(6) Ids.InsertNextId(7) Grid = vtk.vtkUnstructuredGrid() Grid.Allocate(10, 10) Grid.InsertNextCell(12, Ids) Grid.SetPoints(Points) Grid.GetPointData().SetScalars(Scalars) # Find the triangles that lie along the 0.5 contour in this cube. Marching = vtk.vtkContourFilter() Marching.SetInputData(Grid) Marching.SetValue(0, 0.5) Marching.Update() # Extract the edges of the triangles just found. triangleEdges = vtk.vtkExtractEdges() triangleEdges.SetInputConnection(Marching.GetOutputPort()) # Draw the edges as tubes instead of lines. Also create the associated # mapper and actor to display the tubes. triangleEdgeTubes = vtk.vtkTubeFilter() triangleEdgeTubes.SetInputConnection(triangleEdges.GetOutputPort()) triangleEdgeTubes.SetRadius(.005) triangleEdgeTubes.SetNumberOfSides(6) triangleEdgeTubes.UseDefaultNormalOn() triangleEdgeTubes.SetDefaultNormal(.577, .577, .577) triangleEdgeMapper = vtk.vtkPolyDataMapper() triangleEdgeMapper.SetInputConnection( triangleEdgeTubes.GetOutputPort()) triangleEdgeMapper.ScalarVisibilityOff() triangleEdgeActor = vtk.vtkActor() triangleEdgeActor.SetMapper(triangleEdgeMapper) triangleEdgeActor.GetProperty().SetDiffuseColor( color.GetColor3d("lamp_black")) triangleEdgeActor.GetProperty().SetSpecular(.4) triangleEdgeActor.GetProperty().SetSpecularPower(10) # Shrink the triangles we found earlier. Create the associated mapper # and actor. Set the opacity of the shrunken triangles. aShrinker = vtk.vtkShrinkPolyData() aShrinker.SetShrinkFactor(1) aShrinker.SetInputConnection(Marching.GetOutputPort()) aMapper = vtk.vtkPolyDataMapper() aMapper.ScalarVisibilityOff() aMapper.SetInputConnection(aShrinker.GetOutputPort()) Triangles = vtk.vtkActor() Triangles.SetMapper(aMapper) Triangles.GetProperty().SetDiffuseColor(color.GetColor3d("banana")) Triangles.GetProperty().SetOpacity(.6) # Draw a cube the same size and at the same position as the one # created previously. Extract the edges because we only want to see # the outline of the cube. Pass the edges through a vtkTubeFilter so # they are displayed as tubes rather than lines. CubeModel = vtk.vtkCubeSource() CubeModel.SetCenter(.5, .5, .5) Edges = vtk.vtkExtractEdges() Edges.SetInputConnection(CubeModel.GetOutputPort()) Tubes = vtk.vtkTubeFilter() Tubes.SetInputConnection(Edges.GetOutputPort()) Tubes.SetRadius(.01) Tubes.SetNumberOfSides(6) Tubes.UseDefaultNormalOn() Tubes.SetDefaultNormal(.577, .577, .577) # Create the mapper and actor to display the cube edges. TubeMapper = vtk.vtkPolyDataMapper() TubeMapper.SetInputConnection(Tubes.GetOutputPort()) CubeEdges = vtk.vtkActor() CubeEdges.SetMapper(TubeMapper) CubeEdges.GetProperty().SetDiffuseColor(color.GetColor3d("khaki")) CubeEdges.GetProperty().SetSpecular(.4) CubeEdges.GetProperty().SetSpecularPower(10) # Create a sphere to use as a glyph source for vtkGlyph3D. Sphere = vtk.vtkSphereSource() Sphere.SetRadius(0.04) Sphere.SetPhiResolution(20) Sphere.SetThetaResolution(20) # Remove the part of the cube with data values below 0.5. ThresholdIn = vtk.vtkThresholdPoints() ThresholdIn.SetInputData(Grid) ThresholdIn.ThresholdByUpper(.5) # Display spheres at the vertices remaining in the cube data set after # it was passed through vtkThresholdPoints. Vertices = vtk.vtkGlyph3D() Vertices.SetInputConnection(ThresholdIn.GetOutputPort()) Vertices.SetSourceConnection(Sphere.GetOutputPort()) # Create a mapper and actor to display the glyphs. SphereMapper = vtk.vtkPolyDataMapper() SphereMapper.SetInputConnection(Vertices.GetOutputPort()) SphereMapper.ScalarVisibilityOff() CubeVertices = vtk.vtkActor() CubeVertices.SetMapper(SphereMapper) CubeVertices.GetProperty().SetDiffuseColor(color.GetColor3d("tomato")) # Define the text for the label caseLabel = vtk.vtkVectorText() caseLabel.SetText("Case 1") # Set up a transform to move the label to a new position. aLabelTransform = vtk.vtkTransform() aLabelTransform.Identity() aLabelTransform.Translate(-0.2, 0, 1.25) aLabelTransform.Scale(.05, .05, .05) # Move the label to a new position. labelTransform = vtk.vtkTransformPolyDataFilter() labelTransform.SetTransform(aLabelTransform) labelTransform.SetInputConnection(caseLabel.GetOutputPort()) # Create a mapper and actor to display the text. labelMapper = vtk.vtkPolyDataMapper() labelMapper.SetInputConnection(labelTransform.GetOutputPort()) labelActor = vtk.vtkActor() labelActor.SetMapper(labelMapper) # Define the base that the cube sits on. Create its associated mapper # and actor. Set the position of the actor. baseModel = vtk.vtkCubeSource() baseModel.SetXLength(1.5) baseModel.SetYLength(.01) baseModel.SetZLength(1.5) baseMapper = vtk.vtkPolyDataMapper() baseMapper.SetInputConnection(baseModel.GetOutputPort()) base = vtk.vtkActor() base.SetMapper(baseMapper) base.SetPosition(.5, -0.09, .5) # Set the scalar values for this case of marching cubes. # A negative case number will generate a complementary case mcCase = mcCases[i] if mcCase < 0: cases[-mcCase](Scalars, caseLabel, 0, 1) else: cases[mcCase](Scalars, caseLabel, 1, 0) # Force the grid to update. Grid.Modified() # Add the actors to the renderer renderers[i].AddActor(triangleEdgeActor) renderers[i].AddActor(base) renderers[i].AddActor(labelActor) renderers[i].AddActor(CubeEdges) renderers[i].AddActor(CubeVertices) renderers[i].AddActor(Triangles) # Set the background color. renderers[i].SetBackground(color.GetColor3d("slate_grey")) # Position the camera. renderers[i].GetActiveCamera().Dolly(1.2) renderers[i].GetActiveCamera().Azimuth(30) renderers[i].GetActiveCamera().Elevation(20) renderers[i].ResetCamera() renderers[i].ResetCameraClippingRange() if i > 0: renderers[i].SetActiveCamera(renderers[0].GetActiveCamera()) # Setup viewports for the renderers rendererSize = 300 xGridDimensions = 4 if len(mcCases) < 4: xGridDimensions = len(mcCases) yGridDimensions = (len(mcCases) - 1) // 4 + 1 print("x, y:", xGridDimensions, ",", yGridDimensions) renWin.SetSize(rendererSize * xGridDimensions, rendererSize * yGridDimensions) for row in range(0, yGridDimensions): for col in range(0, xGridDimensions): index = row * xGridDimensions + col # (xmin, ymin, xmax, ymax) viewport = [ float(col) / xGridDimensions, float(yGridDimensions - (row + 1)) / yGridDimensions, float(col + 1) / xGridDimensions, float(yGridDimensions - row) / yGridDimensions ] renderers[index].SetViewport(viewport) iren.Initialize() renWin.Render() iren.Start()
def doWrap(Act, wc, wrap=[0., 360]): if wrap is None: return Act Mapper = Act.GetMapper() data = Mapper.GetInput() xmn = min(wc[0], wc[1]) xmx = max(wc[0], wc[1]) if numpy.allclose(xmn, 1.e20) or numpy.allclose(xmx, 1.e20): xmx = abs(wrap[1]) xmn = -wrap[1] ymn = min(wc[2], wc[3]) ymx = max(wc[2], wc[3]) if numpy.allclose(ymn, 1.e20) or numpy.allclose(ymx, 1.e20): ymx = abs(wrap[0]) ymn = -wrap[0] ## Prepare MultiBlock and puts in oriinal data appendFilter = vtk.vtkAppendPolyData() appendFilter.AddInputData(data) appendFilter.Update() ## X axis wrappping Amn, Amx = Act.GetXRange() if wrap[1] != 0.: i = 0 while Amn > xmn: i += 1 Amn -= wrap[1] Tpf = vtk.vtkTransformPolyDataFilter() Tpf.SetInputData(data) T = vtk.vtkTransform() T.Translate(-i * wrap[1], 0, 0) Tpf.SetTransform(T) Tpf.Update() appendFilter.AddInputData(Tpf.GetOutput()) appendFilter.Update() i = 0 while Amx < xmx: i += 1 Amx += wrap[1] Tpf = vtk.vtkTransformPolyDataFilter() Tpf.SetInputData(data) T = vtk.vtkTransform() T.Translate(i * wrap[1], 0, 0) Tpf.SetTransform(T) Tpf.Update() appendFilter.AddInputData(Tpf.GetOutput()) appendFilter.Update() # Y axis wrapping Amn, Amx = Act.GetYRange() if wrap[0] != 0.: i = 0 while Amn > ymn: i += 1 Amn -= wrap[0] Tpf = vtk.vtkTransformPolyDataFilter() Tpf.SetInputData(data) T = vtk.vtkTransform() T.Translate(0, i * wrap[0], 0) Tpf.SetTransform(T) Tpf.Update() appendFilter.AddInputData(Tpf.GetOutput()) appendFilter.Update() i = 0 while Amx < ymx: i += 1 Amx += wrap[0] Tpf = vtk.vtkTransformPolyDataFilter() Tpf.SetInputData(data) T = vtk.vtkTransform() T.Translate(0, -i * wrap[0], 0) Tpf.SetTransform(T) Tpf.Update() appendFilter.AddInputData(Tpf.GetOutput()) appendFilter.Update() appendFilter.Update() Actor = vtk.vtkActor() Actor.SetProperty(Act.GetProperty()) #Mapper2 = vtk.vtkDataSetMapper() #Mapper2 = vtk.vtkCompositePolyDataMapper() Mapper2 = vtk.vtkPolyDataMapper() Mapper2.SetInputData(appendFilter.GetOutput()) Mapper2.SetLookupTable(Mapper.GetLookupTable()) Mapper2.SetScalarRange(Mapper.GetScalarRange()) Mapper2.SetScalarMode(Mapper.GetScalarMode()) setClipPlanes(Mapper2, xmn, xmx, ymn, ymx) Mapper2.Update() Actor.SetMapper(Mapper2) return Actor
def CreateSurfaceFromPolydata(self, polydata, overwrite=False, name=None, colour=None, transparency=None, volume=None, area=None, scalar=False): if self.converttoInV and self.affine is not None: transform = vtk.vtkTransform() transform.SetMatrix(self.affine) transformFilter = vtk.vtkTransformPolyDataFilter() transformFilter.SetTransform(transform) transformFilter.SetInputData(polydata) transformFilter.Update() polydata = transformFilter.GetOutput() self.converttoInV = None normals = vtk.vtkPolyDataNormals() normals.SetInputData(polydata) normals.SetFeatureAngle(80) normals.AutoOrientNormalsOn() normals.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(normals.GetOutput()) if scalar: mapper.ScalarVisibilityOn() else: mapper.ScalarVisibilityOff() mapper.ImmediateModeRenderingOn() # improve performance actor = vtk.vtkActor() actor.SetMapper(mapper) print("BOunds", actor.GetBounds()) if overwrite: surface = Surface(index=self.last_surface_index) else: surface = Surface() if not colour: surface.colour = random.choice(const.SURFACE_COLOUR) else: surface.colour = colour surface.polydata = polydata if transparency: surface.transparency = transparency if name: surface.name = name # Append surface into Project.surface_dict proj = prj.Project() if overwrite: proj.ChangeSurface(surface) else: index = proj.AddSurface(surface) surface.index = index self.last_surface_index = index # Set actor colour and transparency actor.GetProperty().SetColor(surface.colour) actor.GetProperty().SetOpacity(1 - surface.transparency) self.actors_dict[surface.index] = actor session = ses.Session() session.ChangeProject() # The following lines have to be here, otherwise all volumes disappear if not volume or not area: triangle_filter = vtk.vtkTriangleFilter() triangle_filter.SetInputData(polydata) triangle_filter.Update() measured_polydata = vtk.vtkMassProperties() measured_polydata.SetInputConnection( triangle_filter.GetOutputPort()) measured_polydata.Update() volume = measured_polydata.GetVolume() area = measured_polydata.GetSurfaceArea() surface.volume = volume surface.area = area print(">>>>", surface.volume) else: surface.volume = volume surface.area = area self.last_surface_index = surface.index Publisher.sendMessage('Load surface actor into viewer', actor=actor) Publisher.sendMessage('Update surface info in GUI', surface=surface) return surface.index
def vis_ested_pcd_corners(ind=1): # pair_ind = 9 pcd_result_file = "output/pcd_seg/" + str(ind).zfill(4) + "_pcd_result.pkl" csv_file = "pcd/" + str(ind).zfill(4) + ".csv" full_arr = np.genfromtxt(csv_file, delimiter=",", skip_header=1) grid_coords = generate_grid_coords() with open(os.path.abspath(pcd_result_file), "r") as f: pcd_result_ls = cPickle.load(f) assert pcd_result_ls is not None rot1 = pcd_result_ls[0] t1 = pcd_result_ls[1].reshape(1, 3) rot2 = pcd_result_ls[2] t2 = pcd_result_ls[3].reshape(1, 3) trans_grid_ls = [] for coords in grid_coords: args = [[coord, rot1, rot2, t1, t2] for coord in coords[:3]] trans_coords = map(transform_grid, args) trans_coords.append(coords[3]) trans_grid_ls.append(trans_coords) ren = vtk.vtkRenderer() ren.SetBackground(.2, .3, .4) ren.SetBackground(0.90196079, 0.96078432, 0.59607846) # ren.SetBackground(1., 1., 1.) for i in xrange(len(trans_grid_ls)): tmp_actor = draw_one_grd_vtk(trans_grid_ls[i]) tmp_actor.GetProperty().SetOpacity(0.5) ren.AddActor(tmp_actor) show_only_marker = True if show_only_marker: marker_full_data_arr = exact_full_marker_data(csv_file, [pcd_result_ls[-1]]) actor2 = vis_3D_points(marker_full_data_arr, color_style="intens_rg") else: actor2 = vis_3D_points(full_arr, color_style="intens_rg") ren.AddActor(actor2) transform2 = vtk.vtkTransform() transform2.Translate(0.0, 0.0, 0.0) axes2 = vtk.vtkAxesActor() axes2.SetUserTransform(transform2) ren.AddActor(axes2) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetWindowName(str(i).zfill(4)) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) def get_camera_info(obj, ev): if iren.GetKeyCode() == "s": w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(renWin) w2if.Update() writer = vtk.vtkPNGWriter() writer.SetFileName("screenshot.png") writer.SetInputData(w2if.GetOutput()) writer.Write() print "screenshot saved" style = vtk.vtkInteractorStyleSwitch() iren.SetRenderWindow(renWin) iren.SetInteractorStyle(style) # style.SetCurrentStyleToTrackballActor() style.SetCurrentStyleToTrackballCamera() iren.AddObserver(vtk.vtkCommand.KeyPressEvent, get_camera_info, 1) iren.Initialize() renWin.Render() renWin.SetWindowName(str(ind).zfill(4)) iren.Start()
def fitToViewport(Actor, Renderer, vp, wc=None, geo=None): T = vtk.vtkTransform() ## Data range in World Coordinates if wc is None: Xrg = list(Actor.GetXRange()) Yrg = list(Actor.GetYRange()) else: Xrg = [float(wc[0]), float(wc[1])] Yrg = [float(wc[2]), float(wc[3])] if Yrg[0] > Yrg[1]: #Yrg=[Yrg[1],Yrg[0]] #T.RotateY(180) Yrg = [Yrg[1], Yrg[0]] flipY = True else: flipY = False if Xrg[0] > Xrg[1]: Xrg = [Xrg[1], Xrg[0]] flipX = True else: flipX = False if geo is not None: pt = vtk.vtkPoints() pt.SetNumberOfPoints(1) Xrg2 = [1.e20, -1.e20] Yrg2 = [1.e20, -1.e20] Npts = 50. for x in numpy.arange(Xrg[0], Xrg[1], (Xrg[1] - Xrg[0]) / Npts): for y in numpy.arange(Yrg[0], Yrg[1], (Yrg[1] - Yrg[0]) / Npts): pt.SetPoint(0, x, y, 0) pts = vtk.vtkPoints() geo.TransformPoints(pt, pts) b = pts.GetBounds() xm, xM, ym, yM = b[:4] if xm != -numpy.inf: Xrg2[0] = min(Xrg2[0], xm) if xM != numpy.inf: Xrg2[1] = max(Xrg2[1], xM) if ym != -numpy.inf: Yrg2[0] = min(Yrg2[0], ym) if yM != numpy.inf: Yrg2[1] = max(Yrg2[1], yM) Xrg = Xrg2 Yrg = Yrg2 Renderer.SetViewport(vp[0], vp[2], vp[1], vp[3]) rw = Renderer.GetRenderWindow() sc = rw.GetSize() wRatio = float(sc[0]) / float(sc[1]) dRatio = (Xrg[1] - Xrg[0]) / (Yrg[1] - Yrg[0]) vRatio = float(vp[1] - vp[0]) / float(vp[3] - vp[2]) if wRatio > 1.: #landscape orientated window yScale = 1. xScale = vRatio * wRatio / dRatio else: xScale = 1. yScale = dRatio / (vRatio * wRatio) T.Scale(xScale, yScale, 1.) Actor.SetUserTransform(T) mapper = Actor.GetMapper() planeCollection = mapper.GetClippingPlanes() # We have to transform the hardware clip planes as well if (planeCollection is not None): planeCollection.InitTraversal() plane = planeCollection.GetNextItem() while (plane): origin = plane.GetOrigin() inOrigin = [origin[0], origin[1], origin[2], 1.0] outOrigin = [origin[0], origin[1], origin[2], 1.0] normal = plane.GetNormal() inNormal = [normal[0], normal[1], normal[2], 0.0] outNormal = [normal[0], normal[1], normal[2], 0.0] T.MultiplyPoint(inOrigin, outOrigin) if (outOrigin[3] != 0.0): outOrigin[0] /= outOrigin[3] outOrigin[1] /= outOrigin[3] outOrigin[2] /= outOrigin[3] plane.SetOrigin(outOrigin[0], outOrigin[1], outOrigin[2]) # For normal matrix, compute the transpose of inverse normalTransform = vtk.vtkTransform() normalTransform.DeepCopy(T) mat = vtk.vtkMatrix4x4() normalTransform.GetTranspose(mat) normalTransform.GetInverse(mat) normalTransform.SetMatrix(mat) normalTransform.MultiplyPoint(inNormal, outNormal) if (outNormal[3] != 0.0): outNormal[0] /= outNormal[3] outNormal[1] /= outNormal[3] outNormal[2] /= outNormal[3] plane.SetNormal(outNormal[0], outNormal[1], outNormal[2]) plane = planeCollection.GetNextItem() xc = xScale * float(Xrg[1] + Xrg[0]) / 2. yc = yScale * float(Yrg[1] + Yrg[0]) / 2. xd = xScale * float(Xrg[1] - Xrg[0]) / 2. yd = yScale * float(Yrg[1] - Yrg[0]) / 2. cam = Renderer.GetActiveCamera() cam.ParallelProjectionOn() cam.SetParallelScale(yd) cd = cam.GetDistance() cam.SetPosition(xc, yc, cd) cam.SetFocalPoint(xc, yc, 0.) if geo is None: if flipY: cam.Elevation(180.) cam.Roll(180.) pass if flipX: cam.Azimuth(180.)
def vis_all_markers(ls=[1]): import vtk ren = vtk.vtkRenderer() # ren.SetBackground(.2, .3, .4) ren.SetBackground(.5, .6, .7) for i in ls: pcd_result_file = "output/pcd_seg/" + str(i).zfill( 4) + "_pcd_result.pkl" csv_path = "pcd/" + str(i).zfill(4) + ".csv" with open(os.path.abspath(pcd_result_file), "r") as f: pcd_result_ls = cPickle.load(f) assert pcd_result_ls is not None marker_full_data_arr = exact_full_marker_data(csv_path, [pcd_result_ls[-1]]) marker_arr = marker_full_data_arr[:, :3] # transformed_pcd = roate_with_rt(np.array(r_t), marker_arr) if i % 4 == 0: actor2 = vis_3D_points(np.hstack([ marker_arr + np.array([0, 0, 0]), marker_full_data_arr[:, 3:] ]), color_style="intens") elif i % 4 == 1: actor2 = vis_3D_points(np.hstack([ marker_arr + np.array([0, 0, 0]), marker_full_data_arr[:, 3:] ]), color_style="autumn") elif i % 4 == 2: actor2 = vis_3D_points(np.hstack([ marker_arr + np.array([0, 0, 0]), marker_full_data_arr[:, 3:] ]), color_style="cool") else: actor2 = vis_3D_points(np.hstack([ marker_arr + np.array([0, 0, 0]), marker_full_data_arr[:, 3:] ]), color_style="intens_rg") ren.AddActor(actor2) transform2 = vtk.vtkTransform() transform2.Translate(0.0, 0.0, 0.0) axes2 = vtk.vtkAxesActor() axes2.SetUserTransform(transform2) ren.AddActor(axes2) cubeAxesActor = vtk.vtkCubeAxesActor() cubeAxesActor.SetBounds((-3, 3, -3, 3, -2, 2)) cubeAxesActor.SetCamera(ren.GetActiveCamera()) cubeAxesActor.GetTitleTextProperty(0).SetColor(1.0, 0.0, 0.0) cubeAxesActor.GetLabelTextProperty(0).SetColor(1.0, 0.0, 0.0) cubeAxesActor.GetTitleTextProperty(1).SetColor(0.0, 1.0, 0.0) cubeAxesActor.GetLabelTextProperty(1).SetColor(0.0, 1.0, 0.0) cubeAxesActor.GetTitleTextProperty(2).SetColor(0.0, 0.0, 1.0) cubeAxesActor.GetLabelTextProperty(2).SetColor(0.0, 0.0, 1.0) cubeAxesActor.DrawXGridlinesOn() cubeAxesActor.DrawYGridlinesOn() cubeAxesActor.DrawZGridlinesOn() # if vtk.VTK_MAJOR_VERSION > 5: # cubeAxesActor.SetGridLineLocation(vtk.VTK_GRID_LINES_FURTHEST) cubeAxesActor.XAxisMinorTickVisibilityOff() cubeAxesActor.YAxisMinorTickVisibilityOff() cubeAxesActor.ZAxisMinorTickVisibilityOff() # cubeAxesActor.GetProperty().SetColor(0, 255, 0) cubeAxesActor.GetXAxesLinesProperty().SetColor(0, 255, 0) cubeAxesActor.GetYAxesLinesProperty().SetColor(0, 255, 0) cubeAxesActor.GetZAxesLinesProperty().SetColor(0, 255, 0) ren.AddActor(cubeAxesActor) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() style = vtk.vtkInteractorStyleSwitch() iren.SetInteractorStyle(style) style.SetCurrentStyleToTrackballCamera() def get_camera_info(obj, ev): if iren.GetKeyCode() == "s": w2if = vtk.vtkWindowToImageFilter() w2if.SetInput(renWin) w2if.Update() writer = vtk.vtkPNGWriter() writer.SetFileName("screenshot.png") writer.SetInputData(w2if.GetOutput()) writer.Write() print "screenshot saved" # save to pdf if iren.GetKeyCode() == "s": exp = vtk.vtkGL2PSExporter() exp.SetRenderWindow(renWin) exp.SetFilePrefix("screenpdf") exp.SetFileFormat(2) exp.SetCompress(False) exp.SetLandscape(False) exp.SetSortToBSP() # exp.SetSortToSimple() # less expensive sort algorithm exp.DrawBackgroundOn() exp.SetWrite3DPropsAsRasterImage(False) iren.AddObserver(vtk.vtkCommand.KeyPressEvent, get_camera_info, 1) iren.SetRenderWindow(renWin) renWin.Render() # ren.SetActiveCamera(camera) iren.Initialize() iren.Start()
def TestSection_ImportExportSegment(self): # Import/export, both one label and all labels logging.info('Test section: Import/export segment') # Export single segment to model node bodyModelNode = slicer.vtkMRMLModelNode() bodyModelNode.SetName('BodyModel') slicer.mrmlScene.AddNode(bodyModelNode) bodySegment = self.inputSegmentationNode.GetSegmentation().GetSegment( self.bodySegmentName) result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode( bodySegment, bodyModelNode) self.assertTrue(result) self.assertIsNotNone(bodyModelNode.GetPolyData()) #TODO: Number of points increased to 1677 due to end-capping, need to investigate! #self.assertEqual(bodyModelNode.GetPolyData().GetNumberOfPoints(), 302) #TODO: On Linux and Windows it is 588, on Mac it is 580. Need to investigate # self.assertEqual(bodyModelNode.GetPolyData().GetNumberOfCells(), 588) #self.assertTrue(bodyModelNode.GetPolyData().GetNumberOfCells() == 588 or bodyModelNode.GetPolyData().GetNumberOfCells() == 580) # Export single segment to volume node bodyLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode() bodyLabelmapNode.SetName('BodyLabelmap') slicer.mrmlScene.AddNode(bodyLabelmapNode) result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode( bodySegment, bodyLabelmapNode) self.assertTrue(result) bodyImageData = bodyLabelmapNode.GetImageData() self.assertIsNotNone(bodyImageData) imageStat = vtk.vtkImageAccumulate() imageStat.SetInputData(bodyImageData) imageStat.Update() self.assertEqual(imageStat.GetVoxelCount(), 792) self.assertEqual(imageStat.GetMin()[0], 0) self.assertEqual(imageStat.GetMax()[0], 1) # Export multiple segments to volume node allSegmentsLabelmapNode = slicer.vtkMRMLLabelMapVolumeNode() allSegmentsLabelmapNode.SetName('AllSegmentsLabelmap') slicer.mrmlScene.AddNode(allSegmentsLabelmapNode) result = slicer.vtkSlicerSegmentationsModuleLogic.ExportAllSegmentsToLabelmapNode( self.inputSegmentationNode, allSegmentsLabelmapNode) self.assertTrue(result) allSegmentsImageData = allSegmentsLabelmapNode.GetImageData() self.assertIsNotNone(allSegmentsImageData) imageStat = vtk.vtkImageAccumulate() imageStat.SetInputData(allSegmentsImageData) imageStat.SetComponentExtent(0, 5, 0, 0, 0, 0) imageStat.SetComponentOrigin(0, 0, 0) imageStat.SetComponentSpacing(1, 1, 1) imageStat.Update() imageStatResult = imageStat.GetOutput() for i in range(4): logging.info("Volume {0}: {1}".format( i, imageStatResult.GetScalarComponentAsDouble(i, 0, 0, 0))) self.assertEqual(imageStat.GetVoxelCount(), 127109360) self.assertEqual( imageStatResult.GetScalarComponentAsDouble(0, 0, 0, 0), 78967249) self.assertEqual( imageStatResult.GetScalarComponentAsDouble(1, 0, 0, 0), 39705288) self.assertEqual( imageStatResult.GetScalarComponentAsDouble(2, 0, 0, 0), 890883) self.assertEqual( imageStatResult.GetScalarComponentAsDouble(3, 0, 0, 0), 7545940) # Import model to segment modelImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass( 'vtkMRMLSegmentationNode', 'ModelImport') modelImportSegmentationNode.GetSegmentation( ).SetMasterRepresentationName(self.closedSurfaceReprName) modelSegment = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromModelNode( bodyModelNode) modelSegment.UnRegister(None) # Need to release ownership self.assertIsNotNone(modelSegment) self.assertIsNotNone( modelSegment.GetRepresentation(self.closedSurfaceReprName)) # Import multi-label labelmap to segmentation multiLabelImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass( 'vtkMRMLSegmentationNode', 'MultiLabelImport') multiLabelImportSegmentationNode.GetSegmentation( ).SetMasterRepresentationName(self.binaryLabelmapReprName) result = slicer.vtkSlicerSegmentationsModuleLogic.ImportLabelmapToSegmentationNode( allSegmentsLabelmapNode, multiLabelImportSegmentationNode) self.assertTrue(result) self.assertEqual( multiLabelImportSegmentationNode.GetSegmentation(). GetNumberOfSegments(), 3) # Import labelmap into single segment singleLabelImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass( 'vtkMRMLSegmentationNode', 'SingleLabelImport') singleLabelImportSegmentationNode.GetSegmentation( ).SetMasterRepresentationName(self.binaryLabelmapReprName) # Should not import multi-label labelmap to segment nullSegment = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromLabelmapVolumeNode( allSegmentsLabelmapNode) self.assertIsNone(nullSegment) logging.info( '(This error message is a result of testing an impossible scenario, it is supposed to appear)' ) # Make labelmap single-label and import again threshold = vtk.vtkImageThreshold() threshold.SetInValue(0) threshold.SetOutValue(1) threshold.ReplaceInOn() threshold.ThresholdByLower(0) threshold.SetOutputScalarType(vtk.VTK_UNSIGNED_CHAR) if vtk.VTK_MAJOR_VERSION <= 5: threshold.SetInput(allSegmentsLabelmapNode.GetImageData()) else: threshold.SetInputData(allSegmentsLabelmapNode.GetImageData()) threshold.Update() allSegmentsLabelmapNode.GetImageData().ShallowCopy( threshold.GetOutput()) labelSegment = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromLabelmapVolumeNode( allSegmentsLabelmapNode) labelSegment.UnRegister(None) # Need to release ownership self.assertIsNotNone(labelSegment) self.assertIsNotNone( labelSegment.GetRepresentation(self.binaryLabelmapReprName)) # Import/export with transforms logging.info('Test subsection: Import/export with transforms') # Create transform node that will be used to transform the tested nodes bodyModelTransformNode = slicer.vtkMRMLLinearTransformNode() slicer.mrmlScene.AddNode(bodyModelTransformNode) bodyModelTransform = vtk.vtkTransform() bodyModelTransform.Translate(1000.0, 0.0, 0.0) bodyModelTransformNode.ApplyTransformMatrix( bodyModelTransform.GetMatrix()) # Set transform as parent to input segmentation node self.inputSegmentationNode.SetAndObserveTransformNodeID( bodyModelTransformNode.GetID()) # Export single segment to model node from transformed segmentation bodyModelNodeTransformed = slicer.vtkMRMLModelNode() bodyModelNodeTransformed.SetName('BodyModelTransformed') slicer.mrmlScene.AddNode(bodyModelNodeTransformed) bodySegment = self.inputSegmentationNode.GetSegmentation().GetSegment( self.bodySegmentName) result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode( bodySegment, bodyModelNodeTransformed) self.assertTrue(result) self.assertIsNotNone(bodyModelNodeTransformed.GetParentTransformNode()) # Export single segment to volume node from transformed segmentation bodyLabelmapNodeTransformed = slicer.vtkMRMLLabelMapVolumeNode() bodyLabelmapNodeTransformed.SetName('BodyLabelmapTransformed') slicer.mrmlScene.AddNode(bodyLabelmapNodeTransformed) result = slicer.vtkSlicerSegmentationsModuleLogic.ExportSegmentToRepresentationNode( bodySegment, bodyLabelmapNodeTransformed) self.assertTrue(result) self.assertIsNotNone( bodyLabelmapNodeTransformed.GetParentTransformNode()) # Create transform node that will be used to transform the tested nodes modelTransformedImportSegmentationTransformNode = slicer.vtkMRMLLinearTransformNode( ) slicer.mrmlScene.AddNode( modelTransformedImportSegmentationTransformNode) modelTransformedImportSegmentationTransform = vtk.vtkTransform() modelTransformedImportSegmentationTransform.Translate(-500.0, 0.0, 0.0) modelTransformedImportSegmentationTransformNode.ApplyTransformMatrix( modelTransformedImportSegmentationTransform.GetMatrix()) # Import transformed model to segment in transformed segmentation modelTransformedImportSegmentationNode = slicer.mrmlScene.AddNewNodeByClass( 'vtkMRMLSegmentationNode', 'ModelImportTransformed') modelTransformedImportSegmentationNode.GetSegmentation( ).SetMasterRepresentationName(self.closedSurfaceReprName) modelTransformedImportSegmentationNode.SetAndObserveTransformNodeID( modelTransformedImportSegmentationTransformNode.GetID()) modelSegmentTranformed = slicer.vtkSlicerSegmentationsModuleLogic.CreateSegmentFromModelNode( bodyModelNodeTransformed, modelTransformedImportSegmentationNode) modelSegmentTranformed.UnRegister(None) # Need to release ownership self.assertIsNotNone(modelSegmentTranformed) modelSegmentTransformedPolyData = modelSegmentTranformed.GetRepresentation( self.closedSurfaceReprName) self.assertIsNotNone(modelSegmentTransformedPolyData) self.assertEqual(int(modelSegmentTransformedPolyData.GetBounds()[0]), 1332) self.assertEqual(int(modelSegmentTransformedPolyData.GetBounds()[1]), 1675) # Clean up temporary nodes slicer.mrmlScene.RemoveNode(bodyModelNode) slicer.mrmlScene.RemoveNode(bodyLabelmapNode) slicer.mrmlScene.RemoveNode(allSegmentsLabelmapNode) slicer.mrmlScene.RemoveNode(modelImportSegmentationNode) slicer.mrmlScene.RemoveNode(multiLabelImportSegmentationNode) slicer.mrmlScene.RemoveNode(singleLabelImportSegmentationNode) slicer.mrmlScene.RemoveNode(bodyModelTransformNode) slicer.mrmlScene.RemoveNode(bodyModelNodeTransformed) slicer.mrmlScene.RemoveNode(bodyLabelmapNodeTransformed) slicer.mrmlScene.RemoveNode(modelTransformedImportSegmentationNode)
def expand_cyclic_modal_stress(self, result, result_r, hindex, phase, as_complex, full_rotor, scale=True): """ Combines repeated results from ANSYS """ if as_complex or full_rotor: result_combined = result + result_r*1j if phase: result_combined *= 1*np.cos(phase) - 1j*np.sin(phase) else: # convert to real result_combined = result*np.cos(phase) - result_r*np.sin(phase) # just return single sector if not full_rotor: return result_combined # Generate full rotor solution result_expanded = np.empty((self.n_sector, result.shape[0], result.shape[1]), np.complex128) result_expanded[:] = result_combined # scale # if scale: # if hindex == 0 or hindex == self.n_sector/2: # result_expanded /= self.n_sector**0.5 # else: # result_expanded /= (self.n_sector/2)**0.5 f_arr = np.zeros(self.n_sector) f_arr[hindex] = 1 jang = np.fft.ifft(f_arr)[:self.n_sector]*self.n_sector cjang = jang * (np.cos(phase) - np.sin(phase) * 1j) full_result = np.real(result_expanded*cjang.reshape(-1, 1, 1)) # # rotate cyclic result inplace # angles = np.linspace(0, 2*np.pi, self.n_sector + 1)[:-1] + phase # for i, angle in enumerate(angles): # isnan = _binary_reader.tensor_rotate_z(result_expanded[i], angle) # result_expanded[i, isnan] = np.nan cs_cord = self.resultheader['csCord'] if cs_cord > 1: matrix = self.cs_4x4(cs_cord, as_vtk_matrix=True) i_matrix = self.cs_4x4(cs_cord, as_vtk_matrix=True) i_matrix.Invert() else: matrix = vtk.vtkMatrix4x4() i_matrix = vtk.vtkMatrix4x4() shp = (self.n_sector, result.shape[0], result.shape[1]) full_result = np.empty(shp) full_result[:] = result rang = 360.0 / self.n_sector for i in range(self.n_sector): # transform to standard position, rotate about Z axis, # transform back transform = vtk.vtkTransform() transform.RotateZ(rang*i) transform.Update() rot_matrix = transform.GetMatrix() if cs_cord > 1: temp_matrix = vtk.vtkMatrix4x4() rot_matrix.Multiply4x4(i_matrix, rot_matrix, temp_matrix) rot_matrix.Multiply4x4(temp_matrix, matrix, rot_matrix) trans = pv.trans_from_matrix(rot_matrix) _binary_reader.tensor_arbitrary(full_result[i], trans) return full_result
def SliceOrder(): # # These transformations permute medical image data to maintain proper orientation # regardless of the acquisition order. After applying these transforms with # vtkTransformFilter, a view up of 0,-1,0 will result in the body part # facing the viewer. # NOTE: some transformations have a -1 scale factor for one of the components. # To ensure proper polygon orientation and normal direction, you must # apply the vtkPolyDataNormals filter. # # Naming: # si - superior to inferior (top to bottom) # is - inferior to superior (bottom to top) # ap - anterior to posterior (front to back) # pa - posterior to anterior (back to front) # lr - left to right # rl - right to left # sliceOrder = dict() siMatrix = [1, 0, 0, 0, 0, 0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1] si = vtk.vtkTransform() si.SetMatrix(siMatrix) sliceOrder["si"] = si isMatrix = [1, 0, 0, 0, 0, 0, -1, 0, 0, -1, 0, 0, 0, 0, 0, 1] i_s = vtk.vtkTransform() # 'is' is a keyword in Python, changed to 'i_s' i_s.SetMatrix(isMatrix) sliceOrder["is"] = i_s ap = vtk.vtkTransform() ap.Scale(1, -1, 1) sliceOrder["ap"] = ap pa = vtk.vtkTransform() pa.Scale(1, -1, -1) sliceOrder["pa"] = pa lrMatrix = [0, 0, -1, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1] lr = vtk.vtkTransform() lr.SetMatrix(lrMatrix) sliceOrder["lr"] = lr rlMatrix = [0, 0, 1, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1] rl = vtk.vtkTransform() rl.SetMatrix(rlMatrix) sliceOrder["rl"] = rl # # The previous transforms assume radiological views of the slices (viewed from the feet). other # modalities such as physical sectioning may view from the head. these transforms modify the original # with a 180 rotation about y # hfMatrix = [-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1] hf = vtk.vtkTransform() hf.SetMatrix(hfMatrix) sliceOrder["hf"] = hf hfsi = vtk.vtkTransform() hfsi.Concatenate(hf.GetMatrix()) hfsi.Concatenate(si.GetMatrix()) sliceOrder["hfsi"] = hfsi hfis = vtk.vtkTransform() hfis.Concatenate(hf.GetMatrix()) hfis.Concatenate(i_s.GetMatrix()) sliceOrder["hfis"] = hfis hfap = vtk.vtkTransform() hfap.Concatenate(hf.GetMatrix()) hfap.Concatenate(ap.GetMatrix()) sliceOrder["hfap"] = hfap hfpa = vtk.vtkTransform() hfpa.Concatenate(hf.GetMatrix()) hfpa.Concatenate(pa.GetMatrix()) sliceOrder["hfpa"] = hfpa hflr = vtk.vtkTransform() hflr.Concatenate(hf.GetMatrix()) hflr.Concatenate(lr.GetMatrix()) sliceOrder[""] = hflr hfrl = vtk.vtkTransform() hfrl.Concatenate(hf.GetMatrix()) hfrl.Concatenate(rl.GetMatrix()) sliceOrder["hfrl"] = hfrl return sliceOrder