def PlaneSphereActors(): ps = vtk.vtkPlaneSource() ps.SetXResolution(10) ps.SetYResolution(10) ss = vtk.vtkSphereSource() ss.SetRadius (0.3) group = vtk.vtkMultiBlockDataGroupFilter() group.AddInputConnection(ps.GetOutputPort()) group.AddInputConnection(ss.GetOutputPort()) ag = vtk.vtkRandomAttributeGenerator() ag.SetInputConnection(group.GetOutputPort()) ag.GenerateCellScalarsOn() ag.AttributesConstantPerBlockOn() n = vtk.vtkPolyDataNormals() n.SetInputConnection(ag.GetOutputPort()) n.Update (); actors = [] it = n.GetOutputDataObject(0).NewIterator() it.InitTraversal() while not it.IsDoneWithTraversal(): pm = vtk.vtkPolyDataMapper() pm.SetInputData(it.GetCurrentDataObject()) a = vtk.vtkActor() a.SetMapper(pm) actors.append (a) it.GoToNextItem() return actors
def __init__( self ): PerkEvaluatorMetric.__init__( self ) self.outputPolyData = vtk.vtkAppendPolyData() self.planeSource = vtk.vtkPlaneSource() self.planePolyData = self.planeSource.GetOutput()
def __init__(self, module_manager): SimpleVTKClassModuleBase.__init__( self, module_manager, vtk.vtkPlaneSource(), 'Processing.', (), ('vtkPolyData',), replaceDoc=True, inputFunctions=None, outputFunctions=None)
def __init__(self, name, sliceDirections, defaultPlaneOrientation=2): self.sliceDirections = sliceDirections self._defaultPlaneOrientation = 2 # orthoPipeline is a list of dictionaries. each dictionary is: # {'planeSource' : vtkPlaneSource, 'planeActor' : vtkActor, # 'textureMapToPlane' : vtkTextureMapToPlane, # ' self._orthoPipeline = [] # this is the frame that we will use to display our slice pipeline self._orthoViewFrame = None # self._renderer = None # list of vtkImagePlaneWidgets (first is "primary", rest are overlays) self._ipws = [] # then some state variables self._enabled = True self._interactionEnabled = True # list of objects that want to be contoured by this slice self._contourObjectsDict = {} self.overlayMode = 'greenOpacityRange' self.fusionAlpha = 0.4 # we'll use this to store the polydata of our primary slice self._primaryCopyPlaneSource = vtk.vtkPlaneSource() self._primaryCopyPlaneSource.SetXResolution(64) self._primaryCopyPlaneSource.SetYResolution(64) self.primaryPolyData = self._primaryCopyPlaneSource.GetOutput()
def __init__(self, parent = None): super(VTKFrame, self).__init__(parent) self.vtkWidget = QVTKRenderWindowInteractor(self) vl = QtGui.QVBoxLayout(self) vl.addWidget(self.vtkWidget) vl.setContentsMargins(0, 0, 0, 0) self.ren = vtk.vtkRenderer() self.ren.SetBackground(0.1, 0.2, 0.4) self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() # Provide some geometry resolution = 8 aPlane = vtk.vtkPlaneSource() aPlane.SetXResolution(resolution) aPlane.SetYResolution(resolution) # Create cell data cellData = vtk.vtkFloatArray() for i in range(resolution * resolution): cellData.InsertNextValue(i+1) # Create a lookup table to map cell data to colors lut = vtk.vtkLookupTable() tableSize = max(resolution*resolution+1, 10) lut.SetNumberOfTableValues(tableSize) lut.Build() # Fill in a few known colors, the rest will be generated if needed lut.SetTableValue(0 , 0 , 0 , 0, 1)# Black lut.SetTableValue(1, 0.8900, 0.8100, 0.3400, 1)# Banana lut.SetTableValue(2, 1.0000, 0.3882, 0.2784, 1)# Tomato lut.SetTableValue(3, 0.9608, 0.8706, 0.7020, 1)# Wheat lut.SetTableValue(4, 0.9020, 0.9020, 0.9804, 1)# Lavender lut.SetTableValue(5, 1.0000, 0.4900, 0.2500, 1)# Flesh lut.SetTableValue(6, 0.5300, 0.1500, 0.3400, 1)# Raspberry lut.SetTableValue(7, 0.9804, 0.5020, 0.4471, 1)# Salmon lut.SetTableValue(8, 0.7400, 0.9900, 0.7900, 1)# Mint lut.SetTableValue(9, 0.2000, 0.6300, 0.7900, 1)# Peacock aPlane.Update() #Force an update so we can set cell data aPlane.GetOutput().GetCellData().SetScalars(cellData) # Create a mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(aPlane.GetOutputPort()) mapper.SetScalarRange(0, tableSize - 1) mapper.SetLookupTable(lut) # Create an actor actor = vtk.vtkActor() actor.SetMapper(mapper) self.ren.AddActor(actor) self.ren.ResetCamera() self._initialized = False
def initSeedPoint(self): print "initializing SeedPoint" self.vtkSeeds = vtk.vtkPlaneSource() self.vtkSeeds.SetXResolution(4) self.vtkSeeds.SetYResolution(4) self.vtkSeeds.SetOrigin(0.0, 0.0, 0.0) self.vtkSeeds.SetPoint1(-10.0, -10.0, -10.0) self.vtkSeeds.SetPoint2(10.0, 10.0, 10.0)
def coplanar(self): numSelected = EventHandler().get_num_selected() if numSelected !=3: error_msg("You must first select exactly 3 markers", ) return # SetNormal is missing from the 4.2 python API so this is # a long winded way of setting the pw to intersect 3 # selected markers m1, m2, m3 = EventHandler().get_selected() p1 = m1.get_center() p2 = m2.get_center() p3 = m3.get_center() pw = pwo.get_pw() planeO = vtk.vtkPlaneSource() planeO.SetOrigin(pw.GetOrigin()) planeO.SetPoint1(pw.GetPoint1()) planeO.SetPoint2(pw.GetPoint2()) planeO.Update() planeN = vtk.vtkPlaneSource() planeN.SetOrigin(p1) planeN.SetPoint1(p2) planeN.SetPoint2(p3) planeN.Update() normal = planeN.GetNormal() planeO.SetNormal(normal) planeO.SetCenter( (p1[0] + p2[0] + p3[0])/3, (p1[1] + p2[1] + p3[1])/3, (p1[2] + p2[2] + p3[2])/3, ) planeO.Update() pwxyz = pwo.get_pwxyz() pw.SetOrigin(planeO.GetOrigin()) pw.SetPoint1(planeO.GetPoint1()) pw.SetPoint2(planeO.GetPoint2()) pw.UpdatePlacement() pwo.update_plane() pwo.Render() pwxyz.Render()
def __init__(self, center=(0,0,0), color=(0,0,1) ): self.src = vtk.vtkPlaneSource() #self.src.SetCenter(center) self.mapper = vtk.vtkPolyDataMapper() self.mapper.SetInput(self.src.GetOutput()) self.SetMapper(self.mapper) self.SetColor(color) self.SetOrigin(center)
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 _MakeXYActors(self, reduce=1): # get a texture-mapped actor extent = self._ImageReslice.GetOutputExtent() origin = self._ImageReslice.GetOutputOrigin() spacing = self._ImageReslice.GetOutputSpacing() bounds = [origin[0] + spacing[0] * (extent[0] - 0.5), origin[0] + spacing[0] * (extent[1] + 0.5), origin[1] + spacing[1] * (extent[2] - 0.5), origin[1] + spacing[1] * (extent[3] + 0.5), origin[2] + spacing[2] * (extent[4] - 0.5), origin[2] + spacing[2] * (extent[5] + 0.5)] for sliceNumber in range(extent[4], old_div((extent[5] + 1), reduce)): # the z position of the slice z = origin[2] + reduce * sliceNumber * spacing[2] plane = vtk.vtkPlaneSource() plane.SetXResolution(1) plane.SetYResolution(1) plane.SetOrigin(bounds[0], bounds[2], z) plane.SetPoint1(bounds[1], bounds[2], z) plane.SetPoint2(bounds[0], bounds[3], z) imageClip = vtk.vtkExtractVOI() imageClip.SetInput(self._ImageToStructuredPoints.GetOutput()) imageClip.SetVOI(extent[0], extent[1], extent[2], extent[3], reduce * sliceNumber, reduce * sliceNumber) imageClip.ReleaseDataFlagOn() texture = vtk.vtkTexture() texture.SetQualityTo32Bit() texture.SetInput(imageClip.GetOutput()) texture.RepeatOff() texture.InterpolateOn() texture.MapColorScalarsThroughLookupTableOff() for i in range(3): mapper = vtk.vtkPolyDataMapper() mapper.SetInput(plane.GetOutput()) mapper.SetClippingPlanes(self._ClippingPlanes[i]) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.SetTexture(texture) actor.PickableOff() actor.SetProperty(self._PropertyXY) self._PlanesXY.append(plane) self._ImageClipsXY.append(imageClip) self._ActorsXY.append(actor) numberOfPlanes = (extent[5] - extent[4] + 1) / reduce * 3 return self._ActorsXY[-numberOfPlanes:]
def SetInput(self, imagedata): axes = PLANE_DATA[self.orientation][0] # "x", "y" or "z" colour = PLANE_DATA[self.orientation][1] #if self.orientation == SAGITAL: # spacing = min(imagedata.GetSpacing()) # permute = vtk.vtkImagePermute() # permute.SetInput(imagedata) # permute.GetOutput().ReleaseDataFlagOn() # permute.SetOutputSpacing(spacing, spacing, spacing) # imagedata = permute.GetOutput() # Picker for enabling plane motion. # Allows selection of a cell by shooting a ray into graphics window picker = vtk.vtkCellPicker() picker.SetTolerance(0.005) picker.PickFromListOn() # 3D widget for reslicing image data. # This 3D widget defines a plane that can be interactively placed in an image volume. widget = vtk.vtkImagePlaneWidget() widget.SetInput(imagedata) widget.SetSliceIndex(self.index) widget.SetPicker(picker) widget.SetKeyPressActivationValue(axes) widget.SetInteractor(self.iren) widget.TextureVisibilityOff() widget.DisplayTextOff() widget.RestrictPlaneToVolumeOff() exec("widget.SetPlaneOrientationTo"+axes.upper()+"Axes()") widget.AddObserver("InteractionEvent",self.Update) self.widget = widget prop = widget.GetPlaneProperty() prop.SetColor(colour) # Syncronize coloured outline with texture appropriately source = vtk.vtkPlaneSource() source.SetOrigin(widget.GetOrigin()) source.SetPoint1(widget.GetPoint1()) source.SetPoint2(widget.GetPoint2()) source.SetNormal(widget.GetNormal()) self.source = source mapper = vtk.vtkPolyDataMapper() mapper.SetInput(source.GetOutput()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.SetTexture(widget.GetTexture()) actor.VisibilityOff() self.actor = actor self.render.AddActor(actor)
def _create_geometry(self): self._plane_source = vtk.vtkPlaneSource() self._plane_source.SetNormal((0.0,0.0,1.0)) self._plane_source.SetXResolution(1) self._plane_source.SetYResolution(1) m = vtk.vtkPolyDataMapper() m.SetInputConnection(self._plane_source.GetOutputPort()) a = vtk.vtkActor() a.SetMapper(m) a.GetProperty().SetOpacity(0.3) a.GetProperty().SetColor(0.0, 0.0, 0.7) self.props = [a]
def MakePlane(): ''' Make a plane as the source. :return: vtkPolyData with normal and scalar data. ''' source = vtk.vtkPlaneSource() source.SetOrigin(-10.0, -10.0, 0.0) source.SetPoint2(-10.0, 10.0, 0.0) source.SetPoint1(10.0, -10.0, 0.0) source.SetXResolution(20) source.SetYResolution(20) source.Update() return MakeElevations(source.GetOutput())
def createPlaneActor(plane): center = plane.center() normal = plane.normal() source = vtk.vtkPlaneSource() source.SetCenter(center[0], center[1], center[2]) source.SetNormal(normal[0], normal[1], normal[2]) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) obj = vtk.vtkActor() obj.SetMapper(mapper) return obj
def __init__(self, origin, p1, p2, width, height): logging.debug("In Slice::__init__()") self._p1 = p1 self._p2 = p2 self._width = width self._origin = origin self._height = height self._plane = vtk.vtkPlaneSource() self._plane.SetOrigin(self._origin) self._plane.SetPoint1(self._p1) self._plane.SetPoint2(self._p2) self._plane.Update() self.normalizePlaneSize() self.createBoundsPlanes() self._resliceTransform = None
def Plane(self): p = vtkPlaneSource() # Default is: # Centre = 0,0,0 # Normal = 0,0,1 # Origin = -0.5, -0.5, 0 # So set the radius first while it's simple p.SetOrigin(-self.Radius, -self.Radius, 0.) p.SetPoint1(+self.Radius, -self.Radius, 0.) p.SetPoint2(-self.Radius, +self.Radius, 0.) # Shift to the right place p.SetCenter(self.Centre.x, self.Centre.y, self.Centre.z) # Orient correctly p.SetNormal(self.Normal.x, self.Normal.y, self.Normal.z) return p
def init_fiducial_actor(self, fiducial_obj): """Initialize a plane VTK actor to display the fiducials.""" plane_source = vtk.vtkPlaneSource() plane_source.SetCenter(0.0, 0.0, 0.0) plane_source.SetNormal(0.0, 0.0, 1.0) plane_source.Update() plane = plane_source.GetOutput() mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(plane) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(1.0, 0.0, 0.0) actor.SetScale(fiducial_obj.apriltag_properties.dimensions.x, fiducial_obj.apriltag_properties.dimensions.y, 1.0) return actor
def planesCallback(self, obj, event): fp = self.ren_list[1].GetActiveCamera().GetFocalPoint() p = self.ren_list[1].GetActiveCamera().GetPosition() dist = np.sqrt((p[0] - fp[0]) ** 2 + (p[1] - fp[1]) ** 2 + (p[2] - fp[2]) ** 2) self.ren_list[1].GetActiveCamera().SetPosition(fp[0], fp[1], fp[2] + dist) self.ren_list[1].GetActiveCamera().SetViewUp(0.0, 1.0, 0.0) fp = self.ren_list[2].GetActiveCamera().GetFocalPoint() p = self.ren_list[2].GetActiveCamera().GetPosition() dist = np.sqrt((p[0] - fp[0]) ** 2 + (p[1] - fp[1]) ** 2 + (p[2] - fp[2]) ** 2) self.ren_list[2].GetActiveCamera().SetPosition(fp[0] + dist, fp[1], fp[2]) self.ren_list[2].GetActiveCamera().SetViewUp(0.0, -1.0, 0.0) self.ren_list[2].GetActiveCamera().Roll(90) fp = self.ren_list[3].GetActiveCamera().GetFocalPoint() p = self.ren_list[3].GetActiveCamera().GetPosition() dist = np.sqrt((p[0] - fp[0]) ** 2 + (p[1] - fp[1]) ** 2 + (p[2] - fp[2]) ** 2) self.ren_list[3].GetActiveCamera().SetPosition(fp[0], fp[1] - dist, fp[2]) self.ren_list[3].GetActiveCamera().SetViewUp(-1.0, 0.0, 0.0) self.ren_list[3].GetActiveCamera().Roll(90) new_center = obj.GetCenter() new_normal = obj.GetNormal() index = obj.index new_source = vtk.vtkPlaneSource() new_source.SetCenter(new_center) new_source.SetNormal(new_normal) new_source.Update() self.geo_data.foliation_modify(index, X=new_center[0], Y=new_center[1], Z=new_center[2], G_x=new_normal[0], G_y=new_normal[1], G_z=new_normal[2]) render = obj.n_render if render != 0: self.f_rend_1[obj.n_plane].SetInputData(new_source.GetOutput()) self.f_rend_1[obj.n_plane].SetNormal(new_normal) if render != 1: self.f_rend_2[obj.n_plane].SetInputData(new_source.GetOutput()) self.f_rend_2[obj.n_plane].SetNormal(new_normal) if render != 2: self.f_rend_3[obj.n_plane].SetInputData(new_source.GetOutput()) self.f_rend_3[obj.n_plane].SetNormal(new_normal) if render != 3: self.f_rend_4[obj.n_plane].SetInputData(new_source.GetOutput()) self.f_rend_4[obj.n_plane].SetNormal(new_normal)
def Plane(center=(0, 0, 0), direction=(0, 0, 1), i_size=1, j_size=1, i_resolution=10, j_resolution=10): """ Create a plane Parameters ---------- center : list or np.ndarray Location of the centroid in [x, y, z] direction : list or np.ndarray Direction cylinder points to in [x, y, z] i_size : float Size of the plane in the i direction. j_size : float Size of the plane in the i direction. i_resolution : int Number of points on the plane in the i direction. j_resolution : int Number of points on the plane in the j direction. Returns ------- plane : pyvista.PolyData Plane mesh """ planeSource = vtk.vtkPlaneSource() planeSource.SetXResolution(i_resolution) planeSource.SetYResolution(j_resolution) planeSource.Update() surf = pyvista.PolyData(planeSource.GetOutput()) surf.points[:, 0] *= i_size surf.points[:, 1] *= j_size surf.rotate_y(-90) translate(surf, center, direction) return surf
def floor(): plane = vtk.vtkPlaneSource() reader = vtk.vtkJPEGReader() reader.SetFileName( pkg_resources.resource_filename( __name__, '/'.join(('media', 'imgs', 'floor.jpg')))) texture = vtk.vtkTexture() texture.SetInputConnection(reader.GetOutputPort()) map_to_plane = vtk.vtkTextureMapToPlane() map_to_plane.SetInputConnection(plane.GetOutputPort()) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(map_to_plane.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.SetTexture(texture) return actor
def makeBorderPD(ipw): # setup source ps = vtk.vtkPlaneSource() ps.SetOrigin(ipw.GetOrigin()) ps.SetPoint1(ipw.GetPoint1()) ps.SetPoint2(ipw.GetPoint2()) fe = vtk.vtkFeatureEdges() fe.SetInput(ps.GetOutput()) tubef = vtk.vtkTubeFilter() tubef.SetNumberOfSides(12) tubef.SetRadius(0.5) tubef.SetInput(fe.GetOutput()) return tubef.GetOutput()
def CreateImageLabelModel(self, width, height): # Create Image Label Transform if not in scene already try: self.imageLabelTransform = slicer.util.getNode( "ImageLabelTransform") except: self.imageLabelTransform = slicer.util.loadTransform( os.path.join(self.resourcePath, 'Resources/ImageLabelTransform.h5')) self.imageLabelTransform.SetAndObserveTransformNodeID( self.sceneTransform.GetID()) # Create Backup so we can move red border back to there self.imageLabelMatrix = vtk.vtkMatrix4x4() self.imageLabelTransform.GetMatrixTransformToParent( self.imageLabelMatrix) self.imageLabelTransformBackup = self.imageLabelTransform # Create Instruction Model Node if not in scene already try: self.imageLabelModelNode = slicer.util.getNode("ImageLabelModel") except: self.imageLabelPlane = vtk.vtkPlaneSource() self.imageLabelPlane.SetPoint1(0, height, 0) self.imageLabelPlane.SetPoint2(width, 0, 0) self.imageLabelPlane.SetOrigin(0, 0, 0) self.imageLabelPlane.Update() self.pngImageReader = vtk.vtkPNGReader() self.pngImageReader.SetFileName( os.path.join(self.resourcePath, 'Resources/RedBorderTrans.png')) self.pngImageReader.Update() self.imageLabelModelNode = slicer.mrmlScene.AddNewNodeByClass( 'vtkMRMLModelNode') self.imageLabelModelNode.SetName("ImageLabelModel") self.imageLabelModelNode.CreateDefaultDisplayNodes() self.imageLabelModelNode.SetAndObservePolyData( self.imageLabelPlane.GetOutput()) self.imageLabelModelNode.SetAndObserveTransformNodeID( self.imageLabelTransform.GetID()) self.imageLabelModelDisplay = self.imageLabelModelNode.GetDisplayNode( ) self.imageLabelModelDisplay.SetTextureImageDataConnection( self.pngImageReader.GetOutputPort()) self.imageLabelModelDisplay.VisibilityOn() self.imageLabelModelDisplay.SetFrontfaceCulling(False) self.imageLabelModelDisplay.SetBackfaceCulling(False)
def __add_plane_to_ren(center, normal, length, ren): import vtk center = np.array(center) source = vtk.vtkPlaneSource() source.SetOrigin(0, 0, 0) source.SetPoint1(length, 0, 0) source.SetPoint2(0, length, 0) source.SetCenter(*center) source.SetNormal(*normal) source.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) ac = vtk.vtkActor() ac.SetMapper(mapper) ren.AddActor(ac) return ac
def make_vtk_plane(): ''' Create a plane in vtk and return the actor for the plane.''' # create source source = vtk.vtkPlaneSource() source.SetPoint1(-10, 10, 0) source.SetPoint2(10, -10, 0) source.SetOrigin(-10, -10, 0) # mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) # actor actor = vtk.vtkActor() actor.SetMapper(mapper) return actor
def grid(pos=[0, 0, 0], normal=[0, 0, 1], sx=1, sy=1, c='g', bc='darkgreen', lw=1, alpha=1, legend=None, resx=10, resy=10): '''Return a grid plane. .. hint:: Example: `brownian2D.py <https://github.com/marcomusy/vtkplotter/blob/master/examples/advanced/brownian2D.py>`_ .. image:: https://user-images.githubusercontent.com/32848391/50738948-73ce8300-11d9-11e9-8ef6-fc4f64c4a9ce.gif ''' ps = vtk.vtkPlaneSource() ps.SetResolution(resx, resy) ps.Update() poly0 = ps.GetOutput() t0 = vtk.vtkTransform() t0.Scale(sx, sy, 1) tf0 = vtk.vtkTransformPolyDataFilter() tf0.SetInputData(poly0) tf0.SetTransform(t0) tf0.Update() poly = tf0.GetOutput() axis = np.array(normal) / np.linalg.norm(normal) theta = np.arccos(axis[2]) phi = np.arctan2(axis[1], axis[0]) t = vtk.vtkTransform() t.PostMultiply() t.RotateY(theta * 57.3) t.RotateZ(phi * 57.3) tf = vtk.vtkTransformPolyDataFilter() tf.SetInputData(poly) tf.SetTransform(t) tf.Update() pd = tf.GetOutput() actor = Actor(pd, c=c, bc=bc, alpha=alpha, legend=legend) actor.GetProperty().SetRepresentationToWireframe() actor.GetProperty().SetLineWidth(lw) actor.SetPosition(pos) actor.PickableOff() return actor
def Grid( pos=(0, 0, 0), normal=(0, 0, 1), sx=1, sy=1, c="g", bc="darkgreen", lw=1, alpha=1, resx=10, resy=10, ): """Return a grid plane. .. hint:: |brownian2D| |brownian2D.py|_ """ ps = vtk.vtkPlaneSource() ps.SetResolution(resx, resy) ps.Update() poly0 = ps.GetOutput() t0 = vtk.vtkTransform() t0.Scale(sx, sy, 1) tf0 = vtk.vtkTransformPolyDataFilter() tf0.SetInputData(poly0) tf0.SetTransform(t0) tf0.Update() poly = tf0.GetOutput() axis = np.array(normal) / np.linalg.norm(normal) theta = np.arccos(axis[2]) phi = np.arctan2(axis[1], axis[0]) t = vtk.vtkTransform() t.PostMultiply() t.RotateY(np.rad2deg(theta)) t.RotateZ(np.rad2deg(phi)) tf = vtk.vtkTransformPolyDataFilter() tf.SetInputData(poly) tf.SetTransform(t) tf.Update() pd = tf.GetOutput() actor = Actor(pd, c=c, bc=bc, alpha=alpha) actor.GetProperty().SetRepresentationToWireframe() actor.GetProperty().SetLineWidth(lw) actor.SetPosition(pos) settings.collectable_actors.append(actor) return actor
def __init__(self, parent=None): super(VTKFrame, self).__init__(parent) self.vtkWidget = QVTKRenderWindowInteractor(self) vl = QtGui.QVBoxLayout(self) vl.addWidget(self.vtkWidget) vl.setContentsMargins(0, 0, 0, 0) self.ren = vtk.vtkRenderer() self.ren.SetBackground(0.1, 0.2, 0.4) self.vtkWidget.GetRenderWindow().AddRenderer(self.ren) self.iren = self.vtkWidget.GetRenderWindow().GetInteractor() # Provide some geometry resolution = 8 aPlane = vtk.vtkPlaneSource() aPlane.SetXResolution(resolution) aPlane.SetYResolution(resolution) aPlane.Update() # Create cell data cellData = vtk.vtkUnsignedCharArray() cellData.SetNumberOfComponents(3) cellData.SetNumberOfTuples(aPlane.GetOutput().GetNumberOfCells()) for i in range(aPlane.GetOutput().GetNumberOfCells()): rgb = random.randint(64, 255), random.randint(64, 255), random.randint( 64, 255) cellData.InsertTuple(i, rgb) aPlane.GetOutput().GetCellData().SetScalars(cellData) # Create a mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(aPlane.GetOutputPort()) # Create an actor actor = vtk.vtkActor() actor.SetMapper(mapper) self.ren.AddActor(actor) self.ren.ResetCamera() self._initialized = False
def make_color_plane(x, y, colors): plane = vtk.vtkPlaneSource() plane.SetXResolution(x) plane.SetYResolution(y) plane.Update() colorData = colors_to_scalars(colors) plane.GetOutput().GetCellData().SetScalars(colorData) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(plane.GetOutputPort()) mapper.SetScalarModeToUseCellData() mapper.Update() actor = vtk.vtkActor() actor.SetMapper(mapper) return actor
def addPlane(self, name, point1, point2, point3, color=np.array([255.0, 255.0, 255.0]), opacity=1.0): self.removeActorByName(name) # Create a plane planeSource = vtk.vtkPlaneSource() # planeSource.SetOrigin(center_point[0], center_point[1], center_point[2]) # #planeSource.SetNormal(normal_vector[0], normal_vector[1], normal_vector[2]) # #print(dir(planeSource)) # planeSource.SetPoint1(top_left_point[0], top_left_point[1], top_left_point[2]) # planeSource.SetPoint2(bot_right_point[0], bot_right_point[1], bot_right_point[2]) # planeSource.SetXResolution(10) # planeSource.SetYResolution(340) planeSource.SetOrigin(point1[0], point1[1], point1[2]) planeSource.SetPoint1(point2[0], point2[1], point2[2]) planeSource.SetPoint2(point3[0], point3[1], point3[2]) planeSource.SetXResolution(10) planeSource.SetYResolution(340) planeSource.Update() plane = planeSource.GetOutput() # Create a mapper and actor polygonMapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: polygonMapper.SetInputConnection(polygon.GetProducerPort()) else: polygonMapper.SetInputData(plane) polygonMapper.Update() polygonActor = vtk.vtkActor() polygonActor.SetMapper(polygonMapper) polygonActor.GetProperty().SetColor([color[0], color[1], color[2]]) polygonActor.GetProperty().SetOpacity(opacity) #actor.GetProperty().SetColor(colors->GetColor3d("Cyan").GetData()); self.ren.AddActor(polygonActor) self.actor_list[name] = polygonActor
def call_back_plane_move_changes(self, indices): df_changes = self.model._orientations.df.loc[np.atleast_1d(indices).astype(int)][['X', 'Y', 'Z', 'G_x', 'G_y', 'G_z', 'id']] for index, new_values_df in df_changes.iterrows(): new_center = new_values_df[['X', 'Y', 'Z']].values new_normal = new_values_df[['G_x', 'G_y', 'G_z']].values new_source = vtk.vtkPlaneSource() new_source.SetCenter(new_center) new_source.SetNormal(new_normal) new_source.Update() plane1 = self.orientations_widgets[index] # plane1.SetInputData(new_source.GetOutput()) plane1.SetNormal(new_normal) plane1.SetCenter(new_center[0], new_center[1], new_center[2]) _color_lot = self._get_color_lot(is_faults=True, is_basement=False, index='id') plane1.GetPlaneProperty().SetColor(mcolors.hex2color(_color_lot[int(new_values_df['id'])])) plane1.GetHandleProperty().SetColor(mcolors.hex2color(_color_lot[int(new_values_df['id'])]))
def makeZCutter(self, bounds, scaleFactor, value): """ create z cutter plane """ npos = self._calculateZCutterPos(value) self.zplane = vtk.vtkPlane() self.zplane.SetOrigin(0, 0, npos) self.zplane.SetNormal(0, 0, 1) self.ZCutter = vtk.vtkCutter() self.ZCutter.SetInputConnection(self.warp.GetOutputPort()) self.ZCutter.SetCutFunction(self.zplane) self.ZCutter.GenerateCutScalarsOff() self.ZCutterMapper = vtk.vtkPolyDataMapper() self.ZCutterMapper.SetInputConnection(self.ZCutter.GetOutputPort()) # visual plane to move plane = vtk.vtkPlaneSource() plane.SetResolution(50, 50) plane.SetCenter(0, 0, 0) plane.SetNormal(0, 0, 1) tran = vtk.vtkTransform() tran.Translate((bounds[1] - bounds[0]) / 2. - (0 - bounds[0]), (bounds[3] - bounds[2]) / 2. - (0 - bounds[2]), npos) tran.Scale((bounds[1] - bounds[0]), (bounds[3] - bounds[2]), 1) tran.PostMultiply() self.ZCutterTransform = tran tranf = vtk.vtkTransformPolyDataFilter() tranf.SetInputConnection(plane.GetOutputPort()) tranf.SetTransform(tran) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(tranf.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(0.9, 0.9, 0.9) actor.GetProperty().SetOpacity(self.opacitySlice) return actor
def plane(pos=[0, 0, 0], normal=[0, 0, 1], sx=1, sy=None, c='g', bc='darkgreen', alpha=1, legend=None, texture=None): ''' Draw a plane of size sx and sy oriented perpendicular to vector normal and so that it passes through point pos. ''' if sy is None: sy = sx ps = vtk.vtkPlaneSource() ps.SetResolution(1, 1) tri = vtk.vtkTriangleFilter() tri.SetInputConnection(ps.GetOutputPort()) tri.Update() poly = tri.GetOutput() axis = np.array(normal) / np.linalg.norm(normal) theta = np.arccos(axis[2]) phi = np.arctan2(axis[1], axis[0]) t = vtk.vtkTransform() t.PostMultiply() t.Scale(sx, sy, 1) t.RotateY(theta * 57.3) t.RotateZ(phi * 57.3) tf = vtk.vtkTransformPolyDataFilter() vu.setInput(tf, poly) tf.SetTransform(t) tf.Update() pd = tf.GetOutput() actor = vu.makeActor(pd, c=c, bc=bc, alpha=alpha, legend=legend, texture=texture) actor.SetPosition(pos) actor.PickableOff() return actor
def make_texture_overly_object(self): input_image = self.session.overlay_image_fname reader = vtk.vtkJPEGReader() reader.SetFileName(input_image) texture = vtk.vtkTexture() texture.SetInput(reader.GetOutput()) texture.SetInputConnection(reader.GetOutputPort()) texture.InterpolateOn() plane = vtk.vtkPlaneSource() plane.SetOrigin((0, 0, 0)) plane.SetPoint1(self.bounds.lat_max_distance) plane.SetPoint2(self.bounds.long_max_distance) planeMapper = vtk.vtkPolyDataMapper() planeMapper.SetInputConnection(plane.GetOutputPort()) self.overlayActor = vtk.vtkActor() self.overlayActor.SetMapper(planeMapper) self.overlayActor.SetTexture(texture) self.actors.append(self.overlayActor)
def add_plane(self, center, normal): """Add a plane to the viewer Parameters ---------- center : array_like The origin of the plane normal : array_like The normal of the plane """ plane = vtk.vtkPlaneSource() plane.SetCenter(center) plane.SetNormal(normal) mapper = vtk.vtkPolyDataMapper() if vtk.VTK_MAJOR_VERSION <= 5: mapper.SetInput(plane.GetOutput()) else: mapper.SetInputData(plane.GetOutput())
def __create_planes(self): plane_list = [] scaling = self.settings.scaling for x in self.settings.plane_surface_list: actor = vtk.vtkActor() plane = vtk.vtkPlaneSource() plane.SetOrigin(x["origin"] * scaling) plane.SetPoint1(x["axis1"] * scaling) plane.SetPoint2(x["axis2"] * scaling) mapper = vtk.vtkPolyDataMapper() mapper.SetInput(plane.GetOutput()) actor.SetMapper(mapper) prop = actor.GetProperty() prop.SetColor(x["color"]) prop.SetOpacity(x["opacity"]) plane_list.append(actor) return plane_list
def _create_planes(self): plane_list = [] scaling = self.settings.scaling for x in self.settings.plane_surface_list: actor = vtk.vtkActor() plane = vtk.vtkPlaneSource() plane.SetOrigin(numpy.array(x['origin']) * scaling) plane.SetPoint1(numpy.array(x['axis1']) * scaling) plane.SetPoint2(numpy.array(x['axis2']) * scaling) mapper = vtk.vtkPolyDataMapper() mapper.SetInput(plane.GetOutput()) actor.SetMapper(mapper) prop = actor.GetProperty() prop.SetColor(x['color']) prop.SetOpacity(x['opacity']) plane_list.append(actor) return plane_list
def create_textured_plane(**kwargs): """ create a plane with correct size and texture it with a map """ image_reader = vtk.vtkPNGReader() image_reader.SetFileName(kwargs['map']) plane = vtk.vtkPlaneSource() size = kwargs['size'] z_level = 0.0 plane.SetOrigin(-0.5 * size[0], -0.5 * size[1], z_level) plane.SetPoint1(+0.5 * size[0], -0.5 * size[1], z_level) plane.SetPoint2(-0.5 * size[0], +0.5 * size[1], z_level) texture = vtk.vtkTexture() texture.SetInputConnection(image_reader.GetOutputPort()) texture_plane = vtk.vtkTextureMapToPlane() texture_plane.SetInputConnection(plane.GetOutputPort()) return texture_plane, texture
def create_textured_plane(**kwargs): """ create a plane with correct size and texture it with a map """ image_reader = vtk.vtkPNGReader() image_reader.SetFileName(kwargs['map']) plane = vtk.vtkPlaneSource() size = kwargs['size'] z_level = 0.0 plane.SetOrigin(-0.5*size[0], -0.5*size[1], z_level) plane.SetPoint1(+0.5*size[0], -0.5*size[1], z_level) plane.SetPoint2(-0.5*size[0], +0.5*size[1], z_level) texture = vtk.vtkTexture() texture.SetInputConnection(image_reader.GetOutputPort()) texture_plane = vtk.vtkTextureMapToPlane() texture_plane.SetInputConnection(plane.GetOutputPort()) return texture_plane, texture
def CreatePlaneModel(self, width, height): # Create Instruction Transform Node if not in scene already try: self.instructionTransform = slicer.util.getNode( "InstructionTransform") except: self.instructionTransform = slicer.util.loadTransform( os.path.join(self.resourcePath, 'Resources/InstructionTransform.h5')) self.instructionTransform.SetAndObserveTransformNodeID( self.sceneTransform.GetID()) # Create Instruction Model Node if not in scene already try: self.instructionModelNode = slicer.util.getNode("InstructionModel") except: self.imagePlane = vtk.vtkPlaneSource() self.imagePlane.SetPoint1(0, height, 0) self.imagePlane.SetPoint2(width, 0, 0) self.imagePlane.SetOrigin(0, 0, 0) self.imagePlane.Update() self.pngReader = vtk.vtkPNGReader() #self.pngReader.SetFileName(os.path.join(self.resourcePath, 'Resources/Instructions2.png')) self.pngReader.SetFileName( os.path.join(self.resourcePath, 'Resources/ThreeViews3.png')) self.pngReader.Update() self.instructionModelNode = slicer.mrmlScene.AddNewNodeByClass( 'vtkMRMLModelNode') self.instructionModelNode.SetName("InstructionModel") self.instructionModelNode.CreateDefaultDisplayNodes() self.instructionModelNode.SetAndObservePolyData( self.imagePlane.GetOutput()) self.instructionModelNode.SetAndObserveTransformNodeID( self.instructionTransform.GetID()) self.instructionModelDisplay = self.instructionModelNode.GetDisplayNode( ) self.instructionModelDisplay.SetTextureImageDataConnection( self.pngReader.GetOutputPort()) self.instructionModelDisplay.VisibilityOn() self.instructionModelDisplay.SetFrontfaceCulling(False) self.instructionModelDisplay.SetBackfaceCulling(False)
def grid(pos=[0, 0, 0], normal=[0, 0, 1], sx=1, sy=1, c='g', bc='darkgreen', lw=1, alpha=1, legend=None, resx=10, resy=10): '''Return a grid plane''' ps = vtk.vtkPlaneSource() ps.SetResolution(resx, resy) ps.Update() poly0 = ps.GetOutput() t0 = vtk.vtkTransform() t0.Scale(sx, sy, 1) tf0 = vtk.vtkTransformPolyDataFilter() vu.setInput(tf0, poly0) tf0.SetTransform(t0) tf0.Update() poly = tf0.GetOutput() axis = np.array(normal) / np.linalg.norm(normal) theta = np.arccos(axis[2]) phi = np.arctan2(axis[1], axis[0]) t = vtk.vtkTransform() t.PostMultiply() t.RotateY(theta * 57.3) t.RotateZ(phi * 57.3) tf = vtk.vtkTransformPolyDataFilter() vu.setInput(tf, poly) tf.SetTransform(t) tf.Update() pd = tf.GetOutput() actor = vu.makeActor(pd, c=c, bc=bc, alpha=alpha, legend=legend) actor.GetProperty().SetRepresentationToWireframe() actor.GetProperty().SetLineWidth(lw) actor.SetPosition(pos) actor.PickableOff() return actor
def create_ground_frame(size=300): planeSource = vtk.vtkPlaneSource() planeSource.SetXResolution(10) planeSource.SetYResolution(10) planeSource.SetCenter(0.0, 0.0, 0.0) planeSource.SetNormal(0.0, 0.0, 1.0) planeSource.Update() scaled_plane = scale_object(planeSource, size) # Create a mapper and actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(scaled_plane.GetOutput()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().EdgeVisibilityOn() actor.GetProperty().LightingOff() actor.GetProperty().SetOpacity(0.3) actor.GetProperty().SetColor([255, 0, 0]) return actor
def DrawPlan(renderer,color,center,normal,scaleFactor,oldActor=None): # Create a plane planeSource = vtk.vtkPlaneSource() planeSource.SetCenter(0,0,0) planeSource.SetNormal(normal) planeSource.Update() # Scale plane scaleTransform=vtk.vtkTransform() scaleTransform.Scale((scaleFactor)) scaleFilter = vtk.vtkTransformPolyDataFilter() scaleFilter.SetInputConnection(planeSource.GetOutputPort()) scaleFilter.SetTransform(scaleTransform) scaleFilter.Update() # Translate plane translation = vtk.vtkTransform() translation.Translate(center) transformFilter = vtk.vtkTransformPolyDataFilter() transformFilter.SetInputConnection(scaleFilter.GetOutputPort()) transformFilter.SetTransform(translation) transformFilter.Update() plane = transformFilter.GetOutput() # Create a mapper and actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(plane) actor = vtk.vtkActor() actor.SetMapper(mapper) #actor.GetProperty().SetRepresentationToWireframe() #plan unfilled actor.GetProperty().SetColor(color) actor.GetProperty().SetOpacity(0.5) if oldActor != None : renderer.RemoveActor(oldActor) renderer.AddActor(actor) return actor
def __init__(self, renderer, parent, screenDistance, width, height, isActiveCamera = False): ''' Initialize the CameraScreen model. If you are going to stream data to it, set isActiveCamera to true in the constructor parameters and pass jpeg data to the update method. ''' # Call the parent constructor super(CameraScreen,self).__init__(renderer, parent) # Create a plane for the camera # Ref: http://www.vtk.org/doc/nightly/html/classvtkPlaneSource.html planeSource = vtk.vtkPlaneSource() # Defaults work for this, so just push it out a bit #planeSource.Push(screenDistance) # Transform scale it to the right size trans = vtk.vtkTransform() trans.Scale(width, height, 1) trans.Translate(0, 0, screenDistance) trans.RotateY(180) # Effectively flipping the UV (texture) mapping so that the video isn't left/right flipped transF = vtk.vtkTransformPolyDataFilter() transF.SetInputConnection(planeSource.GetOutputPort()) transF.SetTransform(trans) # Create a test picture and assign it to the screen for now... # Ref: http://vtk.org/gitweb?p=VTK.git;a=blob;f=Examples/Rendering/Python/TPlane.py if not isActiveCamera: self.__textReader = vtk.vtkPNGReader() self.__textReader.SetFileName("../scene/media/semisortedcameralogo.png") else: self.__textReader = vtk.vtkJPEGReader() self.cameraVtkTexture = vtk.vtkTexture() self.cameraVtkTexture.SetInputConnection(self.__textReader.GetOutputPort()) self.cameraVtkTexture.InterpolateOn() # Finally assign the mapper and the actor planeMapper = vtk.vtkPolyDataMapper() planeMapper.SetInputConnection(transF.GetOutputPort()) self.vtkActor.SetMapper(planeMapper) self.vtkActor.SetTexture(self.cameraVtkTexture)
def TextureMappedPlane(self, obj, event): # use dummy image data here e = vtk.vtkImageEllipsoidSource() scene = slicer.mrmlScene # Create model node model = slicer.vtkMRMLModelNode() model.SetScene(scene) model.SetName(scene.GenerateUniqueName("2DImageModel")) planeSource = vtk.vtkPlaneSource() model.SetAndObservePolyData(planeSource.GetOutput()) # Create display node modelDisplay = slicer.vtkMRMLModelDisplayNode() modelDisplay.SetColor(1, 1, 0) # yellow # modelDisplay.SetBackfaceCulling(0) modelDisplay.SetScene(scene) scene.AddNode(modelDisplay) model.SetAndObserveDisplayNodeID(modelDisplay.GetID()) modelDisplay.SetSliceIntersectionVisibility(True) modelDisplay.SetVisibility(True) # Add to scene modelDisplay.SetTextureImageDataConnection(e.GetOutputPort()) # modelDisplay.SetInputPolyDataConnection(model.GetPolyDataConnection()) scene.AddNode(model) transform = slicer.vtkMRMLLinearTransformNode() scene.AddNode(transform) model.SetAndObserveTransformNodeID(transform.GetID()) vTransform = vtk.vtkTransform() vTransform.Scale(50, 50, 50) vTransform.RotateX(30) # transform.SetAndObserveMatrixTransformToParent(vTransform.GetMatrix()) transform.SetMatrixTransformToParent(vTransform.GetMatrix())
def _createOrthoPipelineForNewIPW(self, ipw): """This will create and append all the necessary constructs for a single new layer (ipw) to the self._orthoPipeline. Make sure you only call this method if the orthoView exists! After having done this, you still need to call _syncOrthoView() or _resetOrthoView() if you've added a new primary. """ _ps = vtk.vtkPlaneSource() _pa = vtk.vtkActor() _tm2p = vtk.vtkTextureMapToPlane() self._orthoPipeline.append({ 'planeSource': _ps, 'planeActor': _pa, 'textureMapToPlane': _tm2p }) _tm2p.AutomaticPlaneGenerationOff() _tm2p.SetInput(_ps.GetOutput()) mapper = vtk.vtkPolyDataMapper() mapper.SetInput(_tm2p.GetOutput()) _pa.SetMapper(mapper) otherTexture = ipw.GetTexture() # we don't just use the texture, else VTK goes mad re-uploading # the same texture unnecessarily... let's just make use of the # same input, we get much more effective use of the # host->GPU bus texture = vtk.vtkTexture() texture.SetInterpolate(otherTexture.GetInterpolate()) texture.SetQuality(otherTexture.GetQuality()) texture.MapColorScalarsThroughLookupTableOff() texture.RepeatOff() texture.SetInput(otherTexture.GetInput()) _pa.SetTexture(texture) self._renderer.AddActor(_pa)
def Create(self): self.plane_widget = plane_widget = vtk.vtkImagePlaneWidget() plane_widget.SetInputData(self.img) plane_widget.SetPlaneOrientationToXAxes() #plane_widget.SetResliceInterpolateToLinear() plane_widget.TextureVisibilityOff() #Set left mouse button to move and rotate plane plane_widget.SetLeftButtonAction(1) #SetColor margin to green margin_property = plane_widget.GetMarginProperty() margin_property.SetColor(0, 0.8, 0) #Disable cross cursor_property = plane_widget.GetCursorProperty() cursor_property.SetOpacity(0) self.plane_source = plane_source = vtk.vtkPlaneSource() plane_source.SetOrigin(plane_widget.GetOrigin()) plane_source.SetPoint1(plane_widget.GetPoint1()) plane_source.SetPoint2(plane_widget.GetPoint2()) plane_source.SetNormal(plane_widget.GetNormal()) plane_mapper = self.plane_mapper = vtk.vtkPolyDataMapper() plane_mapper.SetInputData(plane_source.GetOutput()) self.plane_actor = plane_actor = vtk.vtkActor() plane_actor.SetMapper(plane_mapper) plane_actor.GetProperty().BackfaceCullingOn() plane_actor.GetProperty().SetOpacity(0) plane_widget.AddObserver("InteractionEvent", self.Update) Publisher.sendMessage('AppendActor', actor=self.plane_actor) Publisher.sendMessage('Set Widget Interactor', widget=self.plane_widget) plane_actor.SetVisibility(1) plane_widget.On() self.plane = plane = vtk.vtkPlane() plane.SetNormal(self.plane_source.GetNormal()) plane.SetOrigin(self.plane_source.GetOrigin()) self.volume_mapper.AddClippingPlane(plane) #Storage First Position self.origin = plane_widget.GetOrigin() self.p1 = plane_widget.GetPoint1() self.p2 = plane_widget.GetPoint2() self.normal = plane_widget.GetNormal()
def _createOrthoPipelineForNewIPW(self, ipw): """This will create and append all the necessary constructs for a single new layer (ipw) to the self._orthoPipeline. Make sure you only call this method if the orthoView exists! After having done this, you still need to call _syncOrthoView() or _resetOrthoView() if you've added a new primary. """ _ps = vtk.vtkPlaneSource() _pa = vtk.vtkActor() _tm2p = vtk.vtkTextureMapToPlane() self._orthoPipeline.append( {'planeSource' : _ps, 'planeActor' : _pa, 'textureMapToPlane': _tm2p}) _tm2p.AutomaticPlaneGenerationOff() _tm2p.SetInput(_ps.GetOutput()) mapper = vtk.vtkPolyDataMapper() mapper.SetInput(_tm2p.GetOutput()) _pa.SetMapper(mapper) otherTexture = ipw.GetTexture() # we don't just use the texture, else VTK goes mad re-uploading # the same texture unnecessarily... let's just make use of the # same input, we get much more effective use of the # host->GPU bus texture = vtk.vtkTexture() texture.SetInterpolate(otherTexture.GetInterpolate()) texture.SetQuality(otherTexture.GetQuality()) texture.MapColorScalarsThroughLookupTableOff() texture.RepeatOff() texture.SetInput(otherTexture.GetInput()) _pa.SetTexture(texture) self._renderer.AddActor(_pa)
def Plane(pos=(0, 0, 0), normal=(0, 0, 1), sx=1, sy=None, c="g", bc="darkgreen", alpha=1, texture=None): """ Draw a plane of size `sx` and `sy` oriented perpendicular to vector `normal` and so that it passes through point `pos`. |Plane| """ if sy is None: sy = sx ps = vtk.vtkPlaneSource() ps.SetResolution(1, 1) tri = vtk.vtkTriangleFilter() tri.SetInputConnection(ps.GetOutputPort()) tri.Update() poly = tri.GetOutput() axis = np.array(normal) / np.linalg.norm(normal) theta = np.arccos(axis[2]) phi = np.arctan2(axis[1], axis[0]) t = vtk.vtkTransform() t.PostMultiply() t.Scale(sx, sy, 1) t.RotateY(np.rad2deg(theta)) t.RotateZ(np.rad2deg(phi)) tf = vtk.vtkTransformPolyDataFilter() tf.SetInputData(poly) tf.SetTransform(t) tf.Update() pd = tf.GetOutput() actor = Actor(pd, c=c, bc=bc, alpha=alpha, texture=texture) actor.SetPosition(pos) settings.collectable_actors.append(actor) return actor
def create_plane(self, props, texture): """Create flat plane""" # Pull and scale dimensions SIZE = np.asarray(props["Size"]) POS = np.asarray(props["Translate"]) # Create texture reader reader = vtk.vtkJPEGReader() reader.SetFileName(texture) # Create texture object texture = vtk.vtkTexture() texture.SetInputConnection(reader.GetOutputPort()) texture.InterpolateOn() # Create plane model plane = vtk.vtkPlaneSource() plane.SetResolution(1, 1) plane.SetPoint1(0, SIZE[1], 0) plane.SetPoint2(SIZE[0], 0, 0) # Translate to centre transP = vtk.vtkTransform() transP.Translate(POS[0], POS[1], POS[2]) tpd = vtk.vtkTransformPolyDataFilter() tpd.SetInputConnection(plane.GetOutputPort()) tpd.SetTransform(transP) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(tpd.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.SetTexture(texture) actor.GetProperty().SetAmbient(1.0) actor.GetProperty().SetSpecular(.5) actor.GetProperty().SetSpecularPower(5.0) actor.GetProperty().SetDiffuse(0.2) return actor
def Create(self): self.plane_widget = plane_widget = vtk.vtkImagePlaneWidget() plane_widget.SetInputData(self.img) plane_widget.SetPlaneOrientationToXAxes() #plane_widget.SetResliceInterpolateToLinear() plane_widget.TextureVisibilityOff() #Set left mouse button to move and rotate plane plane_widget.SetLeftButtonAction(1) #SetColor margin to green margin_property = plane_widget.GetMarginProperty() margin_property.SetColor(0,0.8,0) #Disable cross cursor_property = plane_widget.GetCursorProperty() cursor_property.SetOpacity(0) self.plane_source = plane_source = vtk.vtkPlaneSource() plane_source.SetOrigin(plane_widget.GetOrigin()) plane_source.SetPoint1(plane_widget.GetPoint1()) plane_source.SetPoint2(plane_widget.GetPoint2()) plane_source.SetNormal(plane_widget.GetNormal()) plane_mapper = self.plane_mapper = vtk.vtkPolyDataMapper() plane_mapper.SetInputData(plane_source.GetOutput()) self.plane_actor = plane_actor = vtk.vtkActor() plane_actor.SetMapper(plane_mapper) plane_actor.GetProperty().BackfaceCullingOn() plane_actor.GetProperty().SetOpacity(0) plane_widget.AddObserver("InteractionEvent", self.Update) Publisher.sendMessage('AppendActor', self.plane_actor) Publisher.sendMessage('Set Widget Interactor', self.plane_widget) plane_actor.SetVisibility(1) plane_widget.On() self.plane = plane = vtk.vtkPlane() plane.SetNormal(self.plane_source.GetNormal()) plane.SetOrigin(self.plane_source.GetOrigin()) self.volume_mapper.AddClippingPlane(plane) #Storage First Position self.origin = plane_widget.GetOrigin() self.p1 = plane_widget.GetPoint1() self.p2 = plane_widget.GetPoint2() self.normal = plane_widget.GetNormal()
def CreateGround(self, size=4000): # create plane source plane = vtk.vtkPlaneSource() plane.SetXResolution(100) plane.SetYResolution(100) plane.SetCenter(0.3, 0.3, 0) plane.SetNormal(0, 0, 1) # mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(plane.GetOutputPort()) # actor actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetRepresentationToWireframe() actor.GetProperty().SetColor(211 / 255, 211 / 255, 211 / 255) transform = vtk.vtkTransform() transform.Scale(size, size, 1) actor.SetUserTransform(transform) return actor
def main(): colors = vtk.vtkNamedColors() # Set the background color. colors.SetColor('BkgColor', [26, 51, 77, 255]) # Create a plane planeSource = vtk.vtkPlaneSource() planeSource.SetCenter(1.0, 0.0, 0.0) planeSource.SetNormal(1.0, 0.0, 1.0) planeSource.Update() plane = planeSource.GetOutput() # Create a mapper and actor mapper = vtk.vtkPolyDataMapper() mapper.SetInputData(plane) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(colors.GetColor3d('Banana')) # Create a renderer, render window and interactor renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.SetWindowName('Plane') renderWindow.AddRenderer(renderer) renderWindowInteractor = vtk.vtkRenderWindowInteractor() renderWindowInteractor.SetRenderWindow(renderWindow) # Add the actors to the scene renderer.AddActor(actor) renderer.SetBackground(colors.GetColor3d('BkgColor')) # Render and interact renderWindow.Render() renderWindowInteractor.Start()
def main(vector_file, magnitude_file): num_critical_points = 6 CriticalPoints = vtk.vtkPoints() CriticalPoints.InsertNextPoint(35, 14, 20) CriticalPoints.InsertNextPoint(55, 15, 20) CriticalPoints.InsertNextPoint(65, 45, 19) CriticalPoints.InsertNextPoint(45, 44.8, 20) CriticalPoints.InsertNextPoint(20, 29.7, 19.8) CriticalPoints.InsertNextPoint(10, 32.2, 16.1) ColorRange = vtk.vtkLookupTable() ColorRange.SetTableRange(0, 1) ColorRange.SetHueRange(0, 1) ColorRange.SetSaturationRange(1, 1) ColorRange.SetAlphaRange(0.3, 0.5) ColorRange.Build() reader = vtk.vtkStructuredPointsReader() reader.SetFileName(vector_file) reader.Update() mags = reader.GetOutput() range1 = mags.GetScalarRange() v0 = range1[0] v1 = range1[1] reader_magnitude = vtk.vtkStructuredPointsReader() reader_magnitude.SetFileName(magnitude_file) reader_magnitude.Update() # All entities initialized equal to number of critical points sphere1, stream1, scalarSurface1, tube1, dataMapper1, dataActor1, criticalMarker1, criticalMapper1, criticalActor1, probe1, mask1, glyph1, glyphMapper1, glyphActor1, plane1 = ( [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], ) for i in range(0, num_critical_points): sphere1.append(vtk.vtkSphereSource()) stream1.append(vtk.vtkStreamLine()) scalarSurface1.append(vtk.vtkRuledSurfaceFilter()) tube1.append(vtk.vtkTubeFilter()) dataMapper1.append(vtk.vtkPolyDataMapper()) dataActor1.append(vtk.vtkActor()) criticalMarker1.append(vtk.vtkSphereSource()) criticalMapper1.append(vtk.vtkPolyDataMapper()) criticalActor1.append(vtk.vtkActor()) probe1.append(vtk.vtkProbeFilter()) mask1.append(vtk.vtkMaskPoints()) glyph1.append(vtk.vtkGlyph3D()) glyphMapper1.append(vtk.vtkPolyDataMapper()) glyphActor1.append(vtk.vtkActor()) plane1.append(vtk.vtkPlaneSource()) integ = vtk.vtkRungeKutta4() cone = vtk.vtkConeSource() cone.SetResolution(8) cone.SetHeight(1.0) cone.SetRadius(0.2) transform = vtk.vtkTransform() transform.Translate(0, 0, 0) transformFilter = vtk.vtkTransformPolyDataFilter() transformFilter.SetInput(cone.GetOutput()) transformFilter.SetTransform(transform) outline = vtk.vtkOutlineFilter() outline.SetInput(reader.GetOutput()) outlineMapper = vtk.vtkPolyDataMapper() outlineMapper.SetInput(outline.GetOutput()) outlineActor = vtk.vtkActor() outlineActor.SetMapper(outlineMapper) outlineActor.GetProperty().SetColor(1, 1, 1) bar = vtk.vtkScalarBarActor() bar.SetLookupTable(ColorRange) renderer = vtk.vtkRenderer() for i in range(0, num_critical_points): sphere1[i].SetRadius(2) sphere1[i].SetCenter( CriticalPoints.GetPoint(i)[0], CriticalPoints.GetPoint(i)[1], CriticalPoints.GetPoint(i)[2] ) sphere1[i].SetThetaResolution(1) stream1[i].SetInput(reader.GetOutput()) stream1[i].SetSource(sphere1[i].GetOutput()) stream1[i].SetIntegrator(integ) stream1[i].SetMaximumPropagationTime(500) stream1[i].SetIntegrationStepLength(0.1) stream1[i].SetIntegrationDirectionToIntegrateBothDirections() stream1[i].SetStepLength(0.1) scalarSurface1[i].SetInput(stream1[i].GetOutput()) scalarSurface1[i].SetOffset(0) scalarSurface1[i].SetOnRatio(2) scalarSurface1[i].PassLinesOn() scalarSurface1[i].SetRuledModeToPointWalk() scalarSurface1[i].SetDistanceFactor(50) tube1[i].SetInput(scalarSurface1[i].GetOutput()) tube1[i].SetRadius(0.1) tube1[i].SetNumberOfSides(6) dataMapper1[i].SetInput(tube1[i].GetOutput()) dataMapper1[i].SetScalarRange(v0, v1) dataMapper1[i].SetLookupTable(ColorRange) dataActor1[i].SetMapper(dataMapper1[i]) # renderer.AddActor(dataActor1[i]) criticalMarker1[i].SetRadius(1.0) criticalMarker1[i].SetCenter( CriticalPoints.GetPoint(i)[0], CriticalPoints.GetPoint(i)[1], CriticalPoints.GetPoint(i)[2] ) criticalMarker1[i].SetThetaResolution(10) criticalMapper1[i].SetInput(criticalMarker1[i].GetOutput()) criticalActor1[i].SetMapper(criticalMapper1[i]) criticalActor1[i].GetProperty().SetColor(1, 1, 0) criticalActor1[i].GetProperty().SetOpacity(0.5) # renderer.AddActor(criticalActor1[i]) probe1[i].SetInput(stream1[i].GetOutput()) probe1[i].SetSource(reader.GetOutput()) mask1[i].SetInput(probe1[i].GetOutput()) mask1[i].SetOnRatio(60) mask1[i].RandomModeOn() glyph1[i].SetInput(mask1[i].GetOutput()) glyph1[i].SetSource(transformFilter.GetOutput()) glyph1[i].SetScaleModeToScaleByVector() glyph1[i].SetScaleFactor(2) glyph1[i].SetVectorModeToUseVector() glyph1[i].SetColorModeToColorByVector() glyphMapper1[i].SetInput(glyph1[i].GetOutput()) glyphMapper1[i].SetLookupTable(ColorRange) glyphActor1[i].SetMapper(glyphMapper1[i]) # renderer.AddActor(glyphActor1[i]) # removeActors1(renderer, dataActor, criticalActor, glyphActor, dataActor1, criticalActor1, glyphActor1) mags = reader.GetOutput() bounds = mags.GetBounds() x0 = bounds[0] x1 = bounds[1] y0 = bounds[2] y1 = bounds[3] z0 = bounds[4] z1 = bounds[5] range1 = mags.GetScalarRange() v0 = range1[0] v1 = range1[1] plane1[0].SetOrigin(x0, y0, z0) plane1[0].SetPoint1(x0, y1, z0) plane1[0].SetPoint2(x0, y0, z1) plane1[1].SetOrigin(x0, y0, z0) plane1[1].SetPoint1(x0, y1, z0) plane1[1].SetPoint2(x1, y0, z0) plane1[2].SetOrigin(x0, y0, z0) plane1[2].SetPoint1(x0, y0, z1) plane1[2].SetPoint2(x1, y0, z0) plane1[3].SetOrigin(x1, y1, z1) plane1[3].SetPoint1(x1, y1, z0) plane1[3].SetPoint2(x1, y0, z1) plane1[4].SetOrigin(x1, y1, z1) plane1[4].SetPoint1(x0, y1, z1) plane1[4].SetPoint2(x1, y1, z0) plane1[5].SetOrigin(x1, y1, z1) plane1[5].SetPoint1(x0, y1, z1) plane1[5].SetPoint2(x1, y1, z0) for i in range(0, num_critical_points): plane1[i].SetResolution(5, 5) stream1[i].SetSource(plane1[i].GetOutput()) renderer.AddActor(dataActor1[i]) renderer.AddActor(glyphActor1[i]) glyph1[i].SetScaleFactor(4) renderer.AddActor(bar) renderer.AddActor(outlineActor) for i in range(0, num_critical_points): renderer.AddActor(criticalActor1[i]) renderer_window = vtk.vtkRenderWindow() renderer_window.AddRenderer(renderer) renderer_window.SetSize(512, 512) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderer_window) style = vtk.vtkInteractorStyleTrackballCamera() interactor.SetInteractorStyle(style) renderer.AddActor(bar) renderer.AddActor(outlineActor) renderer_window.Render() interactor.Start()
def init_planes(self): self.vtkPlanes = vtk.vtkPlaneSource() plane_mapper = vtk.vtkPolyDataMapper() plane_mapper.SetInput(self.vtkPlanes.GetOutput()) self.plane_vtkActor = vtk.vtkActor() self.plane_vtkActor.SetMapper(plane_mapper)
import vtk # create a rendering window and renderer ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) # create a renderwindowinteractor iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin) # create source source = vtk.vtkPlaneSource() source.SetCenter(1,0,0) source.SetNormal(1,2,3) # mapper mapper = vtk.vtkPolyDataMapper() mapper.SetInput(source.GetOutput()) # actor actor = vtk.vtkActor() actor.SetMapper(mapper) # assign actor to the renderer ren.AddActor(actor) # enable user interface interactor iren.Initialize() renWin.Render() iren.Start()