def main():
# Create the MayaVi engine and start it.
e = Engine()
# Starting the engine registers the engine with the registry and
# notifies others that the engine is ready.
e.start()
# Do this if you need to see the MayaVi tree view UI.
ev = EngineView(engine=e)
ui = ev.edit_traits()
# Create a new scene.
scene = e.new_scene()
# Now create a new scene just for kicks.
scene1 = e.new_scene()
# Now setup a normal MayaVi pipeline.
src = VTKXMLFileReader()
src.initialize(join(get_data_dir(abspath(__file__)),
'fire_ug.vtu'))
e.add_source(src)
e.add_module(Outline())
e.add_module(ScalarCutPlane())
e.add_module(Streamline())
return e, ui
def main():
# Create the MayaVi engine and start it.
e = Engine()
# Starting the engine registers the engine with the registry and
# notifies others that the engine is ready.
e.start()
# Do this if you need to see the MayaVi tree view UI.
ev = EngineView(engine=e)
ui = ev.edit_traits()
# Create a new scene.
scene = e.new_scene()
# Now create a new scene just for kicks.
scene1 = e.new_scene()
# Now setup a normal MayaVi pipeline.
src = VTKXMLFileReader()
src.initialize(join(get_data_dir(abspath(__file__)),
'fire_ug.vtu'))
e.add_source(src)
e.add_module(Outline())
e.add_module(ScalarCutPlane())
e.add_module(Streamline())
return e, ui
def __init__(self,type,r,penal,move,e,nu,volfac,**traits):
HasTraits.__init__(self, **traits)
self.scene.mayavi_scene.name = 'Geometry'
self.scene.foreground = (1,170/255,0)
self.scene0.mayavi_scene.name = 'Displacement'
self.scene1.mayavi_scene.name = 'Stress'
self.scene2.mayavi_scene.name = 'Strain'
self.scene3.mayavi_scene.name = 'Density'
self.scene4.mayavi_scene.name = 'Animate'
#初始化enine_view
self.engine_view = EngineView(engine=self.scene.engine)
#对current_selection 进行动态监听，如果current_selection的值发生变化就调用 self._selection_change
self.scene.engine.on_trait_change(self._selection_change,name = 'current_selection')
self.simp_solver = None
self.type = type
self.r = r
self.penal = penal
self.move = move
self.e = e
self.nu = nu
self.volfac = volfac
self.address = 'H:\GitHub\Topology-optimization-of-structure-via-simp-method'
self.i = 1
def show_engine(self, engine=None, rich_view=True):
""" Show a dialog with the mayavi pipeline. This dialog allows to
edit graphicaly the properties of the different objects on
the scenes.
"""
if engine is None:
engine = self.get_engine()
if engine.__class__.__name__ == 'EnvisageEngine' or \
options.backend == 'test':
# FIXME: This should pop up the relevent envisage view
pass
elif rich_view:
from mayavi.core.ui.engine_rich_view import \
EngineRichView
figure = engine.current_scene
view = EngineRichView(engine=engine)
if figure is None:
scene = None
else:
scene = figure.scene
return view.scene_editing_view(scene=scene)
else:
from mayavi.core.ui.engine_view import \
EngineView
scene = engine.current_scene
view = EngineView(engine=engine)
return view.edit_traits()
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 view3d(sgrid):
from mayavi.sources.vtk_data_source import VTKDataSource
from mayavi.modules.api import Outline, GridPlane
from mayavi.api import Engine
from mayavi.core.ui.engine_view import EngineView
e=Engine()
e.start()
s = e.new_scene()
# Do this if you need to see the MayaVi tree view UI.
ev = EngineView(engine=e)
ui = ev.edit_traits()
# mayavi.new_scene()
src = VTKDataSource(data=sgrid)
e.add_source(src)
e.add_module(Outline())
g = GridPlane()
g.grid_plane.axis = 'x'
e.add_module(g)
def __init__(self, **traits):
HasTraits.__init__(self, **traits)
self.engine_view = EngineView(engine=self.scene.engine)
# Hook up the current_selection to change when the one in the engine
# changes. This is probably unnecessary in Traits3 since you can show
# the UI of a sub-object in T3.
self.scene.engine.on_trait_change(self._selection_change,
'current_selection')
self.generate_data_mayavi()
def main():
# Create the MayaVi engine and start it.
e = Engine()
# Starting the engine registers the engine with the registry and
# notifies others that the engine is ready.
e.start()
# Do this if you need to see the MayaVi tree view UI.
ev = EngineView(engine=e)
ui = ev.edit_traits()
# Create a new scene.
#scene = e.new_scene()
#renderLearningData('pattern.json')
#scene = e.new_scene()
#renderLearningData('pattern2.json')
#renderLearningData('pattern3.json')
scene = e.new_scene()
ExampleRenderer('cluster.json', scene)
scene = e.new_scene()
ExampleRenderer('nocluster.json', scene)
show()
return e, ui
def _engine_view_factory(self, window, **traits):
""" Factory method for engine views. """
from pyface.workbench.traits_ui_view import \
TraitsUIView
from mayavi.core.ui.engine_view import \
EngineView
engine_view = EngineView(engine=self._get_engine(window))
tui_engine_view = TraitsUIView(obj=engine_view,
id=ENGINE_VIEW,
name='Mayavi',
window=window,
position='left',
**traits)
return tui_engine_view
def main():
parser = argparse.ArgumentParser()
parser.add_argument('filename', nargs='+',
help='name of flydra .hdf5 file',
)
parser.add_argument("--stim-xml",
type=str,
default=None,
help="name of XML file with stimulus info",
required=True,
)
parser.add_argument("--align-json",
type=str,
default=None,
help="previously exported json file containing s,R,T",
)
parser.add_argument("--radius", type=float,
help="radius of line (in meters)",
default=0.002,
metavar="RADIUS")
parser.add_argument("--obj-only", type=str)
parser.add_argument("--obj-filelist", type=str,
help="use object ids from list in text file",
)
parser.add_argument(
"-r", "--reconstructor", dest="reconstructor_path",
type=str,
help=("calibration/reconstructor path (if not specified, "
"defaults to FILE)"))
args = parser.parse_args()
options = args # optparse OptionParser backwards compatibility
reconstructor_path = args.reconstructor_path
fps = None
ca = core_analysis.get_global_CachingAnalyzer()
by_file = {}
for h5_filename in args.filename:
assert(tables.is_hdf5_file(h5_filename))
obj_ids, use_obj_ids, is_mat_file, data_file, extra = ca.initial_file_load(
h5_filename)
this_fps = result_utils.get_fps( data_file, fail_on_error=False )
if fps is None:
if this_fps is not None:
fps = this_fps
if reconstructor_path is None:
reconstructor_path = data_file
by_file[h5_filename] = (use_obj_ids, data_file)
del h5_filename
del obj_ids, use_obj_ids, is_mat_file, data_file, extra
if options.obj_only is not None:
obj_only = core_analysis.parse_seq(options.obj_only)
else:
obj_only = None
if reconstructor_path is None:
raise RuntimeError('must specify reconstructor from CLI if not using .h5 files')
R = reconstruct.Reconstructor(reconstructor_path)
if fps is None:
fps = 100.0
warnings.warn('Setting fps to default value of %f'%fps)
else:
fps = 1.0
if options.stim_xml is None:
raise ValueError(
'stim_xml must be specified (how else will you align the data?')
if 1:
stim_xml = xml_stimulus.xml_stimulus_from_filename(
options.stim_xml,
)
try:
fanout = xml_stimulus.xml_fanout_from_filename( options.stim_xml )
except xml_stimulus.WrongXMLTypeError:
pass
else:
include_obj_ids, exclude_obj_ids = fanout.get_obj_ids_for_timestamp(
timestamp_string=file_timestamp )
if include_obj_ids is not None:
use_obj_ids = include_obj_ids
if exclude_obj_ids is not None:
use_obj_ids = list( set(use_obj_ids).difference(
exclude_obj_ids ) )
print('using object ids specified in fanout .xml file')
if stim_xml.has_reconstructor():
stim_xml.verify_reconstructor(R)
x = []
y = []
z = []
speed = []
if options.obj_filelist is not None:
obj_filelist=options.obj_filelist
else:
obj_filelist=None
if obj_filelist is not None:
obj_only = 1
if obj_only is not None:
if len(by_file) != 1:
raise RuntimeError("specifying obj_only can only be done for a single file")
if obj_filelist is not None:
data = np.loadtxt(obj_filelist,delimiter=',')
obj_only = np.array(data[:,0], dtype='int')
print(obj_only)
use_obj_ids = numpy.array(obj_only)
h5_filename = by_file.keys()[0]
(prev_use_ob_ids, data_file) = by_file[h5_filename]
by_file[h5_filename] = (use_obj_ids, data_file)
for h5_filename in by_file:
(use_obj_ids, data_file) = by_file[h5_filename]
for obj_id_enum,obj_id in enumerate(use_obj_ids):
rows = ca.load_data( obj_id, data_file,
use_kalman_smoothing=False,
#dynamic_model_name = dynamic_model_name,
#frames_per_second=fps,
#up_dir=up_dir,
)
verts = numpy.array( [rows['x'], rows['y'], rows['z']] ).T
if len(verts)>=3:
verts_central_diff = verts[2:,:] - verts[:-2,:]
dt = 1.0/fps
vels = verts_central_diff/(2*dt)
speeds = numpy.sqrt(numpy.sum(vels**2,axis=1))
# pad end points
speeds = numpy.array([speeds[0]] + list(speeds) + [speeds[-1]])
else:
speeds = numpy.zeros( (verts.shape[0],) )
if verts.shape[0] != len(speeds):
raise ValueError('mismatch length of x data and speeds')
x.append( verts[:,0] )
y.append( verts[:,1] )
z.append( verts[:,2] )
speed.append(speeds)
data_file.close()
del h5_filename, use_obj_ids, data_file
if 0:
# debug
if stim_xml is not None:
v = None
for child in stim_xml.root:
if child.tag == 'cubic_arena':
info = stim_xml._get_info_for_cubic_arena(child)
v=info['verts4x4']
if v is not None:
for vi in v:
print('adding',vi)
x.append( [vi[0]] )
y.append( [vi[1]] )
z.append( [vi[2]] )
speed.append( [100.0] )
x = np.concatenate(x)
y = np.concatenate(y)
z = np.concatenate(z)
w = np.ones_like(x)
speed = np.concatenate(speed)
# homogeneous coords
verts = np.array([x,y,z,w])
#######################################################
# Create the MayaVi engine and start it.
e = Engine()
# start does nothing much but useful if someone is listening to
# your engine.
e.start()
# Create a new scene.
from tvtk.tools import ivtk
#viewer = ivtk.IVTK(size=(600,600))
viewer = IVTKWithCalGUI(size=(800,600))
viewer.open()
e.new_scene(viewer)
viewer.cal_align.set_data(verts,speed,R,args.align_json)
if 0:
# Do this if you need to see the MayaVi tree view UI.
ev = EngineView(engine=e)
ui = ev.edit_traits()
# view aligned data
e.add_source(viewer.cal_align.source)
v = Vectors()
v.glyph.scale_mode = 'data_scaling_off'
v.glyph.color_mode = 'color_by_scalar'
v.glyph.glyph_source.glyph_position='center'
v.glyph.glyph_source.glyph_source = tvtk.SphereSource(
radius=options.radius,
)
e.add_module(v)
if stim_xml is not None:
if 0:
stim_xml.draw_in_mayavi_scene(e)
else:
actors = stim_xml.get_tvtk_actors()
viewer.scene.add_actors(actors)
gui = GUI()
gui.start_event_loop()
