Exemplo n.º 1
2
    def initArea(self):
        '''
        Sets up the VTK simulation area
        :return:None
        '''

        self.actors_dict = {}

        self.actorCollection=vtk.vtkActorCollection()
        self.borderActor    = vtk.vtkActor()
        self.borderActorHex = vtk.vtkActor()
        self.clusterBorderActor    = vtk.vtkActor()
        self.clusterBorderActorHex = vtk.vtkActor()
        self.cellGlyphsActor  = vtk.vtkActor()
        self.FPPLinksActor  = vtk.vtkActor()  # used for both white and colored links
        self.outlineActor = vtk.vtkActor()
        # self.axesActor = vtk.vtkCubeAxesActor2D()
        self.axesActor = vtk.vtkCubeAxesActor()


        self.outlineDim=[0,0,0]
        
        self.cellsActor     = vtk.vtkActor()
        self.cellsActor.GetProperty().SetInterpolationToFlat() # ensures that pixels are drawn exactly not with interpolations/antialiasing
        
        self.hexCellsActor     = vtk.vtkActor()
        self.hexCellsActor.GetProperty().SetInterpolationToFlat() # ensures that pixels are drawn exactly not with interpolations/antialiasing
        
        self.conActor       = vtk.vtkActor()
        self.conActor.GetProperty().SetInterpolationToFlat()

        self.hexConActor       = vtk.vtkActor()
        self.hexConActor.GetProperty().SetInterpolationToFlat()
        
        self.contourActor   = vtk.vtkActor()      

        self.glyphsActor=vtk.vtkActor()
        #self.linksActor=vtk.vtkActor()

        # # Concentration lookup table
        
        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()

        # Contour lookup table
        # Do I need lookup table? May be just one color?
        self.ctlut = vtk.vtkLookupTable()
        self.ctlut.SetHueRange(0.6, 0.6)
        self.ctlut.SetSaturationRange(0,1.0)
        self.ctlut.SetValueRange(1.0,1.0)
        self.ctlut.SetAlphaRange(1.0,1.0)
        self.ctlut.SetNumberOfColors(1024)
        self.ctlut.Build()
Exemplo n.º 2
0
def main():
    filename = get_program_parameters()

    colors = vtk.vtkNamedColors()

    renderer = vtk.vtkRenderer()
    render_window = vtk.vtkRenderWindow()
    render_window.AddRenderer(renderer)

    render_window_interactor = vtk.vtkRenderWindowInteractor()
    render_window_interactor.SetRenderWindow(render_window)

    # VRML Import
    importer = vtk.vtkVRMLImporter()
    importer.SetFileName(filename)
    importer.SetRenderWindow(render_window)
    importer.Update()

    actors = vtk.vtkActorCollection()
    actors = renderer.GetActors()
    print("There are", actors.GetNumberOfItems(), "actors")

    renderer.SetBackground(colors.GetColor3d("Burlywood"))
    render_window.SetSize(512, 512)
    render_window.Render()
    render_window_interactor.Start()
    def initArea(self):
        '''
        Sets up the VTK simulation area
        :return:None
        '''

        self.actors_dict = {}

        self.actorCollection = vtk.vtkActorCollection()
        self.borderActor = vtk.vtkActor()
        self.borderActorHex = vtk.vtkActor()
        self.clusterBorderActor = vtk.vtkActor()
        self.clusterBorderActorHex = vtk.vtkActor()
        self.cellGlyphsActor = vtk.vtkActor()
        self.FPPLinksActor = vtk.vtkActor(
        )  # used for both white and colored links
        self.outlineActor = vtk.vtkActor()
        # self.axesActor = vtk.vtkCubeAxesActor2D()
        self.axesActor = vtk.vtkCubeAxesActor()

        self.outlineDim = [0, 0, 0]

        self.cellsActor = vtk.vtkActor()
        self.cellsActor.GetProperty().SetInterpolationToFlat(
        )  # ensures that pixels are drawn exactly not with interpolations/antialiasing

        self.hexCellsActor = vtk.vtkActor()
        self.hexCellsActor.GetProperty().SetInterpolationToFlat(
        )  # ensures that pixels are drawn exactly not with interpolations/antialiasing

        self.conActor = vtk.vtkActor()
        self.conActor.GetProperty().SetInterpolationToFlat()

        self.hexConActor = vtk.vtkActor()
        self.hexConActor.GetProperty().SetInterpolationToFlat()

        self.contourActor = vtk.vtkActor()

        self.glyphsActor = vtk.vtkActor()
        #self.linksActor=vtk.vtkActor()

        # # Concentration lookup table

        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()

        # Contour lookup table
        # Do I need lookup table? May be just one color?
        self.ctlut = vtk.vtkLookupTable()
        self.ctlut.SetHueRange(0.6, 0.6)
        self.ctlut.SetSaturationRange(0, 1.0)
        self.ctlut.SetValueRange(1.0, 1.0)
        self.ctlut.SetAlphaRange(1.0, 1.0)
        self.ctlut.SetNumberOfColors(1024)
        self.ctlut.Build()
Exemplo n.º 4
0
def main():
    filename_obj, filename_mtl, texturepath = get_program_parameters()

    importer = vtk.vtkOBJImporter()
    importer.SetFileName(filename_obj)
    importer.SetFileNameMTL(filename_mtl)
    importer.SetTexturePath(texturepath)

    colors = vtk.vtkNamedColors()

    renderer = vtk.vtkRenderer()
    render_window = vtk.vtkRenderWindow()
    render_window_interactor = vtk.vtkRenderWindowInteractor()

    renderer.SetBackground2(colors.GetColor3d("Silver"))
    renderer.SetBackground(colors.GetColor3d("Gold"))
    renderer.GradientBackgroundOn()
    render_window.AddRenderer(renderer)
    renderer.UseHiddenLineRemovalOn()
    render_window.AddRenderer(renderer)
    render_window.SetSize(640, 480)

    render_window_interactor.SetRenderWindow(render_window)
    importer.SetRenderWindow(render_window)
    importer.Update()

    actors = vtk.vtkActorCollection()
    actors = renderer.GetActors()
    actors.InitTraversal()
    print("There are", actors.GetNumberOfItems(), "actors")

    for a in range(0, actors.GetNumberOfItems()):
        print(importer.GetOutputDescription(a))

        actor = actors.GetNextActor()

        # OBJImporter turns texture interpolation off
        if actor.GetTexture():
            print("Hastexture\n")
            actor.GetTexture().InterpolateOn()

        pd = actor.GetMapper().GetInput()
        clean = vtk.vtkCleanPolyData()
        clean.SetInputData(pd)
        clean.Update()

        normals = vtk.vtkPolyDataNormals()

        normals.SetInputData(pd)
        normals.SplittingOff()
        normals.ConsistencyOn()
        normals.Update()
        mapper = actor.GetMapper()
        mapper.SetInputData(normals.GetOutput())
        mapper.SetInputData(pd)

    render_window.Render()
    render_window_interactor.Start()
Exemplo n.º 5
0
 def __init__(self, element_id, position, no_pick=True):
     super().__init__()
     self.no_pick = no_pick
     self.cell_id = 0
     self.points = vtk.vtkPoints()
     self.points.SetNumberOfPoints(1)
     self.points.SetPoint(0, position)
     actor = FakeActor(element_id)
     self.actors = vtk.vtkActorCollection()
     self.actors.AddItem(actor)
Exemplo n.º 6
0
    def event_type(self, clean_level, clean_dict=None):
        for tel_id in self.tel_ids:

            telescope = self.event.inst.subarray.tel[tel_id]

            # tel_coords = self.event.inst.subarray.tel_coords
            tel_x_pos = self.tel_coords[tel_id].x.to_value(u.m)
            tel_y_pos = self.tel_coords[tel_id].y.to_value(u.m)
            tel_z_pos = self.tel_coords[tel_id].z.to_value(u.m)

            camera_actor = camera_structure(self.event, tel_id, clean_level,
                                            clean_dict)
            camera_frame_actor = camera_frame(telescope.camera.cam_id)

            actorCollection = vtk.vtkActorCollection()

            actorCollection.AddItem(camera_actor)
            actorCollection.AddItem(camera_frame_actor)

            if telescope.optics.name == "LST":
                CSS_LST_actor = LST_tel_structure()
                mirror_plate_actor = LST_create_mirror_plane()
                actorCollection.AddItem(mirror_plate_actor)
                actorCollection.AddItem(CSS_LST_actor)
            elif telescope.optics.name == "MST":
                MST_mirror_plate_actor = MST_create_mirror_plane()
                MST_tel_structure_actor = MST_tel_structure()
                actorCollection.AddItem(MST_mirror_plate_actor)
                actorCollection.AddItem(MST_tel_structure_actor)
            elif telescope.optics.name == 'SST':
                SST_primary_mirror_plane_actor = SST_primary_mirror_plane()
                SST_tel_structure_actor = SST_tel_structure()
                actorCollection.AddItem(SST_primary_mirror_plane_actor)
                actorCollection.AddItem(SST_tel_structure_actor)

            actorCollection.InitTraversal()

            transform = vtk.vtkTransform()
            transform.PostMultiply()
            transform.RotateY(-self.pointing[tel_id]['alt'])
            transform.Translate(tel_x_pos, tel_y_pos, tel_z_pos)

            for a in range(actorCollection.GetNumberOfItems()):
                actor = actorCollection.GetNextActor()
                actor.SetUserTransform(transform)
                self.tel_id[tel_id].append(actor)
Exemplo n.º 7
0
 def iniVTK(self):
     self.last_added_sphere_ren1 = None
     self.newed_spheres = vtk.vtkCollection()
     self.sphere_radius_ren1 = 2.0
     self.bouttons_spheres = []
     self.slice_assembly = None
     self.image_roi = None
     self.im_importer = vtk.vtkImageImport()
     self.sphere = vtk.vtkSphereSource()
     self.sphere.SetRadius(2.0)
     self.sphere_mapper = vtk.vtkPolyDataMapper()
     self.sphere_mapper.SetInputConnection(self.sphere.GetOutputPort())
     self.sphere_actor_ren2 = vtk.vtkActor()
     self.sphere.SetCenter(show_height / 2, show_width / 2, 0)
     self.sphere_actor_ren2.SetMapper(self.sphere_mapper)
     self.sphere_actor_ren2.GetProperty().SetColor(255.0, 0, 0)
     self.vtk_widget.GetRenderWindow().SetSize(800, 400)
     self.image_actor = vtk.vtkImageActor()
     self.ren1 = vtk.vtkRenderer()
     self.ren2 = vtk.vtkRenderer()
     self.interactorStyle = BouttonInteractorStyle()
     self.vtk_widget.SetInteractorStyle(self.interactorStyle)
     self.vtk_widget.GetRenderWindow().AddRenderer(self.ren1)
     self.vtk_widget.GetRenderWindow().AddRenderer(self.ren2)
     self.ren1.SetViewport(0.0, 0.0, 0.5, 1.0)
     self.ren2.SetViewport(0.5, 0.0, 1.0, 1.0)
     self.ren2.AddActor(self.sphere_actor_ren2)
     self.imageLevelFilter = vtk.vtkImageMapToWindowLevelColors()
     self.imageLevelFilter.SetLevel(400)
     self.imageLevelFilter.SetWindow(800)
     self.im_importer.SetNumberOfScalarComponents(1)
     self.im_importer.SetDataScalarTypeToUnsignedShort()
     self.im_importer.SetDataExtent(0, show_width - 1, 0, show_height - 1,
                                    0, 0)
     self.im_importer.SetWholeExtent(0, show_width - 1, 0, show_height - 1,
                                     0, 0)
     self.imageLevelFilter.SetInputConnection(
         self.im_importer.GetOutputPort())
     self.image_actor.SetInput(self.imageLevelFilter.GetOutput())
     self.ren1_sphere_actors = vtk.vtkActorCollection()
     self.pointPicker = vtk.vtkPointPicker()
     self.actorPicker = vtk.vtkPropPicker()
     self.pickedActor = None
     self.ren1.AddActor(self.image_actor)
     self.ren2.AddActor(self.image_actor)
Exemplo n.º 8
0
    def __GroupChannelAdd(self):
        """
        Populate the electrode's actor collection with channel properties from
        list-dictionary
        """

        # Reset the actor collection for adding the new actors.
        self.channelActors = vtk.vtkActorCollection()

        # Run through each channel and add a new actor for each loaded chan
        # Info was stored as strings, needs to be converted back to float
        for chan in self.channelInfo:
            nextLoadActor = self.AddChannelRepresentationActor(\
                    float(chan[self.channelProperties[1]]),\
                    float(chan[self.channelProperties[2]]),\
                    float(chan[self.channelProperties[3]]),\
                    float(chan[self.channelProperties[4]]),\
                    float(chan[self.channelProperties[5]]),\
                    float(chan[self.channelProperties[6]]))
Exemplo n.º 9
0
    def __init__(self, planeWidget, owner, orientation, imageData=None):
        print "PlaneWidgetObserver.__init__(): orientation=",orientation
        MarkerWindowInteractor.__init__(self)
        self.interactButtons = (1,2,3)
        self.pw = planeWidget
        self.owner = owner
        self.orientation = orientation
        self.observer = vtk.vtkImagePlaneWidget()

        self.camera = self.renderer.GetActiveCamera()

        self.ringActors = vtk.vtkActorCollection()
        self.defaultRingLine = 1
        self.textActors = {}
        self.hasData = 0

        self.set_image_data(imageData)
        self.lastTime = 0
        self.set_mouse1_to_move()
Exemplo n.º 10
0
    def __init__(self, planeWidget, owner, orientation, imageData=None):
        print "PlaneWidgetObserver.__init__(): orientation=", orientation
        MarkerWindowInteractor.__init__(self)
        self.interactButtons = (1, 2, 3)
        self.pw = planeWidget
        self.owner = owner
        self.orientation = orientation
        self.observer = vtk.vtkImagePlaneWidget()

        self.camera = self.renderer.GetActiveCamera()

        self.ringActors = vtk.vtkActorCollection()
        self.defaultRingLine = 1
        self.textActors = {}
        self.hasData = 0

        self.set_image_data(imageData)
        self.lastTime = 0
        self.set_mouse1_to_move()
Exemplo n.º 11
0
    def __GroupChannelAdd(self):
        """
        Populate the electrode's actor collection with channel properties from
        list-dictionary
        """

        # Reset the actor collection for adding the new actors.
        self.channelActors = vtk.vtkActorCollection()

        # Run through each channel and add a new actor for each loaded chan
        # Info was stored as strings, needs to be converted back to float
        for chan in self.channelInfo:
            nextLoadActor = self.AddChannelRepresentationActor(\
                    float(chan[self.channelProperties[1]]),\
                    float(chan[self.channelProperties[2]]),\
                    float(chan[self.channelProperties[3]]),\
                    float(chan[self.channelProperties[4]]),\
                    float(chan[self.channelProperties[5]]),\
                    float(chan[self.channelProperties[6]]))
Exemplo n.º 12
0
 def iniVTK(self):
     self.last_added_sphere_ren1 = None
     self.newed_spheres = vtk.vtkCollection()
     self.sphere_radius_ren1 = 2.0
     self.bouttons_spheres = []
     self.slice_assembly = None
     self.image_roi = None
     self.im_importer = vtk.vtkImageImport()       
     self.sphere = vtk.vtkSphereSource()
     self.sphere.SetRadius(2.0)
     self.sphere_mapper = vtk.vtkPolyDataMapper()
     self.sphere_mapper.SetInputConnection(self.sphere.GetOutputPort())
     self.sphere_actor_ren2 = vtk.vtkActor()
     self.sphere.SetCenter(show_height / 2, show_width / 2, 0)
     self.sphere_actor_ren2.SetMapper(self.sphere_mapper)
     self.sphere_actor_ren2.GetProperty().SetColor(255.0, 0, 0)
     self.vtk_widget.GetRenderWindow().SetSize(800, 400)
     self.image_actor = vtk.vtkImageActor()
     self.ren1 = vtk.vtkRenderer()
     self.ren2 = vtk.vtkRenderer()
     self.interactorStyle = BouttonInteractorStyle()
     self.vtk_widget.SetInteractorStyle(self.interactorStyle)
     self.vtk_widget.GetRenderWindow().AddRenderer(self.ren1)
     self.vtk_widget.GetRenderWindow().AddRenderer(self.ren2)
     self.ren1.SetViewport(0.0, 0.0, 0.5, 1.0)
     self.ren2.SetViewport(0.5, 0.0, 1.0, 1.0)
     self.ren2.AddActor(self.sphere_actor_ren2)
     self.imageLevelFilter = vtk.vtkImageMapToWindowLevelColors()
     self.imageLevelFilter.SetLevel(400)
     self.imageLevelFilter.SetWindow(800)
     self.im_importer.SetNumberOfScalarComponents(1)
     self.im_importer.SetDataScalarTypeToUnsignedShort()
     self.im_importer.SetDataExtent(0, show_width - 1, 0, show_height - 1, 0, 0)
     self.im_importer.SetWholeExtent(0, show_width - 1, 0, show_height - 1, 0, 0)
     self.imageLevelFilter.SetInputConnection(self.im_importer.GetOutputPort())
     self.image_actor.SetInput(self.imageLevelFilter.GetOutput())
     self.ren1_sphere_actors = vtk.vtkActorCollection()
     self.pointPicker = vtk.vtkPointPicker()
     self.actorPicker = vtk.vtkPropPicker()
     self.pickedActor = None
     self.ren1.AddActor(self.image_actor)
     self.ren2.AddActor(self.image_actor)
Exemplo n.º 13
0
 def __init__(self):
     """
     Set a particular cursor for mapping channels for this electrode, and
     initialize actor collections and actor property lists
     """
     # Set the electrode placement cursor
     self.channelCursor = self.__CreateChannelRepresentationActor()
     self.channelCursor.GetProperty().SetColor(0, 1, 0)
     self.channelCursor.PickableOff()
     # Instantiate an collection for positioned channel actors
     self.channelActors = vtk.vtkActorCollection()
     # Instantiate a dictionary list to hold information mapped channel info
     self.channelInfo = []
     self.channelProperties = ['channelID',\
                               'x_coor',\
                               'y_coor',\
                               'z_coor',\
                               'red_px',\
                               'grn_px',\
                               'blu_px']
 def __init__(self):
     '''
     Constructor
     '''
     self.__Type = self.VTK_META_UNKNOWN
     self.__pickedPointId = -1                       #int
     self.__PickedCellId = -1                        #int
     self.__DataSet  = 0                             #vtkDataSet
     self.__ActorList = vtk.vtkActorCollection()     #vtkDataArrayCollection
     self.__Time = -1                                #double
     self.__Property = 0                             #vtkObject
     self.__ArrayCollection = vtk.vtkDataArrayCollection() #vtkDataArrayCollection
     
     self.__CurrentScalarArray = 0                   #vtkDataArray
     self.__Name = ""                                #string
     self.__FilePath = ""                            #string
     self.__Tag = ""                                 #string
     self.__Lock = 0                                 #int
     
     self.__MetaDataDictionary = None                #itk.MetaDataDictionary
     
     self.__WirePolyData = None                      #vtkPolyData
     
     self.Initialize()
Exemplo n.º 15
0
class EventHandler:
    __sharedState = {}
    markers = vtk.vtkActorCollection()
    defaultColor = (0,0,1)
    labelsOn = 1
    observers = {}
    selected = {}
    __NiftiQForm=None
    __NiftiSpacings=(1.0,1.0,1.0)

    def __init__(self):
        self.__dict__ = self.__sharedState            

    def add_selection(self, marker):
        self.selected[marker] = 1
        self.notify('select marker', marker)
        
    def remove_selection(self, marker):
        if self.selected.has_key(marker):
            del self.selected[marker]
            self.notify('unselect marker', marker)
        
        
    def select_new(self, marker):
        for oldMarker in self.selected.keys():
            self.remove_selection(oldMarker)
        self.add_selection(marker)
    
    def add_marker(self, marker):
        # break undo cycle 
        func, args = UndoRegistry().get_last_pop()
        #print 'add', func, args
        if len(args)==0 or \
               (func, args[0]) != (self.add_marker, marker):
            UndoRegistry().push_command(self.remove_marker, marker)
        self.markers.AddItem(marker)
        self.notify('add marker', marker)


    def remove_marker(self, marker):
        # break undo cycle

        func, args = UndoRegistry().get_last_pop()
        #print 'remove', func, args
        if len(args)==0 or \
               (func, args[0]) != (self.remove_marker, marker):
            UndoRegistry().push_command(self.add_marker, marker)
        self.markers.RemoveItem(marker)
        self.notify('remove marker', marker)

    def get_markers(self):
        return self.markers

    def get_markers_as_seq(self):
        numMarkers = self.markers.GetNumberOfItems()
        self.markers.InitTraversal()
        return [self.markers.GetNextActor() for i in range(numMarkers)]


    def set_default_color(self, color):
        self.defaultColor = color

    def get_default_color(self):
        return self.defaultColor


    def save_markers_as(self, fname):
        self.markers.InitTraversal()
        numMarkers = self.markers.GetNumberOfItems()
        lines = []; conv_lines = []
        
        #self.printTalairachResults()

        for i in range(numMarkers):
            marker = self.markers.GetNextActor()
            if marker is None: continue
            else:
                #XXX if self.__Nifti:
                if self.__NiftiQForm is not None:
                    conv_marker=marker.convert_coordinates(self.__NiftiQForm,self.__NiftiSpacings)
                    #XXX conv_marker=marker.convert_coordinates(QForm)
                    center = conv_marker.get_center()
                    request = "1,%i,%i,%i" % (int(center[0]),int(center[1]),int(center[2]))
                    result=self.query_talairach(request)
                    conv_lines.append("%.3f, %.3f, %.3f, %s"%(center[0],center[1],center[2],result))

                lines.append(marker.to_string())
        lines.sort()

        fh = file(fname, 'w')
        fh.write('\n'.join(lines) + '\n')
        if self.__NiftiQForm is not None:
            fn = file(fname+".conv", 'w') #only needed for nifti, but what the hell
            conv_lines.sort()
            fn.write('\n'.join(conv_lines) + '\n')
    
    def query_talairach(self, request):
            sock = socket.socket()
            sock.connect(("talairach.org",1600))
            sock.settimeout(10.0)
            sock.send(request)
            res = sock.recv(1000)
            #print "res=", res
            return res
    
    def printTalairachResults(self):
        """For testing: query talairach-daemon and print results"""
        self.markers.InitTraversal()
        numMarkers = self.markers.GetNumberOfItems()
        
        for i in range(numMarkers):
            marker = self.markers.GetNextActor()
            if marker is None: continue
            
            if self.__NiftiQForm is not None:
                conv_marker=marker.convert_coordinates(self.__NiftiQForm,self.__NiftiSpacings)
                center = conv_marker.get_center()
                request = "1,%i,%i,%i" % (int(center[0]),int(center[1]),int(center[2]))
            if debug:
                print "Marker", center, ":", self.query_talairach(request)
                
        
    def setNifti(self,QForm,spacings):
        self.__NiftiQForm=QForm
        self.__NiftiSpacings=spacings

    def set_vtkactor(self, vtkactor):
        if debug:
            print "EventHandler.set_vtkactor()"
        self.vtkactor = vtkactor

    def save_registration_as(self, fname):
        if debug:
            print "EventHandler.save_registration_as(", fname,")"
        fh = file(fname, 'w')

        # XXX mcc: somehow get the transform for the VTK actor. aiieeee
        #xform = self.vtkactor.GetUserTransform()
        loc = self.vtkactor.GetOrigin()
        pos = self.vtkactor.GetPosition()
        scale = self.vtkactor.GetScale()
        mat = self.vtkactor.GetMatrix()
        orient = self.vtkactor.GetOrientation()
        
        if debug:
            print "EventHandler.save_registration_as(): vtkactor has origin, pos, scale, mat, orient=", loc, pos, scale, mat, orient, "!!"


        def vtkmatrix4x4_to_array(vtkmat):
            scipy_array = zeros((4,4), 'd')

            for i in range(0,4):
                for j in range(0,4):
                    scipy_array[i][j] = mat.GetElement(i,j)

            return scipy_array

        scipy_mat = vtkmatrix4x4_to_array(mat)

        pickle.dump(scipy_mat, fh)
        fh.close()
        
        
    def load_markers_from(self, fname):

        self.notify('render off')
        for line in file(fname, 'r'):
            marker = Marker.from_string(line)
            self.add_marker(marker)
        self.notify('render on')
        UndoRegistry().flush()

    def attach(self, observer):
        self.observers[observer] = 1

    def detach(self, observer):
        try:
            del self.observers[observer]
        except KeyError: pass

    def notify(self, event, *args):
        for observer in self.observers.keys():
            if debug:
                print "EventHandler.notify(", event, "): calling update_viewer for ", observer
            observer.update_viewer(event, *args)

    def get_labels_on(self):
        return self.labelsOn

    def set_labels_on(self):
        self.labelsOn = 1
        self.notify('labels on')

    def set_labels_off(self):
        self.labelsOn = 0
        self.notify('labels off')


    def is_selected(self, marker):
        return self.selected.has_key(marker)

    def get_selected(self):
        return self.selected.keys()

    def get_num_selected(self):
        return len(self.selected)
Exemplo n.º 16
0
def main():
    filename = get_program_parameters()
    colors = vtk.vtkNamedColors()

    print("Reading " + filename)

    renderer = vtk.vtkRenderer()
    render_window = vtk.vtkRenderWindow()
    render_window.AddRenderer(renderer)

    render_window_interactor = vtk.vtkRenderWindowInteractor()
    render_window_interactor.SetRenderWindow(render_window)

    # VRML Import
    importer = vtk.vtkVRMLImporter()
    importer.SetFileName(filename)
    importer.SetRenderWindow(render_window)
    importer.Update()

    actors = vtk.vtkActorCollection()
    actors = renderer.GetActors()
    print("There are", actors.GetNumberOfItems(), "actors")
    actors.InitTraversal()

    for a in range(0, actors.GetNumberOfItems()):
        actor = actors.GetNextActor()

        # The importer shininess parameter is between 0 and 1. VTK specular power is usually 10 - 100.
        # Also, the default for the specular factor for VRML is 1, while VTK's
        # is 0
        specular_power = actor.GetProperty().GetSpecularPower()
        if specular_power <= 1.0:
            actor.GetProperty().SetSpecularPower(specular_power * 128.0)
        specular = actor.GetProperty().GetSpecular()
        if specular == 0.0:
            actor.GetProperty().SetSpecular(1.0)
            # if 0
            # The VRML default ambient intensity is .2
        ambient_intensity = actor.GetProperty().GetAmbient()
        if ambient_intensity == 0.0:
            actor.GetProperty().SetAmbient(.2)
            # endif
        mapper = actor.GetMapper()
        if (mapper):
            data_set = mapper.GetInput()
            if not data_set.GetPointData().GetNormals():
                normals = vtk.vtkPolyDataNormals()
                normals.SetInputData(data_set)
                normals.SplittingOff()
                normals.Update()
                mapper.SetInputData(normals.GetOutput())

                # If there is a lookup table, convert it to point data
                lut = mapper.GetLookupTable()
                if lut and mapper.GetScalarVisibility():
                    pc = vtk.vtkUnsignedCharArray()
                    pc.SetNumberOfComponents(4)
                    pc.SetNumberOfTuples(lut.GetNumberOfColors())
                    for t in range(0, lut.GetNumberOfColors()):
                        lutc = lut.GetTableValue(t)
                        lutuc = ['', '', '', '']
                        lut.GetColorAsUnsignedChars(lutc, lutuc)
                        pc.SetTypedTuple(t, lutuc)
                    mapper.SetLookupTable(None)
                    mapper.GetInput().GetPointData().SetScalars(pc)

        renderer.ResetCamera()
        renderer.GetActiveCamera().Azimuth(30)
        renderer.GetActiveCamera().Elevation(30)
        renderer.GetActiveCamera().Dolly(1.4)
        renderer.ResetCameraClippingRange()

        renderer.SetBackground(colors.GetColor3d("PaleGreen"))
        render_window.SetSize(640, 480)
        render_window.Render()
        render_window_interactor.Start()
Exemplo n.º 17
0
import vtk

c = vtk.vtkActorCollection()

a1 = vtk.vtkActor()
a2 = vtk.vtkActor()
c.AddItem(a1)
c.AddItem(a2)
print c.GetNumberOfItems()
c.InitTraversal()
for i in xrange(2):
    print c.GetNextActor()
    
    

Exemplo n.º 18
0
ntheme.SetOutlineColor(0.2, 0.2, 0.2)
ntheme.SetPointColor(0.1, 0.1, 0.1)
ntheme.SetPointOpacity(1.0)

nodeMapper = vtk.vtkGraphMapper()
nodeMapper.SetInput(nodeGraph)
nodeMapper.SetColorEdges(False)
nodeMapper.ApplyViewTheme(ntheme)

nodeActor = vtk.vtkActor()
nodeActor.SetMapper(nodeMapper)
nodeActor.SetPosition(0,0,-0.0025)

# ----------
# Create an Actor Collection for applying visibility to group
basisActorCollection = vtk.vtkActorCollection()
basisActorCollection.AddItem(vertActor)
basisActorCollection.AddItem(outlineActor)

# ----------
# Background graph skeleton
graphMapper = vtk.vtkGraphMapper()
graphMapper.SetInputConnection(0, edgeLayout.GetOutputPort(0))
graphMapper.SetColorEdges(True)
graphMapper.SetEdgeColorArrayName('weight')

# Apply a theme to the background graph
gtheme = vtk.vtkViewTheme()
gtheme.SetLineWidth(1)
gtheme.SetPointSize(0)
gtheme.SetOutlineColor(0.8, 0.8, 0.8)
Exemplo n.º 19
0
class EventHandler:
    __sharedState = {}
    markers = vtk.vtkActorCollection()
    defaultColor = (0, 0, 1)
    labelsOn = 1
    observers = {}
    selected = {}

    def __init__(self):
        self.__dict__ = self.__sharedState

    def add_selection(self, marker):
        self.selected[marker] = 1
        self.notify('select marker', marker)

    def remove_selection(self, marker):
        if self.selected.has_key(marker):
            del self.selected[marker]
            self.notify('unselect marker', marker)

    def select_new(self, marker):
        for oldMarker in self.selected.keys():
            self.remove_selection(oldMarker)
        self.add_selection(marker)

    def add_marker(self, marker):
        # break undo cycle
        func, args = UndoRegistry().get_last_pop()
        #print 'add', func, args
        if len(args)==0 or \
               (func, args[0]) != (self.add_marker, marker):
            UndoRegistry().push_command(self.remove_marker, marker)
        self.markers.AddItem(marker)
        self.notify('add marker', marker)

    def remove_marker(self, marker):
        # break undo cycle

        func, args = UndoRegistry().get_last_pop()
        #print 'remove', func, args
        if len(args)==0 or \
               (func, args[0]) != (self.remove_marker, marker):
            UndoRegistry().push_command(self.add_marker, marker)
        self.markers.RemoveItem(marker)
        self.notify('remove marker', marker)

    def get_markers(self):
        return self.markers

    def get_markers_as_seq(self):
        numMarkers = self.markers.GetNumberOfItems()
        self.markers.InitTraversal()
        return [self.markers.GetNextActor() for i in range(numMarkers)]

    def set_default_color(self, color):
        self.defaultColor = color

    def get_default_color(self):
        return self.defaultColor

    def save_markers_as(self, fname):
        fh = file(fname, 'w')
        self.markers.InitTraversal()
        numMarkers = self.markers.GetNumberOfItems()
        lines = []
        for i in range(numMarkers):
            marker = self.markers.GetNextActor()
            if marker is None: continue
            lines.append(marker.to_string())
        lines.sort()
        fh.write('\n'.join(lines) + '\n')

    def set_vtkactor(self, vtkactor):
        print "EventHandler.set_vtkactor()"
        self.vtkactor = vtkactor

    def save_registration_as(self, fname):
        print "EventHandler.save_registration_as(", fname, ")"
        fh = file(fname, 'w')

        # XXX mcc: somehow get the transform for the VTK actor. aiieeee
        #xform = self.vtkactor.GetUserTransform()
        loc = self.vtkactor.GetOrigin()
        pos = self.vtkactor.GetPosition()
        scale = self.vtkactor.GetScale()
        mat = self.vtkactor.GetMatrix()
        orient = self.vtkactor.GetOrientation()

        print "EventHandler.save_registration_as(): vtkactor has origin, pos, scale, mat, orient=", loc, pos, scale, mat, orient, "!!"

        def vtkmatrix4x4_to_array(vtkmat):
            scipy_array = zeros((4, 4), 'd')

            for i in range(0, 4):
                for j in range(0, 4):
                    scipy_array[i][j] = mat.GetElement(i, j)

            return scipy_array

        scipy_mat = vtkmatrix4x4_to_array(mat)

        pickle.dump(scipy_mat, fh)
        fh.close()

    def load_markers_from(self, fname):
        #this runs when you load markers from file. it loads a csv file line by line and adds each marker
        self.notify('render off')
        for line in file(fname, 'r'):
            marker = Marker.from_string(line)
            self.add_marker(marker)  #adds the marker to a vtk actor collection
        self.notify('render on')
        UndoRegistry().flush()

    def attach(self, observer):
        self.observers[observer] = 1

    def detach(self, observer):
        try:
            del self.observers[observer]
        except KeyError:
            pass

    def notify(self, event,
               *args):  #this function maps events to function calls
        for observer in self.observers.keys():
            #print "EventHandler.notify(", event, "): calling update_viewer for ", observer, "with args: ", args #DEBUG MODE ONLY
            observer.update_viewer(event, *args)

    def get_labels_on(self):
        return self.labelsOn

    def set_labels_on(self):
        self.labelsOn = 1
        self.notify('labels on')

    def set_labels_off(self):
        self.labelsOn = 0
        self.notify('labels off')

    def is_selected(self, marker):
        return self.selected.has_key(marker)

    def get_selected(self):
        return self.selected.keys()

    def get_num_selected(self):
        return len(self.selected)
Exemplo n.º 20
0
    def loadGraph():
        
        # ----------
        # Load and construct whole graph and multi-resolution data from Matlab structure
        dataDir = '/Users/emonson/Programming/Matlab/EMonson/Fodava/DocumentAnalysis/Analysis/'
        filename = dataDir + 'X20_042709b.mat'
        # filename = '/Users/emonson/Programming/Python/VTK/X20_040609b.mat'
        X = scipy.io.loadmat(filename)
        # Get graph structure G out of matlab variables
        G = X['G']
        
        # ----------
        # Set multi-resolution level bounds in GUI sliders
        levelMax = G.Tree.shape[0]-1
        ui_window.hSlider_level.setMinimum(1)
        ui_window.hSlider_level.setMaximum(levelMax)
        ui_window.spinBox_level.setMinimum(1)
        ui_window.spinBox_level.setMaximum(levelMax)
        
        # Start setting up basis function for display as subgraph
        ExtBasis = GTree[level,0]['ExtBasis'][0][0][0]
        basisMax = ExtBasis.shape[1]-1    # zero-based indices
        
        # Set particular level basis function bounds in GUI sliders
        ui_window.hSlider_basisIndex.setMinimum(0)
        ui_window.hSlider_basisIndex.setMaximum(basisMax)
        ui_window.spinBox_basisIndex.setMinimum(0)
        ui_window.spinBox_basisIndex.setMaximum(basisMax)
        
        # Build table which will become graph
        table = vtk.vtkTable()
        col0 = vtk.vtkIntArray()
        col0.SetName('index1')
        col1 = vtk.vtkIntArray()
        col1.SetName('index2')
        val = vtk.vtkDoubleArray()
        val.SetName('weight')
        
        Tmat = G.T
        # Tmat = G.W
        
        for ii in range(Tmat.nzmax):
            col0.InsertNextValue(Tmat.rowcol(ii)[0])
            col1.InsertNextValue(Tmat.rowcol(ii)[1])
            val.InsertNextValue(abs(Tmat.getdata(ii)))
        
        table.AddColumn(col0)
        table.AddColumn(col1)
        table.AddColumn(val)
        
        # Vertex links need to be done with index2 first or indexing won't be right...
        # TODO: Make this foolproof so that graph always ends up with correct ordering of indices...
        tgraph = vtk.vtkTableToGraph()
        tgraph.SetInput(table)
        tgraph.AddLinkVertex('index2', 'stuff', False)
        tgraph.AddLinkVertex('index1', 'stuff', False)
        tgraph.AddLinkEdge('index2', 'index1')
        
        rawGraph = tgraph.GetOutput()
        rawGraph.Update()
        # print graph
        
        # Load and assign whole graph pre-layout coordinates
        ptsFile = os.path.splitext(filename)[0] + '_pts.vtp'
        if os.path.exists(ptsFile):
            polyreader = vtk.vtkXMLPolyDataReader()
            polyreader.SetFileName(ptsFile)
            polyreader.Update()
            pts = polyreader.GetOutput().GetPoints()
            rawGraph.SetPoints(pts)
            # print pts
            
        strategy = vtk.vtkPassThroughLayoutStrategy()
        layout = vtk.vtkGraphLayout()
        layout.SetInput(rawGraph)
        layout.SetLayoutStrategy(strategy)
        
        edgeLayout = vtk.vtkEdgeLayout()
        edgeStrategy = vtk.vtkArcParallelEdgeStrategy()
        edgeStrategy.SetNumberOfSubdivisions(50)
        edgeLayout.SetInputConnection(layout.GetOutputPort())
        edgeLayout.SetLayoutStrategy(edgeStrategy)
        
        graph = edgeLayout.GetOutput()
        graph.Update()
        
        # --------
        # Add ExtBasis to graph data & Select particular basis function
        
        # print 'ExtBasis shape: ' + str(ExtBasis[:,basisNum].data.shape) + ' (level,basis) (' + str(level) + ',' + str(basisNum) + ')'
        
        # Indexing of ExtBasis is backwards from graph, so need to reverse with [::-1]
        # and array not "contiguous" if don't do .copy()
        Esub = ExtBasis[:,basisNum].data[::-1].copy()
        EsubSq = Esub**2
        # Esub = N.random.random(ExtBasis[:,basisNum].data.shape[0])
        # SubIdxs = (Esub > 0.001).nonzero()
        # SubIdxs = (Esub**2 > 0.8).nonzero()
        
        # Set ExtBasis vertex data from numpy array
        basisFunc = VN.numpy_to_vtk(Esub)
        basisFunc.SetName('ExtBasis')
        basisFuncSq = VN.numpy_to_vtk(EsubSq)
        basisFuncSq.SetName('ExtBasisSq')
        
        vertexData = graph.GetVertexData()
        vertexData.AddArray(basisFunc)
        vertexData.AddArray(basisFuncSq)
        
        selection = vtk.vtkSelectionSource()
        selection.SetContentType(7) # vtkSelection::THRESHOLDS
        # selection.SetContentType(2) # vtkSelection::PEDIGREE_IDS
        selection.SetFieldType(3) # vtkSelection::VERTEX
        selection.SetArrayName("ExtBasisSq")
        selection.AddThreshold(basisCutoff, 10)
        # TODO: There was something wrong with the indexing in the PEDIGREE_IDS selection...
        # for ii in SubIdxs[0]:
        #     selection.AddID(0,ii)
        minmax = "(%3.2e, %3.2e)" % (EsubSq.min(), EsubSq.max())
        ui_window.label_basisCutoff_minmax.setText(minmax)
        selection.Update()
        
        # ----------
        # Back to pipeline
        degree = vtk.vtkVertexDegree()
        degree.SetInput(graph)
        
        subgraph = vtk.vtkExtractSelectedGraph()
        subgraph.SetRemoveIsolatedVertices(False)
        subgraph.SetInputConnection(degree.GetOutputPort())
        subgraph.SetSelectionConnection(selection.GetOutputPort())
        
        # +++++++++++++
        graphToPoly = vtk.vtkGraphToPolyData()
        graphToPoly.SetInputConnection(subgraph.GetOutputPort())
        edgeMapper = vtk.vtkPolyDataMapper()
        edgeMapper.SetInputConnection(graphToPoly.GetOutputPort())
        edgeMapper.SetScalarModeToUseCellData()
        edgeMapper.SetScalarVisibility(False)
        edgeMapper.SetImmediateModeRendering(True)
        edgeActor = vtk.vtkActor()
        edgeActor.SetMapper(edgeMapper)
        edgeActor.SetPosition(0, 0, -0.003);
        
        lut = vtk.vtkLookupTable()
        lutNum = 256
        lut.SetNumberOfTableValues(lutNum)
        ctf = vtk.vtkColorTransferFunction()
        ctf.SetColorSpaceToDiverging()
        ctf.AddRGBPoint(0.0, 0, 0, 1.0)
        ctf.AddRGBPoint(1.0, 1.0, 0, 0)
        for ii,ss in enumerate([float(xx)/float(lutNum) for xx in range(lutNum)]):
            cc = ctf.GetColor(ss)
            lut.SetTableValue(ii,cc[0],cc[1],cc[2],1.0)
        
        vertGlyph = vtk.vtkVertexGlyphFilter()
        vertGlyph.SetInputConnection(subgraph.GetOutputPort())
        vertMapper = vtk.vtkPolyDataMapper()
        vertMapper.SetInputConnection(vertGlyph.GetOutputPort())
        vertMapper.SetImmediateModeRendering(True)
        vertMapper.SetScalarModeToUsePointFieldData()
        vertMapper.SetLookupTable(lut)
        vertMapper.SelectColorArray('ExtBasis')
        vertMapper.Update()
        vertRange = vertMapper.GetInput().GetPointData().GetArray(vertMapper.GetArrayName()).GetRange()
        vertMapper.SetScalarRange(-1.0*vertRange[1], vertRange[1])
        vertActor = vtk.vtkActor()
        vertActor.SetMapper(vertMapper)
        
        outlineMapper = vtk.vtkPolyDataMapper()
        outlineMapper.SetScalarVisibility(False)
        outlineMapper.SetImmediateModeRendering(True)
        outlineMapper.SetInputConnection(vertGlyph.GetOutputPort())
        outlineActor = vtk.vtkActor()
        outlineActor.PickableOff()
        outlineActor.SetPosition(0, 0, -0.001)
        outlineActor.GetProperty().SetRepresentationToWireframe()
        outlineActor.SetMapper(outlineMapper)
        
        # Create an Actor Collection for applying visibility to group
        basisActorCollection = vtk.vtkActorCollection()
        basisActorCollection.AddItem(vertActor)
        # basisActorCollection.AddItem(edgeActor)
        basisActorCollection.AddItem(outlineActor)
        
        
        # Apply a theme to the views
        theme = vtk.vtkViewTheme.CreateMellowTheme()
        theme.SetLineWidth(3)
        theme.SetPointSize(5)
        theme.SetSelectedCellColor(1,1,1)
        theme.SetSelectedPointColor(1,1,1)
        theme.SetOutlineColor(0.8, 0.8, 0.8)
        # theme.SetPointColor(0.9, 0.7, 0.3)
        theme.SetCellColor(0.9, 0.7, 0.3)
        # theme.SetPointOpacity(0.5)
        # theme.SetPointHueRange(0.0, 0.15)
        # theme.SetPointSaturationRange(0.6, 0.8)
        # theme.SetPointValueRange(0.4,0.8)
        # theme.SetPointAlphaRange(0.2,0.8)
        # theme.SetPointAlphaRange(1.0,1.0)

        
        # Apply theme
        # vertActor.GetProperty().SetColor(theme.GetPointColor())
        # vertActor.GetProperty().SetOpacity(theme.GetPointOpacity())
        vertActor.GetProperty().SetPointSize(theme.GetPointSize())
        outlineActor.GetProperty().SetPointSize(vertActor.GetProperty().GetPointSize()+2)
        outlineActor.GetProperty().SetColor(theme.GetOutlineColor())
        outlineActor.GetProperty().SetOpacity(theme.GetPointOpacity())
        edgeActor.GetProperty().SetColor(theme.GetCellColor())
        edgeActor.GetProperty().SetOpacity(theme.GetCellOpacity())
        edgeActor.GetProperty().SetLineWidth(theme.GetLineWidth())
        
        
        # ----------
        # Background graph skeleton
        graphMapper = vtk.vtkGraphMapper()
        graphMapper.SetInputConnection(0, degree.GetOutputPort(0))
        
        # Apply a theme to the background graph
        gtheme = vtk.vtkViewTheme()
        gtheme.SetLineWidth(1)
        gtheme.SetPointSize(0)
        gtheme.SetCellColor(0.8, 0.8, 0.8)
        gtheme.SetCellOpacity(0.2)
        gtheme.SetOutlineColor(0.8, 0.8, 0.8)
        gtheme.SetPointColor(0.8, 0.8, 0.8)
        gtheme.SetPointOpacity(0.0)
        graphMapper.ApplyViewTheme(gtheme)

        graphActor = vtk.vtkActor()
        graphActor.SetMapper(graphMapper)
        graphActor.SetPosition(0,0,-0.005)
        
        # ----------
        # Background vertices
        graphPoly = vtk.vtkGraphToPolyData()
        graphPoly.SetInputConnection(0, tgraph.GetOutputPort(0))
        
        vertGlyph = vtk.vtkGlyph3D()
        vertGlyph.SetInputConnection(0, graphPoly.GetOutputPort())
        glyphSource = vtk.vtkGlyphSource2D()
        glyphSource.SetGlyphTypeToVertex()
        # glyphSource.SetGlyphTypeToCircle()
        # glyphSource.SetScale(0.025)
        vertGlyph.SetInputConnection(1, glyphSource.GetOutputPort())
        
        vertexMapper = vtk.vtkPolyDataMapper()
        vertexMapper.SetInputConnection(vertGlyph.GetOutputPort())
        vertexActor = vtk.vtkActor()
        vertexActor.SetMapper(vertexMapper)
        vertexActor.GetProperty().SetPointSize(4)
        vertexActor.GetProperty().SetOpacity(0.5)
        vertexActor.GetProperty().SetColor(0.6, 0.6, 0.6)
        vertexActor.SetPosition(0, 0, -0.004)
        
        # ----------
        # Vertex index labels
        labelMapper = vtk.vtkDynamic2DLabelMapper()
        labelMapper.SetInputConnection(0, graphPoly.GetOutputPort(0))
        labelMapper.SetLabelModeToLabelFieldData()
        labelMapper.SetFieldDataName("label")
        labelMapper.SetLabelFormat("%s")
        labelMapper.GetLabelTextProperty().SetColor(0.0, 0.0, 0.0)
        
        labelActor = vtk.vtkActor2D()
        labelActor.SetMapper(labelMapper)
        
        # ----------
        # MultiScale Graph
        msGraph = buildSubGraph(level) 
        
        msMapper = vtk.vtkGraphMapper()
        msMapper.SetInput(msGraph)
        msMapper.SetColorEdges(True)
        msMapper.SetEdgeColorArrayName('weight')
        
        # Apply a theme to the background graph
        mtheme = vtk.vtkViewTheme()
        mtheme.SetLineWidth(3)
        mtheme.SetPointSize(11)
        # mtheme.SetCellColor(0.5, 0.5, 0.7)
        # mtheme.SetCellOpacity(0.5)
        mtheme.SetOutlineColor(0.8, 0.8, 0.8)
        mtheme.SetPointColor(0.3, 0.3, 0.6)
        mtheme.SetPointOpacity(1.0)
        mtheme.SetCellHueRange(0.67, 0.67)
        mtheme.SetCellSaturationRange(0.6, 0.1)
        mtheme.SetCellValueRange(0.5,1.0)
        mtheme.SetCellAlphaRange(0.2,0.8)
        msMapper.ApplyViewTheme(mtheme)

        msActor = vtk.vtkActor()
        msActor.SetMapper(msMapper)
        msActor.SetPosition(0,0,-0.002)
        
        # ----------
        # Set up window and add actors        
        view.SetLayoutStrategyToPassThrough()
        # view.ApplyViewTheme(theme)                
        # view.SetupRenderWindow(win)
        view.GetRenderer().SetBackground(theme.GetBackgroundColor())
        view.GetRenderer().SetBackground2(theme.GetBackgroundColor2())
        view.GetRenderer().SetGradientBackground(True)
        view.GetRenderer().AddActor(vertActor)
        view.GetRenderer().AddActor(outlineActor)
        view.GetRenderer().AddActor(edgeActor)
        view.GetRenderer().AddActor(graphActor)
        view.GetRenderer().AddActor(vertexActor)
        view.GetRenderer().AddActor(labelActor)
        view.GetRenderer().AddActor(msActor)
        
        # ----------
        # General interactor
        isty = vtk.vtkInteractorStyleRubberBand2D()
        # RubberBand2D assumes/needs parallel projection ON
        view.GetRenderer().GetActiveCamera().ParallelProjectionOn()
        iren = view.GetRenderWindow().GetInteractor()
        iren.SetInteractorStyle(isty)        
        # Interactor style must be set before scalar bar can be shown
        # view.SetVertexScalarBarVisibility(True)

        sbActor = vtk.vtkScalarBarActor()
        sbActor.SetLookupTable(vertMapper.GetLookupTable())
        sbActor.SetTitle(vertMapper.GetArrayName())
        sbActor.SetNumberOfLabels(3)
        vertexScalarBar = vtk.vtkScalarBarWidget()
        vertexScalarBar.SetScalarBarActor(sbActor)
        vertexScalarBar.SetInteractor(iren)
        vertexScalarBar.SetDefaultRenderer(view.GetRenderer())
        vertexScalarBar.SetCurrentRenderer(view.GetRenderer())
        vertexScalarBar.SetEnabled(True)
        scalarBarRep = vertexScalarBar.GetRepresentation()
        scalarBarRep.SetOrientation(1)  # 0 = Horizontal, 1 = Vertical
        scalarBarRep.GetPositionCoordinate().SetValue(0.05,0.05)
        scalarBarRep.GetPosition2Coordinate().SetValue(0.15,0.25)
        
        # Adding it this way gets it to show up, but it's not interactive
        view.GetRenderer().AddActor(sbActor)
        view.ResetCamera()
        view.Render()
        
        # ----------
        # Add Actors to QListWidget to allow check and uncheck for visibility
        listItem0 = QtGui.QListWidgetItem()
        listItem0.setText('Index Labels')
        listItem0.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        labelActor.SetVisibility(0)
        listItem0.setCheckState(QtCore.Qt.Unchecked)
        # Put actor it in as data in the list widget item
        listItem0.setData(QtCore.Qt.UserRole, QtCore.QVariant(labelActor))
        ui_window.listWidget.insertItem(0,listItem0)
        
        # Test retrieval of actor from list widget item
        # tmpItem = ui_window.listWidget.item(0)
        # tmpQtActor = tmpItem.data(QtCore.Qt.UserRole)
        # tmpActor = tmpQtActor.toPyObject()
        # tmpActor.SetVisibility(0)
        
        # Shorter way to add item to list widget
        listItem1 = QtGui.QListWidgetItem('Vertices (background)', ui_window.listWidget)
        listItem1.setData(QtCore.Qt.UserRole, QtCore.QVariant(vertexActor))
        listItem1.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        listItem1.setCheckState(QtCore.Qt.Checked)

        listItem2 = QtGui.QListWidgetItem('Graph (background)', ui_window.listWidget)
        listItem2.setData(QtCore.Qt.UserRole, QtCore.QVariant(graphActor))
        listItem2.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        listItem2.setCheckState(QtCore.Qt.Checked)

        listItem3 = QtGui.QListWidgetItem()
        listItem3.setText('Basis Function Vertices')
        listItem3.setData(QtCore.Qt.UserRole, QtCore.QVariant(basisActorCollection))
        listItem3.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        listItem3.setCheckState(QtCore.Qt.Checked)
        ui_window.listWidget.insertItem(1,listItem3)
        
        listItem6 = QtGui.QListWidgetItem()
        listItem6.setText('Basis Function Edges')
        listItem6.setData(QtCore.Qt.UserRole, QtCore.QVariant(edgeActor))
        listItem6.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        listItem6.setCheckState(QtCore.Qt.Checked)
        ui_window.listWidget.insertItem(2,listItem6)
        
        listItem4 = QtGui.QListWidgetItem()
        listItem4.setText('MultiScale Graph')
        listItem4.setData(QtCore.Qt.UserRole, QtCore.QVariant(msActor))
        listItem4.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        listItem4.setCheckState(QtCore.Qt.Checked)
        ui_window.listWidget.insertItem(3,listItem4)
                
        listItem5 = QtGui.QListWidgetItem()
        listItem5.setText('Basis Function Scale Bar')
        listItem5.setData(QtCore.Qt.UserRole, QtCore.QVariant(sbActor))
        listItem5.setFlags(QtCore.Qt.ItemIsUserCheckable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable)
        listItem5.setCheckState(QtCore.Qt.Checked)
        ui_window.listWidget.insertItem(3,listItem5)
        
        iren.Initialize()
        iren.Start()
Exemplo n.º 21
-1
 def __init__(self):
     """
     Set a particular cursor for mapping channels for this electrode, and
     initialize actor collections and actor property lists
     """
     # Set the electrode placement cursor
     self.channelCursor = self.__CreateChannelRepresentationActor()
     self.channelCursor.GetProperty().SetColor(0, 1, 0)
     self.channelCursor.PickableOff()
     # Instantiate an collection for positioned channel actors
     self.channelActors = vtk.vtkActorCollection()
     # Instantiate a dictionary list to hold information mapped channel info
     self.channelInfo = []
     self.channelProperties = ['channelID',\
                               'x_coor',\
                               'y_coor',\
                               'z_coor',\
                               'red_px',\
                               'grn_px',\
                               'blu_px']