Python api.HasTraits類代碼示例

    def __init__(self, parent=None, manage_overlay=True, **traits):
        HasTraits.__init__(self, **traits)
        self.master_src # instantiates default master_src and blender
        self.func_man
        from xipy.vis.mayavi_widgets.overlay_blending import ImageBlendingComponent
        from xipy.vis.mayavi_widgets.overlay_thresholding_surface import OverlayThresholdingSurfaceComponent
        from xipy.vis.mayavi_widgets.cortical_surface import CorticalSurfaceComponent
        from xipy.vis.mayavi_widgets.translated_planes import TranslatedPlanes

        # set up components
        self.vis_helpers.append(
            ImageBlendingComponent(self, manage_overlay)
            )
        self.vis_helpers.append(
            TranslatedPlanes(self)
            )
        self.vis_helpers.append(
            OverlayThresholdingSurfaceComponent(self)
            )

        self.vis_helpers.append(
            CorticalSurfaceComponent(self)
            )
                        
        
        anat_alpha = np.ones(256)
        anat_alpha[:5] = 0
        self.blender.set(main_alpha=anat_alpha, trait_notify_change=False)
        self.__reposition_planes_after_interaction = False

 def __init__(self, source, **traits):
     HasTraits.__init__(self, **traits)
     nTs = self.time.shape[0]
     if isinstance(source, HasTraits):
         self.traited = True
         self.tracking = source.traits(track=True).keys()
         for attr in self.tracking:
             shape = (nTs,)
             if type(getattr(source, attr)) is _numpy.ndarray:
                 shape += getattr(source, attr).shape
             self.data[attr] = _numpy.zeros(shape, "d")
     else:
         if type(source) is type([]):
             self.tracking = source
             for var in source:
                 self.data[var] = _numpy.zeros((nTs,), "d")
             self._update = _copy(source)
         elif type(source) is type({}):
             self.tracking = source.keys()
             for var in self.tracking:
                 shape = (nTs,) + tuple(source[var])
                 self.data[var] = _numpy.zeros(shape, "d")
             self._update = _copy(self.tracking)
         else:
             raise TypeError, self.__class__.__doc__
     self.source = source

  def handle_arguments(self,*args,**kwargs): 
    HasTraits.__init__(self)		#magic by fnoble
    for a in args:
      if isinstance(a,Frame):
        self.parent=a
    for k,v in kwargs.items():
      if k == 'frame':
        self.parent=v
      elif k == 'T':
         if isinstance(v,Expression):
           self.T=v
         else:
           self.T=self.parent.variables.new_expression(v)
      elif len(self.trait_get(k))>0:
         #self.trait_set({k:v})
         self.__setattr__(k,v)
      elif len(self.actor.trait_get(k))>0:
         self.actor.__setattr__(k,v)
      elif len(self.properties.trait_get(k))>0:
         self.properties.__setattr__(k,v)
      elif len(self.source.trait_get(k))>0:
         self.source.__setattr__(k,v)
      else :
         print "unknown argument", k , v

    if not(self.parent):
      self.parent = WorldFrame()

    def __init__(self, fgcolor=(0.0, 0.0, 0.0), bgcolor=(1.0, 1.0, 1.0),
                 **traits):
        HasTraits.__init__(self, **traits)
        scene = self.scene.scene

        scene.foreground = fgcolor
        scene.background = bgcolor

 def _showerror_fired(self,evt):
     if self.tmodel.lastfitfailure:
         ex = self.tmodel.lastfitfailure
         dialog = HasTraits(s=ex.__class__.__name__+': '+str(ex))
         view = View(Item('s',style='custom',show_label=False),
                     resizable=True,buttons=['OK'],title='Fitting error message')
         dialog.edit_traits(view=view)

 def __init__(self, pos_data, **traits):
     """Required first argument is the 4-column data array from a Pos.p file
     """
     HasTraits.__init__(self, **traits)
     if not (pos_data[:,-1] == -99).all():
         valid = (pos_data[:,-1] != -99).nonzero()[0]
         pos_data = pos_data[valid]
     self.t, self.x, self.y, self.angle = pos_data.T

 def __init__(self, condition, avg_beams, stats_results, **traits):
     HasTraits.__init__(self, **traits)
     self._avg_dict = {}
     self.stats_results = stats_results
     
     for c, b in zip(condition, avg_beams):
         self._avg_beams.append(str(c))
         self._avg_dict[str(c)] = b

 def __init__(self, *args, **kw):
     HasTraits.__init__(self, *args, **kw)
     numpoints = 200
     plotdata = ArrayPlotData(x=sort(random(numpoints)), y=random(numpoints))
     plot = Plot(plotdata)
     plot.plot(("x", "y"), type="scatter")
     plot.tools.append(PanTool(plot))
     plot.overlays.append(ZoomTool(plot))
     self.plot = plot

    def __init__(self, **traits):
        HasTraits.__init__(self, **traits)
        self.engine_view = EngineView(engine=self.scene.engine)

        # Hook up the current_selection to change when the one in the engine
        # changes.  This is probably unnecessary in Traits3 since you can show
        # the UI of a sub-object in T3.
        self.scene.engine.on_trait_change(self._selection_change,
                                          'current_selection')

 def __init__ ( self, object, name, index, trait, value ):
     HasTraits.__init__( self )
     self.inited = False
     self.object = object
     self.name   = name
     self.index  = index
     if trait is not None:
         self.add_trait( 'value', trait )
         self.value  = value
     self.inited = True

 def __init__(self, *args, **kw):
     HasTraits.__init__(self, *args, **kw)
     # Create the data and the PlotData object
     x = linspace(-14, 14, 100)
     y = sin(x) * x**3
     plotdata = ArrayPlotData(x = x, y = y)
     # Create the scatter plot
     plot = Plot(plotdata)
     plot.plot(("x", "y"), type=self.plot_type, color="blue")
     plot.tools.append(PanTool(plot))
     plot.tools.append(ZoomTool(plot))
     self.plot = plot

    def __init__(self, **traits):
        HasTraits.__init__(self, **traits)
        
        try:
            if not path.exists(self.datadir):
                makedirs(self.datadir)
        except OSError:
            self.out('Reverting to base directory:\n%s'%ANA_DIR, error=True)
            self.datadir = ANA_DIR
        finally:
            self.datadir = path.abspath(self.datadir)

        self.out('%s initialized:\n%s'%(self.__class__.__name__, str(self)))

 def __init__(self, pmap, **traits):
     HasTraits.__init__(self, **traits)
     try:
         self.PMap = pmap
     except TraitError:
         self.out('PlaceMap subclass instance required', error=True)
         return
     self.fdata = self.PMap.get_field_data()
     self.udata = self.PMap.get_unit_data()
     self.add_trait('unit', Range(low=0, high=self.PMap.num_maps-1))
     self._update_unit_values()
     self.out('Bringing up place-map visualization...')
     self.view()
     self.out('Done!')

 def __init__(self, eval=None, label='Value',
              trait=None, min=0.0, max=1.0,
              initial=None, **traits):
     HasTraits.__init__(self, **traits)
     if trait is None:
         if min > max:
             min, max = max, min
         if initial is None:
             initial = min
         elif not (min <= initial <= max):
             initial = [min, max][
                 abs(initial - min) >
                 abs(initial - max)]
         trait = Range(min, max, value=initial)
     self.add_trait(label, trait)

 def __init__(self, *l, **kw):
     # TODO: implement aspect ratio maintaining
     HasTraits.__init__(self, *l, **kw)
     #self.plotdata = ArrayPlotData(x=self.pointsx, y=self.pointsy)
     plot = Plot(self.plotdata)
     plot.plot(("x", "y"))
     plot.plot(("x", "y"), type='scatter')
     
     plot.tools.append(PanTool(plot, drag_button='left'))
     plot.tools.append(ZoomTool(plot, tool_mode='box'))
     plot.tools.append(DragZoom(plot, tool_mode='box', drag_button='right'))
     plot.tools.append(CustomSaveTool(plot))#, filename='/home/pankaj/Desktop/file.png'))
     plot.tools.append(TraitsTool(plot))
     self.plot = plot
     self.set_plotdata()