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)
