def CreateAxes(): global xAxis, yAxis, zAxis, popSplatter # Create axes. popSplatter.Update() bounds = popSplatter.GetOutput().GetBounds() axes = vtk.vtkAxes() axes.SetOrigin(bounds[0], bounds[2], bounds[4]) axes.SetScaleFactor(popSplatter.GetOutput().GetLength()/5.0) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(axes.GetScaleFactor()/25.0) axesTubes.SetNumberOfSides(6) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # Label the axes. XText = vtk.vtkVectorText() XText.SetText(xAxis) XTextMapper = vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor = vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(0.02, .02, .02) XActor.SetPosition(0.35, -0.05, -0.05) XActor.GetProperty().SetColor(0, 0, 0) YText = vtk.vtkVectorText() YText.SetText(yAxis) YTextMapper = vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor = vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(0.02, .02, .02) YActor.SetPosition(-0.05, 0.35, -0.05) YActor.GetProperty().SetColor(0, 0, 0) ZText = vtk.vtkVectorText() ZText.SetText(zAxis) ZTextMapper = vtk.vtkPolyDataMapper() ZTextMapper.SetInputConnection(ZText.GetOutputPort()) ZActor = vtk.vtkFollower() ZActor.SetMapper(ZTextMapper) ZActor.SetScale(0.02, .02, .02) ZActor.SetPosition(-0.05, -0.05, 0.35) ZActor.GetProperty().SetColor(0, 0, 0) return axesActor, XActor, YActor, ZActor
def showAxis(self): if self.axis: xmin, xmax, ymin, ymax, zmin, zmax = self.bounds[:] axes=vtk.vtkAxes() axes.SetOrigin(0.0,0.0,0.0) axes.SetScaleFactor(0.1*max([xmax-xmin,ymax-ymin,zmax-zmin])) axesTubes=vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(0.2) axesTubes.SetNumberOfSides(6) axesMapper=vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor=vtk.vtkActor() axesActor.SetMapper(axesMapper) XText=vtk.vtkVectorText() XText.SetText("X") XTextMapper=vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor=vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(2.0, 2.0, 2.0) XActor.SetPosition(1.11*xmax, ymin, zmin) XActor.GetProperty().SetColor(0,0,0) XActor.SetCamera(self.cam) YText=vtk.vtkVectorText() YText.SetText("Y") YTextMapper=vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor=vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(2.0, 2.0, 2.0) YActor.SetPosition(xmin, 1.11*ymax, zmin) YActor.GetProperty().SetColor(0,0,0) YActor.SetCamera(self.cam) ZText=vtk.vtkVectorText() ZText.SetText("Z") ZTextMapper=vtk.vtkPolyDataMapper() ZTextMapper.SetInputConnection(ZText.GetOutputPort()) ZActor=vtk.vtkFollower() ZActor.SetMapper(ZTextMapper) ZActor.SetScale(2.0, 2.0, 2.0) ZActor.SetPosition(xmin, ymin, 1.11*zmax) ZActor.GetProperty().SetColor(0,0,0) ZActor.SetCamera(self.cam) self.ren.AddActor(axesActor) self.ren.AddActor(XActor) self.ren.AddActor(YActor) self.ren.AddActor(ZActor)
def initArea(self): # Zoom items self.zitems = [] self.cellTypeActors={} self.outlineActor = vtk.vtkActor() self.outlineDim=[0,0,0] self.invisibleCellTypes={} self.typesInvisibleStr="" self.set3DInvisibleTypes() axesActor = vtk.vtkActor() axisTextActor = vtk.vtkFollower() self.clut = vtk.vtkLookupTable() self.clut.SetHueRange(0.67, 0.0) self.clut.SetSaturationRange(1.0,1.0) self.clut.SetValueRange(1.0,1.0) self.clut.SetAlphaRange(1.0,1.0) self.clut.SetNumberOfColors(1024) self.clut.Build() ## Set up the mapper and actor (3D) for concentration field. # self.conMapper = vtk.vtkPolyDataMapper() self.conActor = vtk.vtkActor() self.glyphsActor=vtk.vtkActor() # self.glyphsMapper=vtk.vtkPolyDataMapper() self.cellGlyphsActor = vtk.vtkActor() self.FPPLinksActor = vtk.vtkActor() # Weird attributes self.typeActors = {} # vtkActor
def add_ring_actor(self, marker): ringActor = RingActor(marker, self.pw, lineWidth=self.defaultRingLine) vis = ringActor.update() self.renderer.AddActor(ringActor) self.ringActors.AddItem(ringActor) # a hack to keep vtk from casting my class when I put it in # the collection. If I don't register some func, I lose all # the derived methods self.observer.AddObserver('EndInteractionEvent', ringActor.silly_hack) text = vtk.vtkVectorText() text.SetText(marker.get_label()) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInput(text.GetOutput()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) size = 2*marker.get_size() textActor.SetScale(size, size, size) x,y,z = marker.get_center() textActor.SetPosition(x, y, z) textActor.SetCamera(self.camera) textActor.GetProperty().SetColor(marker.get_label_color()) if EventHandler().get_labels_on() and vis: textActor.VisibilityOn() else: textActor.VisibilityOff() self.textActors[marker] = textActor self.renderer.AddActor(textActor)
def _build_planet_actors(self, key: str, Center: np.array(3), radius: float, color: str): sphereSource = vtk.vtkSphereSource() # Make the surface smooth. sphereSource.SetPhiResolution(100) sphereSource.SetThetaResolution(100) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphereSource.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(Colors.GetColor3d(color)) sphereSource.SetCenter(Center[0], Center[1], Center[2]) sphereSource.SetRadius(radius) # 标签 vText = vtkVectorText() vText.SetText(key) textMapper = vtkPolyDataMapper() textMapper.SetInputConnection(vText.GetOutputPort()) textActor = vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(0.05) # textActor.AddPosition(Center[0], Center[1], Center[2]) textActor.SetPosition(Center[0], Center[1], Center[2]) textActor.SetCamera(self.vtkWidget.renderer.GetActiveCamera()) # 加入数据集 self.dataProvider.add_sphere_source(key, sphereSource, textActor) self.vtkWidget.renderer.AddActor(actor) self.vtkWidget.renderer.AddActor(textActor) return
def AddStock(renderers, apf, filename, name, zPosition): print("Adding", name) # Read the data PolyDataRead = vtk.vtkPolyDataReader() PolyDataRead.SetFileName(filename) PolyDataRead.Update() TubeFilter = vtk.vtkTubeFilter() TubeFilter.SetInputConnection(PolyDataRead.GetOutputPort()) TubeFilter.SetNumberOfSides(8) TubeFilter.SetRadius(0.5) TubeFilter.SetRadiusFactor(10000) Transform = vtk.vtkTransform() Transform.Translate(0, 0, zPosition) Transform.Scale(0.15, 1, 1) TransformFilter = vtk.vtkTransformPolyDataFilter() TransformFilter.SetInputConnection(TubeFilter.GetOutputPort()) TransformFilter.SetTransform(Transform) apf.AddInputData(TransformFilter.GetOutput()) # Create the labels. TextSrc = vtk.vtkVectorText() TextSrc.SetText(name) numberOfPoints = PolyDataRead.GetOutput().GetNumberOfPoints() nameIndex = int((numberOfPoints - 1) * 0.8) nameLocation = PolyDataRead.GetOutput().GetPoint(nameIndex) x = nameLocation[0] * 0.15 y = nameLocation[1] + 5.0 z = zPosition for r in range(0, len(renderers)): LabelMapper = vtk.vtkPolyDataMapper() LabelMapper.SetInputConnection(TextSrc.GetOutputPort()) LabelActor = vtk.vtkFollower() LabelActor.SetMapper(LabelMapper) LabelActor.SetPosition(x, y, z) LabelActor.SetScale(2, 2, 2) LabelActor.SetOrigin(TextSrc.GetOutput().GetCenter()) # Increment zPosition. zPosition += 8.0 StockMapper = vtk.vtkPolyDataMapper() StockMapper.SetInputConnection(TransformFilter.GetOutputPort()) StockMapper.SetScalarRange(0, 8000) StockActor = vtk.vtkActor() StockActor.SetMapper(StockMapper) renderers[r].AddActor(StockActor) renderers[r].AddActor(LabelActor) LabelActor.SetCamera(renderers[r].GetActiveCamera()) return zPosition
def add_marker(self, marker): print "PlaneWidgetsXYZ.add_marker(): self.renderer.AddActor(marker)" self.renderer.AddActor(marker) text = vtk.vtkVectorText() text.SetText(marker.get_label()) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInput(text.GetOutput()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) size = marker.get_size() textActor.SetScale(size, size, size) x,y,z = marker.get_center() textActor.SetPosition(x+size, y+size, z+size) textActor.SetCamera(self.camera) textActor.GetProperty().SetColor(marker.get_label_color()) if EventHandler().get_labels_on(): print "VisibilityOn" textActor.VisibilityOn() else: print "VisibilityOff" textActor.VisibilityOff() self.textActors[marker] = textActor print "PlaneWidgetsXYZ.add_marker(): self.renderer.AddActor(textActor)" self.renderer.AddActor(textActor)
def __init__(self, text, position=(0, 0, 0), follow_cam=True, scale=1, color=None, opacity=None, fig="gcf"): super().__init__(fig) # Create the 3D text and the associated mapper and follower (a type of # actor). Position the text so it is displayed over the origin of the # axes. self.source = vtk.vtkVectorText() self.text = text # This chunk is different to how most plots objects construct # themselves. So super().add_to_plot() wont work unfortunately. self.actor = vtk.vtkFollower() self.scale = scale self.position = position self.mapper = vtk.vtkPolyDataMapper() self.actor.SetMapper(self.mapper) self.property = self.actor.GetProperty() self.mapper.SetInputConnection(self.source.GetOutputPort()) self.fig += self self.color_opacity(color, opacity) if follow_cam: self.actor.SetCamera(self.fig.renderer.GetActiveCamera())
def add_ring_actor(self, marker): ringActor = RingActor(marker, self.pw, lineWidth=self.defaultRingLine) vis = ringActor.update() self.renderer.AddActor(ringActor) self.ringActors[marker.uuid] = ringActor text = vtk.vtkVectorText() text.SetText(marker.get_label()) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInput(text.GetOutput()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) size = 2*marker.get_size() textActor.SetScale(size, size, size) x,y,z = marker.get_center() textActor.SetPosition(x, y, z) textActor.SetCamera(self.camera) textActor.GetProperty().SetColor(marker.get_label_color()) if EventHandler().get_labels_on() and vis: textActor.VisibilityOn() else: textActor.VisibilityOff() self.textActors[marker.uuid] = textActor self.renderer.AddActor(textActor)
def create_actors(x, y, temperature, is_visible): if temperature is None: return None, None cube_source = vtk.vtkCubeSource() cube_source.SetXLength(30) cube_source.SetYLength(30) cube_source.SetZLength(1) cube_source.SetCenter(x, y - 19, 0) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(cube_source.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) temperature_label = temperature_labels[get_temperature_label_index( temperature)] actor.GetProperty().SetColor( temperature_colors.GetColor3d(temperature_label)) actor.SetVisibility(is_visible) atext = vtk.vtkVectorText() atext.SetText("{:.1f}".format(temperature).center(5)) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(8, 8, 8) textActor.AddPosition(x - 16, y - 23, 1) textActor.GetProperty().SetColor(0, 0, 0) textActor.SetVisibility(is_visible) return actor, textActor
def add_ring_actor(self, marker): ringActor = RingActor(marker, self.pw, lineWidth=self.defaultRingLine) vis = ringActor.update() self.renderer.AddActor(ringActor) self.ringActors.AddItem(ringActor) # a hack to keep vtk from casting my class when I put it in # the collection. If I don't register some func, I lose all # the derived methods self.observer.AddObserver('EndInteractionEvent', ringActor.silly_hack) text = vtk.vtkVectorText() text.SetText(marker.get_label()) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInput(text.GetOutput()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) size = 2 * marker.get_size() textActor.SetScale(size, size, size) x, y, z = marker.get_center() textActor.SetPosition(x, y, z) textActor.SetCamera(self.camera) textActor.GetProperty().SetColor(marker.get_label_color()) if EventHandler().get_labels_on() and vis: textActor.VisibilityOn() else: textActor.VisibilityOff() self.textActors[marker] = textActor self.renderer.AddActor(textActor)
def add_marker(self, marker): if debug: print "PlaneWidgetsXYZ.add_marker(): self.renderer.AddActor(marker)" self.renderer.AddActor(marker) text = vtk.vtkVectorText() text.SetText(marker.get_label()) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInput(text.GetOutput()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) size = marker.get_size() textActor.SetScale(size, size, size) x,y,z = marker.get_center() textActor.SetPosition(x+size, y+size, z+size) textActor.SetCamera(self.camera) textActor.GetProperty().SetColor(marker.get_label_color()) if EventHandler().get_labels_on(): if debug: print "VisibilityOn" textActor.VisibilityOn() else: if debug: print "VisibilityOff" textActor.VisibilityOff() self.textActors[marker] = textActor if debug: print "PlaneWidgetsXYZ.add_marker(): self.renderer.AddActor(textActor)" self.renderer.AddActor(textActor)
def temperature_actor(x, y, temp, col): cube_source = vtk.vtkCubeSource() cube_source.SetXLength(30) cube_source.SetYLength(30) cube_source.SetZLength(1) cube_source.SetCenter(x, y - 19, 0) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(cube_source.GetOutputPort()) actor = vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(col) actor.SetVisibility(True) atext = vtk.vtkVectorText() atext.SetText("{:.0f}".format(temp).center(4)) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(8, 8, 8) textActor.AddPosition(x - 15, y - 23, 1) textActor.GetProperty().SetColor(1, 1, 1) textActor.SetVisibility(True) return actor, textActor
def add_picker(self): # Create a cell picker. picker = vtk.vtkCellPicker() # Create a Python function to create the text for the text mapper used # to display the results of picking. source = vtk.vtkVectorText() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) follower = vtk.vtkFollower() follower.SetMapper(mapper) follower.GetProperty().SetColor((0, 0, 0)) follower.SetScale(0.2) self.ren.AddActor(follower) follower.SetCamera(self.ren.GetActiveCamera()) follower.VisibilityOff() def annotate_pick(obj, event): if picker.GetCellId() < 0: follower.VisibilityOff() else: pick_pos = picker.GetPickPosition() mapper = picker.GetMapper() if mapper in self.mapper_map: site = self.mapper_map[mapper] output = [site.species_string, "Frac. coords: " + " ".join(["{:.4f}".format(c) for c in site.frac_coords])] source.SetText("\n".join(output)) follower.SetPosition(pick_pos) follower.VisibilityOn() picker.AddObserver("EndPickEvent", annotate_pick) self.picker = picker self.iren.SetPicker(picker)
def make_render_window(): #cone actor cone = vtk.vtkConeSource() coneMapper = vtk.vtkPolyDataMapper() coneMapper.SetInputConnection(cone.GetOutputPort()) coneActor = vtk.vtkActor() coneActor.SetMapper(coneMapper) #text actor following camera text = vtk.vtkVectorText() text.SetText("Origin") textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(text.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) ren = vtk.vtkRenderer() ren.AddActor(coneActor) ren.AddActor(textActor) textActor.SetCamera(ren.GetActiveCamera()) renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) return renWin
def mark(x, y, z): #function for placing a landmark sphere sphere = vtk.vtkSphereSource() sphere.SetRadius(1) res = 20 sphere.SetThetaResolution(res) sphere.SetPhiResolution(res) sphere.SetCenter(x, y, z) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphere.GetOutputPort()) marker = vtk.vtkActor() marker.SetMapper(mapper) renderer.AddActor(marker) marker.GetProperty().SetColor((1, 0, 0)) #annotate the mark atext = vtk.vtkVectorText() atext.SetText(str(len(landmarks) + 1)) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(3, 3, 3) textActor.AddPosition(x, y, z) textActor.SetCamera(renderer.GetActiveCamera()) actortextdict[marker] = textActor renderer.AddActor(textActor) show_m.iren.Render()
def add_picker(self): # Create a cell picker. picker = vtk.vtkCellPicker() # Create a Python function to create the text for the text mapper used # to display the results of picking. source = vtk.vtkVectorText() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) follower = vtk.vtkFollower() follower.SetMapper(mapper) follower.GetProperty().SetColor((0, 0, 0)) follower.SetScale(0.2) self.ren.AddActor(follower) follower.SetCamera(self.ren.GetActiveCamera()) follower.VisibilityOff() def annotate_pick(obj, event): if picker.GetCellId() < 0: follower.VisibilityOff() else: pick_pos = picker.GetPickPosition() mapper = picker.GetMapper() if mapper in self.mapper_map: site = self.mapper_map[mapper] output = [ site.species_string, "Frac. coords: " + " ".join( ["{:.4f}".format(c) for c in site.frac_coords]) ] source.SetText("\n".join(output)) follower.SetPosition(pick_pos) follower.VisibilityOn() picker.AddObserver("EndPickEvent", annotate_pick) self.picker = picker self.iren.SetPicker(picker)
def add_axes_labels(self): labels = shared.labels self.axes_labels=labels self.axes_labels_actors=[] size = abs(self.imageData.GetSpacing()[0]) * 5 for i,b in enumerate(self.imageData.GetBounds()): coords = list(self.imageData.GetCenter()) coords[i/2] = b*1.12 idx_label = 1*i #historical reasons for using this label = labels[idx_label] if shared.debug: print i,b, coords, label if self.orientation == 0: if label in ["R","L"]: continue if self.orientation == 1: if label in ["A","P"]: continue if self.orientation == 2: if label in ["S","I"]: continue #Orientation should be correct due to reading affine in vtkNifti text = vtk.vtkVectorText() text.SetText(label) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInput(text.GetOutput()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(size, size, size) x,y,z = coords textActor.SetPosition(x, y, z) textActor.GetProperty().SetColor(*self.axes_labels_color) textActor.SetCamera(self.camera) self.axes_labels_actors.append(textActor) self.renderer.AddActor(textActor) #Reorient camera to have head up center = self.imageData.GetCenter() spacing = self.imageData.GetSpacing() bounds = np.array(self.imageData.GetBounds()) if shared.debug: print "***center,spacing,bounds", center,spacing,bounds pos = [center[0], center[1], center[2]] camera_up = [0,0,0] if self.orientation == 0: pos[0] += max((bounds[1::2]-bounds[0::2]))*2 camera_up[2] = 1 elif self.orientation == 1: pos[1] += max((bounds[1::2]-bounds[0::2]))*2 camera_up[2] = 1 elif self.orientation == 2: pos[2] += max((bounds[1::2]-bounds[0::2]))*2 camera_up[0] = -1 if shared.debug: print camera_up fpu = center, pos, tuple(camera_up) if shared.debug: print "***fpu2:", fpu self.set_camera(fpu) self.scroll_depth(self.sliceIncrement)
def plot_embedding_3d(X, Y, title=None): renderer = vtk.vtkRenderer() renderer.GradientBackgroundOn() renderer.SetBackground2(0.05, 0.05, 0.05) renderer.SetBackground(0.25, 0.25, 0.31) x_min, x_max = np.min(X, 0), np.max(X, 0) X = (X - x_min) / (x_max - x_min) camera = renderer.GetActiveCamera() for i, pos in enumerate(X): # print(i, pos) text = vtk.vtkVectorText() text.SetText('M' if Y[i] > 0 else 'B') mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(text.GetOutputPort()) actor = vtk.vtkFollower() actor.SetMapper(mapper) actor.SetScale(0.02, 0.02, 0.02) actor.AddPosition(pos) actor.SetCamera(camera) if Y[i]: actor.GetProperty().SetColor(1.0, 0.8, 0.25) else: actor.GetProperty().SetColor(0.25, 0.75, 0.9) renderer.AddActor(actor) renderer.ResetCamera() renderer.ResetCameraClippingRange() renwin = vtk.vtkRenderWindow() renwin.AddRenderer(renderer) renwin.SetSize(800, 800) renwin.Render() iren = vtk.vtkRenderWindowInteractor() iren.SetInteractorStyle(vtk.vtkInteractorStyleTrackballCamera()) iren.SetRenderWindow(renwin) iren.Start() # focal = camera.GetFocalPoint() # pos = camera.GetPosition() # camera.SetFocalPoint(focal) # camera.SetPosition(pos) # camera.Azimuth(20); # camera.Elevation(40); # # renderer.SetActiveCamera(camera) # camera.Roll(50); # renderer.ResetCamera() # renderer.ResetCameraClippingRange() return renderer
def _draw_text(self): for i in range(len(self.text_mappers)): actor = vtkFollower() actor.SetMapper(self.text_mappers[i]) actor.GetProperty().SetColor(Colours.BASE02) actor.SetScale(2.0, 2.0, 2.0) # Tweak to shift the text a little more central pos = [x-5.0 for x in self.layout_grid[i]] actor.AddPosition(pos) self.actors.append(actor)
def BuildLabelActor(self, text, op_dict): label = vtk.vtkVectorText() label.SetText(text) labelTransform = self.TransformLabel(label, op_dict) labelTransformFilter = self.TransformLabelFilter(label, labelTransform) labelMapper = vtk.vtkPolyDataMapper() labelMapper.SetInput(labelTransformFilter.GetOutput()) actor = vtk.vtkFollower() actor.SetMapper(labelMapper) return actor
def polygon(pos=[0, 0, 0], normal=[0, 0, 1], nsides=6, r=1, c='coral', bc='darkgreen', lw=1, alpha=1, legend=None, texture=None, followcam=False, camera=None): ''' Build a 2D polygon of `nsides` of radius `r` oriented as `normal`. If ``followcam=True`` the polygon will always reorient itself to current camera. ''' ps = vtk.vtkRegularPolygonSource() ps.SetNumberOfSides(nsides) ps.SetRadius(r) ps.SetNormal(-np.array(normal)) ps.Update() tf = vtk.vtkTriangleFilter() tf.SetInputConnection(ps.GetOutputPort()) tf.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(tf.GetOutputPort()) if followcam: # follow cam actor = vtk.vtkFollower() actor.SetCamera(camera) if not camera: colors.printc('Warning: vtkCamera does not yet exist for polygon', c=5) else: actor = Actor() # vtk.vtkActor() actor.SetMapper(mapper) actor.GetProperty().SetColor(colors.getColor(c)) # check if color string contains a float, in this case ignore alpha al = colors._getAlpha(c) if al: alpha = al actor.GetProperty().SetOpacity(alpha) actor.GetProperty().SetLineWidth(lw) actor.GetProperty().SetInterpolationToFlat() if bc: # defines a specific color for the backface backProp = vtk.vtkProperty() backProp.SetDiffuseColor(colors.getColor(bc)) backProp.SetOpacity(alpha) actor.SetBackfaceProperty(backProp) if texture: actor.texture(texture) actor.SetPosition(pos) return actor
def main(): colors = vtk.vtkNamedColors() # Create the axes and the associated mapper and actor. axes = vtk.vtkAxes() axes.SetOrigin(0, 0, 0) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # Create the 3D text and the associated mapper and follower (a type of actor). Position the text so it is displayed over the origin of the axes. atext = vtk.vtkVectorText() atext.SetText('Origin') textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(0.2, 0.2, 0.2) textActor.AddPosition(0, -0.1, 0) textActor.GetProperty().SetColor(colors.GetColor3d('Peacock')) # Create the Renderer, RenderWindow, and RenderWindowInteractor. renderer = vtk.vtkRenderer() renderWindow = vtk.vtkRenderWindow() renderWindow.AddRenderer(renderer) renderWindow.SetSize(640, 480) interactor = vtk.vtkRenderWindowInteractor() interactor.SetRenderWindow(renderWindow) style = vtk.vtkInteractorStyleTrackballCamera() interactor.SetInteractorStyle(style) # Add the actors to the renderer. renderer.AddActor(axesActor) renderer.AddActor(textActor) renderer.SetBackground(colors.GetColor3d('Silver')) # Zoom in closer. renderer.ResetCamera() renderer.GetActiveCamera().Zoom(1.6) renderer.SetBackground(colors.GetColor3d('Silver')) # Reset the clipping range of the camera; set the camera of the follower; render. renderer.ResetCameraClippingRange() textActor.SetCamera(renderer.GetActiveCamera()) interactor.Initialize() renderWindow.SetWindowName('TextOrigin') renderWindow.Render() interactor.Start()
def generateAxes(printer): xmax, ymax, zmax = printer.getPrintingDimensions() axes = vtk.vtkAxes() axes.SetOrigin(-xmax/2, -ymax/2, 0) axes.SetScaleFactor(20) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(2) axesTubes.SetNumberOfSides(4) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) XText = vtk.vtkVectorText() XText.SetText('X') XTextMapper = vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor = vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(5, 5, 5) XActor.SetPosition(-xmax/2 + 20, -ymax/2 - 10, 5) XActor.GetProperty().SetColor(1, 0, 0) YText = vtk.vtkVectorText() YText.SetText('Y') YTextMapper = vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor = vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(5, 5, 5) YActor.SetPosition(-xmax/2 - 5, -ymax/2 + 20, 5) YActor.GetProperty().SetColor(1, 1, 0) ZText = vtk.vtkVectorText() ZText.SetText('Z') ZTextMapper = vtk.vtkPolyDataMapper() ZTextMapper.SetInputConnection(ZText.GetOutputPort()) ZActor = vtk.vtkFollower() ZActor.SetMapper(ZTextMapper) ZActor.SetScale(5, 5, 5) ZActor.SetPosition(-xmax/2, -ymax/2, 25) ZActor.GetProperty().SetColor(0, 1, 0) return axesActor, XActor, YActor, ZActor
def getAxes(Origin, scale=1): axes = vtk.vtkAxes() axes.SetOrigin(*Origin) axes.SetScaleFactor(scale) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(0.01) axesTubes.SetNumberOfSides(6) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) XText = vtk.vtkVectorText() XText.SetText("x") XTextMapper = vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor = vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(.1, .1, .1) XActor.SetPosition(1, Origin[1], Origin[2]) XActor.GetProperty().SetColor(0, 0, 0) YText = vtk.vtkVectorText() YText.SetText("y") YTextMapper = vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor = vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(.1, .1, .1) YActor.SetPosition(Origin[0], 1, Origin[2]) YActor.GetProperty().SetColor(0, 0, 0) return axesActor, XActor, YActor
def getAxes(Origin, scale = 1): axes = vtk.vtkAxes() axes.SetOrigin(*Origin) axes.SetScaleFactor(scale) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(0.01) axesTubes.SetNumberOfSides(6) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) XText = vtk.vtkVectorText() XText.SetText("x") XTextMapper = vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor = vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(.1, .1, .1) XActor.SetPosition(1, Origin[1], Origin[2]) XActor.GetProperty().SetColor(0, 0, 0) YText = vtk.vtkVectorText() YText.SetText("y") YTextMapper = vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor = vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(.1, .1, .1) YActor.SetPosition(Origin[0], 1, Origin[2]) YActor.GetProperty().SetColor(0, 0, 0) return axesActor, XActor, YActor
def makeTextActor(text,size,pos): at = vtk.vtkVectorText() at.SetText(text) tMap = vtk.vtkPolyDataMapper() tMap.SetInputConnection(at.GetOutputPort()) tAct = vtk.vtkFollower() tAct.SetMapper(tMap) tAct.GetProperty().SetColor(0,0,0) tAct.SetScale(size) tAct.SetPosition(pos) tAct.PickableOff() return tAct
def add_text(self, coords, text, color = (0,0,0)): source = vtk.vtkVectorText() source.SetText(text) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) follower = vtk.vtkFollower() follower.SetMapper(mapper) follower.GetProperty().SetColor(color) follower.SetPosition(coords) follower.SetScale(0.5) self.ren.AddActor(follower) follower.SetCamera(self.ren.GetActiveCamera())
def Polygon(pos=(0, 0, 0), normal=(0, 0, 1), nsides=6, r=1, c="coral", bc="darkgreen", lw=1, alpha=1, followcam=False): """ Build a 2D polygon of `nsides` of radius `r` oriented as `normal`. :param followcam: if `True` the text will auto-orient itself to the active camera. A ``vtkCamera`` object can also be passed. :type followcam: bool, vtkCamera |Polygon| """ ps = vtk.vtkRegularPolygonSource() ps.SetNumberOfSides(nsides) ps.SetRadius(r) ps.SetNormal(-np.array(normal)) ps.Update() tf = vtk.vtkTriangleFilter() tf.SetInputConnection(ps.GetOutputPort()) tf.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(tf.GetOutputPort()) if followcam: import vtkplotter.plotter as plt actor = vtk.vtkFollower() if isinstance(followcam, vtk.vtkCamera): actor.SetCamera(followcam) else: actor.SetCamera(plt._plotter_instance.camera) else: actor = Actor() actor.SetMapper(mapper) actor.GetProperty().SetColor(colors.getColor(c)) actor.GetProperty().SetOpacity(alpha) actor.GetProperty().SetLineWidth(lw) actor.GetProperty().SetInterpolationToFlat() if bc: # defines a specific color for the backface backProp = vtk.vtkProperty() backProp.SetDiffuseColor(colors.getColor(bc)) backProp.SetOpacity(alpha) actor.SetBackfaceProperty(backProp) actor.SetPosition(pos) return actor
def get_axis_label_actor(self, text, position, ren): atext = vtk.vtkVectorText() atext.SetText(text) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(20, 20, 20) textActor.AddPosition(position[0], position[1], position[2]) textActor.GetProperty().SetColor(0, 0, 0) textActor.SetCamera(ren.GetActiveCamera()) return textActor
def addVertex(self,index): coord=self.vertices[index] self.vActors[index]=self.addPoint(coord) text=vtk.vtkVectorText() text.SetText(str(index)) tMapper=vtk.vtkPolyDataMapper() tMapper.SetInput(text.GetOutput()) tActor = vtk.vtkFollower() tActor.SetMapper(tMapper) tActor.SetScale(2*self.vRadius,2*self.vRadius,2*self.vRadius) tActor.AddPosition(coord[0]+self.vRadius,coord[1]+self.vRadius,coord[2]+self.vRadius) tActor.SetCamera(self.cam) tActor.GetProperty().SetColor(1.0,0.,0.) self.ren.AddActor(tActor)
def add_text(_renderer, position, text="TEXT", color=[0.5, 0.5, 0.5], scale=0.1): # Create text with the x-y-z coordinate system _text = vtk.vtkVectorText() _text.SetText(text) mapper_text = vtk.vtkPolyDataMapper() mapper_text.SetInputConnection(_text.GetOutputPort()) # actor_text_origin = vtk.vtkActor() actor_text = vtk.vtkFollower() # actor_text.SetCamera(_renderer.GetActiveCamera()) actor_text.SetMapper(mapper_text) actor_text.SetScale(scale, scale, scale) actor_text.GetProperty().SetColor(color) actor_text.AddPosition([sum(x) for x in zip(position, [0, -0.1, 0])]) # plus of 2 arrays _renderer.AddActor(actor_text)
def CreateTextItem(text, scale, camera, color=None): textSource = vtkVectorText() textSource.SetText(text) textMapper = vtkPolyDataMapper() textMapper.SetInputConnection(textSource.GetOutputPort()) textFollower = vtkFollower() textFollower.SetMapper(textMapper) textFollower.SetCamera(camera) textFollower.SetScale(scale) # Give the actor a custom color ColorActor(textFollower, color) return textFollower
def label(text='Origin', pos=(0, 0, 0), scale=(0.2, 0.2, 0.2), color=(1, 1, 1)): """Create a label actor. This actor will always face the camera Parameters ---------- text : str Text for the label. pos : (3,) array_like, optional Left down position of the label. scale : (3,) array_like Changes the size of the label. color : (3,) array_like Label color as ``(r,g,b)`` tuple. Returns ------- l : vtkActor object Label. Examples -------- >>> from fury import window, actor >>> scene = window.Scene() >>> l = actor.label(text='Hello') >>> scene.add(l) >>> #window.show(scene) """ atext = vtk.vtkVectorText() atext.SetText(text) textm = vtk.vtkPolyDataMapper() textm.SetInputConnection(atext.GetOutputPort()) texta = vtk.vtkFollower() texta.SetMapper(textm) texta.SetScale(scale) texta.GetProperty().SetColor(color) texta.SetPosition(pos) return texta
def vtk_label_iod(receptor_dirs, triangles, renderers): dists = get_mean_interommatidial_distance(receptor_dirs, triangles) pi = 3.1415926535897931 R2D = 180.0 / pi for v, dist in zip(receptor_dirs, dists): atext = vtk.vtkVectorText() atext.SetText("%.1f" % (dist * R2D, )) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) scale = 0.03 textActor.SetScale(scale, scale, scale) mult = 1.02 textActor.AddPosition(v.x * mult, v.y * mult, v.z * mult) for renderer in renderers: renderer.AddActor(textActor)
def vtk_label_iod( receptor_dirs, triangles, renderers ): dists = get_mean_interommatidial_distance( receptor_dirs, triangles ) pi = 3.1415926535897931 R2D = 180.0/pi for v,dist in zip(receptor_dirs,dists): atext = vtk.vtkVectorText() atext.SetText("%.1f"%(dist*R2D,)) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInput(atext.GetOutput()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) scale = 0.03 textActor.SetScale(scale, scale, scale) mult = 1.02 textActor.AddPosition(v.x*mult,v.y*mult,v.z*mult) for renderer in renderers: renderer.AddActor( textActor )
def add_axes_labels(self): #if shared.debug: print "***Adding axes labels" #if shared.debug: print labels labels = shared.labels #labels = list(np.array(labels)[[4,5,2,3,0,1]]) self.axes_labels=labels self.axes_labels_actors=[] size = abs(self.imageData.GetSpacing()[0]) * 5 #if shared.debug: print "***size", size for i,b in enumerate(self.imageData.GetBounds()): coords = list(self.imageData.GetCenter()) coords[i/2] = b*1.1 #Correction for negative spacings idx_label = 1*i label = labels[idx_label] if shared.debug: print i,b, coords, label #Orientation should be correct due to reading affine in vtkNifti text = vtk.vtkVectorText() text.SetText(label) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInput(text.GetOutput()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(size, size, size) x,y,z = coords textActor.SetPosition(x, y, z) textActor.GetProperty().SetColor(*self.axes_labels_color) textActor.SetCamera(self.camera) self.axes_labels_actors.append(textActor) self.renderer.AddActor(textActor) #Reorient camera to have head up center = self.imageData.GetCenter() spacing = self.imageData.GetSpacing() bounds = np.array(self.imageData.GetBounds()) if shared.debug: print "***center,spacing,bounds", center,spacing,bounds #idx_left = labels.index("L") pos = [center[0], center[1], center[2]] pos[0] += max((bounds[1::2]-bounds[0::2]))*2 #idx_sup = labels.index("S") camera_up = [0,0,0] camera_up[2] = 1 if shared.debug: print camera_up fpu = center, pos, tuple(camera_up) if shared.debug: print "***fpu2:", fpu self.set_camera(fpu)
def drawText(featurePoints, featureText): textActorList = [] #print(len(featureText)) #print(featurePoints) #print(len(featurePoints)) for i in range(len(featurePoints)): atext = vtk.vtkVectorText() atext.SetText(featureText[i]) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(0.05, 0.05, 0.05) textActor.AddPosition(featurePoints[i]) textActorList.append(textActor) return textActorList
def addlabel(ren,text='Origin',pos=(0,0,0),scale=(0.1,0.1,0.1)): atext=vtk.vtkVectorText() atext.SetText(text) textm=vtk.vtkPolyDataMapper() textm.SetInput(atext.GetOutput()) texta=vtk.vtkFollower() texta.SetMapper(textm) texta.SetScale(scale) texta.SetPosition(pos) ren.AddActor(texta) texta.SetCamera(ren.GetActiveCamera()) return texta
def get_actor_from_text(text, position=(0, 0, 0), scale=5, color=(0, 0, 1)): text_source = vtk.vtkVectorText() text_source.SetText(text) text_source.Update() mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(text_source.GetOutputPort()) actor = vtk.vtkFollower() actor.SetMapper(mapper) actor.SetScale(scale, scale, scale) actor.AddPosition(position[0], position[1], position[2]) actor.GetProperty().SetColor(color[0], color[1], color[2]) return actor
def __init__(self, member, nodes, textHeight=5): # Generate a line for the member line = vtk.vtkLineSource() # Step through each node in the model and find the position of the i-node and j-node for node in nodes: # Check to see if the current node is the i-node if node.Name == member.iNode.Name: Xi = node.X Yi = node.Y Zi = node.Z line.SetPoint1(Xi, Yi, Zi) # Check to see if the current node is the j-node elif node.Name == member.jNode.Name: Xj = node.X Yj = node.Y Zj = node.Z line.SetPoint2(Xj, Yj, Zj) # Set up a mapper for the member mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(line.GetOutputPort()) # Set up an actor for the member self.actor = vtk.vtkActor() self.actor.SetMapper(mapper) # Create the text for the member label label = vtk.vtkVectorText() label.SetText(member.Name) # Set up a mapper for the member label lblMapper = vtk.vtkPolyDataMapper() lblMapper.SetInputConnection(label.GetOutputPort()) # Set up an actor for the member label self.lblActor = vtk.vtkFollower() self.lblActor.SetMapper(lblMapper) self.lblActor.SetScale(textHeight, textHeight, textHeight) self.lblActor.SetPosition((Xi + Xj) / 2, (Yi + Yj) / 2, (Zi + Zj) / 2)
def label(text='Origin', pos=(0, 0, 0), scale=(0.2, 0.2, 0.2), color=(1, 1, 1)): atext = vtk.vtkVectorText() atext.SetText(text) textm = vtk.vtkPolyDataMapper() textm.SetInputConnection(atext.GetOutputPort()) texta = vtk.vtkFollower() texta.SetMapper(textm) texta.SetScale(scale) texta.GetProperty().SetColor(color) texta.SetPosition(pos) return texta
def mark(x, y, z): sphere = vtk.vtkSphereSource() sphere.SetRadius(1) res = 20 sphere.SetThetaResolution(res) sphere.SetPhiResolution(res) sphere.SetCenter(x, y, z) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(sphere.GetOutputPort()) marker = vtk.vtkActor() marker.SetMapper(mapper) renderer.AddActor(marker) marker.GetProperty().SetColor((0, 0, 1)) #annotate the mark atext = vtk.vtkVectorText() atext.SetText(str(len(landmarks) + 1)) textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(3, 3, 3) textActor.AddPosition(x, y, z) textActor.SetCamera(renderer.GetActiveCamera()) actortextdict[marker] = textActor renderer.AddActor(textActor) #add line if len(landmarks) > 0: lineSource = vtk.vtkLineSource() lineSource.SetPoint1(landmarks[-1]) lineSource.SetPoint2([x, y, z]) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(lineSource.GetOutputPort()) lineActor = vtk.vtkActor() lineActor.SetMapper(mapper) lineActor.GetProperty().SetLineWidth(4) lineActor.GetProperty().SetColor((0, 1, 0)) actorlinedict[marker] = lineActor renderer.AddActor(lineActor) show_m.iren.Render()
def label(ren,text='Origin',pos=(0,0,0),scale=(0.2,0.2,0.2),color=(1,1,1)): ''' Create a label actor This actor will always face the camera Parameters ---------- ren : vtkRenderer() object as returned from ren() text : a text for the label pos : left down position of the label scale : change the size of the label color : (r,g,b) and RGB tuple Returns ---------- vtkActor object Examples -------- >>> from dipy.viz import fos >>> r=fos.ren() >>> l=fos.label(r) >>> fos.add(r,l) >>> fos.show(r) ''' atext=vtk.vtkVectorText() atext.SetText(text) textm=vtk.vtkPolyDataMapper() textm.SetInput(atext.GetOutput()) texta=vtk.vtkFollower() texta.SetMapper(textm) texta.SetScale(scale) texta.GetProperty().SetColor(color) texta.SetPosition(pos) ren.AddActor(texta) texta.SetCamera(ren.GetActiveCamera()) return texta
def add_text(self, coords, text, color=(0, 0, 0)): """ Add text at a coordinate. Args: coords: Coordinates to add text at. text: Text to place. color: Color for text as RGB. Defaults to black. """ source = vtk.vtkVectorText() source.SetText(text) mapper = vtk.vtkPolyDataMapper() mapper.SetInputConnection(source.GetOutputPort()) follower = vtk.vtkFollower() follower.SetMapper(mapper) follower.GetProperty().SetColor(color) follower.SetPosition(coords) follower.SetScale(0.5) self.ren.AddActor(follower) follower.SetCamera(self.ren.GetActiveCamera())
def __init__(self, render, label, color): self.render = render self.colors = { 'Marine Blue': [0.1, 0.2, 0.4], 'Deep Blue': [0.2, 0.2, 1.0], 'Red': [1.0, 0.0, 0.0], 'Yellow': [1.0, 1.0, 0.0], 'Green': [0.0, 1.0, 0.0], 'Orange': [1.0, 0.5, 0.0], 'Magenta': [1.0, 0.0, 1.0], 'Grey': [0.5, 0.5, 0.5], 'Black': [0.0, 0.0, 0.0], 'Cyan': [0.0, 1.0, 1.0], 'Turquoise': [0.0, 0.5, 0.5], 'White': [1.0, 1.0, 1.0], 'Light green': [0.5, 1.0, 0.5], } if color: self.color = color else: self.color = "Yellow" self.__isSelected = False self.points = vtk.vtkPoints() self.points.SetDataTypeToFloat() self.property = vtk.vtkProperty() self.actor = vtk.vtkActor() self.actor.SetProperty(self.property) self.label = label self.labels = vtk.vtkVectorText() self.labels.SetText(label) self.labelProp = vtk.vtkProperty() self.labelActor = vtk.vtkFollower()
def testFinancialField(self): """ Demonstrate the use and manipulation of fields and use of vtkProgrammableDataObjectSource. This creates fields the hard way (as compared to reading a vtk field file), but shows you how to interface to your own raw data. The image should be the same as financialField.tcl """ xAxis = "INTEREST_RATE" yAxis = "MONTHLY_PAYMENT" zAxis = "MONTHLY_INCOME" scalar = "TIME_LATE" # Parse an ascii file and manually create a field. Then construct a # dataset from the field. dos = vtk.vtkProgrammableDataObjectSource() def parseFile(): f = open(VTK_DATA_ROOT + "/Data/financial.txt", "r") line = f.readline().split() # From the size calculate the number of lines. numPts = int(line[1]) numLines = (numPts - 1) / 8 + 1 # create the data object field = vtk.vtkFieldData() field.AllocateArrays(4) # read TIME_LATE - dependent variable while True: line = f.readline().split() if len(line) > 0: break; timeLate = vtk.vtkFloatArray() timeLate.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: timeLate.InsertNextValue(float(j)) field.AddArray(timeLate) # MONTHLY_PAYMENT - independent variable while True: line = f.readline().split() if len(line) > 0: break; monthlyPayment = vtk.vtkFloatArray() monthlyPayment.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: monthlyPayment.InsertNextValue(float(j)) field.AddArray(monthlyPayment) # UNPAID_PRINCIPLE - skip while True: line = f.readline().split() if len(line) > 0: break; for i in range(0, numLines): line = f.readline() # LOAN_AMOUNT - skip while True: line = f.readline().split() if len(line) > 0: break; for i in range(0, numLines): line = f.readline() # INTEREST_RATE - independent variable while True: line = f.readline().split() if len(line) > 0: break; interestRate = vtk.vtkFloatArray() interestRate.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: interestRate.InsertNextValue(float(j)) field.AddArray(interestRate) # MONTHLY_INCOME - independent variable while True: line = f.readline().split() if len(line) > 0: break; monthlyIncome = vtk.vtkFloatArray() monthlyIncome.SetName(line[0]) for i in range(0, numLines): line = f.readline().split() for j in line: monthlyIncome.InsertNextValue(float(j)) field.AddArray(monthlyIncome) dos.GetOutput().SetFieldData(field) dos.SetExecuteMethod(parseFile) # Create the dataset do2ds = vtk.vtkDataObjectToDataSetFilter() do2ds.SetInputConnection(dos.GetOutputPort()) do2ds.SetDataSetTypeToPolyData() #format: component#, arrayname, arraycomp, minArrayId, maxArrayId, normalize do2ds.DefaultNormalizeOn() do2ds.SetPointComponent(0, xAxis, 0) do2ds.SetPointComponent(1, yAxis, 0) do2ds.SetPointComponent(2, zAxis, 0) do2ds.Update() rf = vtk.vtkRearrangeFields() rf.SetInputConnection(do2ds.GetOutputPort()) rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.RemoveOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.RemoveAllOperations() rf.AddOperation("MOVE", scalar, "DATA_OBJECT", "POINT_DATA") rf.Update() max = rf.GetOutput().GetPointData().GetArray(scalar).GetRange(0)[1] calc = vtk.vtkArrayCalculator() calc.SetInputConnection(rf.GetOutputPort()) calc.SetAttributeModeToUsePointData() calc.SetFunction("s / %f" % max) calc.AddScalarVariable("s", scalar, 0) calc.SetResultArrayName("resArray") aa = vtk.vtkAssignAttribute() aa.SetInputConnection(calc.GetOutputPort()) aa.Assign("resArray", "SCALARS", "POINT_DATA") aa.Update() rf2 = vtk.vtkRearrangeFields() rf2.SetInputConnection(aa.GetOutputPort()) rf2.AddOperation("COPY", "SCALARS", "POINT_DATA", "DATA_OBJECT") # construct pipeline for original population popSplatter = vtk.vtkGaussianSplatter() popSplatter.SetInputConnection(rf2.GetOutputPort()) popSplatter.SetSampleDimensions(50, 50, 50) popSplatter.SetRadius(0.05) popSplatter.ScalarWarpingOff() popSurface = vtk.vtkContourFilter() popSurface.SetInputConnection(popSplatter.GetOutputPort()) popSurface.SetValue(0, 0.01) popMapper = vtk.vtkPolyDataMapper() popMapper.SetInputConnection(popSurface.GetOutputPort()) popMapper.ScalarVisibilityOff() popMapper.ImmediateModeRenderingOn() popActor = vtk.vtkActor() popActor.SetMapper(popMapper) popActor.GetProperty().SetOpacity(0.3) popActor.GetProperty().SetColor(.9, .9, .9) # construct pipeline for delinquent population lateSplatter = vtk.vtkGaussianSplatter() lateSplatter.SetInputConnection(aa.GetOutputPort()) lateSplatter.SetSampleDimensions(50, 50, 50) lateSplatter.SetRadius(0.05) lateSplatter.SetScaleFactor(0.05) lateSurface = vtk.vtkContourFilter() lateSurface.SetInputConnection(lateSplatter.GetOutputPort()) lateSurface.SetValue(0, 0.01) lateMapper = vtk.vtkPolyDataMapper() lateMapper.SetInputConnection(lateSurface.GetOutputPort()) lateMapper.ScalarVisibilityOff() lateActor = vtk.vtkActor() lateActor.SetMapper(lateMapper) lateActor.GetProperty().SetColor(1.0, 0.0, 0.0) # create axes popSplatter.Update() bounds = popSplatter.GetOutput().GetBounds() axes = vtk.vtkAxes() axes.SetOrigin(bounds[0], bounds[2], bounds[4]) axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5.0) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(axes.GetScaleFactor() / 25.0) axesTubes.SetNumberOfSides(6) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # label the axes XText = vtk.vtkVectorText() XText.SetText(xAxis) XTextMapper = vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor = vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(0.02, .02, .02) XActor.SetPosition(0.35, -0.05, -0.05) XActor.GetProperty().SetColor(0, 0, 0) YText = vtk.vtkVectorText() YText.SetText(yAxis) YTextMapper = vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor = vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(0.02, .02, .02) YActor.SetPosition(-0.05, 0.35, -0.05) YActor.GetProperty().SetColor(0, 0, 0) ZText = vtk.vtkVectorText() ZText.SetText(zAxis) ZTextMapper = vtk.vtkPolyDataMapper() ZTextMapper.SetInputConnection(ZText.GetOutputPort()) ZActor = vtk.vtkFollower() ZActor.SetMapper(ZTextMapper) ZActor.SetScale(0.02, .02, .02) ZActor.SetPosition(-0.05, -0.05, 0.35) ZActor.GetProperty().SetColor(0, 0, 0) # Graphics stuff # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetWindowName("vtk(-, Field.Data") renWin.SetSize(300, 300) # Add the actors to the renderer, set the background and size # ren.AddActor(axesActor) ren.AddActor(lateActor) ren.AddActor(XActor) ren.AddActor(YActor) ren.AddActor(ZActor) ren.AddActor(popActor) #it's last because its translucent) ren.SetBackground(1, 1, 1) camera = vtk.vtkCamera() camera.SetClippingRange(.274, 13.72) camera.SetFocalPoint(0.433816, 0.333131, 0.449) camera.SetPosition(-1.96987, 1.15145, 1.49053) camera.SetViewUp(0.378927, 0.911821, 0.158107) ren.SetActiveCamera(camera) XActor.SetCamera(camera) YActor.SetCamera(camera) ZActor.SetCamera(camera) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin); renWin.Render() img_file = "financialField3.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def testFinancialField(self): size = 3187 #maximum number possible #set size 100 #maximum number possible xAxis = "INTEREST_RATE" yAxis = "MONTHLY_PAYMENT" zAxis = "MONTHLY_INCOME" scalar = "TIME_LATE" # extract data from field as a polydata (just points), then extract scalars fdr = vtk.vtkDataObjectReader() fdr.SetFileName(VTK_DATA_ROOT + "/Data/financial.vtk") do2ds = vtk.vtkDataObjectToDataSetFilter() do2ds.SetInputConnection(fdr.GetOutputPort()) do2ds.SetDataSetTypeToPolyData() #format: component#, arrayname, arraycomp, minArrayId, maxArrayId, normalize do2ds.DefaultNormalizeOn() do2ds.SetPointComponent(0, xAxis, 0) do2ds.SetPointComponent(1, yAxis, 0, 0, size, 1) do2ds.SetPointComponent(2, zAxis, 0) do2ds.Update() fd2ad = vtk.vtkFieldDataToAttributeDataFilter() fd2ad.SetInputConnection(do2ds.GetOutputPort()) fd2ad.SetInputFieldToDataObjectField() fd2ad.SetOutputAttributeDataToPointData() fd2ad.DefaultNormalizeOn() fd2ad.SetScalarComponent(0, scalar, 0) # construct pipeline for original population popSplatter = vtk.vtkGaussianSplatter() popSplatter.SetInputConnection(fd2ad.GetOutputPort()) popSplatter.SetSampleDimensions(50, 50, 50) popSplatter.SetRadius(0.05) popSplatter.ScalarWarpingOff() popSurface = vtk.vtkMarchingContourFilter() popSurface.SetInputConnection(popSplatter.GetOutputPort()) popSurface.SetValue(0, 0.01) popMapper = vtk.vtkPolyDataMapper() popMapper.SetInputConnection(popSurface.GetOutputPort()) popMapper.ScalarVisibilityOff() popActor = vtk.vtkActor() popActor.SetMapper(popMapper) popActor.GetProperty().SetOpacity(0.3) popActor.GetProperty().SetColor(.9, .9, .9) # construct pipeline for delinquent population lateSplatter = vtk.vtkGaussianSplatter() lateSplatter.SetInputConnection(fd2ad.GetOutputPort()) lateSplatter.SetSampleDimensions(50, 50, 50) lateSplatter.SetRadius(0.05) lateSplatter.SetScaleFactor(0.05) lateSurface = vtk.vtkMarchingContourFilter() lateSurface.SetInputConnection(lateSplatter.GetOutputPort()) lateSurface.SetValue(0, 0.01) lateMapper = vtk.vtkPolyDataMapper() lateMapper.SetInputConnection(lateSurface.GetOutputPort()) lateMapper.ScalarVisibilityOff() lateActor = vtk.vtkActor() lateActor.SetMapper(lateMapper) lateActor.GetProperty().SetColor(1.0, 0.0, 0.0) # create axes popSplatter.Update() bounds = popSplatter.GetOutput().GetBounds() axes = vtk.vtkAxes() axes.SetOrigin(bounds[0], bounds[2], bounds[4]) axes.SetScaleFactor(popSplatter.GetOutput().GetLength() / 5.0) axesTubes = vtk.vtkTubeFilter() axesTubes.SetInputConnection(axes.GetOutputPort()) axesTubes.SetRadius(axes.GetScaleFactor() / 25.0) axesTubes.SetNumberOfSides(6) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axesTubes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # label the axes XText = vtk.vtkVectorText() XText.SetText(xAxis) XTextMapper = vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor = vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(0.02, .02, .02) XActor.SetPosition(0.35, -0.05, -0.05) XActor.GetProperty().SetColor(0, 0, 0) YText = vtk.vtkVectorText() YText.SetText(yAxis) YTextMapper = vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor = vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(0.02, .02, .02) YActor.SetPosition(-0.05, 0.35, -0.05) YActor.GetProperty().SetColor(0, 0, 0) ZText = vtk.vtkVectorText() ZText.SetText(zAxis) ZTextMapper = vtk.vtkPolyDataMapper() ZTextMapper.SetInputConnection(ZText.GetOutputPort()) ZActor = vtk.vtkFollower() ZActor.SetMapper(ZTextMapper) ZActor.SetScale(0.02, .02, .02) ZActor.SetPosition(-0.05, -0.05, 0.35) ZActor.GetProperty().SetColor(0, 0, 0) # Graphics stuff # ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) renWin.SetWindowName("vtk - Field.Data") # Add the actors to the renderer, set the background and size # ren.AddActor(axesActor) ren.AddActor(lateActor) ren.AddActor(XActor) ren.AddActor(YActor) ren.AddActor(ZActor) ren.AddActor(popActor) #it's last because its translucent) ren.SetBackground(1, 1, 1) renWin.SetSize(400, 400) camera = vtk.vtkCamera() camera.SetClippingRange(.274, 13.72) camera.SetFocalPoint(0.433816, 0.333131, 0.449) camera.SetPosition(-1.96987, 1.15145, 1.49053) camera.SetViewUp(0.378927, 0.911821, 0.158107) ren.SetActiveCamera(camera) XActor.SetCamera(camera) YActor.SetCamera(camera) ZActor.SetCamera(camera) # render and interact with data iRen = vtk.vtkRenderWindowInteractor() iRen.SetRenderWindow(renWin); renWin.Render() img_file = "financialField.png" vtk.test.Testing.compareImage(iRen.GetRenderWindow(), vtk.test.Testing.getAbsImagePath(img_file), threshold=25) vtk.test.Testing.interact()
def show_axes(ren): # Create the axes and the associated mapper and actor. axes = vtk.vtkAxes() axes.SetOrigin(0, 0, 0) # length - hardwired for our images, which are usually 80 on a side # (80/2 = 40) AxisLength = 35.0 TextScale = 1.5 TextR = 0.4 TextG = 0.4 TextB = 0.8 axes.SetScaleFactor(AxisLength) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # Label the axes XText = vtk.vtkVectorText() XText.SetText("X") XTextMapper = vtk.vtkPolyDataMapper() XTextMapper.SetInputConnection(XText.GetOutputPort()) XActor = vtk.vtkFollower() XActor.SetMapper(XTextMapper) XActor.SetScale(TextScale, TextScale, TextScale) XActor.SetPosition(AxisLength, 0.0, 0.0) XActor.GetProperty().SetColor(TextR, TextG, TextB) YText = vtk.vtkVectorText() YText.SetText("Y") YTextMapper = vtk.vtkPolyDataMapper() YTextMapper.SetInputConnection(YText.GetOutputPort()) YActor = vtk.vtkFollower() YActor.SetMapper(YTextMapper) YActor.SetScale(TextScale, TextScale, TextScale) YActor.SetPosition(0.0, AxisLength, 0.0) YActor.GetProperty().SetColor(TextR, TextG, TextB) ZText = vtk.vtkVectorText() ZText.SetText("Z") ZTextMapper = vtk.vtkPolyDataMapper() ZTextMapper.SetInputConnection(ZText.GetOutputPort()) ZActor = vtk.vtkFollower() ZActor.SetMapper(ZTextMapper) ZActor.SetScale(TextScale, TextScale, TextScale) ZActor.SetPosition(0.0, 0.0, AxisLength) ZActor.GetProperty().SetColor(TextR, TextG, TextB) ren.AddActor(axesActor) ren.AddActor(XActor) ren.AddActor(YActor) ren.AddActor(ZActor)
def vtkCube(self, data_matrix=None): # We begin by creating the data we want to render. # For this tutorial, we create a 3D-image containing three overlaping cubes. # This data can of course easily be replaced by data from a medical CT-scan or anything else three dimensional. # The only limit is that the data must be reduced to unsigned 8 bit or 16 bit integers. #data_matrix = zeros([75, 75, 75], dtype=uint8) #data_matrix[0:35, 0:35, 0:35] = 50 #data_matrix[25:55, 25:55, 25:55] = 100 #data_matrix[45:74, 45:74, 45:74] = 150 # For VTK to be able to use the data, it must be stored as a VTK-image. This can be done by the vtkImageImport-class which # imports raw data and stores it. dataImporter = vtk.vtkImageImport() # The preaviusly created array is converted to a string of chars and imported. data_string = data_matrix.tostring() dataImporter.CopyImportVoidPointer(data_string, len(data_string)) # The type of the newly imported data is set to unsigned char (uint8) dataImporter.SetDataScalarTypeToUnsignedChar() # Because the data that is imported only contains an intensity value (it isnt RGB-coded or someting similar), the importer # must be told this is the case. dataImporter.SetNumberOfScalarComponents(1) # The following two functions describe how the data is stored and the dimensions of the array it is stored in. For this # simple case, all axes are of length 75 and begins with the first element. For other data, this is probably not the case. # I have to admit however, that I honestly dont know the difference between SetDataExtent() and SetWholeExtent() although # VTK complains if not both are used. dataImporter.SetDataExtent(0, 9, 0, 9, 0, 9) dataImporter.SetWholeExtent(0, 9, 0, 9, 0, 9) #dataImporter.SetDataExtent(0, 74, 0, 74, 0, 74) #dataImporter.SetWholeExtent(0, 74, 0, 74, 0, 74) # The following class is used to store transparencyv-values for later retrival. In our case, we want the value 0 to be # completly opaque whereas the three different cubes are given different transperancy-values to show how it works. alphaChannelFunc = vtk.vtkPiecewiseFunction() alphaChannelFunc.AddPoint(0, 0.6) alphaChannelFunc.AddPoint(33, 0.2) alphaChannelFunc.AddPoint(66, 0.1) alphaChannelFunc.AddPoint(100, 0.01) # Gradient opacity # other way: misfit 0 is anti opacity volumeGradientOpacity = vtk.vtkPiecewiseFunction() volumeGradientOpacity.AddPoint(70, 1.0) volumeGradientOpacity.AddPoint(50, 0.5) volumeGradientOpacity.AddPoint(20, 0.0) # This class stores color data and can create color tables from a few color points. For this demo, we want the three cubes # to be of the colors red green and blue. colorFunc = vtk.vtkColorTransferFunction() colorFunc.AddRGBPoint(00, 1.0, 0.0, 0.0) colorFunc.AddRGBPoint(30, 0.0, 1.0, 0.0) colorFunc.AddRGBPoint(60, 0.0, 0.0, 1.0) # The preavius two classes stored properties. Because we want to apply these properties to the volume we want to render, # we have to store them in a class that stores volume prpoperties. volumeProperty = vtk.vtkVolumeProperty() volumeProperty.SetColor(colorFunc) volumeProperty.SetScalarOpacity(alphaChannelFunc) volumeProperty.SetGradientOpacity(volumeGradientOpacity) volumeProperty.SetInterpolationTypeToLinear() volumeProperty.ShadeOff() volumeProperty.SetAmbient(0.1) volumeProperty.SetDiffuse(0.6) volumeProperty.SetSpecular(0.2) # This class describes how the volume is rendered (through ray tracing). compositeFunction = vtk.vtkVolumeRayCastCompositeFunction() # We can finally create our volume. We also have to specify the data for it, as well as how the data will be rendered. volumeMapper = vtk.vtkVolumeRayCastMapper() volumeMapper.SetVolumeRayCastFunction(compositeFunction) volumeMapper.SetInputConnection(dataImporter.GetOutputPort()) # The class vtkVolume is used to pair the preaviusly declared volume as well as the properties to be used when rendering that volume. volume = vtk.vtkVolume() volume.SetMapper(volumeMapper) volume.SetProperty(volumeProperty) # Text am Nullpunkt atext = vtk.vtkVectorText() atext.SetText("(0,0,0)") textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(10, 10, 10) textActor.AddPosition(0, -0.1, 78) # Cube to give some orientation # (from http://www.vtk.org/Wiki/VTK/Examples/Python/Widgets/OrientationMarkerWidget) axesActor = vtk.vtkAnnotatedCubeActor(); axesActor.SetXPlusFaceText('N') axesActor.SetXMinusFaceText('S') axesActor.SetYMinusFaceText('W') axesActor.SetYPlusFaceText('E') axesActor.SetZMinusFaceText('D') axesActor.SetZPlusFaceText('U') axesActor.GetTextEdgesProperty().SetColor(1,1,0) axesActor.GetTextEdgesProperty().SetLineWidth(2) axesActor.GetCubeProperty().SetColor(0,0,1) # With almost everything else ready, its time to initialize the renderer and window, as well as creating a method for exiting the application renderer = vtk.vtkRenderer() renderWin = vtk.vtkRenderWindow() renderWin.AddRenderer(renderer) renderInteractor = vtk.vtkRenderWindowInteractor() renderInteractor.SetRenderWindow(renderWin) axes = vtk.vtkOrientationMarkerWidget() axes.SetOrientationMarker(axesActor) axes.SetInteractor(renderInteractor) axes.EnabledOn() axes.InteractiveOn() renderer.ResetCamera() # We add the volume to the renderer ... renderer.AddVolume(volume) # ... set background color to white ... renderer.SetBackground(0.7,0.7,0.7) # ... and set window size. renderWin.SetSize(400, 400) # Fuege Text am Nullpunkt hinzu: renderer.AddActor(textActor) # A simple function to be called when the user decides to quit the application. def exitCheck(obj, event): if obj.GetEventPending() != 0: obj.SetAbortRender(1) # Tell the application to use the function as an exit check. renderWin.AddObserver("AbortCheckEvent", exitCheck) renderInteractor.Initialize() # Because nothing will be rendered without any input, we order the first render manually before control is handed over to the main-loop. renderWin.Render() renderInteractor.Start()
def Initialize(self): """Prepare the class to work.""" self.Initialized = True # Radius self.r = r = 0.1 # Disk self.diskSrc = diskSrc = vtk.vtkDiskSource() diskSrc.SetCircumferentialResolution(50) diskSrc.SetInnerRadius(r) diskSrc.SetOuterRadius(3*r) diskSrc.Update() # Lens Triangle self.trianglePoints = trianglePoints = vtk.vtkPoints() trianglePoints.InsertNextPoint(0,-r*0.9,0) trianglePoints.InsertNextPoint(-r*0.05,-r,0) trianglePoints.InsertNextPoint(r*0.05,-r,0) self.triangleSrc = triangleSrc = vtk.vtkTriangle() for i in range(3): triangleSrc.GetPointIds().SetId(i,i) self.triangleCells = triangleCells = vtk.vtkCellArray() triangleCells.InsertNextCell(triangleSrc) self.trianglePD = trianglePD = vtk.vtkPolyData() trianglePD.SetPoints(trianglePoints) trianglePD.SetPolys(triangleCells) # Mappers self.diskMapper = diskMapper = vtk.vtkPolyDataMapper() diskMapper.SetInputConnection(diskSrc.GetOutputPort()) self.triangleMapper = triangleMapper = vtk.vtkPolyDataMapper() triangleMapper.SetInput(trianglePD) # Actors self.diskActor = diskActor = vtk.vtkFollower() diskActor.SetMapper(diskMapper) diskActor.GetProperty().SetColor(0,0,0) self.triangleActor = triangleActor = vtk.vtkFollower() triangleActor.SetMapper(triangleMapper) triangleActor.GetProperty().SetColor(0,0,0) # Positioning self.cam = self.sc.GetCamera() self.p = self.cam.GetPosition() self.d = d = self.cam.GetDirectionOfProjection() factor = 0.2 diskActor.AddPosition(self.p[0] + factor*d[0], \ self.p[1] + factor*d[1], self.p[2] + factor*d[2]) triangleActor.AddPosition(self.p[0] + factor*d[0], \ self.p[1] + factor*d[1], self.p[2] + factor*d[2]) self.ren = ren = self.sc.GetRenderWindow().GetRenderers().GetFirstRenderer() ren.AddActor(diskActor) ren.AddActor(triangleActor) diskActor.SetCamera(self.cam) triangleActor.SetCamera(self.cam)
# Create the axes and the associated mapper and actor. axes = vtk.vtkAxes() axes.SetOrigin(0, 0, 0) axesMapper = vtk.vtkPolyDataMapper() axesMapper.SetInputConnection(axes.GetOutputPort()) axesActor = vtk.vtkActor() axesActor.SetMapper(axesMapper) # Create the 3D text and the associated mapper and follower (a type of # actor). Position the text so it is displayed over the origin of the # axes. atext = vtk.vtkVectorText() atext.SetText("Origin") textMapper = vtk.vtkPolyDataMapper() textMapper.SetInputConnection(atext.GetOutputPort()) textActor = vtk.vtkFollower() textActor.SetMapper(textMapper) textActor.SetScale(0.1, 0.1, 0.1) buttonRepresentation = vtk.vtkProp3DButtonRepresentation() #buttonRepresentation.FollowCameraOn() buttonRepresentation.SetNumberOfStates(1) buttonRepresentation.SetButtonProp( 0, textActor ) # Create the Renderer, RenderWindow, and RenderWindowInteractor. ren = vtk.vtkRenderer() renWin = vtk.vtkRenderWindow() renWin.AddRenderer(ren) iren = vtk.vtkRenderWindowInteractor() iren.SetRenderWindow(renWin)