Python vtk.vtkFollower函数代码示例

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 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 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):
        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 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 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_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 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 _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 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 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 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)