def get_additional_group(self):
og = Group(Item('laser_controller', show_label=False,
editor=InstanceEditor(view='control_view'),
style='custom'),
label='Optics',
)
ac = Group(
og,
show_border=True,
label='Additional Controls',
layout='tabbed')
aclist = self.get_additional_controls()
if aclist is None:
og.label = 'Optics'
og.show_border = True
ac = og
else:
for ai in aclist:
ac.content.append(ai)
return ac
class House(HasTraits):
address = Str
bedrooms = Int
pool = Bool
price = Int
# View object designed to display two objects of class 'House'
comp_view = View(Group(Group(Item('h1.address', resizable=True),
Item('h1.bedrooms'),
Item('h1.pool'),
Item('h1.price'),
show_border=True),
Group(Item('h2.address', resizable=True),
Item('h2.bedrooms'),
Item('h2.pool'),
Item('h2.price'),
show_border=True),
orientation='horizontal'),
title='House Comparison')
# A pair of houses to demonstrate the View
house1 = House(address='4743 Dudley Lane',
bedrooms=3,
pool=False,
price=150000)
house2 = House(address='11604 Autumn Ridge',
bedrooms=3,
pool=True,
class MATS3DDesmorat(MATSBondSlipBase):
node_name = 'bond model: damage-plasticity'
'''Damage - plasticity model of bond.
'''
#-------------------------------------------------------------------------
# Material parameters
#-------------------------------------------------------------------------
E_m = tr.Float(16e+3,
label="E_m",
desc="Young's Modulus",
auto_set=False,
input=True)
E_b = tr.Float(19e+3,
label="E_b",
desc="Young's Modulus Bond",
auto_set=False,
input=True)
nu = tr.Float(0.2,
label='nu',
desc="Poison ratio",
auto_set=False,
input=True)
def _get_lame_m_params(self):
la = self.E_m * self.nu / ((1. + self.nu) * (1. - 2. * self.nu))
# second Lame parameter (shear modulus)
mu = self.E_m / (2. + 2. * self.nu)
return la, mu
D_m_abef = tr.Property(tr.Array, depends_on='+input')
@tr.cached_property
def _get_D_m_abef(self):
la = self._get_lame_m_params()[0]
mu = self._get_lame_m_params()[1]
delta = np.identity(3)
D_m_abef = (np.einsum(',ij,kl->ijkl', la, delta, delta) +
np.einsum(',ik,jl->ijkl', mu, delta, delta) +
np.einsum(',il,jk->ijkl', mu, delta, delta))
return D_m_abef
def _get_lame_b_params(self):
la = self.E_b * self.nu / ((1. + self.nu) * (1. - 2. * self.nu))
# second Lame parameter (shear modulus)
mu = self.E_b / (2. + 2. * self.nu)
return la, mu
D_b_abef = tr.Property(tr.Array, depends_on='+input')
@tr.cached_property
def _get_D_b_abef(self):
la = self._get_lame_b_params()[0]
mu = self._get_lame_b_params()[1]
delta = np.identity(3)
D_b_abef = (np.einsum(',ij,kl->ijkl', la, delta, delta) +
np.einsum(',ik,jl->ijkl', mu, delta, delta) +
np.einsum(',il,jk->ijkl', mu, delta, delta))
return D_b_abef
tree_node_list = List([])
gamma = Float(110,
label="Gamma",
desc="kinematic hardening modulus",
MAT=True,
symbol=r'\gamma',
unit='MPa/mm',
enter_set=True,
auto_set=False)
K = Float(130,
label="K",
desc="isotropic hardening modulus",
MAT=True,
symbol='K',
unit='MPa/mm',
enter_set=True,
auto_set=False)
S = Float(476e-6,
label="S",
desc="damage strength",
MAT=True,
symbol='S',
unit='MPa/mm',
enter_set=True,
auto_set=False)
tau_bar = Float(6,
label="Tau_0 ",
desc="yield stress",
symbol=r'\bar{\tau}',
unit='MPa',
MAT=True,
enter_set=True,
auto_set=False)
sv_names = [
'tau_e',
'tau',
'eps_pi',
'X'
'z',
'D',
'Y',
'eps_cum',
]
def get_next_state(self, eps, eps_pi, Y, D, z, X, tau_e, tau, g, eps_cum):
D_m = self.D_m_abef
D_b = self.D_b_abef
for i in range(len(s) - 1):
# trial stress - assuming elastic increment.
eps_diff = eps[i + 1] - eps_pi[i]
tau_trial = (np.einsum('ijkl,lk->ij', D_m, eps[i + 1]) *
(1. - D[i]) +
(np.einsum('ijkl,lk->ij', D_b, eps[i + 1])) *
(1. - D[i]) - np.einsum('ijkl,lk->ij', D_b,
eps_pi[i])) * (1. - D[i])
tau_e_trial = (np.einsum('ijkl,lk->ij', D_b, eps_diff))
norm = tau_e_trial - X[i]
f_trial = np.sqrt(np.einsum('nj,nj', norm,
norm)) - self.tau_bar - self.K * z[i]
if f_trial <= 0:
tau_e[i + 1] = tau_e_trial
tau[i + 1] = tau_trial
eps_pi[i + 1] = eps_pi[i]
z[i + 1] = z[i]
X[i + 1] = X[i]
D[i + 1] = D[i]
Y[i + 1] = Y[i]
g[i + 1] = g[i]
eps_cum[i + 1] = eps_cum[i]
# identify values beyond the elastic limit
else:
# identify values beyond the elastic limit
# sliding multiplier
delta_pi = f_trial / \
(self.E_b + (self.K + self.gamma) * (1. - D[i]))
# return mapping for isotropic and kinematic hardening
numerador = tau_e_trial - X[i]
norm = np.sqrt(np.einsum('nj,nj', numerador, numerador))
sign = numerador / norm
eps_pi[i + 1] = eps_pi[i] + delta_pi * sign
eps_cum[i + 1] = eps_cum[i] + delta_pi * \
np.einsum('ij,lk->ik', sign, sign)
Y[i + 1] = 0.5 * (np.einsum('ij,ijkl,lk', eps[i + 1], D_m, eps[i + 1])) + \
0.5 * (np.einsum('ij,ijkl,lk', eps_diff, D_b, eps_diff))
D_trial = D[i] + (Y[i + 1] / self.S) * delta_pi
if D[i] > 0.9:
break
else:
D[i + 1] = D_trial
g[i + 1] = g[i] + (1. - D[i + 1]) * delta_pi * sign
X[i + 1] = self.gamma * g[i + 1]
z[i + 1] = z[i] + delta_pi * (1. - D[i + 1])
# apply damage law to the effective stress
eps_diff = eps[i + 1] - eps_pi[i + 1]
tau[i + 1] = (np.einsum('ijkl,lk->ij', D_m, eps[i + 1]) *
(1. - D[i + 1]) +
(np.einsum('ijkl,lk->ij', D_b, eps[i + 1])) *
(1. - D[i + 1]) -
np.einsum('ijkl,lk->ij', D_b, eps_pi[i + 1])) * (
1. - D[i + 1])
tau_e[i + 1] = (np.einsum('ijkl,lk->ij', D_b, eps_diff))
# if tau[i, 0, 0] > 0:
# tau[i, 0, 0] = 0
# D[i] = 0
# s_cum = [i, 0, 0]
# break
return eps_pi, Y, D, z, X, tau_e, tau, g, eps_cum
traits_view = View(
Group(
VGroup(
Item('E_b', full_size=True, resizable=True),
Item('E_m'),
Item('gamma'),
Item('K'),
Item('S'),
Item('tau_bar'),
), ),
width=0.4,
height=0.8,
)
tree_view = traits_view
font = "Courier 10"
def __init__(self, **traits):
super(SegmentAdapter, self).__init__(**traits)
def _get_Segment_bg_color(self):
col = self.item.color
return col
from ..cluster_ui import ClusterEditor, ClusterAdapter
segment_editor_group = \
VGroup( Group(
Item("auto_aggregate"),
Item("render_segments"),
Item("render_tracks"),
),
Include("algorithm_widgets"),
Group(Item("segments",
name='segments',
editor=TabularEditor(
adapter=SegmentAdapter(),
editable=False),
height=400, width=200, show_label=False),
label="Segmentation Options",
show_border=True)
)
class SegmentationEditor(ClusterEditor):
class TwoPlots(HasTraits):
global numboards
data = Instance(AbstractPlotData)
normalize = False
p1 = Instance(Plot)
# set up appropriate view(s)
view = View( Item('p1', show_label=False, editor=ComponentEditor() ),
width=1000,
height=500,
resizable=True)
# print "TwoPlots numboards = ",numboards
if numboards==2:
plot2 = Instance(Plot)
view = View(Group(
Item('p1', show_label=False, editor=ComponentEditor() ),
Item('p2', show_label=False, editor=ComponentEditor() ),
),
width=1000,
height=600,
resizable=True)
# DATA INITIALIZATION STEP timer
startdata1 = np.zeros((2,Nsources*8),np.int32)
x = np.linspace(0, 1, 2)
data = ArrayPlotData(x=x, #need to be extended to y0-y63
y0=startdata1[:,0], y1=startdata1[:,1], y2=startdata1[:,2],
y3=startdata1[:,3], y4=startdata1[:,4], y5=startdata1[:,5],
y6=startdata1[:,6], y7=startdata1[:,7], y8=startdata1[:,8],
y9=startdata1[:,9], y10=startdata1[:,10], y11=startdata1[:,11],
y12=startdata1[:,12], y13=startdata1[:,13], y14=startdata1[:,14],
y15=startdata1[:,15], y16=startdata1[:,16], y17=startdata1[:,17],
y18=startdata1[:,18], y19=startdata1[:,19], y20=startdata1[:,20],
y21=startdata1[:,21], y22=startdata1[:,22], y23=startdata1[:,23],
y24=startdata1[:,24], y25=startdata1[:,25], y26=startdata1[:,26],
y27=startdata1[:,27], y28=startdata1[:,28], y29=startdata1[:,29],
y30=startdata1[:,30], y31=startdata1[:,31], y32=startdata1[:,32],
y33=startdata1[:,33], y34=startdata1[:,34], y35=startdata1[:,35],
y36=startdata1[:,36], y37=startdata1[:,37], y38=startdata1[:,38],
y39=startdata1[:,39], y40=startdata1[:,40], y41=startdata1[:,41],
y42=startdata1[:,42], y43=startdata1[:,43], y44=startdata1[:,44],
y45=startdata1[:,45], y46=startdata1[:,46], y47=startdata1[:,47],
y48=startdata1[:,48], y49=startdata1[:,49], y50=startdata1[:,50],
y51=startdata1[:,51], y52=startdata1[:,52], y53=startdata1[:,53],
y54=startdata1[:,54], y55=startdata1[:,55], y56=startdata1[:,56],
y57=startdata1[:,57], y58=startdata1[:,58], y59=startdata1[:,59],
y60=startdata1[:,60], y61=startdata1[:,61], y62=startdata1[:,62],
y63=startdata1[:,63])
# PLOT CREATION STEP
p1 = Plot(data)
plotchan = ['x','y0','y1','y2','y3','y4','y5','y6','y7','y8','y9','y10','y11','y12','y13','y14','y15','y16','y17',
'y18','y19','y20','y21','y22','y23','y24','y25','y26','y27','y28','y29','y30','y31','y32','y33','y34','y35',
'y36','y37','y38','y39','y40','y41','y42','y43','y44','y45','y46','y47','y48','y49','y50','y51','y52','y53',
'y54','y55','y56','y57','y58','y59','y60','y61','y62','y63']
p1.plot(plotchan,color_mapper=COLOR_PALETTE)
p1.padding_top = 5
p1.padding_bottom = 6 # hide xlabel
p1.padding_left = 40
p1.padding_right = 5
# color_mapper doesn't work so ... need to be extended to y0-y63
p1.plots['plot0'][0].color = 'blue'
p1.plots['plot0'][1].color = 'green'
p1.plots['plot0'][2].color = 'red'
p1.plots['plot0'][3].color = 'cyan'
p1.plots['plot0'][4].color = 'magenta'
p1.plots['plot0'][5].color = 'yellow'
p1.plots['plot0'][6].color = 'black'
p1.plots['plot0'][7].color = 'brown'
p1.plots['plot0'][8].color = 'blue'
p1.plots['plot0'][9].color = 'green'
p1.plots['plot0'][10].color = 'red'
p1.plots['plot0'][11].color = 'cyan'
p1.plots['plot0'][12].color = 'magenta'
p1.plots['plot0'][13].color = 'yellow'
p1.plots['plot0'][14].color = 'black'
p1.plots['plot0'][15].color = 'brown'
p1.plots['plot0'][16].color = 'blue'
p1.plots['plot0'][17].color = 'green'
p1.plots['plot0'][18].color = 'red'
p1.plots['plot0'][19].color = 'cyan'
p1.plots['plot0'][20].color = 'magenta'
p1.plots['plot0'][21].color = 'yellow'
p1.plots['plot0'][22].color = 'black'
p1.plots['plot0'][23].color = 'brown'
p1.plots['plot0'][24].color = 'blue'
p1.plots['plot0'][25].color = 'green'
p1.plots['plot0'][26].color = 'red'
p1.plots['plot0'][27].color = 'cyan'
p1.plots['plot0'][28].color = 'magenta'
p1.plots['plot0'][29].color = 'yellow'
p1.plots['plot0'][30].color = 'black'
p1.plots['plot0'][31].color = 'brown'
p1.plots['plot0'][32].color = 'blue'
p1.plots['plot0'][33].color = 'green'
p1.plots['plot0'][34].color = 'red'
p1.plots['plot0'][35].color = 'cyan'
p1.plots['plot0'][36].color = 'magenta'
p1.plots['plot0'][37].color = 'yellow'
p1.plots['plot0'][38].color = 'black'
p1.plots['plot0'][39].color = 'brown'
p1.plots['plot0'][40].color = 'blue'
p1.plots['plot0'][41].color = 'green'
p1.plots['plot0'][42].color = 'red'
p1.plots['plot0'][43].color = 'cyan'
p1.plots['plot0'][44].color = 'magenta'
p1.plots['plot0'][45].color = 'yellow'
p1.plots['plot0'][46].color = 'black'
p1.plots['plot0'][47].color = 'brown'
p1.plots['plot0'][48].color = 'blue'
p1.plots['plot0'][49].color = 'green'
p1.plots['plot0'][50].color = 'red'
p1.plots['plot0'][51].color = 'cyan'
p1.plots['plot0'][52].color = 'magenta'
p1.plots['plot0'][53].color = 'yellow'
p1.plots['plot0'][54].color = 'black'
p1.plots['plot0'][55].color = 'brown'
p1.plots['plot0'][56].color = 'blue'
p1.plots['plot0'][57].color = 'green'
p1.plots['plot0'][58].color = 'red'
p1.plots['plot0'][59].color = 'cyan'
p1.plots['plot0'][60].color = 'magenta'
p1.plots['plot0'][61].color = 'yellow'
p1.plots['plot0'][62].color = 'black'
p1.plots['plot0'][63].color = 'brown'
if normalize:
p1.value_range.set_bounds(0,1)
else:
p1.value_range.set_bounds(int_yscale_min,int_yscale_max)
class MayaviGrid(HasTraits):
''' This class is used to plot the data in a vlsv file as a mayavi grid The following will bring up a new window and plot the grid in the vlsv file:
.. code-block:: python
grid = pt.grid.MayaviGrid(vlsvReader=f, variable="rho", operator='pass', threaded=False)
Once you have the window open you can use the picker tool in the right-upper corner and use various point-click tools for analyzing data.
Picker options:
**None** Does nothing upon clicking somewhere in the grid
**Velocity_space** Plots the velocity space at a specific position upon clicking somewhere in the grid Note: If the vlsv file does not have the velocity space at the position where you are clicking, this will not work
**Velocity_space_iso_surface** Plots the velocity space at a specific position upon clicking somewhere in the grid in iso-surface plotting style Note: If the vlsv file does not have the velocity space at the position where you are clicking, this will not work
**Velocity_space_nearest_cellid** Plots the velocity space of the closest cell id to the picking point Note: If the vlsv file does not have velocity space saved at all, this will not work
**Velocity_space_nearest_cellid_iso_surface** Plots the velocity space of the closest cell id to the picking point in iso-surface plotting style Note: If the vlsv file does not have velocity space saved at all, this will not work
**Pitch_angle** Plots the pitch angle distribution at the clicking position Note: If the vlsv file does not have the velocity space at the position where you are clicking, this will not work
**Gyrophase_angle** Plots the gyrophase angle distribution at the clicking position Note: If the vlsv file does not have the velocity space at the position where you are clicking, this will not work
**Cut_through** Is used to plot or save the cut-through between two clicking points. This option requires you to use the args section at top-left. To use the args section to plot variables you must write for example: **plot rho B,x E,y** Upon clicking at two points a new window would open with a cut-through plot of rho, x-component of B and y-component of E Alternatively, you can save the cut-through to a variable in the MayaviGrid class by typing instead: **rho B,x E,y** and then going to the terminal and typing
.. code-block:: python
cut_through_data = grid.cut_through
print cut_through_data
'''
picker = Enum('None', "Velocity_space_nearest_cellid",
'Velocity_space_nearest_cellid_iso_surface', "Pitch_angle",
"Gyrophase_angle", "Cut_through", "Themis_detector",
"Themis_contour", "Themis_helistyle")
args = ""
variable_plotted = ""
labels = []
cut_through = []
plot = []
scene = Instance(MlabSceneModel, ())
engine_view = Instance(EngineView)
current_selection = Property
dataset = []
values = []
picker_functions = {}
# Define the view:
view = View(
HGroup(
Item('scene',
editor=SceneEditor(scene_class=MayaviScene),
height=250,
width=300,
show_label=False,
resizable=True),
Group(
#'cell_pick',
'picker',
'args',
show_labels=True),
),
resizable=True,
)
def __init__(self,
vlsvReader,
variable,
operator="pass",
threaded=False,
**traits):
''' Initializes the class and loads the mayavi grid
:param vlsvReader: Some vlsv reader with a file open
:type vlsvReader: :class:`vlsvfile.VlsvReader`
:param variable: Name of the variable
:param operator: Operator for the variable
:param threaded: Boolean value for using threads or not using threads to draw the grid (threads enable interactive mode)
'''
HasTraits.__init__(self, **traits)
self.vlsvReader = vlsvReader
self.engine_view = EngineView(engine=self.scene.engine)
self.__engine = self.scene.engine
self.__picker = []
self.__mins = []
self.__maxs = []
self.__cells = []
self.__last_pick = []
self.__grid_figure = mayavi.mlab.gcf(engine=self.__engine)
self.__structured_figures = []
self.__unstructured_figures = []
self.__thread = []
self.__load_grid(variable=variable,
operator=operator,
threaded=threaded)
self.values = []
self.variable_plotted = variable
def __module_manager(self):
import mayavi.core.module_manager as MM
module_manager = self.scene.mayavi_scene
# Find the module manager:
while (True):
module_manager = module_manager.children[0]
if type(module_manager) == type(MM.ModuleManager()):
break
return module_manager
def __add_label(self, cellid):
# Get spatial grid sizes:
xcells = (int)(self.vlsvReader.read_parameter("xcells_ini"))
ycells = (int)(self.vlsvReader.read_parameter("ycells_ini"))
zcells = (int)(self.vlsvReader.read_parameter("zcells_ini"))
xmin = self.vlsvReader.read_parameter("xmin")
ymin = self.vlsvReader.read_parameter("ymin")
zmin = self.vlsvReader.read_parameter("zmin")
xmax = self.vlsvReader.read_parameter("xmax")
ymax = self.vlsvReader.read_parameter("ymax")
zmax = self.vlsvReader.read_parameter("zmax")
dx = (xmax - xmin) / (float)(xcells)
dy = (ymax - ymin) / (float)(ycells)
dz = (zmax - zmin) / (float)(zcells)
# Add a point in the place:
cell_coordinates = self.vlsvReader.get_cell_coordinates(cellid)
x = [cell_coordinates[0]]
y = [cell_coordinates[1]]
z = [cell_coordinates[2]]
s = [(dx + dy + dx) / 3.0]
points = self.scene.mlab.points3d(x,
y,
z,
s,
scale_factor=3,
figure=self.__grid_figure,
reset_zoom=False)
def __add_normal_labels(self, point1, point2):
# Get spatial grid sizes:
xcells = (int)(self.vlsvReader.read_parameter("xcells_ini"))
ycells = (int)(self.vlsvReader.read_parameter("ycells_ini"))
zcells = (int)(self.vlsvReader.read_parameter("zcells_ini"))
xmin = self.vlsvReader.read_parameter("xmin")
ymin = self.vlsvReader.read_parameter("ymin")
zmin = self.vlsvReader.read_parameter("zmin")
xmax = self.vlsvReader.read_parameter("xmax")
ymax = self.vlsvReader.read_parameter("ymax")
zmax = self.vlsvReader.read_parameter("zmax")
dx = (xmax - xmin) / (float)(xcells)
dy = (ymax - ymin) / (float)(ycells)
dz = (zmax - zmin) / (float)(zcells)
# Get normal vector from point2 and point1
point1 = np.array(point1)
point2 = np.array(point2)
normal_vector = (point2 - point1) / np.linalg.norm(point2 - point1)
normal_vector = np.dot(rotation_matrix_2d(
-0.5 * np.pi), (point2 - point1)) / np.linalg.norm(point2 - point1)
normal_vector = normal_vector * np.array([1, 1, 0])
point1_shifted = point1 + 0.5 * (point2 -
point1) - normal_vector * (8 * dx)
point2_shifted = point1 + 0.5 * (point2 -
point1) + normal_vector * (8 * dx)
point1 = np.array(point1_shifted)
point2 = np.array(point2_shifted)
cellid1 = self.vlsvReader.get_cellid(point1)
cellid2 = self.vlsvReader.get_cellid(point2)
# Input label:
self.__add_label(cellid1)
self.__add_label(cellid2)
def __load_grid(self, variable, operator="pass", threaded=False):
''' Creates a grid and inputs scalar variables from a vlsv file
:param variable: Name of the variable to plot
:param operator: Operator for the variable
:param threaded: Boolean value for using threads or not using threads to draw the grid (threads enable interactive mode)
'''
# Get the cell params:
mins = np.array([
self.vlsvReader.read_parameter("xmin"),
self.vlsvReader.read_parameter("ymin"),
self.vlsvReader.read_parameter("zmin")
])
cells = np.array([
self.vlsvReader.read_parameter("xcells_ini"),
self.vlsvReader.read_parameter("ycells_ini"),
self.vlsvReader.read_parameter("zcells_ini")
])
maxs = np.array([
self.vlsvReader.read_parameter("xmax"),
self.vlsvReader.read_parameter("ymax"),
self.vlsvReader.read_parameter("zmax")
])
# Get the variables:
index_for_cellid_dict = self.vlsvReader.get_cellid_locations()
if isinstance(variable, str):
variable_array = self.vlsvReader.read_variable(name=variable,
operator=operator)
else:
variable_array = variable
# Sort the dictionary by cell id
import operator as oper
sorted_index_for_cellid_dict = sorted(
index_for_cellid_dict.iteritems(), key=oper.itemgetter(0))
# Add the variable values:
variable_array_sorted = []
for i in sorted_index_for_cellid_dict:
variable_array_sorted.append(variable_array[i[1]])
# Store the mins and maxs:
self.__mins = mins
self.__maxs = maxs
self.__cells = cells
# Draw the grid:
if threaded == True:
thread = threading.Thread(target=self.__generate_grid,
args=(mins, maxs, cells,
variable_array_sorted, variable))
thread.start()
else:
self.__generate_grid(mins=mins,
maxs=maxs,
cells=cells,
datas=variable_array_sorted,
names=variable)
def __picker_callback(self, picker):
""" This gets called when clicking on a cell
"""
if (self.picker != "Cut_through"):
# Make sure the last pick is null (used in cut_through)
self.__last_pick = []
coordinates = picker.pick_position
coordinates = np.array(
[coordinates[0], coordinates[1], coordinates[2]])
# Check for 2d
for i in xrange(3):
if self.__cells[i] == 1:
coordinates[i] = (self.__mins[i] + self.__maxs[i]) / 2.0
print "CLICKED COORDINATES:" + str(coordinates)
cellid = self.vlsvReader.get_cellid(coordinates)
print "CLICKED CELL ID: " + str(int(cellid))
# Check for an invalid cell id
if cellid == 0:
print "Invalid cell id"
return
args = self.args.split() # Split args field in the mayavi into a list
if (self.picker == "Velocity_space"):
# Set label to give out the location of the cell:
self.__add_label(cellid)
# Generate velocity space
self.__generate_velocity_grid(cellid)
elif (self.picker == "Velocity_space_nearest_cellid"):
# Find the nearest cell id with distribution:
# Read cell ids with velocity distribution in:
cell_candidates = self.vlsvReader.read(mesh="SpatialGrid",
tag="CELLSWITHBLOCKS")
# Read in the coordinates of the cells:
cell_candidate_coordinates = [
self.vlsvReader.get_cell_coordinates(cell_candidate)
for cell_candidate in cell_candidates
]
# Read in the cell's coordinates:
pick_cell_coordinates = self.vlsvReader.get_cell_coordinates(
cellid)
if len(cell_candidates) == 0:
print "No velocity distribution data found in this file!"
return
# Find the nearest:
from operator import itemgetter
norms = np.sum(
(cell_candidate_coordinates - pick_cell_coordinates)**2,
axis=-1)**(1. / 2)
norm, i = min((norm, idx) for (idx, norm) in enumerate(norms))
# Get the cell id:
cellid = cell_candidates[i]
print "PLOTTED CELL ID: " + str(cellid)
# Set label to give out the location of the cell:
self.__add_label(cellid)
# Generate velocity grid
self.__generate_velocity_grid(cellid)
elif (self.picker == "Velocity_space_iso_surface"):
# Set label to give out the location of the cell:
self.__add_label(cellid)
self.__generate_velocity_grid(cellid, True)
elif (self.picker == "Velocity_space_nearest_cellid_iso_surface"):
# Find the nearest cell id with distribution:
# Read cell ids with velocity distribution in:
cell_candidates = self.vlsvReader.read(mesh="SpatialGrid",
tag="CELLSWITHBLOCKS")
if len(cell_candidates) == 0:
print "No velocity distribution data found in this file!"
return
# Read in the coordinates of the cells:
cell_candidate_coordinates = [
self.vlsvReader.get_cell_coordinates(cell_candidate)
for cell_candidate in cell_candidates
]
# Read in the cell's coordinates:
pick_cell_coordinates = self.vlsvReader.get_cell_coordinates(
cellid)
# Find the nearest:
from operator import itemgetter
norms = np.sum(
(cell_candidate_coordinates - pick_cell_coordinates)**2,
axis=-1)**(1. / 2)
norm, i = min((norm, idx) for (idx, norm) in enumerate(norms))
# Get the cell id:
cellid = cell_candidates[i]
print "PLOTTED CELL ID: " + str(cellid)
# Set label to give out the location of the cell:
self.__add_label(cellid)
# Generate velocity grid
self.__generate_velocity_grid(cellid, True)
elif (self.picker == "Pitch_angle"):
# Find the nearest cell id with distribution:
# Read cell ids with velocity distribution in:
cell_candidates = self.vlsvReader.read(mesh="SpatialGrid",
tag="CELLSWITHBLOCKS")
if len(cell_candidates) == 0:
print "No velocity distribution data found in this file!"
return
# Read in the coordinates of the cells:
cell_candidate_coordinates = [
self.vlsvReader.get_cell_coordinates(cell_candidate)
for cell_candidate in cell_candidates
]
# Read in the cell's coordinates:
pick_cell_coordinates = self.vlsvReader.get_cell_coordinates(
cellid)
# Find the nearest:
from operator import itemgetter
norms = np.sum(
(cell_candidate_coordinates - pick_cell_coordinates)**2,
axis=-1)**(1. / 2)
norm, i = min((norm, idx) for (idx, norm) in enumerate(norms))
# Get the cell id:
cellid = cell_candidates[i]
print "PLOTTED CELL ID: " + str(cellid)
# Set label to give out the location of the cell:
self.__add_label(cellid)
# Plot pitch angle distribution:
from pitchangle import pitch_angles
result = pitch_angles(vlsvReader=self.vlsvReader,
cellid=cellid,
cosine=True,
plasmaframe=True)
# plot:
pl.hist(result[0].data, weights=result[1].data, bins=50, log=False)
pl.show()
elif (self.picker == "Gyrophase_angle"):
# Find the nearest cell id with distribution:
# Read cell ids with velocity distribution in:
cell_candidates = self.vlsvReader.read(mesh="SpatialGrid",
tag="CELLSWITHBLOCKS")
if len(cell_candidates) == 0:
print "No velocity distribution data found in this file!"
return
# Read in the coordinates of the cells:
cell_candidate_coordinates = [
self.vlsvReader.get_cell_coordinates(cell_candidate)
for cell_candidate in cell_candidates
]
# Read in the cell's coordinates:
pick_cell_coordinates = self.vlsvReader.get_cell_coordinates(
cellid)
# Find the nearest:
from operator import itemgetter
norms = np.sum(
(cell_candidate_coordinates - pick_cell_coordinates)**2,
axis=-1)**(1. / 2)
norm, i = min((norm, idx) for (idx, norm) in enumerate(norms))
# Get the cell id:
cellid = cell_candidates[i]
print "PLOTTED CELL ID: " + str(cellid)
# Set label to give out the location of the cell:
self.__add_label(cellid)
# Plot gyrophase angle distribution:
from gyrophaseangle import gyrophase_angles_from_file
result = gyrophase_angles_from_file(vlsvReader=self.vlsvReader,
cellid=cellid)
# plot:
pl.hist(result[0].data,
weights=result[1].data,
bins=36,
range=[-180.0, 180.0],
log=True,
normed=1)
pl.show()
elif (self.picker == "Cut_through"):
# Get the cut-through points
point1 = self.__last_pick
point2 = coordinates
if len(self.__last_pick) == 3:
from lineout import lineout
from variable import VariableInfo
if len(args) == 0:
#Do nothing
print "Bad args"
self.__last_pick = []
return
plotCut = False
# Optimize file read:
self.vlsvReader.optimize_open_file()
variables = []
distances = []
# Save variables
plotCut = False
for i in xrange(len(args)):
# Check if the user has given the plot argument
if args[i] == "plot":
plotCut = True
else:
# Get the name of the variable and its operator as given by the user
if args[i].find(",") != -1:
_variable = args[i].split(',')[0]
_operator = args[i].split(',')[1]
else:
_variable = args[i]
_operator = "pass"
# Get the lineout
line = lineout(self.vlsvReader,
point1,
point2,
_variable,
operator=_operator,
interpolation_order=1,
points=1000)
distance = line[0]
coordinates = line[1]
values = line[2]
variables.append(
VariableInfo(values,
name=_variable + " "
" " + _operator,
units=""))
distances.append(
VariableInfo(distance, name="distance", units="m"))
self.cut_through.append(values)
if plotCut == True:
# Add also streamline
self.draw_streamline(point1, point2)
from plot import plot_multiple_variables
fig = plot_multiple_variables(distances,
variables,
figure=[])
pl.show()
# Close the optimized file read:
self.vlsvReader.optimize_close_file()
# Read in the necessary variables:
self.__last_pick = []
else:
self.__last_pick = coordinates
elif (self.picker == "Themis_detector"):
# Parse args: Spacecraft detector axis
if len(args) == 0:
detectoraxis = np.array([0, 1, 0])
else:
detectoraxis = np.array(
[float(args[0]),
float(args[1]),
float(args[2])])
# Find the nearest cell id with distribution:
# Read cell ids with velocity distribution in:
cell_candidates = self.vlsvReader.read(mesh="SpatialGrid",
tag="CELLSWITHBLOCKS")
if len(cell_candidates) == 0:
print "No velocity distribution data found in this file!"
return
# Read in the coordinates of the cells:
cell_candidate_coordinates = [
self.vlsvReader.get_cell_coordinates(cell_candidate)
for cell_candidate in cell_candidates
]
# Read in the cell's coordinates:
pick_cell_coordinates = self.vlsvReader.get_cell_coordinates(
cellid)
# Find the nearest:
from operator import itemgetter
norms = np.sum(
(cell_candidate_coordinates - pick_cell_coordinates)**2,
axis=-1)**(1. / 2)
norm, i = min((norm, idx) for (idx, norm) in enumerate(norms))
# Get the cell id:
cellid = cell_candidates[i]
print "PLOTTED CELL ID: " + str(cellid)
# Set label to give out the location of the cell:
self.__add_label(cellid)
# Plot pitch angle distribution:
from themis_observation import themis_plot_detector
themis_plot_detector(self.vlsvReader, cellid, detectoraxis)
elif (self.picker == "Themis_contour"):
# Find the nearest cell id with distribution:
# Read cell ids with velocity distribution in:
cell_candidates = self.vlsvReader.read(mesh="SpatialGrid",
tag="CELLSWITHBLOCKS")
if len(cell_candidates) == 0:
print "No velocity distribution data found in this file!"
return
# Read in the coordinates of the cells:
cell_candidate_coordinates = [
self.vlsvReader.get_cell_coordinates(cell_candidate)
for cell_candidate in cell_candidates
]
# Read in the cell's coordinates:
pick_cell_coordinates = self.vlsvReader.get_cell_coordinates(
cellid)
# Find the nearest:
from operator import itemgetter
norms = np.sum(
(cell_candidate_coordinates - pick_cell_coordinates)**2,
axis=-1)**(1. / 2)
norm, i = min((norm, idx) for (idx, norm) in enumerate(norms))
# Get the cell id:
cellid = cell_candidates[i]
print "PLOTTED CELL ID: " + str(cellid)
# Parse args: Plotting plane
plane = [np.array([1., 0, 0]), np.array([0, 1., 0])]
labels = ["Vx", "Vy"]
for i in range(len(args)):
if args[i] == "x":
plane[i] = np.array([1., 0, 0])
labels[i] = "Vx"
if args[i] == "y":
plane[i] = np.array([0, 1., 0])
labels[i] = "Vy"
if args[i] == "z":
plane[i] = np.array([0, 0, 1.])
labels[i] = "Vz"
if args[i] == "B":
B = self.vlsvReader.read_variable("B", cellid)
plane[i] = B
labels[i] = "V||B"
if args[i] == "v":
v = self.vlsvReader.read_variable("v", cellid)
plane[i] = v
labels[i] = "V_perp, direction of V_bulk"
if args[i] == "Bxv":
v = self.vlsvReader.read_variable("v", cellid)
B = self.vlsvReader.read_variable("B", cellid)
plane[i] = np.cross(B, v)
labels[i] = "V_perp, direction of B x V"
print(
"Getting data from nearest velocity space cell with cellid " +
str(cellid))
# Set label to give out the location of the cell:
self.__add_label(cellid)
from themis_observation import themis_plot_phasespace_contour
themis_plot_phasespace_contour(self.vlsvReader,
cellid,
plane[0],
plane[1],
xlabel=labels[0],
ylabel=labels[1])
elif (self.picker == "Themis_helistyle"):
# Find the nearest cell id with distribution:
# Read cell ids with velocity distribution in:
cell_candidates = self.vlsvReader.read(mesh="SpatialGrid",
tag="CELLSWITHBLOCKS")
if len(cell_candidates) == 0:
print "No velocity distribution data found in this file!"
return
# Read in the coordinates of the cells:
cell_candidate_coordinates = [
self.vlsvReader.get_cell_coordinates(cell_candidate)
for cell_candidate in cell_candidates
]
# Read in the cell's coordinates:
pick_cell_coordinates = self.vlsvReader.get_cell_coordinates(
cellid)
# Find the nearest:
from operator import itemgetter
norms = np.sum(
(cell_candidate_coordinates - pick_cell_coordinates)**2,
axis=-1)**(1. / 2)
norm, i = min((norm, idx) for (idx, norm) in enumerate(norms))
# Get the cell id:
cellid = cell_candidates[i]
print "PLOTTED CELL ID: " + str(cellid)
# Parse args: Plotting plane
plane = [np.array([1., 0, 0]), np.array([0, 1., 0])]
labels = ["Vx", "Vy"]
for i in range(len(args)):
if args[i] == "x":
plane[i] = np.array([1., 0, 0])
labels[i] = "Vx"
if args[i] == "y":
plane[i] = np.array([0, 1., 0])
labels[i] = "Vy"
if args[i] == "z":
plane[i] = np.array([0, 0, 1.])
labels[i] = "Vz"
if args[i] == "B":
B = self.vlsvReader.read_variable("B", cellid)
plane[i] = B
labels[i] = "V||B"
if args[i] == "v":
v = self.vlsvReader.read_variable("v", cellid)
plane[i] = v
labels[i] = "V_perp, direction of V_bulk"
if args[i] == "Bxv":
v = self.vlsvReader.read_variable("v", cellid)
B = self.vlsvReader.read_variable("B", cellid)
plane[i] = np.cross(B, v)
labels[i] = "V_perp, direction of B x V"
print(
"Getting data from nearest velocity space cell with cellid " +
str(cellid))
# Set label to give out the location of the cell:
self.__add_label(cellid)
from themis_observation import themis_plot_phasespace_helistyle
themis_plot_phasespace_helistyle(self.vlsvReader,
cellid,
plane[0],
plane[1],
xlabel=labels[0],
ylabel=labels[1])
elif self.picker in self.picker_functions:
# Call the corresponding pickerfunction
self.picker_functions[self.picker](self, self.vlsvReader,
coordinates, args)
def draw_streamline(self, x0, x1):
''' Draws a line from x0 to x1 coordinates
'''
self.scene.mlab.plot3d([x0[0], x1[0]], [x0[1], x1[1]],
[x0[2] + 4.0e5, x1[2] + 4.0e5],
tube_radius=3.0e5)
return
def draw_streamline_long(self, list_of_coordinates):
''' Draws a set of lines as given by list of coordinates
'''
self.scene.mlab.plot3d(list_of_coordinates[0],
list_of_coordinates[1],
list_of_coordinates[2] +
np.ones(len(list_of_coordinates[2])) * 4e5,
tube_radius=1.0e5)
return
def __generate_grid(self, mins, maxs, cells, datas, names):
''' Generates a grid from given data
:param mins: An array of minimum coordinates for the grid for ex. [-100, 0, 0]
:param maxs: An array of maximum coordinates for the grid for ex. [-100, 0, 0]
:param cells: An array of number of cells in x, y, z direction
:param datas: Scalar data for the grid e.g. array([ cell1Rho, cell2Rho, cell3Rho, cell4Rho, .., cellNRho ])
:param names: Name for the scalar data
'''
# Create nodes
x, y, z = mgrid[mins[0]:maxs[0]:(cells[0] + 1) * complex(0, 1),
mins[1]:maxs[1]:(cells[1] + 1) * complex(0, 1),
mins[2]:maxs[2]:(cells[2] + 1) * complex(0, 1)]
# Create points for the nodes:
pts = empty(z.shape + (3, ), dtype=float)
pts[..., 0] = x
pts[..., 1] = y
pts[..., 2] = z
# Input scalars
scalars = np.array(datas)
# We reorder the points, scalars and vectors so this is as per VTK's
# requirement of x first, y next and z last.
pts = pts.transpose(2, 1, 0, 3).copy()
pts.shape = pts.size / 3, 3
scalars = scalars.T.copy()
# Create the dataset.
sg = tvtk.StructuredGrid(dimensions=x.shape, points=pts)
sg.cell_data.scalars = ravel(scalars.copy())
if isinstance(names, str) == False:
names = "custom"
sg.cell_data.scalars.name = names
# Visualize the data
d = self.scene.mlab.pipeline.add_dataset(sg)
iso = self.scene.mlab.pipeline.surface(d)
# Add labels:
# from mayavi.modules.labels import Labels
# testlabels = self.scene.mlab.pipeline.labels(d)
self.dataset = d
print scalars[0]
# Configure traits
self.configure_traits()
self.__grid_figure = mayavi.mlab.gcf(engine=self.__engine)
# Note: This is not working properly -- it seemingly works out at first but it eventually causes segmentation faults in some places
#self.__thread = threading.Thread(target=self.configure_traits, args=())
#self.__thread.start()
def __generate_velocity_grid(self, cellid, iso_surface=False):
'''Generates a velocity grid from a given spatial cell id
:param cellid: The spatial cell's ID
:param iso_surface: If true, plots the iso surface
'''
# Create nodes
# Get velocity blocks and avgs:
blocksAndAvgs = self.vlsvReader.read_blocks(cellid)
if len(blocksAndAvgs) == 0:
print "CELL " + str(cellid) + " HAS NO VELOCITY BLOCK"
return False
# Create a new scene
self.__engine.new_scene()
mayavi.mlab.set_engine(self.__engine) #CONTINUE
# Create a new figure
figure = mayavi.mlab.gcf(engine=self.__engine)
figure.scene.disable_render = True
blocks = blocksAndAvgs[0]
avgs = blocksAndAvgs[1]
# Get nodes:
nodesAndKeys = self.vlsvReader.construct_velocity_cell_nodes(blocks)
# Create an unstructured grid:
points = nodesAndKeys[0]
tets = nodesAndKeys[1]
tet_type = tvtk.Voxel().cell_type #VTK_VOXEL
ug = tvtk.UnstructuredGrid(points=points)
# Set up the cells
ug.set_cells(tet_type, tets)
# Input data
values = np.ravel(avgs)
ug.cell_data.scalars = values
ug.cell_data.scalars.name = 'avgs'
# Plot B if possible:
# Read B vector and plot it:
if self.vlsvReader.check_variable("B") == True:
B = self.vlsvReader.read_variable(name="B", cellids=cellid)
elif self.vlsvReader.check_variable("B_vol") == True:
B = self.vlsvReader.read_variable(name="B_vol", cellids=cellid)
else:
B = self.vlsvReader.read_variable(
name="background_B",
cellids=cellid) + self.vlsvReader.read_variable(
name="perturbed_B", cellids=cellid)
points2 = np.array([[0, 0, 0]])
ug2 = tvtk.UnstructuredGrid(points=points2)
ug2.point_data.vectors = [B / np.linalg.norm(B)]
ug2.point_data.vectors.name = 'B_vector'
#src2 = VTKDataSource(data = ug2)
d2 = mayavi.mlab.pipeline.add_dataset(ug2)
#mayavi.mlab.add_module(Vectors())
vec = mayavi.mlab.pipeline.vectors(d2)
vec.glyph.mask_input_points = True
vec.glyph.glyph.scale_factor = 1e6
vec.glyph.glyph_source.glyph_source.center = [0, 0, 0]
# Visualize
d = mayavi.mlab.pipeline.add_dataset(ug)
if iso_surface == False:
iso = mayavi.mlab.pipeline.surface(d)
else:
ptdata = mayavi.mlab.pipeline.cell_to_point_data(d)
iso = mayavi.mlab.pipeline.iso_surface(
ptdata, contours=[1e-15, 1e-14, 1e-12], opacity=0.3)
figure.scene.disable_render = False
self.__unstructured_figures.append(figure)
# Name the figure
figure.name = str(cellid) + ", " + self.variable_plotted + " = " + str(
self.vlsvReader.read_variable(self.variable_plotted,
cellids=cellid))
from mayavi.modules.axes import Axes
axes = Axes()
axes.name = 'Axes'
axes.axes.fly_mode = 'none'
axes.axes.number_of_labels = 8
axes.axes.font_factor = 0.5
#module_manager = self.__module_manager()
# Add the label / marker:
self.__engine.add_filter(axes)
from mayavi.modules.outline import Outline
outline = Outline()
outline.name = 'Outline'
self.__engine.add_filter(outline)
return True
def generate_diff_grid(self, cellid1, cellid2):
''' Generates a diff grid of given cell ids (shows avgs diff)
:param cellid1: The first cell id
:param cellid2: The second cell id
.. code-block:: python
# Example:
grid.generate_diff_grid( 29219, 2910 )
.. note:: If the cell id does not have a certain velocity cell, it is assumed that the avgs value of that cell is 0
'''
# Create nodes
# Get velocity blocks and avgs (of cellid 1)
blocksAndAvgs1 = self.vlsvReader.read_blocks(cellid1)
if len(blocksAndAvgs1) == 0:
print "CELL " + str(cellid1) + " HAS NO VELOCITY BLOCK"
return False
blocks1 = blocksAndAvgs1[0]
avgs1 = blocksAndAvgs1[1]
# Get velocity blocks and avgs (of cellid 2)
blocksAndAvgs2 = self.vlsvReader.read_blocks(cellid2)
if len(blocksAndAvgs2) == 0:
print "CELL " + str(cellid2) + " HAS NO VELOCITY BLOCK"
return False
blocks2 = blocksAndAvgs2[0]
avgs2 = blocksAndAvgs2[1]
print len(avgs2)
print len(blocks2)
# Compare blocks and create a new avgs array values:
avgs_same = []
avgs_cellid1 = []
avgs_cellid2 = []
blocks_same = []
blocks_cellid1 = []
blocks_cellid2 = []
print np.shape(avgs1[0])
for i in xrange(len(blocks1)):
b = blocks1[i]
# Get index of block
i2 = np.where(blocks2 == b)[0]
if len(i2) != 0:
# Fetch the block:
#print avgs1[64*i:64*(i+1)]
#print avgs2[64*i2[0]:64*(i2[0]+1)]
avgs_same.append(avgs1[i:(i + 1)] - avgs2[i2[0]:(i2[0] + 1)])
blocks_same.append(b)
else:
avgs_cellid1.append(avgs1[i:(i + 1)])
blocks_cellid1.append(b)
for i in xrange(len(blocks2)):
b = blocks2[i]
if (b in blocks1) == False:
avgs_cellid2.append(avgs2[i:(i + 1)])
blocks_cellid2.append(b)
# Make a list for the avgs etc
avgs = np.zeros(
64 * (len(avgs_same) + len(avgs_cellid1) + len(avgs_cellid2)))
#avgs = np.reshape(avgs, (len(avgs_same)+len(avgs_cellid1)+len(avgs_cellid2), 64))
print np.shape(avgs_same)
blocks = np.zeros(
len(blocks_same) + len(blocks_cellid1) + len(blocks_cellid2))
index = 0
avgs[64 * index:64 * (index + len(blocks_same))] = np.ravel(
np.array(avgs_same))
blocks[index:index + len(blocks_same)] = np.array(blocks_same)
index = index + len(blocks_same)
avgs[64 * index:64 * (index + len(blocks_cellid1))] = np.ravel(
np.array(avgs_cellid1))
blocks[index:index + len(blocks_cellid1)] = np.array(blocks_cellid1)
index = index + len(blocks_cellid1)
avgs[64 * index:64 * (index + len(blocks_cellid2))] = np.ravel(
np.array(avgs_cellid2))
blocks[index:index + len(blocks_cellid2)] = np.array(blocks_cellid2)
blocks = blocks.astype(int)
# Get nodes:
nodesAndKeys = self.vlsvReader.construct_velocity_cell_nodes(blocks)
# Create an unstructured grid:
points = nodesAndKeys[0]
tets = nodesAndKeys[1]
# Create a new scene
self.__engine.new_scene()
mayavi.mlab.set_engine(self.__engine) #CONTINUE
# Create a new figure
figure = mayavi.mlab.gcf(engine=self.__engine)
figure.scene.disable_render = True
tet_type = tvtk.Voxel().cell_type #VTK_VOXEL
ug = tvtk.UnstructuredGrid(points=points)
#Thissetsupthecells.
ug.set_cells(tet_type, tets)
#Attributedata.
values = np.ravel(avgs)
ug.cell_data.scalars = values
ug.cell_data.scalars.name = 'avgs'
d = mayavi.mlab.pipeline.add_dataset(ug)
iso = mayavi.mlab.pipeline.surface(d)
figure.scene.disable_render = False
self.__unstructured_figures.append(figure)
# Name the figure
figure.name = str(cellid1) + " " + str(cellid2)
mayavi.mlab.show()
return True
def __do_nothing(self, picker):
return
# Trait events:
@on_trait_change('scene.activated')
def set_mouse_click(self):
# Temporary bug fix (MayaVi needs a dummy pick to be able to remove cells callbacks from picker.. )
#self.figure.on_mouse_pick( self.__do_nothing, type='world'
self.figure = self.scene.mlab.gcf()
# Cell picker
func = self.__picker_callback
typeid = 'world'
click = 'Left'
picker = self.figure.on_mouse_pick(func, type='world')
self.__picker = [func, typeid, click]
#picker.tolerance = 0
# Show legend bar
manager = self.figure.children[0].children[0]
manager.scalar_lut_manager.show_scalar_bar = True
manager.scalar_lut_manager.show_legend = True
class MandelbrotDemo(HasTraits):
color_maps = List
current_map = Str("Blues_r")
loc_info = Str
figure = Instance(Figure)
N = Int(100)
R = Float(10)
cx = Float(0)
cy = Float(0)
d = Float(1.5)
view = View(VGroup(
HGroup(Item("current_map",
label=u"Color map",
editor=EnumEditor(name="object.color_maps")),
"R",
"N",
show_labels=True),
Item("loc_info", show_label=False, style="readonly"),
Group(Item("figure", editor=MPLFigureEditor(toolbar=False)),
show_labels=False,
orientation='horizontal')),
width=SIZE,
height=SIZE + 80,
title=u"Mandelbrot Demo",
resizable=True)
def __init__(self, **kw):
super(MandelbrotDemo, self).__init__(**kw)
self.array = np.zeros((SIZE, SIZE))
self.img = self.figure.figimage(self.array, cmap=self.current_map)
def _figure_default(self):
return Figure(figsize=(SIZE / 100.0, SIZE / 100.0), dpi=100)
def _color_maps_default(self):
return sorted(cm.cmap_d.keys())
def init_plot(self):
self.figure.canvas.mpl_connect('button_press_event', self.on_press)
self.figure.canvas.mpl_connect('motion_notify_event', self.on_move)
self.figure.canvas.mpl_connect('scroll_event', self.on_scroll)
self.update_plot()
def _current_map_changed(self):
self.img.set_cmap(self.current_map)
self.update_plot()
@on_trait_change("R, N")
def update_plot(self):
mandelbrot(self.cx,
self.cy,
self.d,
out=self.array,
n=self.N,
R=self.R)
self.loc_info = "%g, %g, d=%g" % (self.cx, self.cy, self.d)
self.img.set_data(self.array)
self.figure.canvas.draw()
def on_press(self, evt):
if evt.button == 1:
self.last_pos = evt.x, evt.y, self.cx, self.cy
def on_move(self, evt):
if evt.button != 1:
return
x, y, cx, cy = self.last_pos
dx = (x - evt.x) * 2 * self.d / SIZE
dy = (evt.y - y) * 2 * self.d / SIZE
self.cx = cx + dx
self.cy = cy + dy
self.update_plot()
def on_scroll(self, evt):
x0, x1, y0, y1 = self.cx - self.d, self.cx + self.d, self.cy - self.d, self.cy + self.d
x = x0 + float(evt.x) / SIZE * 2 * self.d
y = y0 + float(SIZE - evt.y) / SIZE * 2 * self.d
if evt.step < 0:
d2 = self.d * 1.2
else:
d2 = self.d / 1.2
scale = d2 / self.d
self.cx = (2 * x + (x0 + x1 - 2 * x) * scale) / 2
self.cy = (2 * y + (y0 + y1 - 2 * y) * scale) / 2
self.d = d2
self.update_plot()
def traits_view(self):
grp = Group(Item('server_username', label='Username'),
Item('server_password', label='Password'),
label='SMTP')
v = View(grp)
return v
def traits_view(self):
grps = self.get_additional_groups()
v = View(Group(*grps, layout='tabbed'))
return v
class SpectralConverter(HasTraits):
h = float(6.626068 * 10**-34) # m**2 kg / s
eVtoJ = float(1.60217646 * 10**-19) #Number of Joules in one Ev
c = float(299792458) #speed of light m/
Units = Trait(
'Meters',
{
'Meters': 1.0,
'Centimeters': .01,
'Micrometers': .000001,
'Nanometers': .000000001, #DEFINE RELATIVE TO METERS
'eV': h * c /
(eVtoJ), #RECIPROCAL UNITS (THESE ARE INVERTED BELOW)
'cm-1': .01,
'Wavenumber(nm-1)':
.000000001, #WAVENUMBER IS INVERSE WAVELENGTH IN NM
'Frequency(Hz)': c, #SIMPLY INVERTED
'Angular Frequency(rad)': 2.0 * pi * c
})
proportional = ['Meters', 'Nanometers', 'Centimeters',
'Micrometers'] #proportional to distance
reciprocal = [
'cm-1', 'eV', 'Wavenumber(nm-1)', 'Frequency(Hz)',
'Angular Frequency(rad)'
] #Inverse to distance (aka energy is recicprocal E=hc/lam)s
input_array = Array() #Set on initialization
input_units = Units() #Set on initialization
output_array = Property(
Array, depends_on=['input_array', 'input_units', 'output_units'])
output_units = Units() #Default unit
valid_units = Property(
List,
depends_on='proportional, reciprocal') #All valid units in the system
xstart = Property(Float, depends_on='input_array')
xend = Property(Float, depends_on='input_array')
xnewstart = Property(Float, depends_on='output_array')
xnewend = Property(Float, depends_on='output_array')
traits_view = View(VSplit(
Group(
HSplit(Item('xstart', label='Old Spectral Min', style='readonly'),
Item('xend', label='Old Spectral Max', style='readonly'),
Item('input_units', style='simple', label='Input Units'))),
Group(
HSplit(
Item('xnewstart', label='New Spectral Min', style='readonly'),
Item('xnewend', label='New Spectral Max', style='readonly'),
Item('output_units', label='Output Units')), )),
kind='modal',
buttons=['Undo', 'OK', 'Cancel', 'Help'],
height=500,
width=500,
resizable=True)
def _get_xstart(self):
return self.input_array[0]
def _get_xend(self):
return self.input_array[-1]
def _get_xnewstart(self):
return self.output_array[0]
def _get_xnewend(self):
return self.output_array[-1]
def _get_valid_units(self):
return self.proportional + self.reciprocal
def specific_array(self, new_unit):
"""Return a unit-converted array without changing current settings"""
if new_unit not in self.valid_units:
raise ConversionError('Invalid spectral unit: %s' % new_unit)
# Temporarily change outunit, send, return it back
old_unit = self.output_units
self.output_units = new_unit
specificarray = self.output_array #propety so not copied
self.output_units = old_unit
return specificarray
# Property implementations
def _get_output_array(self):
if self.input_units in self.proportional and self.output_units in self.proportional:
return (self.input_array * self.input_units_) / self.output_units_
elif self.input_units in self.proportional and self.output_units in self.reciprocal:
return 1.0 / (
(self.input_array * self.input_units_) / self.output_units_)
elif self.input_units in self.reciprocal and self.output_units in self.proportional:
return 1.0 / (
(self.input_array * self.output_units_) / self.input_units_
) #Output/input
elif self.input_units in self.reciprocal and self.output_units in self.reciprocal:
return (self.input_array * self.output_units_) / self.input_units_
def init(self, parent):
"""Finishes initializing the editor by creating the underlying toolkit
widget."""
factory = self.factory
self.filter = factory.filter
columns = factory.columns[:]
if (len(columns) == 0) and (len(self.value) > 0):
columns = [
ObjectColumn(name=name)
for name in self.value[0].editable_traits()
]
self.columns = columns
if factory.table_view_factory is not None:
self.table_view = factory.table_view_factory(editor=self)
if factory.source_model_factory is not None:
self.source_model = factory.source_model_factory(editor=self)
if factory.model_factory is not None:
self.model = factory.model_factory(editor=self)
# Create the table view and model
self.model.setDynamicSortFilter(True)
self.model.setSourceModel(self.source_model)
self.table_view.setModel(self.model)
# Create the vertical header context menu and connect to its signals
self.header_menu = QtGui.QMenu(self.table_view)
insertable = factory.row_factory is not None
if factory.editable:
if insertable:
action = self.header_menu.addAction("Insert new item")
action.triggered.connect(self._on_context_insert)
if factory.deletable:
action = self.header_menu.addAction("Delete item")
action.triggered.connect(self._on_context_remove)
if factory.reorderable:
if factory.editable and (insertable or factory.deletable):
self.header_menu.addSeparator()
self.header_menu_up = self.header_menu.addAction("Move item up")
self.header_menu_up.triggered.connect(self._on_context_move_up)
self.header_menu_down = self.header_menu.addAction(
"Move item down")
self.header_menu_down.triggered.connect(self._on_context_move_down)
# Create the empty space context menu and connect its signals
self.empty_menu = QtGui.QMenu(self.table_view)
action = self.empty_menu.addAction("Add new item")
action.triggered.connect(self._on_context_append)
# When sorting is enabled, the first column is initially displayed with
# the triangle indicating it is the sort index, even though no sorting
# has actually been done. Sort here for UI/model consistency.
if self.factory.sortable and not self.factory.reorderable:
self.model.sort(0, QtCore.Qt.AscendingOrder)
# Connect to the mode specific selection handler and select the first
# row/column/cell. Do this before creating the edit_view to make sure
# that it has a valid item to use when constructing its view.
smodel = self.table_view.selectionModel()
mode_slot = getattr(self, "_on_%s_selection" % factory.selection_mode)
smodel.selectionChanged.connect(mode_slot)
self.table_view.setCurrentIndex(self.model.index(0, 0))
# Create the toolbar if necessary
if factory.show_toolbar and len(factory.filters) > 0:
main_view = QtGui.QWidget()
layout = QtGui.QVBoxLayout(main_view)
layout.setContentsMargins(0, 0, 0, 0)
self.toolbar_ui = self.edit_traits(
parent=parent,
kind="subpanel",
view=View(
Group(
Item("filter{View}", editor=factory._filter_editor),
Item("filter_summary{Results}", style="readonly"),
spring,
orientation="horizontal",
),
resizable=True,
),
)
self.toolbar_ui.parent = self.ui
layout.addWidget(self.toolbar_ui.control)
layout.addWidget(self.table_view)
else:
main_view = self.table_view
# Create auxiliary editor and encompassing splitter if necessary
mode = factory.selection_mode
if (factory.edit_view == " ") or mode not in {"row", "rows"}:
self.control = main_view
else:
if factory.orientation == "horizontal":
self.control = QtGui.QSplitter(QtCore.Qt.Horizontal)
else:
self.control = QtGui.QSplitter(QtCore.Qt.Vertical)
self.control.setSizePolicy(QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
self.control.addWidget(main_view)
self.control.setStretchFactor(0, 2)
# Create the row editor below the table view
editor = InstanceEditor(view=factory.edit_view, kind="subpanel")
self._ui = self.edit_traits(
parent=self.control,
kind="subpanel",
view=View(
Item(
"selected_row",
style="custom",
editor=editor,
show_label=False,
resizable=True,
width=factory.edit_view_width,
height=factory.edit_view_height,
),
resizable=True,
handler=factory.edit_view_handler,
),
)
self._ui.parent = self.ui
self.control.addWidget(self._ui.control)
self.control.setStretchFactor(1, 1)
# Connect to the click and double click handlers
self.table_view.clicked.connect(self._on_click)
self.table_view.doubleClicked.connect(self._on_dclick)
# Make sure we listen for 'items' changes as well as complete list
# replacements
self.context_object.on_trait_change(self.update_editor,
self.extended_name + "_items",
dispatch="ui")
# Listen for changes to traits on the objects in the list
self.context_object.on_trait_change(self.refresh_editor,
self.extended_name + ".-",
dispatch="ui")
# Listen for changes on column definitions
self.on_trait_change(self._update_columns, "columns", dispatch="ui")
self.on_trait_change(self._update_columns,
"columns_items",
dispatch="ui")
# Set up the required externally synchronized traits
is_list = mode in ("rows", "columns", "cells")
self.sync_value(factory.click, "click", "to")
self.sync_value(factory.dclick, "dclick", "to")
self.sync_value(factory.columns_name, "columns", is_list=True)
self.sync_value(factory.selected, "selected", is_list=is_list)
self.sync_value(factory.selected_indices,
"selected_indices",
is_list=is_list)
self.sync_value(factory.filter_name, "filter", "from")
self.sync_value(factory.filtered_indices, "filtered_indices", "to")
self.sync_value(factory.update_filter_name, "update_filter", "from")
self.auto_size = self.factory.auto_size
# Initialize the ItemDelegates for each column
self._update_columns()
class TableFilterEditor(HasTraits):
""" An editor that manages table filters.
"""
# -------------------------------------------------------------------------
# Trait definitions:
# -------------------------------------------------------------------------
#: TableEditor this editor is associated with
editor = Instance(TableEditor)
#: The list of filters
filters = List(TableFilter)
#: The list of available templates from which filters can be created
templates = Property(List(TableFilter), depends_on="filters")
#: The currently selected filter template
selected_template = Instance(TableFilter)
#: The currently selected filter
selected_filter = Instance(TableFilter, allow_none=True)
#: The view to use for the current filter
selected_filter_view = Property(depends_on="selected_filter")
#: Buttons for add/removing filters
add_button = Button("New")
remove_button = Button("Delete")
# The default view for this editor
view = View(
Group(
Group(
Group(
Item("add_button", enabled_when="selected_template"),
Item(
"remove_button",
enabled_when="len(templates) > 1 and "
"selected_filter is not None",
),
orientation="horizontal",
show_labels=False,
),
Label("Base filter for new filters:"),
Item("selected_template", editor=EnumEditor(name="templates")),
Item(
"selected_filter",
style="custom",
editor=EnumEditor(name="filters", mode="list"),
),
show_labels=False,
),
Item(
"selected_filter",
width=0.75,
style="custom",
editor=InstanceEditor(view_name="selected_filter_view"),
),
id="TableFilterEditorSplit",
show_labels=False,
layout="split",
orientation="horizontal",
),
id="traitsui.qt4.table_editor.TableFilterEditor",
buttons=["OK", "Cancel"],
kind="livemodal",
resizable=True,
width=800,
height=400,
title="Customize filters",
)
# -------------------------------------------------------------------------
# Private methods:
# -------------------------------------------------------------------------
# -- Trait Property getter/setters ----------------------------------------
@cached_property
def _get_selected_filter_view(self):
view = None
if self.selected_filter:
model = self.editor.model
index = model.mapToSource(model.index(0, 0))
if index.isValid():
obj = self.editor.items()[index.row()]
else:
obj = None
view = self.selected_filter.edit_view(obj)
return view
@cached_property
def _get_templates(self):
templates = [f for f in self.editor.factory.filters if f.template]
templates.extend(self.filters)
return templates
# -- Trait Change Handlers ------------------------------------------------
def _editor_changed(self):
self.filters = [
f.clone_traits() for f in self.editor.factory.filters
if not f.template
]
self.selected_template = self.templates[0]
def _add_button_fired(self):
""" Create a new filter based on the selected template and select it.
"""
new_filter = self.selected_template.clone_traits()
new_filter.template = False
new_filter.name = new_filter._name = "New filter"
self.filters.append(new_filter)
self.selected_filter = new_filter
def _remove_button_fired(self):
""" Delete the currently selected filter.
"""
if self.selected_template == self.selected_filter:
self.selected_template = self.templates[0]
index = self.filters.index(self.selected_filter)
del self.filters[index]
if index < len(self.filters):
self.selected_filter = self.filters[index]
else:
self.selected_filter = None
@on_trait_change("selected_filter:name")
def _update_filter_list(self):
""" A hack to make the EnumEditor watching the list of filters refresh
their text when the name of the selected filter changes.
"""
filters = self.filters
self.filters = []
self.filters = filters
class GeoCellView(CellView):
'''View a single cell instance.
'''
implements(ICellView)
cell_X_arr = Array
cell_x_arr = Array
def set_cell_traits(self):
self.cell_X_arr = self.cell_grid.get_cell_point_X_arr(self.cell_idx)
self.cell_x_arr = self.cell_grid.get_cell_point_x_arr(self.cell_idx)
#-----------------------------------------------------------------------
# Visualization
#-----------------------------------------------------------------------
draw_cell = Bool(False)
view = View(
Item('cell_idx', style='readonly', label='Cell index',
resizable=False),
Group(
Item('cell_X_arr',
editor=coord_tabular_editor,
style='readonly',
show_label=False)),
Item('draw_cell', label='show geometrical nodes'))
# register the pipelines for plotting labels and geometry
#
mvp_cell_node_labels = Trait(MVPointLabels)
def _mvp_cell_node_labels_default(self):
return MVPointLabels(name='Geo node numbers',
points=self._get_cell_mvpoints,
scalars=self._get_cell_node_labels,
color=(0.254902, 0.411765, 0.882353))
mvp_cell_geo = Trait(MVPolyData)
def _mvp_cell_geo_default(self):
return MVPolyData(name='Geo node numbers',
points=self._get_cell_points,
lines=self._get_cell_lines,
color=(0.254902, 0.411765, 0.882353))
def redraw(self):
if self.draw_cell:
self.mvp_cell_node_labels.redraw()
#-----------------------------------------------------------------------
# Private methods
#-----------------------------------------------------------------------
def _get_cell_mvpoints(self):
return self.cell_grid.get_cell_mvpoints(self.cell_idx)
def _get_cell_node_labels(self):
return self.cell_grid.get_cell_node_labels(self.cell_idx)
def _get_cell_lines(self):
return self.cell_grid.grid_cell_spec.cell_lines
class InteractiveAnimation(HasTraits):
"""
Animator that renders in the WxWidgets main loop, using idle events.
"""
startButton = Button('Start Animation')
stopButton = Button('Stop Animation')
speed = Range(0.01, 1.0)
traits_view = View(Group(Item('startButton'),
Item('stopButton'),
show_labels=False),
Item('_'),
Item(name='speed'),
title='Animation Controller',
buttons=['OK'])
def __init__(self, tMin, tMax, *renderers):
"""
Initialise idle animator.
@param tMin: Time to start animation.
@param tMax: Time at which to wrap back to tMin.
@param renderers: List of L{AnimatedRenderer} objects.
"""
HasTraits.__init__(self)
self._renderers = renderers
self._tMin = tMin
self._tMax = tMax
self.speed = 1
self.time = tMin
self.playing = False
self._scene = mlab.gcf().scene
autoPositionCamera()
for r in self._renderers:
r.renderUpdate(self.time)
self.edit_traits()
def _startButton_fired(self):
self.playing = True
self.lastRenderTime = time.time()
wx.GetApp().Bind(wx.EVT_IDLE, self._onIdleEvent)
def start(self):
""" Start animation. """
self._startButton_fired()
def _stopButton_fired(self):
wx.GetApp().Bind(wx.EVT_IDLE, None)
self.playing = False
def stop(self):
""" Stop animation. """
self._stopButton_fired()
def _onIdleEvent(self, event):
if self.playing:
self._scene.disable_render = True
timeNow = time.time()
t = self.time + (timeNow - self.lastRenderTime) * self.speed
if t > self._tMax:
self.time = self._tMin + t - self._tMax
else:
self.time = t
self.time = t % self._tMax
self.lastRenderTime = timeNow
for r in self._renderers:
r.renderUpdate(self.time)
self._scene.disable_render = False
event.RequestMore()
class VolumeSlicer(HasTraits):
# The data to plot
data = Array()
# The 4 views displayed
scene3d = Instance(MlabSceneModel, ())
scene_x = Instance(MlabSceneModel, ())
scene_y = Instance(MlabSceneModel, ())
scene_z = Instance(MlabSceneModel, ())
# The data source
data_src3d = Instance(Source)
# The image plane widgets of the 3D scene
ipw_3d_x = Instance(PipelineBase)
ipw_3d_y = Instance(PipelineBase)
ipw_3d_z = Instance(PipelineBase)
_axis_names = dict(x=0, y=1, z=2)
#---------------------------------------------------------------------------
def __init__(self, **traits):
super(VolumeSlicer, self).__init__(**traits)
# Force the creation of the image_plane_widgets:
self.ipw_3d_x
self.ipw_3d_y
self.ipw_3d_z
#---------------------------------------------------------------------------
# Default values
#---------------------------------------------------------------------------
def _data_src3d_default(self):
return mlab.pipeline.scalar_field(self.data,
figure=self.scene3d.mayavi_scene)
def make_ipw_3d(self, axis_name):
ipw = mlab.pipeline.image_plane_widget(
self.data_src3d,
figure=self.scene3d.mayavi_scene,
plane_orientation='%s_axes' % axis_name)
ipw.ipw.reslice_interpolate = 'nearest_neighbour'
return ipw
def _ipw_3d_x_default(self):
return self.make_ipw_3d('x')
def _ipw_3d_y_default(self):
return self.make_ipw_3d('y')
def _ipw_3d_z_default(self):
return self.make_ipw_3d('z')
#---------------------------------------------------------------------------
# Scene activation callbaks
#---------------------------------------------------------------------------
@on_trait_change('scene3d.activated')
def display_scene3d(self):
outline = mlab.pipeline.outline(
self.data_src3d,
figure=self.scene3d.mayavi_scene,
)
self.scene3d.mlab.view(40, 50)
# Interaction properties can only be changed after the scene
# has been created, and thus the interactor exists
for ipw in (self.ipw_3d_x, self.ipw_3d_y, self.ipw_3d_z):
# Turn the interaction off
ipw.ipw.interaction = 0
# choose the flag style lut and reverse it
# this makes it nice for segmentations
ipw.parent.scalar_lut_manager.lut_mode = 'flag'
ipw.parent.scalar_lut_manager.reverse_lut = True
self.scene3d.scene.background = (0, 0, 0)
# Keep the view always pointing up
self.scene3d.scene.interactor.interactor_style = \
tvtk.InteractorStyleTerrain()
def make_side_view(self, axis_name):
scene = getattr(self, 'scene_%s' % axis_name)
# To avoid copying the data, we take a reference to the
# raw VTK dataset, and pass it on to mlab. Mlab will create
# a Mayavi source from the VTK without copying it.
# We have to specify the figure so that the data gets
# added on the figure we are interested in.
outline = mlab.pipeline.outline(
self.data_src3d.mlab_source.dataset,
figure=scene.mayavi_scene,
)
ipw = mlab.pipeline.image_plane_widget(outline,
plane_orientation='%s_axes' %
axis_name)
setattr(self, 'ipw_%s' % axis_name, ipw)
# Synchronize positions between the corresponding image plane
# widgets on different views.
ipw.ipw.sync_trait('slice_position',
getattr(self, 'ipw_3d_%s' % axis_name).ipw)
# Make left-clicking create a crosshair
ipw.ipw.left_button_action = 0
# Add a callback on the image plane widget interaction to
# move the others
def move_view(obj, evt):
position = obj.GetCurrentCursorPosition()
for other_axis, axis_number in self._axis_names.iteritems():
if other_axis == axis_name:
continue
ipw3d = getattr(self, 'ipw_3d_%s' % other_axis)
ipw3d.ipw.slice_position = position[axis_number]
ipw.ipw.add_observer('InteractionEvent', move_view)
ipw.ipw.add_observer('StartInteractionEvent', move_view)
# Center the image plane widget
ipw.ipw.slice_position = 0.5 * self.data.shape[
self._axis_names[axis_name]]
# choose the flag style lut and reverse it
# this makes it nice for segmentations
ipw.parent.scalar_lut_manager.lut_mode = 'flag'
ipw.parent.scalar_lut_manager.reverse_lut = True
ipw.ipw.reslice_interpolate = 'nearest_neighbour'
# Position the view for the scene
views = dict(
x=(0, 90),
y=(90, 90),
z=(0, 0),
)
scene.mlab.view(*views[axis_name])
# 2D interaction: only pan and zoom
scene.scene.interactor.interactor_style = \
tvtk.InteractorStyleImage()
scene.scene.background = (0, 0, 0)
@on_trait_change('scene_x.activated')
def display_scene_x(self):
return self.make_side_view('x')
@on_trait_change('scene_y.activated')
def display_scene_y(self):
return self.make_side_view('y')
@on_trait_change('scene_z.activated')
def display_scene_z(self):
return self.make_side_view('z')
#---------------------------------------------------------------------------
# The layout of the dialog created
#---------------------------------------------------------------------------
view = View(
HGroup(
Group(
Item('scene_y',
editor=SceneEditor(scene_class=Scene),
height=250,
width=300),
Item('scene_z',
editor=SceneEditor(scene_class=Scene),
height=250,
width=300),
show_labels=False,
),
Group(
Item('scene_x',
editor=SceneEditor(scene_class=Scene),
height=250,
width=300),
Item('scene3d',
editor=SceneEditor(scene_class=MayaviScene),
height=250,
width=300),
show_labels=False,
),
),
resizable=True,
title='Volume Slicer',
)
"""
Validator function that returns *val* if *val* is either a number or
the word 'auto'. This is used as a validator for the text editor
in the Traits UI for the **tick_interval** trait.
"""
try:
return float(val)
except:
if isinstance(val, str) and val == "auto":
return val
raise TraitError("Tick interval must be a number or 'auto'.")
# Traits UI for a PlotAxis.
AxisView = View(VGroup(
Group(
Item("object.mapper.range.low", label="Low Range"),
Item("object.mapper.range.high", label="High Range"),
),
Group(
Item("title", label="Title", editor=TextEditor()),
Item("title_font", label="Font", style="simple"),
Item("title_color", label="Color", style="custom"),
Item("tick_interval", label="Interval", editor=TextEditor(evaluate=float_or_auto)),
label="Main"),
Group(
Item("tick_color", label="Color", style="custom"),
Item("tick_weight", label="Thickness"),
Item("tick_label_color", label="Label color", style="custom"),
HGroup(
Item("tick_in", label="Tick in"),
Item("tick_out", label="Tick out"),
),
def get_additional_groups(self):
archivergrp = Group(Item('use_video_archiver'),
Item(
'video_archive_days',
label='Archive after N. days',
enabled_when='use_video_archiver',
),
Item(
'video_archive_hours',
label='Archive after N. hours',
enabled_when='use_video_archiver',
),
Item(
'video_archive_months',
label='Delete after N. months',
enabled_when='use_video_archiver',
),
show_border=True,
label='Archiver')
recgrp = Group(
# Item('record_lasing_video', label='Record Lasing'),
# Item('record_brightness',
# label='Record Brightness Measure',
# ),
Item('video_directory',
label='Save to',
enabled_when='record_lasing_video_video'),
# Item('recording_zoom', enabled_when='record_lasing_video'),
show_border=True,
label='Record')
vservergrp = VGroup(Item('use_video_server', label='Use Server'),
Item('video_server_port',
label='Port',
enabled_when='use_video_server'),
Item('video_server_quality',
label='Quality',
enabled_when='use_video_server'),
show_border=True,
label='Server')
videogrp = VGroup(Item('use_video'),
VGroup(Item('video_identifier',
label='ID',
enabled_when='use_video'),
Item('video_output_mode',
label='Output Mode'),
Item('ffmpeg_path', label='FFmpeg Location'),
Item('use_autocenter', label='Auto Center'),
Item('render_with_markup',
label='Render Snapshot with markup'),
recgrp,
archivergrp,
vservergrp,
enabled_when='use_video'),
label='Video')
canvasgrp = VGroup(
Item('show_bounds_rect'),
Item('show_map'),
Item('show_grids'),
Item('show_laser_position'),
Item('show_desired_position'),
Item('desired_position_color',
show_label=False,
enabled_when='show_desired_position'),
Item('crosshairs_kind',
label='Crosshairs',
enabled_when='show_laser_position'),
Item('crosshairs_radius',
visible_when='crosshairs_kind=="UserRadius"'),
Item('crosshairs_color', enabled_when='show_laser_position'),
HGroup(
Item('crosshairs_offsetx', label='Offset'),
Item('crosshairs_offsety', show_label=False),
),
Item(
'crosshairs_offset_color',
show_label=False,
),
Item('calibration_style'),
Item('scaling'),
label='Canvas',
)
patgrp = Group(Item('record_patterning'),
Item('show_patterning'),
label='Pattern')
powergrp = Group(
# Item('record_lasing_power'),
Item('use_calibrated_power'),
label='Power')
return [canvasgrp, videogrp, patgrp, powergrp]
class GridPlane(Component):
# The version of this class. Used for persistence.
__version__ = 0
# The TVTK object that extracts the grid plane. This is created
# dynamically based on the input data type.
plane = Instance(tvtk.Object)
# The axis which is normal to the plane chosen.
axis = Enum('x',
'y',
'z',
desc='specifies the axis normal to the grid plane')
# The position of the grid plane.
position = Range(value=0,
low='_low',
high='_high',
enter_set=True,
auto_set=False)
########################################
# Private traits.
# Determines the lower limit of the position trait and is always 0.
_low = Int(0)
# Determines the upper limit of the position trait. The value is
# dynamically set depending on the input data and state of the
# axis trait. The default is some large value to avoid errors in
# cases where the user may set the position before adding the
# object to the mayavi tree.
_high = Int(10000)
########################################
# View related traits.
# The View for this object.
view = View(
Group(Item(name='axis'), Item(name='position',
enabled_when='_high > 0')))
######################################################################
# `object` interface
######################################################################
def __get_pure_state__(self):
d = super(GridPlane, self).__get_pure_state__()
# These traits are dynamically created.
for name in ('plane', '_low', '_high'):
d.pop(name, None)
return d
def __set_pure_state__(self, state):
state_pickler.set_state(self, state)
self._position_changed(self.position)
######################################################################
# `Component` interface
######################################################################
def setup_pipeline(self):
"""Override this method so that it *creates* its tvtk
pipeline.
This method is invoked when the object is initialized via
`__init__`. Note that at the time this method is called, the
tvtk data pipeline will *not* yet be setup. So upstream data
will not be available. The idea is that you simply create the
basic objects and setup those parts of the pipeline not
dependent on upstream sources and filters.
"""
pass
def update_pipeline(self):
"""Override this method so that it *updates* the tvtk pipeline
when data upstream is known to have changed.
This method is invoked (automatically) when the input fires a
`pipeline_changed` event.
"""
if len(self.inputs) == 0:
return
input = self.inputs[0].get_output_dataset()
plane = None
if input.is_a('vtkStructuredGrid'):
plane = tvtk.StructuredGridGeometryFilter()
elif input.is_a('vtkStructuredPoints') or input.is_a('vtkImageData'):
plane = tvtk.ImageDataGeometryFilter()
elif input.is_a('vtkRectilinearGrid'):
plane = tvtk.RectilinearGridGeometryFilter()
else:
msg = "The GridPlane component does not support the %s dataset."\
% (input.class_name)
error(msg)
raise TypeError(msg)
self.configure_connection(plane, self.inputs[0])
self.plane = plane
self.plane.update()
self.outputs = [plane]
self._update_limits()
self._update_extents()
# If the data is 2D make sure that we default to the
# appropriate axis.
extents = list(_get_extent(input))
diff = [y - x for x, y in zip(extents[::2], extents[1::2])]
if diff.count(0) > 0:
self.axis = ['x', 'y', 'z'][diff.index(0)]
def update_data(self):
"""Override this method to do what is necessary when upstream
data changes.
This method is invoked (automatically) when any of the inputs
sends a `data_changed` event.
"""
self._update_limits()
self._update_extents()
# Propagate the data_changed event.
self.data_changed = True
def has_output_port(self):
""" The filter has an output port."""
return True
def get_output_object(self):
""" Returns the output port."""
return self.plane.output_port
######################################################################
# Non-public methods.
######################################################################
def _get_axis_index(self):
return {'x': 0, 'y': 1, 'z': 2}[self.axis]
def _update_extents(self):
inp = self.plane.input
extents = list(_get_extent(inp))
pos = self.position
axis = self._get_axis_index()
extents[2 * axis] = pos
extents[2 * axis + 1] = pos
try:
self.plane.set_extent(extents)
except AttributeError:
self.plane.extent = extents
def _update_limits(self):
extents = _get_extent(self.plane.input)
axis = self._get_axis_index()
pos = min(self.position, extents[2 * axis + 1])
self._high = extents[2 * axis + 1]
return pos
def _axis_changed(self, val):
if len(self.inputs) == 0:
return
pos = self._update_limits()
if self.position == pos:
self._update_extents()
self.data_changed = True
else:
self.position = pos
def _position_changed(self, val):
if len(self.inputs) == 0:
return
self._update_extents()
self.data_changed = True
class LoggerView(TraitsUIView):
"""The Workbench View showing the list of log items."""
id = Str("apptools.logger.plugin.view.logger_view.LoggerView")
name = Str("Logger")
service = Instance(LoggerService)
log_records = List(Instance(logging.LogRecord))
formatted_records = Property(Str, depends_on="log_records")
activated = Instance(logging.LogRecord)
activated_text = Property(Str, depends_on="activated")
reset_button = Button("Reset Logs")
show_button = Button("Complete Text Log")
copy_button = Button("Copy Log to Clipboard")
code_editor = CodeEditor(lexer="null", show_line_numbers=False)
log_records_editor = TabularEditor(adapter=LogRecordAdapter(),
editable=False,
activated="activated")
trait_view = View(
Group(
Item("log_records", editor=log_records_editor),
Group(
Item("reset_button"),
spring,
Item("show_button"),
Item("copy_button"),
orientation="horizontal",
show_labels=False,
),
show_labels=False,
))
###########################################################################
# LogQueueHandler view interface
###########################################################################
def update(self, force=False):
"""Update 'log_records' if our handler has new records or 'force' is
set.
"""
service = self.service
if service.handler.has_new_records() or force:
log_records = [
rec for rec in service.handler.get()
if rec.levelno >= service.preferences.level_
]
log_records.reverse()
self.log_records = log_records
###########################################################################
# Private interface
###########################################################################
@on_trait_change("service.preferences.level_")
def _update_log_records(self):
self.service.handler._view = self
self.update(force=True)
def _reset_button_fired(self):
self.service.handler.reset()
self.log_records = []
def _show_button_fired(self):
self.edit_traits(view=View(
Item(
"formatted_records",
editor=self.code_editor,
style="readonly",
show_label=False,
),
width=800,
height=600,
resizable=True,
buttons=["OK"],
title="Complete Text Log",
))
def _copy_button_fired(self):
clipboard.text_data = self.formatted_records
@cached_property
def _get_formatted_records(self):
return "\n".join([
self.service.handler.formatter.format(record)
for record in self.log_records
])
def _activated_changed(self):
if self.activated is None:
return
msg = self.activated.getMessage()
if self.service.preferences.enable_agent:
dialog = QualityAgentView(msg=msg, service=self.service)
dialog.open()
else:
self.edit_traits(view=View(
Item(
"activated_text",
editor=self.code_editor,
style="readonly",
show_label=False,
),
width=800,
height=600,
resizable=True,
buttons=["OK"],
title="Log Message Detail",
))
@cached_property
def _get_activated_text(self):
if self.activated is None:
return ""
else:
return self.activated.getMessage()
class ContainerExample(HasTraits):
plot = Instance(HPlotContainer)
display_button = Button()
display_button1 = Button()
prev = Button()
next = Button()
unzoom = Button()
traits_view = View(
Group(Item('display_button', show_label=False),
Item('display_button1', show_label=False),
Item('prev', show_label=False),
Item('next', show_label=False),
Item('unzoom', show_label=False),
orientation="horizontal"),
Item('plot', editor=ComponentEditor(), show_label=False),
# put the info box that lists the mouse location tuple kls karl
width=1000,
height=600,
resizable=True,
title="Chaco Plot",
# How do I activate these? buttons=["do_nothing","do_nothing_1"]
)
def __init__(self):
super(ContainerExample, self).__init__()
filenames = []
for parameter in sys.argv[1:]:
print("processing parameter", parameter)
if parameter.find("=") == -1:
print("no = in parameter", parameter, "must be a file name")
filenames.append(parameter)
if len(filenames) < 1:
print("just to help me test, if there are no files in the list, ")
print("I will append the file foldplot1.rsf")
filenames.append('foldplot1.rsf')
self.seis_data_0 = SeisData(filenames[0])
self.cmap = jet
self.displayParameters = DisplayParameters()
self.slice_y = self.displayParameters.slice_y
print("self.slice_y=", self.slice_y)
self.arrayPlotData = ArrayPlotData()
self._update_images()
x_extents = (self.seis_data_0.axis_start[1],
self.seis_data_0.axis_end[1])
y_extents = (self.seis_data_0.axis_start[2],
self.seis_data_0.axis_end[2])
bottomplot = Plot(self.arrayPlotData, origin="top left")
self.bottomplot = bottomplot
imgplot = bottomplot.img_plot("xz",
xbounds=x_extents,
ybounds=y_extents,
colormap=self.cmap)[0]
self.bottom = imgplot
plotright = Plot(self.arrayPlotData,
origin="top left",
range2d=bottomplot.range2d)
imgplotright = plotright.img_plot("xz",
xbounds=x_extents,
ybounds=y_extents,
colormap=self.cmap)[0]
self.right = imgplotright
container = HPlotContainer(fill_padding=True,
bgcolor="white",
use_backbuffer=True)
container.add(bottomplot)
container.add(plotright)
self.plot = container
self.displayParameters = DisplayParameters()
self.slice_y = self.displayParameters.slice_y
imgplot.tools.append(CustomTool(imgplot))
imgplot.tools.append(PanTool(imgplot, constrain_key="shift"))
imgplot.overlays.append(
ZoomTool(component=imgplot, tool_mode="box", always_on=False))
imgplotright.tools.append(PanTool(imgplotright, constrain_key="shift"))
imgplotright.overlays.append(
ZoomTool(component=self.right, tool_mode="box", always_on=False))
def _update_images(self):
if self.displayParameters.gain != 0:
rgain = 1. / self.displayParameters.gain
else:
rgain = 1
print("rgain=", rgain)
range = DataRange1D(low=self.seis_data_0.minval * rgain,
high=self.seis_data_0.maxval * rgain)
self.colormap = self.cmap(range)
slice = transpose(self.seis_data_0.vals[self.slice_y, :, :])
self.slice = slice
colorslice = (self.colormap.map_screen(slice) * 255).astype(uint8)
# Transposed required because img_plot() expects data in row-major order
# self.arrayPlotData.set_data("xz", colorslicexz)
self.arrayPlotData.set_data("xz", colorslice)
def _marker_size_changed(self):
self.scatter.marker_size = self.marker_size
def _color_changed(self):
self.scatter.marker_size = self.marker_size
def _display_button_fired(self):
print("Display button pushed")
self.displayParameters.edit_traits()
self._update_images()
def _prev_fired(self):
print("prev button pushed")
slice_y = self.slice_y - self.displayParameters.slice_inc
if (slice_y < 0):
slice_y = self.seis_data_0.vals.shape[0] - 1
print("after decrement slice_y=", slice_y)
self.slice_y = slice_y
self._update_images()
def _next_fired(self):
print("next button pushed")
slice_y = self.slice_y + self.displayParameters.slice_inc
print("shape=", self.seis_data_0.vals.shape)
if (slice_y >= self.seis_data_0.vals.shape[0]):
slice_y = 0
print("after increment slice_y=", slice_y)
self.slice_y = slice_y
self._update_images()
def _unzoom_fired(self):
print("unzoom button pushed")
print("self.bottomplot.range2d=", self.bottomplot.range2d)
print("xmin/xmax=", \
self.bottomplot.range2d.x_range.low, \
self.bottomplot.range2d.x_range.high)
print("ymin/ymax=", \
self.bottomplot.range2d.y_range.low, \
self.bottomplot.range2d.y_range.high)
self.bottomplot.range2d.x_range.low = self.seis_data_0.axis_start[1]
self.bottomplot.range2d.x_range.high = self.seis_data_0.axis_end[1]
self.bottomplot.range2d.y_range.low = self.seis_data_0.axis_start[2]
self.bottomplot.range2d.y_range.high = self.seis_data_0.axis_end[2]
"""
# Authors: Prabhu Ramachandran <*****@*****.**>
# Judah De Paula <*****@*****.**>
# Copyright (c) 2005-2008, Enthought, Inc.
# License: BSD Style.
from traitsui.api import Item, Group, View, InstanceEditor
from mayavi.components.ui.actor import actor_view, texture_view
view = View(Group(
Group(Item(name='contour', style='custom'),
show_labels=False,
show_border=True,
label='Contours'),
Group(Item(name='compute_normals'),
Item(name='normals',
style='custom',
show_label=False,
enabled_when='compute_normals'),
show_border=True,
label='Normals'),
label='Contours',
),
Group(
Item('actor',
resizable=True,
style='custom',
editor=InstanceEditor(view=actor_view)),
label='Actor',
show_labels=False,
),
Group(
class NINM_board0(HasTraits):
# haven't figured out how to have a class that takes arguments (board 0/1)
board = 0
s = []
m=8
# print 'ninm1 root has board',board
#s.append(Instance(Source,(board,1)))
s1 = Instance(Source,(board,1))
s2 = Instance(Source,(board,2))
s3 = Instance(Source,(board,3))
s4 = Instance(Source,(board,4))
s5 = Instance(Source,(board,5))
s6 = Instance(Source,(board,6))
s7 = Instance(Source,(board,7))
s8 = Instance(Source,(board,8))
d1 = Instance(Detector,(board,1))
d2 = Instance(Detector,(board,2))
d3 = Instance(Detector,(board,3))
d4 = Instance(Detector,(board,4))
d5 = Instance(Detector,(board,5))
d6 = Instance(Detector,(board,6))
d7 = Instance(Detector,(board,7))
d8 = Instance(Detector,(board,8))
SallON = Button('Plot ALL Src')
SallOFF = Button('Plot NO Src')
DallON = Button('Plot ALL Det')
DallOFF = Button('Plot NO Det')
view = View( Group(
HGroup( Item('s1',label='S0',style='custom',show_label=True),
Item('s2',label='S1',style='custom',show_label=True),
Item('s3',label='S2',style='custom',show_label=True),
Item('s4',label='S3',style='custom',show_label=True),
Item('s5',label='S4',style='custom',show_label=True),
Item('s6',label='S5',style='custom',show_label=True),
Item('s7',label='S6',style='custom',show_label=True),
Item('s8',label='S7',style='custom',show_label=True),
VGroup( Item('SallON',style="custom",show_label=False,width=-74,height=-25),
Item('SallOFF',style="custom",show_label=False,width=-74,height=-25),
),
),
HGroup( Item('d1',label='D0',style='custom',show_label=True),
Item('d2',label='D1',style='custom',show_label=True),
Item('d3',label='D2',style='custom',show_label=True),
Item('d4',label='D3',style='custom',show_label=True),
Item('d5',label='D4',style='custom',show_label=True),
Item('d6',label='D5',style='custom',show_label=True),
Item('d7',label='D6',style='custom',show_label=True),
Item('d8',label='D7',style='custom',show_label=True),
VGroup( Item('DallON',style="custom",show_label=False,width=-74,height=-25),
Item('DallOFF',style="custom",show_label=False,width=-74,height=-25),
)
),
),
height=0.2,
buttons=NoButtons
)
#all source on and off button
def _SallON_fired(self):
# print "allON fired"
self.s1.enable = True
self.s2.enable = True
self.s3.enable = True
self.s4.enable = True
self.s5.enable = True
self.s6.enable = True
self.s7.enable = True
self.s8.enable = True
def _SallOFF_fired(self):
# print "allOFF fired"
self.s1.enable = False
self.s2.enable = False
self.s3.enable = False
self.s4.enable = False
self.s5.enable = False
self.s6.enable = False
self.s7.enable = False
self.s8.enable = False
def _DallON_fired(self):
# print "allOFF fired"
self.d1.enable = True
self.d2.enable = True
self.d3.enable = True
self.d4.enable = True
self.d5.enable = True
self.d6.enable = True
self.d7.enable = True
self.d8.enable = True
def _DallOFF_fired(self):
# print "allOFF fired"
self.d1.enable = False
self.d2.enable = False
self.d3.enable = False
self.d4.enable = False
self.d5.enable = False
self.d6.enable = False
self.d7.enable = False
self.d8.enable = False
def set_defaults(self):
self._DallON_fired()
self._SallON_fired()
class MATS2DScalarDamage(MATS2DEval):
'''
Scalar Damage Model.
'''
implements(IMATSEval)
#---------------------------------------------------------------------------
# Parameters of the numerical algorithm (integration)
#---------------------------------------------------------------------------
stress_state = Enum("plane_stress", "plane_strain")
stiffness = Enum("secant", "algoritmic")
#---------------------------------------------------------------------------
# Material parameters
#---------------------------------------------------------------------------
E = Float(34e+3, label="E", desc="Young's Modulus", auto_set=False)
nu = Float(0.2, label='nu', desc="Poison's ratio", auto_set=False)
epsilon_0 = Float(59e-6,
label="eps_0",
desc="Breaking Strain",
auto_set=False)
epsilon_f = Float(191e-4,
label="eps_f",
desc="Shape Factor",
auto_set=False)
strain_norm = EitherType(
klasses=[Mazars, Euclidean, Energy, Mises, Rankine])
D_el = Property(Array(float), depends_on='E, nu, stress_state')
@cached_property
def _get_D_el(self):
if self.stress_state == "plane_stress":
return self._get_D_plane_stress()
else:
return self._get_D_plane_strain()
# This event can be used by the clients to trigger an action upon
# the completed reconfiguration of the material model
#
changed = Event
#--------------------------------------------------------------------------
# View specification
#--------------------------------------------------------------------------
view_traits = View(VSplit(
Group(Item('E'), Item('nu'), Item('epsilon_0'), Item('epsilon_f'),
Item('strain_norm')),
Group(
Item('stress_state', style='custom'),
Item('stiffness', style='custom'),
Spring(resizable=True),
label='Configuration parameters',
show_border=True,
),
),
resizable=True)
#--------------------------------------------------------------------------
# Private initialization methods
#--------------------------------------------------------------------------
#--------------------------------------------------------------------------
# Setup for computation within a supplied spatial context
#--------------------------------------------------------------------------
def get_state_array_size(self):
'''
Return number of number to be stored in state array
@param sctx:spatial context
'''
return 2
def setup(self, sctx):
'''
Intialize state variables.
@param sctx:spatial context
'''
state_arr_size = self.get_state_array_size()
sctx.mats_state_array = zeros(state_arr_size, 'float_')
# sctx.update_state_on = False
def new_cntl_var(self):
'''
Return contoll variable array
'''
return zeros(3, float_)
def new_resp_var(self):
'''
Return contoll response array
'''
return zeros(3, float_)
#--------------------------------------------------------------------------
# Evaluation - get the corrector and predictor
#--------------------------------------------------------------------------
def get_corr_pred(self, sctx, eps_app_eng, d_eps, tn, tn1, eps_avg=None):
'''
Corrector predictor computation.
@param eps_app_eng input variable - engineering strain
'''
if eps_avg != None:
pass
else:
eps_avg = eps_app_eng
if sctx.update_state_on:
eps_n = eps_avg - d_eps
e_max, omega = self._get_state_variables(sctx, eps_n)
sctx.mats_state_array[0] = e_max
sctx.mats_state_array[1] = omega
e_max, omega = self._get_state_variables(sctx, eps_app_eng)
if self.stiffness == "algorithmic" and \
e_max > self.epsilon_0 and \
e_max > sctx.mats_state_array[0]:
D_e_dam = self._get_alg_stiffness(eps_app_eng, e_max, omega)
else:
D_e_dam = (1 - omega) * self.D_el
sigma = dot(((1 - omega) * self.D_el), eps_app_eng)
# You print the stress you just computed and the value of the apparent E
return sigma, D_e_dam
#--------------------------------------------------------------------------
# Subsidiary methods realizing configurable features
#--------------------------------------------------------------------------
def _get_state_variables(self, sctx, eps_app_eng):
e_max = sctx.mats_state_array[0]
omega = sctx.mats_state_array[1]
f_trial = self.strain_norm.get_f_trial(eps_app_eng, self.D_el, self.E,
self.nu, e_max)
if f_trial > 0:
e_max += f_trial
omega = self._get_omega(e_max)
return e_max, omega
def _get_omega(self, kappa):
'''
Return new value of damage parameter
@param kappa:
'''
epsilon_0 = self.epsilon_0
epsilon_f = self.epsilon_f
if kappa >= epsilon_0:
# return 1.-epsilon_0/kappa*exp(-1*(kappa-epsilon_0)/epsilon_f)
return 1. - epsilon_0 / kappa * exp(-1 * (kappa - epsilon_0) / \
(epsilon_f - epsilon_0))
else:
return 0.
def _get_alg_stiffness(self, eps_app_eng, e_max, omega):
'''
Return algorithmic stiffness matrix
@param eps_app_eng:strain
@param e_max:kappa
@param omega:damage parameter
'''
epsilon_0 = self.epsilon_0
epsilon_f = self.epsilon_f
dodk = epsilon_0 / (e_max * e_max) * exp(-(e_max - epsilon_0) / epsilon_f) + \
epsilon_0 / e_max / epsilon_f * exp(-(e_max - epsilon_0) / epsilon_f)
dede = self.strain_norm.get_dede(eps_app_eng, self.D_el, self.E,
self.nu)
D_alg = (1 - omega) * self.D_el - \
dot(dot(self.D_el, eps_app_eng), dede) * dodk
return D_alg
def _get_D_plane_stress(self):
'''
Elastic Matrix - Plane Stress
'''
E = self.E
nu = self.nu
D_stress = zeros([3, 3])
D_stress[0][0] = E / (1.0 - nu * nu)
D_stress[0][1] = E / (1.0 - nu * nu) * nu
D_stress[1][0] = E / (1.0 - nu * nu) * nu
D_stress[1][1] = E / (1.0 - nu * nu)
D_stress[2][2] = E / (1.0 - nu * nu) * (1.0 / 2.0 - nu / 2.0)
return D_stress
def _get_D_plane_strain(self):
'''
Elastic Matrix - Plane Strain
'''
E = self.E
nu = self.nu
D_strain = zeros([3, 3])
D_strain[0][0] = E * (1.0 - nu) / (1.0 + nu) / (1.0 - 2.0 * nu)
D_strain[0][1] = E / (1.0 + nu) / (1.0 - 2.0 * nu) * nu
D_strain[1][0] = E / (1.0 + nu) / (1.0 - 2.0 * nu) * nu
D_strain[1][1] = E * (1.0 - nu) / (1.0 + nu) / (1.0 - 2.0 * nu)
D_strain[2][2] = E * (1.0 - nu) / (1.0 + nu) / (2.0 - 2.0 * nu)
return D_strain
#--------------------------------------------------------------------------
# Response trace evaluators
#--------------------------------------------------------------------------
def get_omega(self, sctx, eps_app_eng, *args, **kw):
'''
Return damage parameter for RT
@param sctx:spatial context
@param eps_app_eng:actual strain
'''
return array([sctx.mats_state_array[1]])
# Declare and fill-in the rte_dict - it is used by the clients to
# assemble all the available time-steppers.
#
rte_dict = Trait(Dict)
def _rte_dict_default(self):
return {
'sig_app': self.get_sig_app,
'eps_app': self.get_eps_app,
'omega': self.get_omega
}
Group(
VGroup(
HGroup(
VGroup(
HGroup( # Simulation Control
VGroup(
Item(
name="bit_rate",
label="Bit Rate (Gbps)",
tooltip="bit rate",
show_label=True,
enabled_when="True",
editor=TextEditor(auto_set=False, enter_set=True, evaluate=float),
),
Item(
name="nbits",
label="Nbits",
tooltip="# of bits to run",
editor=TextEditor(auto_set=False, enter_set=True, evaluate=int),
),
Item(
name="nspb",
label="Nspb",
tooltip="# of samples per bit",
editor=TextEditor(auto_set=False, enter_set=True, evaluate=int),
),
Item(
name="mod_type",
label="Modulation",
tooltip="line signalling/modulation scheme",
editor=CheckListEditor(values=[(0, "NRZ"), (1, "Duo-binary"), (2, "PAM-4")]),
),
),
VGroup(
Item(name="do_sweep", label="Do Sweep", tooltip="Run parameter sweeps."),
Item(
name="sweep_aves",
label="SweepAves",
tooltip="# of trials, per sweep, for averaging.",
enabled_when="do_sweep == True",
),
Item(
name="pattern_len",
label="PatLen",
tooltip="length of random pattern to use to construct bit stream",
editor=TextEditor(auto_set=False, enter_set=True, evaluate=int),
),
Item(
name="eye_bits",
label="EyeBits",
tooltip="# of bits to use to form eye diagrams",
editor=TextEditor(auto_set=False, enter_set=True, evaluate=int),
),
),
VGroup(
Item(name="vod", label="Vod (V)", tooltip="Tx output voltage into matched load"),
Item(name="rn", label="Rn (V)", tooltip="standard deviation of random noise"),
Item(name="pn_mag", label="Pn (V)", tooltip="peak magnitude of periodic noise"),
Item(name="pn_freq", label="f(Pn) (MHz)", tooltip="frequency of periodic noise"),
),
),
label="Simulation Control",
show_border=True,
),
VGroup(
Item(
name="thresh",
label="Pj Threshold (sigma)",
tooltip="Threshold for identifying periodic jitter spectral elements. (sigma)",
),
Item(
name="impulse_length",
label="Impulse Response Length (ns)",
tooltip="Manual impulse response length override",
),
Item(name="debug", label="Debug", tooltip="Enable to log extra information to console."),
label="Analysis Parameters",
show_border=True,
),
),
HGroup(
VGroup(
VGroup(
HGroup(
VGroup(
HGroup(
Item(name="tx_ami_valid", show_label=False, style="simple", enabled_when="False"),
Item(name="tx_ami_file", label="AMI File:", tooltip="Choose AMI file."),
),
HGroup(
Item(name="tx_dll_valid", show_label=False, style="simple", enabled_when="False"),
Item(name="tx_dll_file", label="DLL File:", tooltip="Choose DLL file."),
),
),
VGroup(
Item(
name="tx_use_ami",
label="Use AMI",
tooltip="You must select both files, first.",
enabled_when="tx_ami_valid == True and tx_dll_valid == True",
),
Item(
name="tx_use_getwave",
label="Use GetWave",
tooltip="Use the model's GetWave() function.",
enabled_when="tx_use_ami and tx_has_getwave",
),
Item(
"btn_cfg_tx",
show_label=False,
tooltip="Configure Tx AMI parameters.",
enabled_when="tx_ami_valid == True",
),
),
),
label="IBIS-AMI",
show_border=True,
),
VGroup(
Item(
name="tx_taps",
editor=TableEditor(
columns=[
ObjectColumn(name="name", editable=False),
ObjectColumn(name="enabled", style="simple"),
ObjectColumn(name="min_val", horizontal_alignment="center"),
ObjectColumn(name="max_val", horizontal_alignment="center"),
ObjectColumn(name="value", format="%+05.3f", horizontal_alignment="center"),
ObjectColumn(name="steps", horizontal_alignment="center"),
],
configurable=False,
reorderable=False,
sortable=False,
selection_mode="cell",
# auto_size=True,
rows=4,
),
show_label=False,
),
label="Native",
show_border=True,
enabled_when="tx_use_ami == False",
),
label="Tx Equalization",
show_border=True,
),
VGroup(
VGroup(
HGroup(
VGroup(
HGroup(
Item(name="rx_ami_valid", show_label=False, style="simple", enabled_when="False"),
Item(name="rx_ami_file", label="AMI File:", tooltip="Choose AMI file."),
),
HGroup(
Item(name="rx_dll_valid", show_label=False, style="simple", enabled_when="False"),
Item(name="rx_dll_file", label="DLL File:", tooltip="Choose DLL file."),
),
),
VGroup(
Item(
name="rx_use_ami",
label="Use AMI",
tooltip="You must select both files, first.",
enabled_when="rx_ami_valid == True and rx_dll_valid == True",
),
Item(
name="rx_use_getwave",
label="Use GetWave",
tooltip="Use the model's GetWave() function.",
enabled_when="rx_use_ami and rx_has_getwave",
),
Item(
"btn_cfg_rx",
show_label=False,
tooltip="Configure Rx AMI parameters.",
enabled_when="rx_ami_valid == True",
),
),
),
label="IBIS-AMI",
show_border=True,
),
HGroup(
VGroup(
HGroup(
Item(
name="use_ctle_file",
label="fromFile",
tooltip="Select CTLE impulse/step response from file.",
),
Item(name="ctle_file", label="Filename", enabled_when="use_ctle_file == True",
editor=FileEditor(dialog_style="open"),),
),
HGroup(
Item(
name="peak_freq",
label="CTLE fp (GHz)",
tooltip="CTLE peaking frequency (GHz)",
enabled_when="use_ctle_file == False",
),
Item(
name="rx_bw",
label="Bandwidth (GHz)",
tooltip="unequalized signal path bandwidth (GHz).",
enabled_when="use_ctle_file == False",
),
),
HGroup(
Item(
name="peak_mag",
label="CTLE boost (dB)",
tooltip="CTLE peaking magnitude (dB)",
format_str="%4.1f",
enabled_when="use_ctle_file == False",
),
Item(
name="ctle_mode",
label="CTLE mode",
tooltip="CTLE Operating Mode",
enabled_when="use_ctle_file == False",
),
Item(
name="ctle_offset",
tooltip="CTLE d.c. offset (dB)",
show_label=False,
enabled_when='ctle_mode == "Manual"',
),
),
),
label="Native",
show_border=True,
enabled_when="rx_use_ami == False",
),
label="Rx Equalization",
show_border=True,
),
springy=True,
),
HGroup(
VGroup(
HGroup(
Item(name="delta_t", label="Delta-t (ps)", tooltip="magnitude of CDR proportional branch"),
Item(name="alpha", label="Alpha", tooltip="relative magnitude of CDR integral branch"),
),
HGroup(
Item(
name="n_lock_ave",
label="Lock Nave.",
tooltip="# of UI estimates to average, when determining lock",
),
Item(
name="rel_lock_tol", label="Lock Tol.", tooltip="relative tolerance for determining lock"
),
Item(
name="lock_sustain",
label="Lock Sus.",
tooltip="length of lock determining hysteresis vector",
),
),
label="CDR Parameters",
show_border=True,
# enabled_when='rx_use_ami == False or rx_use_ami == True and rx_use_getwave == False',
),
VGroup(
Item(name="use_dfe", label="Use DFE", tooltip="Include DFE in simulation."),
Item(
name="sum_ideal",
label="Ideal DFE",
tooltip="Use ideal DFE. (performance boost)",
enabled_when="use_dfe == True",
),
),
VGroup(
HGroup(
Item(name="n_taps", label="Taps", tooltip="# of taps"),
Item(name="gain", label="Gain", tooltip="error feedback gain"),
Item(name="decision_scaler", label="Level", tooltip="target output magnitude"),
),
HGroup(
Item(name="n_ave", label="Nave.", tooltip="# of CDR adaptations per DFE adaptation"),
Item(
name="sum_bw",
label="BW (GHz)",
tooltip="summing node bandwidth",
enabled_when="sum_ideal == False",
),
),
label="DFE Parameters",
show_border=True,
enabled_when="use_dfe == True",
# enabled_when='rx_use_ami == False or rx_use_ami == True and rx_use_getwave == False',
),
),
# spring,
label="Config.",
id="config",
),
# "Channel" tab.
VGroup( # Channel Parameters
HGroup(
VGroup(
Item(
name="rs",
label="Tx_Rs (Ohms)",
tooltip="Tx differential source impedance",
),
Item(
name="cout",
label="Tx_Cout (pF)",
tooltip="Tx parasitic output capacitance (each pin)",
),
label="Tx",
show_border=True,
),
VGroup(
Item(
name="rin",
label="Rx_Rin (Ohms)",
tooltip="Rx differential input impedance",
),
Item(
name="cin",
label="Rx_Cin (pF)",
tooltip="Rx parasitic input capacitance (each pin)",
),
Item(
name="cac",
label="Rx_Cac (uF)",
tooltip="Rx a.c. coupling capacitance (each pin)",
),
label="Rx",
show_border=True,
),
),
VGroup( # Interconnect
HGroup( # From File
Item(
name="use_ch_file",
show_label=False,
tooltip="Select channel frequency/impulse/step response from file.",
),
Item(name="ch_file", label="File", enabled_when="use_ch_file == True", springy=True,
editor=FileEditor(dialog_style="open"),),
Item(name="Zref", label="Zref", enabled_when="use_ch_file == True",
tooltip="Reference (or, nominal) interconnect impedance."),
Item(name="padded", label="Zero-padded", enabled_when="use_ch_file == True"),
Item(name="windowed", label="Windowed", enabled_when="use_ch_file == True"),
Item(
name="f_step",
label="f_step",
enabled_when="use_ch_file == True",
tooltip="Frequency step to use in generating H(f).",
),
Item(label="MHz"),
label="From File",
show_border=True,
),
VGroup( # Channel Designer
HGroup(
Item(
name="l_ch",
label="Length (m)",
enabled_when="use_ch_file == False",
tooltip="interconnect length",
),
HGroup(
Item(
name="Theta0",
label="Loss Tan.",
tooltip="dielectric loss tangent",
),
Item(
name="Z0",
label="Z0 (Ohms)",
tooltip="characteristic differential impedance",
),
Item(
name="v0",
label="v_rel (c)",
# enabled_when="use_ch_file == False",
tooltip="normalized propagation velocity",
),
Item(
name="Rdc",
label="Rdc (Ohms)",
tooltip="d.c. resistance",
),
Item(
name="w0",
label="w0 (rads./s)",
tooltip="transition frequency",
),
Item(
name="R0",
label="R0 (Ohms)",
tooltip="skin effect resistance",
),
label="Native Channel Parameters",
show_border=True,
enabled_when="use_native == True and use_ch_file == False",
),
),
label="Channel Designer",
show_border=True,
),
label="Interconnect",
show_border=True,
),
label="Channel",
id="channel",
),
# "Optimizer" tab.
VGroup(
HGroup(
Group(
Item(
name="tx_tap_tuners",
editor=TableEditor(
columns=[
ObjectColumn(name="name", editable=False),
ObjectColumn(name="enabled"),
ObjectColumn(name="min_val"),
ObjectColumn(name="max_val"),
ObjectColumn(name="value", format="%+05.3f"),
],
configurable=False,
reorderable=False,
sortable=False,
selection_mode="cell",
auto_size=False,
rows=4,
orientation="horizontal",
is_grid_cell=True,
),
show_label=False,
),
label="Tx Equalization",
show_border=True,
springy=True,
),
# HGroup(
VGroup(
Item(
name="peak_mag_tune",
label="CTLE: boost (dB)",
tooltip="CTLE peaking magnitude (dB)",
format_str="%4.1f",
),
HGroup(
Item(name="peak_freq_tune",
label="fp (GHz)",
tooltip="CTLE peaking frequency (GHz)"
),
Item(
name="rx_bw_tune",
label="BW (GHz)",
tooltip="unequalized signal path bandwidth (GHz).",
),
),
HGroup(
Item(name="ctle_mode_tune", label="mode", tooltip="CTLE Operating Mode"),
Item(
name="ctle_offset_tune",
tooltip="CTLE d.c. offset (dB)",
show_label=False,
enabled_when='ctle_mode_tune == "Manual"',
),
),
HGroup(
Item(name="use_dfe_tune", label="DFE: Enable", tooltip="Include ideal DFE in optimization."),
Item(name="n_taps_tune", label="Taps", tooltip="Number of DFE taps."),
),
label="Rx Equalization",
show_border=True,
),
# ),
VGroup(
Item(
name="max_iter",
label="Max. Iterations",
tooltip="Maximum number of iterations to allow, during optimization.",
),
Item(
name="rel_opt",
label="Rel. Opt.:",
format_str="%7.4f",
tooltip="Relative optimization metric.",
style="readonly",
),
Item(
name="przf_err",
label="PRZF Err.:",
format_str="%5.3f",
tooltip="Pulse Response Zero Forcing approximation error.",
style="readonly",
),
label="Tuning Options",
show_border=True,
),
springy=False,
),
Item(
label="Note: Only CTLE boost will be optimized; please, set peak frequency, bandwidth, and mode appropriately.",
),
Item("plot_h_tune", editor=ComponentEditor(), show_label=False, springy=True),
HGroup(
Item("btn_rst_eq", show_label=False, tooltip="Reset all values to those on the 'Config.' tab."),
Item("btn_save_eq", show_label=False, tooltip="Store all values to 'Config.' tab."),
Item("btn_opt_tx", show_label=False, tooltip="Run Tx tap weight optimization."),
Item("btn_opt_rx", show_label=False, tooltip="Run Rx CTLE optimization."),
Item("btn_coopt", show_label=False, tooltip="Run co-optimization."),
Item("btn_abort", show_label=False, tooltip="Abort all optimizations."),
),
label="Optimizer",
id="eq_tune",
),
Group( # Responses
Group(Item("plots_h", editor=ComponentEditor(), show_label=False), label="Impulses", id="plots_h"),
Group(Item("plots_s", editor=ComponentEditor(), show_label=False), label="Steps", id="plots_s"),
Group(Item("plots_p", editor=ComponentEditor(), show_label=False), label="Pulses", id="plots_p"),
Group(Item("plots_H", editor=ComponentEditor(), show_label=False), label="Freq. Resp.", id="plots_H"),
layout='tabbed',
label='Responses',
id='responses'
),
Group( # Results
Group(Item("plots_dfe", editor=ComponentEditor(), show_label=False), label="DFE", id="plots_dfe"),
Group(Item("plots_out", editor=ComponentEditor(), show_label=False), label="Outputs", id="plots_out"),
Group(Item("plots_eye", editor=ComponentEditor(), show_label=False), label="Eyes", id="plots_eye"),
Group(Item("plots_bathtub", editor=ComponentEditor(), show_label=False), label="Bathtubs", id="plots_bathtub"),
Group(Item("sweep_info", style="readonly", show_label=False), label="Sweep Info"),
layout='tabbed',
label='Results',
id='results'
),
Group( # Jitter
Group(
Item("plots_jitter_dist", editor=ComponentEditor(), show_label=False),
label="Jitter Dist.",
id="plots_jitter_dist",
),
Group(
Item("plots_jitter_spec", editor=ComponentEditor(), show_label=False),
label="Jitter Spec.",
id="plots_jitter_spec",
),
Group(Item("jitter_info", style="readonly", show_label=False), label="Jitter Info"),
layout='tabbed',
label='Jitter',
id='jitter'
),
Group( # Help
Group(
Item("ident", style="readonly", show_label=False),
Item("perf_info", style="readonly", show_label=False),
label="About",
),
Group(Item("instructions", style="readonly", show_label=False), label="Guide"),
Group(Item("console_log", show_label=False, style="custom"), label="Console", id="console"),
layout='tabbed',
label='Help',
id='help'
),
layout="tabbed",
springy=True,
id="tabs",
),
# License: BSD Style.
# configure_traits_view_group.py -- Sample code to demonstrate
# configure_traits()
# --[Imports]--------------------------------------------------------------
from traits.api import HasTraits, Str, Int
from traitsui.api import View, Item, Group
# --[Code]-----------------------------------------------------------------
class SimpleEmployee(HasTraits):
first_name = Str()
last_name = Str()
department = Str()
employee_number = Str()
salary = Int()
view1 = View(
Group(Item(name='first_name'),
Item(name='last_name'),
Item(name='department'),
label='Personnel profile',
show_border=True))
sam = SimpleEmployee()
sam.configure_traits(view=view1)
class SegmentationEditor(ClusterEditor):
# Options for track aggregation
render_segments = Bool(False)
segments_drawn = Bool(False)
segments = List(Instance(Segment))
parameters = []
# Collect labels?
segment_lookup = List()
# local ui
segment_editor_group = segment_editor_group
def __init__(self, **traits):
""" Creates a panel for editing cluster assignments.
"""
super(SegmentationEditor, self).__init__(**traits)
self.segment_editor_group = segment_editor_group
def update_clusters(self):
self.update_segments()
def _auto_aggregate_changed(self):
print "+ automatic aggregation changed:", self.auto_aggregate
if self.auto_aggregate:
self.update_segments()
@on_trait_change('+parameter')
def aggregation_param_changed(self, obj, name, old, new):
print name, "parameter on aggregator changed"
if name in self.parameters and self.auto_aggregate:
self.update_segments()
def _render_segments_changed(self):
print "+ render_segments changed to", self.render_segments
self.scene3d.disable_render = True
for tds in self.track_sets:
tds.set_segment_visibility(self.render_segments)
self.scene3d.disable_render = False
def update_segments(self):
""" Creates new segments when a aggregation parameter has been
changed. Will CREATE MayaVi objects if ``self.interactive``
and ``self.render_segments`` are true.
"""
print "+ Updating segment assignments."
_segments = []
for tnum, tds in enumerate(self.track_sets):
__segments = []
segments = self.segment(tds)
number_of_labeled_segments, indices = summarize_segments(segments)
labels = sorted(number_of_labeled_segments.keys())
for labelnum, label in enumerate(labels):
__segments.append(
Segment(ntracks=len(indices[label]),
segment_id=label,
indices=np.array(indices[label]),
scan_id=tds.scan_id,
segments=segments,
ncoords=number_of_labeled_segments[label]))
# This grabs the colors from the rendered streamlines
tds.set_segments(__segments)
_segments += tds.segments # collect the colorized version
self.segments = _segments
# Take care of the graphics
if self.render_segments:
print "\t++ rendering tracks"
self.draw_segments()
print "+ Aggregation Complete"
## Must be overwritten by a subclass
def segment(self, track_datasets):
raise NotImplementedError()
def draw_segments(self):
if not self.render_segments: return
print "+ Drawing Segments"
self.scene3d.disable_render = True
for tds in self.track_sets:
tds.draw_segments()
self.scene3d.disable_render = False
segment_table = TabularEditor(adapter=SegmentAdapter(), editable=False)
segment_rows = Group(Item(name='segments',
editor=segment_table,
height=400,
show_label=False),
label="Segmentation Options",
show_border=True)
algorithm_widgets = Group()
def default_traits_view(self):
return View(self.segment_editor_group)
browser_view = View(
HSplit(Item('scene3d',
editor=SceneEditor(scene_class=Scene),
height=500,
width=500),
segment_editor_group,
show_labels=False), )
class Volume(Module):
"""The Volume module visualizes scalar fields using volumetric
visualization techniques. This supports ImageData and
UnstructuredGrid data. It also supports the FixedPointRenderer
for ImageData. However, the performance is slow so your best bet
is probably with the ImageData based renderers.
"""
# The version of this class. Used for persistence.
__version__ = 0
volume_mapper_type = DEnum(values_name='_mapper_types',
desc='volume mapper to use')
ray_cast_function_type = DEnum(values_name='_ray_cast_functions',
desc='Ray cast function to use')
volume = ReadOnly
volume_mapper = Property(record=True)
volume_property = Property(record=True)
ray_cast_function = Property(record=True)
lut_manager = Instance(VolumeLUTManager, args=(), allow_none=False,
record=True)
input_info = PipelineInfo(datasets=['image_data',
'unstructured_grid'],
attribute_types=['any'],
attributes=['scalars'])
########################################
# View related code.
update_ctf = Button('Update CTF')
view = View(Group(Item(name='_volume_property', style='custom',
editor=VolumePropertyEditor,
resizable=True),
Item(name='update_ctf'),
label='CTF',
show_labels=False),
Group(Item(name='volume_mapper_type'),
Group(Item(name='_volume_mapper',
style='custom',
resizable=True),
show_labels=False
),
Item(name='ray_cast_function_type'),
Group(Item(name='_ray_cast_function',
enabled_when='len(_ray_cast_functions) > 0',
style='custom',
resizable=True),
show_labels=False),
label='Mapper',
),
Group(Item(name='_volume_property', style='custom',
resizable=True),
label='Property',
show_labels=False),
Group(Item(name='volume', style='custom',
editor=InstanceEditor(),
resizable=True),
label='Volume',
show_labels=False),
Group(Item(name='lut_manager', style='custom',
resizable=True),
label='Legend',
show_labels=False),
resizable=True
)
########################################
# Private traits
_volume_mapper = Instance(tvtk.AbstractVolumeMapper)
_volume_property = Instance(tvtk.VolumeProperty)
_ray_cast_function = Instance(tvtk.Object)
_mapper_types = List(Str, ['TextureMapper2D', 'RayCastMapper', ])
_available_mapper_types = List(Str)
_ray_cast_functions = List(Str)
current_range = Tuple
# The color transfer function.
_ctf = Instance(ColorTransferFunction)
# The opacity values.
_otf = Instance(PiecewiseFunction)
######################################################################
# `object` interface
######################################################################
def __get_pure_state__(self):
d = super(Volume, self).__get_pure_state__()
d['ctf_state'] = save_ctfs(self._volume_property)
for name in ('current_range', '_ctf', '_otf'):
d.pop(name, None)
return d
def __set_pure_state__(self, state):
self.volume_mapper_type = state['_volume_mapper_type']
state_pickler.set_state(self, state, ignore=['ctf_state'])
ctf_state = state['ctf_state']
ctf, otf = load_ctfs(ctf_state, self._volume_property)
self._ctf = ctf
self._otf = otf
self._update_ctf_fired()
######################################################################
# `Module` interface
######################################################################
def start(self):
super(Volume, self).start()
self.lut_manager.start()
def stop(self):
super(Volume, self).stop()
self.lut_manager.stop()
def setup_pipeline(self):
"""Override this method so that it *creates* the tvtk
pipeline.
"""
v = self.volume = tvtk.Volume()
vp = self._volume_property = tvtk.VolumeProperty()
self._ctf = ctf = default_CTF(0, 255)
self._otf = otf = default_OTF(0, 255)
vp.set_color(ctf)
vp.set_scalar_opacity(otf)
vp.shade = True
vp.interpolation_type = 'linear'
v.property = vp
v.on_trait_change(self.render)
vp.on_trait_change(self.render)
available_mappers = find_volume_mappers()
if is_volume_pro_available():
self._mapper_types.append('VolumeProMapper')
available_mappers.append('VolumeProMapper')
self._available_mapper_types = available_mappers
if 'FixedPointVolumeRayCastMapper' in available_mappers:
self._mapper_types.append('FixedPointVolumeRayCastMapper')
self.actors.append(v)
def update_pipeline(self):
"""Override this method so that it *updates* the tvtk pipeline
when data upstream is known to have changed.
This method is invoked (automatically) when any of the inputs
sends a `pipeline_changed` event.
"""
mm = self.module_manager
if mm is None:
return
dataset = mm.source.get_output_dataset()
ug = hasattr(tvtk, 'UnstructuredGridVolumeMapper')
if ug:
if not dataset.is_a('vtkImageData') \
and not dataset.is_a('vtkUnstructuredGrid'):
error('Volume rendering only works with '\
'StructuredPoints/ImageData/UnstructuredGrid datasets')
return
elif not dataset.is_a('vtkImageData'):
error('Volume rendering only works with '\
'StructuredPoints/ImageData datasets')
return
self._setup_mapper_types()
self._setup_current_range()
self._volume_mapper_type_changed(self.volume_mapper_type)
self._update_ctf_fired()
self.pipeline_changed = True
def update_data(self):
"""Override this method so that it flushes the vtk pipeline if
that is necessary.
This method is invoked (automatically) when any of the inputs
sends a `data_changed` event.
"""
self._setup_mapper_types()
self._setup_current_range()
self._update_ctf_fired()
self.data_changed = True
######################################################################
# Non-public methods.
######################################################################
def _setup_mapper_types(self):
"""Sets up the mapper based on input data types.
"""
dataset = self.module_manager.source.get_output_dataset()
if dataset.is_a('vtkUnstructuredGrid'):
if hasattr(tvtk, 'UnstructuredGridVolumeMapper'):
check = ['UnstructuredGridVolumeZSweepMapper',
'UnstructuredGridVolumeRayCastMapper',
]
mapper_types = []
for mapper in check:
if mapper in self._available_mapper_types:
mapper_types.append(mapper)
if len(mapper_types) == 0:
mapper_types = ['']
self._mapper_types = mapper_types
return
else:
if dataset.point_data.scalars.data_type not in \
[vtkConstants.VTK_UNSIGNED_CHAR,
vtkConstants.VTK_UNSIGNED_SHORT]:
if 'FixedPointVolumeRayCastMapper' \
in self._available_mapper_types:
self._mapper_types = ['FixedPointVolumeRayCastMapper']
else:
error('Available volume mappers only work with \
unsigned_char or unsigned_short datatypes')
else:
mapper_types = ['TextureMapper2D', 'RayCastMapper']
check = ['FixedPointVolumeRayCastMapper',
'VolumeProMapper'
]
for mapper in check:
if mapper in self._available_mapper_types:
mapper_types.append(mapper)
self._mapper_types = mapper_types
def _setup_current_range(self):
mm = self.module_manager
# Set the default name and range for our lut.
lm = self.lut_manager
slm = mm.scalar_lut_manager
lm.set(default_data_name=slm.default_data_name,
default_data_range=slm.default_data_range)
# Set the current range.
dataset = mm.source.get_output_dataset()
sc = dataset.point_data.scalars
if sc is not None:
rng = sc.range
else:
error('No scalars in input data!')
rng = (0, 255)
if self.current_range != rng:
self.current_range = rng
def _get_volume_mapper(self):
return self._volume_mapper
def _get_volume_property(self):
return self._volume_property
def _get_ray_cast_function(self):
return self._ray_cast_function
def _volume_mapper_type_changed(self, value):
mm = self.module_manager
if mm is None:
return
old_vm = self._volume_mapper
if old_vm is not None:
old_vm.on_trait_change(self.render, remove=True)
if value == 'RayCastMapper':
new_vm = tvtk.VolumeRayCastMapper()
self._volume_mapper = new_vm
self._ray_cast_functions = ['RayCastCompositeFunction',
'RayCastMIPFunction',
'RayCastIsosurfaceFunction']
new_vm.volume_ray_cast_function = tvtk.VolumeRayCastCompositeFunction()
elif value == 'TextureMapper2D':
new_vm = tvtk.VolumeTextureMapper2D()
self._volume_mapper = new_vm
self._ray_cast_functions = ['']
elif value == 'VolumeProMapper':
new_vm = tvtk.VolumeProMapper()
self._volume_mapper = new_vm
self._ray_cast_functions = ['']
elif value == 'FixedPointVolumeRayCastMapper':
new_vm = tvtk.FixedPointVolumeRayCastMapper()
self._volume_mapper = new_vm
self._ray_cast_functions = ['']
elif value == 'UnstructuredGridVolumeRayCastMapper':
new_vm = tvtk.UnstructuredGridVolumeRayCastMapper()
self._volume_mapper = new_vm
self._ray_cast_functions = ['']
elif value == 'UnstructuredGridVolumeZSweepMapper':
new_vm = tvtk.UnstructuredGridVolumeZSweepMapper()
self._volume_mapper = new_vm
self._ray_cast_functions = ['']
src = mm.source
self.configure_connection(new_vm, src)
self.volume.mapper = new_vm
new_vm.on_trait_change(self.render)
def _update_ctf_fired(self):
set_lut(self.lut_manager.lut, self._volume_property)
self.render()
def _current_range_changed(self, old, new):
rescale_ctfs(self._volume_property, new)
self.render()
def _ray_cast_function_type_changed(self, old, new):
rcf = self.ray_cast_function
if len(old) > 0:
rcf.on_trait_change(self.render, remove=True)
if len(new) > 0:
new_rcf = getattr(tvtk, 'Volume%s'%new)()
new_rcf.on_trait_change(self.render)
self._volume_mapper.volume_ray_cast_function = new_rcf
self._ray_cast_function = new_rcf
else:
self._ray_cast_function = None
self.render()
def _scene_changed(self, old, new):
super(Volume, self)._scene_changed(old, new)
self.lut_manager.scene = new
class Animator(HasTraits):
""" Convenience class to manage a timer and present a convenient
UI. This is based on the code in `tvtk.tools.visual`.
Here is a simple example of using this class::
>>> from mayavi import mlab
>>> def anim():
... f = mlab.gcf()
... while 1:
... f.scene.camera.azimuth(10)
... f.scene.render()
... yield
...
>>> anim = anim()
>>> t = Animator(500, anim.next)
>>> t.edit_traits()
This makes it very easy to animate your visualizations and control
it from a simple UI.
**Notes**
If you want to modify the data plotted by an `mlab` function call,
please refer to the section on: :ref:`mlab-animating-data`
"""
########################################
# Traits.
start = Button('Start Animation')
stop = Button('Stop Animation')
delay = Range(10, 100000, 500, desc='frequency with which timer is called')
# The internal timer we manage.
timer = Any
######################################################################
# User interface view
traits_view = View(Group(Item('start'), Item('stop'), show_labels=False),
Item('_'),
Item(name='delay'),
title='Animation Controller',
buttons=['OK'])
######################################################################
# Initialize object
def __init__(self, millisec, callable, *args, **kwargs):
"""Constructor.
**Parameters**
:millisec: int specifying the delay in milliseconds
between calls to the callable.
:callable: callable function to call after the specified
delay.
:\*args: optional arguments to be passed to the callable.
:\*\*kwargs: optional keyword arguments to be passed to the callable.
"""
HasTraits.__init__(self)
self.delay = millisec
self.ui = None
self.timer = Timer(millisec, callable, *args, **kwargs)
######################################################################
# `Animator` protocol.
######################################################################
def show(self):
"""Show the animator UI.
"""
self.ui = self.edit_traits()
def close(self):
"""Close the animator UI.
"""
if self.ui is not None:
self.ui.dispose()
######################################################################
# Non-public methods, Event handlers
def _start_fired(self):
self.timer.Start(self.delay)
def _stop_fired(self):
self.timer.Stop()
def _delay_changed(self, value):
t = self.timer
if t is None:
return
if t.IsRunning():
t.Stop()
t.Start(value)
elif self.position < 1:
raise ValueError("Invalid position")
PhaseValue(self.model, self, *self._get_attributes())
self.error = False
except Exception, e:
self.error = True
self.error_msg = str(e)
view = View(Group(VGroup(
Item("position", style="custom"),
Item("id", label="Port-ID", style="custom"),
Item("name"),
Item("start_value"),
Item("end_value"),
Item("ticks"),
Item("reset_time"),
),
Group(UItem("error_msg", style="readonly"),
label="Error:",
visible_when="error",
show_border=True,
style_sheet="*{color:red}"),
label="Value-Phase"),
buttons=[ConfirmButton, CancelButton],
resizable=True,
width=300,
height=200,
title="Create Value-Phase")
class PhaseTime(Phase):
class DofCellView(CellView):
'''View a single cell instance.
'''
# implements(ICellView)
elem_dofs = Array
def set_cell_traits(self):
'''Set the trait values for the current cell_idx
'''
self.elem_dofs = self.cell_grid.get_cell_dofs(self.cell_idx)
#---------------------------------------------------------------------
# Visualize
#---------------------------------------------------------------------
draw_cell = Bool(False)
view = View(
Item('cell_idx', style='readonly',
resizable=False, label='Cell index'),
Group(Item('elem_dofs',
editor=dof_tabular_editor,
show_label=False,
resizable=True,
style='readonly')),
Item('draw_cell', label='show DOFs')
)
# register the pipelines for plotting labels and geometry
#
# mvp_elem_labels = Trait(MVPointLabels)
#
# def _mvp_elem_labels_default(self):
# return MVPointLabels(name='Geo node numbers',
# points=self._get_cell_mvpoints,
# vectors=self._get_cell_labels,
# color=(0.0, 0.411765, 0.882353))
#
# mvp_elem_geo = Trait(MVPolyData)
#
# def _mvp_elem_geo_default(self):
# return MVPolyData(name='Geo node numbers',
# points=self._get_elem_points,
# lines=self._get_elem_lines,
# color=(0.254902, 0.411765, 0.882353))
def _get_cell_mvpoints(self):
return self.cell_grid.get_cell_mvpoints(self.cell_idx)
def _get_cell_labels(self):
cell_dofs = self.cell_grid.get_cell_dofs(self.cell_idx)
shape = cell_dofs.shape
if shape[1] < 3:
cd = np.zeros((shape[0], 3))
cd[:, :shape[1]] = cell_dofs
return cd
else:
return cell_dofs
def redraw(self):
if self.draw_cell:
self.mvp_elem_labels.redraw(label_mode='label_vectors')
# View描述了界面的视图类，Item模块描述了界面中的控件类
g1 = [
Item("model_name", label=u"模型名称"),
Item("category", label=u"模型类型"),
]
g2 = [
Item("model_number", label=u"模型数量"),
Item("vertices", label=u"顶点数量"),
]
class ModelManager(HasTraits):
model_name = Str
category = Str
model_number = Int
vertices = Int
traits_view = View(Group(*g1, label=u"模型信息", show_border=True),
Group(*g2, label=u"统计数据", show_border=True),
title=u"内部视图")
global_view = View(Group(*g1, label=u"模型信息11", show_border=True),
Group(*g2, label=u"统计数据11", show_border=True),
title=u"外部视图")
model = ModelManager()
# model.configure_traits() #默认是内部视图
# model.configure_traits(view="traits_view") #有选择的选中某个内部视图
model.configure_traits(view=global_view) #直接将外部视图赋给view
