예제 #1
0
def surf_regular(source):
    """Now visualize the data as done in mlab.
    """
    w = WarpScalar()
    source.add_child(w)
    s = Surface()
    w.add_child(s)
예제 #2
0
def surf_regular(source):
    """Now visualize the data as done in mlab.
    """
    w = WarpScalar()
    source.add_child(w)
    s = Surface()
    w.add_child(s)
예제 #3
0
 def add_source_data(self, data):
     from enthought.mayavi.filters.poly_data_normals import PolyDataNormals
     d = VTKDataSource()
     d.data = data
     obj = self.scene.add_child(d)
     w = WarpScalar()
     d.add_child(w)
     n = PolyDataNormals()
     n.filter.feature_angle = 45
     w.add_child(n)
     s = Surface()
     n.add_child(s)
예제 #4
0
 def add_source_data(self, data):
     from enthought.mayavi.filters.poly_data_normals import PolyDataNormals
     d = VTKDataSource()
     d.data = data
     obj = self.scene.add_child(d)
     w = WarpScalar()
     d.add_child(w)
     n = PolyDataNormals()
     n.filter.feature_angle = 45
     w.add_child(n)
     s = Surface()
     n.add_child(s)
예제 #5
0
def surf_regular():
    """Now visualize the data as done in mlab.
    """
    w = WarpScalar()
    mayavi.add_filter(w)
    o = Outline()
    s = Surface()
    mayavi.add_module(o)
    mayavi.add_module(s)
예제 #6
0
def view():
    from enthought.mayavi.sources.vtk_data_source import VTKDataSource
    from enthought.mayavi.filters.warp_scalar import WarpScalar
    from enthought.mayavi.filters.poly_data_normals import PolyDataNormals
    from enthought.mayavi.modules.surface import Surface

    mayavi.new_scene()
    src = VTKDataSource(data = spoints)
    mayavi.add_source(src)
    mayavi.add_filter(WarpScalar())
    mayavi.add_filter(PolyDataNormals())
    s = Surface()
    mayavi.add_module(s)
예제 #7
0
    def setup_pipeline(self):
        """Override this method so that it *creates* the 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.  You should also
        set the `actors` attribute up at this point.
        """
        # Create the objects.
        self.implicit_plane = ImplicitPlane()
        self.cutter = Cutter()        
        self.contour = Contour(auto_contours=True, number_of_contours=10)
        self.warp_scalar = WarpScalar()
        self.normals = PolyDataNormals()
        self.actor = Actor()
        
        # Setup the actor suitably for this module.
        prop = self.actor.property
        prop.line_width = 2.0
예제 #8
0

def f(x, y):
    return numpy.sin(x * y) / (x * y)


x = numpy.arange(-7., 7.05, 0.1)
y = numpy.arange(-5., 5.05, 0.05)
from enthought.tvtk.tools import mlab
s = mlab.SurfRegular(x, y, f)
from enthought.mayavi.sources.vtk_data_source import VTKDataSource
d = VTKDataSource()
d.data = s.data
mayavi.add_source(d)
from enthought.mayavi.filters.warp_scalar import WarpScalar
w = WarpScalar()
mayavi.add_filter(w)
from enthought.mayavi.modules.outline import Outline
from enthought.mayavi.modules.surface import Surface
o = Outline()
s = Surface()
mayavi.add_module(o)
mayavi.add_module(s)

# <markdowncell>

# You can run this script by running "mayavi2 -n -x script.py", loading it
# through the menu (File -\> Open File), and pressing Ctrl+R, or entering
# "execfile('script.py') in the python shell.
#
# ![](files/MayaVi(2f)Surf_attachments/surf.png
예제 #9
0
import re
print "  done."

frames = glob("output/frame_scal*.vtk")
frames.sort()
max_frame_number = int(re.search("(\d+)", frames[-1]).groups()[0])

print "plotting the main frame..."
width = 640
height = 480
mlab.figure(size=(width, height+32))
mlab.options.offscreen = True
engine = mlab.get_engine()
vtk_file_reader = engine.open(u'output/frame_scal0000.vtk')

warp_scalar = WarpScalar()
engine.add_filter(warp_scalar, vtk_file_reader)
surface = Surface()
engine.add_filter(surface, warp_scalar)
warp_scalar.filter.normal = array([ 0.,  0.,  1.])
warp_scalar.filter.scale_factor = 10.0

module_manager = engine.scenes[0].children[0].children[0].children[0]
module_manager.scalar_lut_manager.use_default_range = False
module_manager.scalar_lut_manager.data_range = array([-1.5, 1.5])
module_manager.scalar_lut_manager.show_scalar_bar = True

mlab.view(-122, 53, 26, array([7.5, 2.5, -0.11]))
mlab.roll(40)
print "  done."
예제 #10
0
    def do(self):
        ############################################################
        # Imports.
        script = self.script
        from enthought.mayavi.filters.optional import Optional
        from enthought.mayavi.filters.warp_scalar import WarpScalar
        from enthought.mayavi.filters.cut_plane import CutPlane
        from enthought.mayavi.components.poly_data_normals import PolyDataNormals
        from enthought.mayavi.components.contour import Contour
        from enthought.mayavi.components.actor import Actor
        from enthought.mayavi.modules.generic_module import GenericModule
        from enthought.mayavi.sources.vtk_xml_file_reader import VTKXMLFileReader

        ############################################################
        # Create a new scene and set up the visualization.
        s = self.new_scene()

        # Read a VTK (old style) data file.
        r = VTKXMLFileReader()
        r.initialize(get_example_data('fire_ug.vtu'))
        script.add_source(r)

        # We now create the complete equivalent of a ScalarCutPlane in
        # the next block!
        cp = CutPlane()
        w = WarpScalar()
        warper = Optional(filter=w, label_text='Enable warping', enabled=False)
        c = Contour()
        ctr = Optional(filter=c, label_text='Enable contours', enabled=False)
        p = PolyDataNormals(name='Normals') 
        normals = Optional(filter=p, label_text='Compute normals', enabled=False)
        a = Actor()
        components = [cp, warper, ctr, normals, a]
        m = GenericModule(name='ScalarCutPlane',
                          components=components,
                          contour=c, actor=a)

        script.add_module(m)
        s.scene.isometric_view()

        ########################################
        # do the testing.
        def check(mod):
            """Check if test status is OK for the given module."""
            cut, warper, ctr, normals, a = mod.components
            c = ctr.filter
            # The intermediate ones are disabled.
            assert normals.outputs[0] is cut.outputs[0]
            # Enable the contours.
            ctr.enabled = True
            assert ctr.outputs[0] is c.outputs[0]
            assert ctr.outputs[0] is normals.outputs[0]
            rng = normals.outputs[0].point_data.scalars.range
            assert (rng[1] - rng[0]) < 1e-4
            # Turn on auto-contours
            c.auto_contours = True
            assert len(normals.outputs[0].points) == 0
            # Increase number of contours and the range should change.
            c.number_of_contours = 10
            assert len(normals.outputs[0].points) != 0
            rng = normals.outputs[0].point_data.scalars.range
            assert rng[0] < rng[1]
            # Check if pipeline_changed is correctly propagated.
            old = normals.outputs[0]
            assert a.mapper.scalar_mode == 'default'
            c.filled_contours = True
            assert normals.outputs[0] != old
            assert normals.outputs[0] is c.outputs[0]
            # Check if the actor responds correctly to the
            # filled_contour change.
            assert a.mapper.scalar_mode == 'use_cell_data'

            # Set back everything to original state.
            c.filled_contours = False
            assert a.mapper.scalar_mode == 'default'
            c.number_of_contours = 1
            c.auto_contours = False
            ctr.enabled = False
            assert normals.outputs[0] is cut.outputs[0]

        check(m)

        ############################################################
        # Test if saving a visualization and restoring it works.

        # Save visualization.
        f = StringIO()
        f.name = abspath('test.mv2') # We simulate a file.
        script.save_visualization(f)
        f.seek(0) # So we can read this saved data.

        # Remove existing scene.
        engine = script.engine
        engine.close_scene(s)

        # Load visualization
        script.load_visualization(f)
        s = engine.current_scene
        s.scene.isometric_view()

        # Now do the check.
        m = s.children[0].children[0].children[0]
        check(m)

        ############################################################
        # Test if the Mayavi2 visualization can be deep-copied.

        # Pop the source object.
        source = s.children.pop()
        # Add it back to see if that works without error.
        s.children.append(source)
        # Now do the check.
        m = s.children[0].children[0].children[0]
        s.scene.isometric_view()
        check(m)

        # Now deepcopy the source and replace the existing one with
        # the copy.  This basically simulates cutting/copying the
        # object from the UI via the right-click menu on the tree
        # view, and pasting the copy back.
        source1 = copy.deepcopy(source)
        s.children[0] = source1
        # Now do the check.
        m = s.children[0].children[0].children[0]
        s.scene.isometric_view()
        check(m)