class RGBA(traits.HasTraits): # r,g,b,a in the range 0-1 with default color 0,0,0,1 (black) r = traits.Range(0., 1., 0.) g = traits.Range(0., 1., 0.) b = traits.Range(0., 1., 0.) a = traits.Range(0., 1., 1.) def __init__(self, r=0., g=0., b=0., a=1.): self.r = r self.g = g self.b = b self.a = a def __repr__(self): return 'r,g,b,a = (%1.2f, %1.2f, %1.2f, %1.2f)'%\ (self.r, self.g, self.b, self.a)
class ExampleScene(TracerScene): source_y = t_api.Range(0., 5., 2.) source_z = t_api.Range(0., 5., 1.) def __init__(self): # The energy bundle we'll use for now: nrm = 1 / (N.sqrt(2)) direct = N.c_[[0, -nrm, nrm], [0, 0, -1]] position = N.tile(N.c_[[0, self.source_y, self.source_z]], (1, 2)) self.bund = RayBundle(vertices=position, directions=direct, energy=N.r_[1, 1]) # The assembly for ray tracing: rot1 = N.dot(G.rotx(N.pi / 4)[:3, :3], G.roty(N.pi)[:3, :3]) surf1 = rect_one_sided_mirror(width=10, height=10) surf1.set_rotation(rot1) surf2 = rect_one_sided_mirror(width=10, height=10) self.assembly = Assembly(objects=[surf1, surf2]) TracerScene.__init__(self, self.assembly, self.bund) @t_api.on_trait_change('_scene.activated') def initialize_camere(self): self._scene.mlab.view(0, -90) self._scene.mlab.roll(0) @t_api.on_trait_change('source_y, source_z') def bundle_move(self): position = N.tile(N.c_[[0, self.source_y, self.source_z]], (1, 2)) self.bund.set_vertices(position) self.plot_ray_trace() view = tui.View( tui.Item('_scene', editor=SceneEditor(scene_class=MayaviScene), height=400, width=300, show_label=False), tui.HGroup('-', 'source_y', 'source_z'))
class MTraitsNamespace: DPI = Float(72.) Alpha = traits.Range(0., 1., 0.) Affine = Trait(Affine()) AntiAliased = traits.true Color = Trait('black', ColorHandler()) DPI = Float(72.) Interval = Array('d', (2, ), npy.array([0.0, 1.0], npy.float_)) LineStyle = Trait('-', '--', '-.', ':', 'steps', None) LineWidth = Float(1.0) Marker = Trait(None, '.', ',', 'o', '^', 'v', '<', '>', 's', '+', 'x', 'd', 'D', '|', '_', 'h', 'H', 'p', '1', '2', '3', '4') MarkerSize = Float(6) Visible = traits.true
class Prop(tvtk_base.TVTKBase): def __init__(self, obj=None, update=1, **traits): tvtk_base.TVTKBase.__init__(self, vtk.vtkProperty, obj, update, **traits) edge_visibility = tvtk_base.false_bool_trait def _edge_visibility_changed(self, old_val, new_val): self._do_change(self._vtk_obj.SetEdgeVisibility, self.edge_visibility_) representation = traits.Trait( 'surface', tvtk_base.TraitRevPrefixMap({ 'points': 0, 'wireframe': 1, 'surface': 2 })) def _representation_changed(self, old_val, new_val): self._do_change(self._vtk_obj.SetRepresentation, self.representation_) opacity = traits.Trait(1.0, traits.Range(0.0, 1.0)) def _opacity_changed(self, old_val, new_val): self._do_change(self._vtk_obj.SetOpacity, self.opacity) specular_color = tvtk_base.vtk_color_trait((1.0, 1.0, 1.0)) def _specular_color_changed(self, old_val, new_val): self._do_change(self._vtk_obj.SetSpecularColor, self.specular_color, 1) diffuse_color = tvtk_base.vtk_color_trait((1.0, 1.0, 1.0)) def _diffuse_color_changed(self, old_val, new_val): self._do_change(self._vtk_obj.SetDiffuseColor, self.diffuse_color, 1) color = tvtk_base.vtk_color_trait((1.0, 1.0, 1.0)) def _color_changed(self, old_val, new_val): self._do_change(self._vtk_obj.SetColor, self.color) _updateable_traits_ = (('edge_visibility', 'GetEdgeVisibility'), ('opacity', 'GetOpacity'), ('specular_color', 'GetSpecularColor'), ('color', 'GetColor'), ('diffuse_color', 'GetDiffuseColor'), ('representation', 'GetRepresentation'))
class IntRangeFeature(traits.HasTraits): """ Defines a feature that is settable by slider """ value = traits.Range('low','high','value_') value_ = traits.CInt(0.) low = traits.CInt(-10000.) high = traits.CInt(10000.) is_settable = traits.Bool(False) id = traits.Property(depends_on = 'name') index = traits.Int(0) name = 'gain' view = ui.View(ui.Item('value', show_label = False, style = 'custom')) def _get_id(self): return _SINGLE_VALUED_FEATURES.get(self.name)
class DataAxis(t.HasTraits): name = t.Str() units = t.Str() scale = t.Float() offset = t.Float() size = t.Int() index_in_array = t.Int() low_value = t.Float() high_value = t.Float() value = t.Range('low_value', 'high_value') low_index = t.Int(0) high_index = t.Int() slice = t.Instance(slice) slice_bool = t.Bool(False) index = t.Range('low_index', 'high_index') axis = t.Array() def __init__(self, size, index_in_array, name='', scale=1., offset=0., units='undefined', slice_bool=False): super(DataAxis, self).__init__() self.name = name self.units = units self.scale = scale self.offset = offset self.size = size self.high_index = self.size - 1 self.low_index = 0 self.index = 0 self.index_in_array = index_in_array self.update_axis() self.on_trait_change(self.update_axis, ['scale', 'offset', 'size']) self.on_trait_change(self.update_value, 'index') self.on_trait_change(self.set_index_from_value, 'value') self.on_trait_change(self._update_slice, 'slice_bool') self.on_trait_change(self.update_index_bounds, 'size') self.slice_bool = slice_bool def __repr__(self): if self.name is not None: return self.name + ' index: ' + str(self.index_in_array) def update_index_bounds(self): self.high_index = self.size - 1 def update_axis(self): self.axis = generate_axis(self.offset, self.scale, self.size) self.low_value, self.high_value = self.axis.min(), self.axis.max() # self.update_value() def _update_slice(self, value): if value is True: self.slice = slice(None) else: self.slice = None def get_axis_dictionary(self): adict = { 'name': self.name, 'scale': self.scale, 'offset': self.offset, 'size': self.size, 'units': self.units, 'index_in_array': self.index_in_array, 'slice_bool': self.slice_bool } return adict def update_value(self): self.value = self.axis[self.index] def value2index(self, value): """Return the closest index to the given value if between the limits, otherwise it will return either the upper or lower limits Parameters ---------- value : float Returns ------- int """ if value is None: return None else: index = int(round((value - self.offset) / \ self.scale)) if self.size > index >= 0: return index elif index < 0: messages.warning("The given value is below the axis limits") return 0 else: messages.warning("The given value is above the axis limits") return int(self.size - 1) def index2value(self, index): return self.axis[index] def set_index_from_value(self, value): self.index = self.value2index(value) # If the value is above the limits we must correct the value self.value = self.index2value(self.index) def calibrate(self, value_tuple, index_tuple, modify_calibration=True): scale = (value_tuple[1] - value_tuple[0]) /\ (index_tuple[1] - index_tuple[0]) offset = value_tuple[0] - scale * index_tuple[0] if modify_calibration is True: self.offset = offset self.scale = scale else: return offset, scale traits_view = \ tui.View( tui.Group( tui.Group( tui.Item(name = 'name'), tui.Item(name = 'size', style = 'readonly'), tui.Item(name = 'index_in_array', style = 'readonly'), tui.Item(name = 'index'), tui.Item(name = 'value', style = 'readonly'), tui.Item(name = 'units'), tui.Item(name = 'slice_bool', label = 'slice'), show_border = True,), tui.Group( tui.Item(name = 'scale'), tui.Item(name = 'offset'), label = 'Calibration', show_border = True,), label = "Data Axis properties", show_border = True,), )
class pdf(TConfig): compression = T.Range(0, 9, 6) fonttype = T.Trait(3, 42) inheritcolor = T.false use14corefonts = T.false
class DeviceAnalogInState(traits.HasTraits): """encapsulate all (relevant) analog input state on the device Making these variables a member of their own HasTraits class means that updates to the device can be treated in an atomic way. """ # Analog input state AIN0_enabled = traits.Bool(False) AIN0_name = traits.String("AIN0") AIN1_enabled = traits.Bool(False) AIN1_name = traits.String("AIN1") AIN2_enabled = traits.Bool(True) AIN2_name = traits.String("AIN2") AIN3_enabled = traits.Bool(False) AIN3_name = traits.String("AIN3") trigger_device = traits.Instance('DeviceModel',transient=True) adc_prescaler = traits.Trait(128.0,{ 128.0:0x07,64.0: 0x06, # According to Atmel's at90usb1287 manual, faster than this is # too fast to get good measurements with 8MHz crystal. ## '32': 0x05,'16': 0x04,'8': 0x03, ## '4': 0x02,'2': 0x00, # also 0x01 }) downsample_bits = traits.Range(low=0,high=2**5-1,value=0) AIN_running = traits.Bool(False) sample_rate_total = traits.Property(label='Sample rate (Hz), all channels', depends_on=['adc_prescaler', 'trigger_device', 'downsample_bits']) sample_rate_chan = traits.Property(label='each channel', depends_on=['sample_rate_total', 'AIN0_enabled','AIN1_enabled', 'AIN2_enabled','AIN3_enabled',]) # but useful when plotting/saving data Vcc = traits.Float(3.3) traits_view = View(Group(Group(Item('AIN_running'), Item( 'Vcc', tooltip=('This does not set Vcc on the AT90USBKEY. Use to record the ' 'value of Vcc. (default = 3.3V)')), orientation='horizontal'), Group(Item('AIN0_enabled',padding=0), Item('AIN0_name',padding=0), Item('AIN1_enabled',padding=0), Item('AIN1_name',padding=0), padding=0, orientation='horizontal'), Group(Item('AIN2_enabled',padding=0), Item('AIN2_name',padding=0), Item('AIN3_enabled',padding=0), Item('AIN3_name',padding=0), padding=0, orientation='horizontal'), Group(Item('adc_prescaler'), Item('downsample_bits'), orientation='horizontal'), Group(Item('sample_rate_total', #show_label=False, style='readonly', ), Item('sample_rate_chan', #show_label=False, style='readonly', ), orientation='horizontal'), )) @traits.cached_property def _get_sample_rate_total(self): if self.trigger_device is not None: input_frequency = self.trigger_device.FOSC/self.adc_prescaler else: input_frequency = 100*1e3 # fake value # from USBKEY datasheet: if input_frequency < 50*1e3: warnings.warn('ADC sample frequency is too slow to get good sampling') if input_frequency > 200*1e3: warnings.warn('ADC sample frequency is too fast to get good sampling') #print 'input_frequency %.1f (kHz)'%(input_frequency/1000.0,) clock_cycles_per_sample = 13.0 clock_adc = input_frequency/clock_cycles_per_sample downsample_factor = self.downsample_bits+1 downsampled_clock_adc = clock_adc/downsample_factor return downsampled_clock_adc @traits.cached_property def _get_sample_rate_chan(self): n_chan = sum(map(int,[self.AIN0_enabled,self.AIN1_enabled, self.AIN2_enabled,self.AIN3_enabled])) if n_chan == 0: return 0.0 rate = self.sample_rate_total/float(n_chan) return rate
class pdf(TConfig): compression = T.Range(0, 9, 6) fonttype = T.Trait(3, 42)