Changeset 2194


Ignore:
Timestamp:
Jan 10, 2006, 3:53:39 PM (19 years ago)
Author:
jack
Message:

Shallow_water.py now uses the VTK visualiser, which now works.

Location:
inundation/pyvolution
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • inundation/pyvolution/shallow_water.py

    r2143 r2194  
    111111        #Realtime visualisation
    112112        if self.visualiser is None:
    113             from realtime_visualisation_new import Visualiser
    114             #from vtk_realtime_visualiser import Visualiser
     113            #from realtime_visualisation_new import Visualiser
     114            from vtk_realtime_visualiser import Visualiser
    115115            self.visualiser = Visualiser(self,scale_z,rect)
    116116            self.visualiser.setup['elevation']=True
    … …  
    120120            self.visualiser.coloring['stage'] = True
    121121            self.visualiser.qcolor['stage'] = (0.0, 0.0, 0.8)
     122        self.visualiser.start()
    122123
    123124    def check_integrity(self):
    … …  
    204205        #Initial update of vertex and edge values before any storage
    205206        #and or visualisation
    206         self.distribute_to_vertices_and_edges()
    207 
     207        #self.distribute_to_vertices_and_edges()
     208        s = '''for x in range(5):
     209  self.distribute_to_vertices_and_edges()'''
     210        global profiler
     211        profiler = profiler.runctx(s, globals(), locals())
    208212
    209213        #Initialise real time viz if requested
    … …  
    212216            #import realtime_visualisation_new as visualise
    213217            #visualise.create_surface(self)
    214             self.initialise_visualiser()
     218            #self.initialise_visualiser()
    215219            self.visualiser.setup_all()
    216220            self.visualiser.update_timer()
    … …  
    233237            if self.visualise is True:
    234238                #pass
    235                 self.visualiser.update_all()
    236                 self.visualiser.update_timer()
     239                #Obseleted by the VTK-Visualiser
     240                #self.visualiser.update_all()
     241                #self.visualiser.update_timer()
     242                self.visualiser.request_redraw()
    237243
    238244            #Store model data, e.g. for subsequent visualisation
    … …  
    245251            #Pass control on to outer loop for more specific actions
    246252            yield(t)
    247 
    248 
     253        import pypar       
     254        profiler.dump_stats("distrib_profile." + str(pypar.size()) + "." + str(pypar.rank()) + ".dat")
    249255    def initialise_storage(self):
    250256        """Create and initialise self.writer object for storing data.
    … …  
    18031809if __name__ == "__main__":
    18041810    pass
     1811
     1812# Profiling stuff
     1813import profile
     1814profiler = profile.Profile()

  • inundation/pyvolution/vtk_realtime_visualiser.py

    r2152 r2194  
    33
    44import threading
     5from Queue import Queue, Empty
    56import Tkinter
    67import vtk
    … …  
    1112    """A VTK-powered visualiser, designed to replace the VPython one.
    1213    Intended to be run in its own thread
    13 
    14     Functions:
    15 
    16     run: Overrides threading.Thread.run(). Do not call. Called by
    17     inherited start().
    18 
    19     initialise_gui: Create the TK window and makes the vtk renderer
    20     available.
    21 
    22     add_axes: Draw axes onto the renderer.
    23    
    2414    """
    2515
    26     def __init__(self, domain, scale_z=1.0, rect=None, title='Test'):
     16    def __init__(self, domain, default_scale_z=1.0, rect=None, title='Test'):
    2717        threading.Thread.__init__(self)
    2818        # Initialise data structures. coloring, setup and updating are maps
    2919        # quantity name -> boolean, setup means to render it,
    3020        # update means to update with time.
    31         # qcolor maps quantity name -> (float, float, float): the colour
     21        # qcolor maps quantity name -> (float, float, float): the colour (r, g, b)
    3222        # to render a quantity.
    3323        self.setup = {}
    … …  
    3626        self.qcolor = {}
    3727        self.scale_z = {}
    38         self.default_scale_z = scale_z
     28        self.default_scale_z = default_scale_z
    3929        self.domain = domain
    4030        self.vertices = domain.vertex_coordinates
     31
     32        self.messages = Queue()
     33
     34        # Internal use - storage of vtk objects
     35        self.grids = {}
     36        self.actors = {}
     37        self.polydata = {}
     38        self.mappers = {}
    4139
    4240        # Default options
    … …  
    6260        self.range_y = self.max_y - self.min_y
    6361        self.range_xy = max(self.range_x, self.range_y)
    64         # Start this off in its own thread.
    65         self.start()
    6662       
    6763    def run(self):
    … …  
    7975        # should a gui need adding.
    8076        self.root = Tkinter.Tk()
     77
     78        # Message handling with after
     79        self.root.after(100, self.handle_messages)
     80       
    8181        self.renderWidget = vtkTkRenderWidget(self.root, width=400, height=400)
    8282        self.renderWidget.pack(expand='true', fill='both')
    … …  
    9595
    9696        self.N_tri = len(self.domain.triangles)
    97         self.grids = {}
    9897        self.cells = vtk.vtkCellArray()
    9998        self.vertices = self.domain.get_vertex_coordinates()
    … …  
    115114        for q in self.domain.quantities:
    116115            if self.setup[q] | self.updating[q]:
    117                 self.qty_index = {}
    118116                self.draw_quantity(q)
    119117
    120118    def draw_quantity(self, q):
     119        qty_index = {}
    121120        for n in range(self.N_tri):
    122121            for v in range(3):
    123                 self.qty_index[self.domain.triangles[n][v]] = self.domain.quantities[q].vertex_values[n][v]
     122                qty_index[self.domain.triangles[n][v]] = self.domain.quantities[q].vertex_values[n][v]
     123
     124        self.grids[q] = vtk.vtkPoints()
     125        grid = self.grids[q]
     126
     127        if self.scale_z.has_key(q):
     128            scale = self.scale_z[q]
     129        else:
     130            scale = self.default_scale_z
    124131               
    125         self.points = vtk.vtkPoints()
    126132        for v in range(self.N_vert):
    127             self.points.InsertNextPoint(self.vert_index[v][0],
    128                                         self.vert_index[v][1],
    129                                         self.qty_index[v])
    130 
    131         self.grid = vtk.vtkPolyData()
    132         self.grid.SetPoints(self.points)
    133         self.grid.SetPolys(self.cells)
    134         self.grids[q] = self.grid
    135 
    136         self.mapper = vtk.vtkPolyDataMapper()
    137         self.mapper.SetInput(self.grid)
    138 
    139         self.actor = vtk.vtkActor()
    140         self.actor.SetMapper(self.mapper)
    141         if self.coloring[q] is True:
    142             self.actor.GetProperty().SetColor(self.qcolor[q])
     133            grid.InsertNextPoint(self.vert_index[v][0],
     134                                 self.vert_index[v][1],
     135                                 qty_index[v] * scale)
     136
     137        # Can't recycle vtkPolyData objects: Apparently they behave
     138        # unusually if the points (i.e. vertex data) is set after
     139        # the polys (i.e. triangle data)
     140        self.polydata[q] = vtk.vtkPolyData()
     141        polydata = self.polydata[q]
     142       
     143        polydata.SetPoints(grid)
     144        polydata.SetPolys(self.cells)
     145
     146        if self.mappers.has_key(q):
     147            mapper = self.mappers[q]
     148            mapper.SetInput(polydata)
     149            mapper.Update()
    143150        else:
    144             self.actor.GetProperty().SetColor(0.5, 0.5, 0.5)
    145 
    146         print "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
    147         self.renderer.AddActor(self.actor)
    148         print "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
     151            self.mappers[q] = vtk.vtkPolyDataMapper()
     152            mapper = self.mappers[q]
     153            mapper.SetInput(polydata)
     154
     155        if not self.actors.has_key(q):
     156            self.actors[q] = vtk.vtkActor()
     157            actor = self.actors[q]
     158            actor.SetMapper(mapper)
     159
     160            if self.coloring[q] is True:
     161                actor.GetProperty().SetColor(self.qcolor[q])
     162            else:
     163                actor.GetProperty().SetColor(0.5, 0.5, 0.5)
     164
     165            self.renderer.AddActor(actor)
    149166
    150167    def update_all(self):
    … …  
    153170    def update_timer(self):
    154171        pass
    155    
    156 if __name__ == '__main__':
    157     v = Visualiser()
    158     v.start()
    159    
     172
     173    def handle_messages(self):
     174        # Expandable to include more kinds of messages if need be
     175        # This lookup table is copied because it is modified later
     176        handlers = {'redraw': self.message_redraw}.copy()
     177        try:
     178            while True:
     179                message = self.messages.get_nowait()
     180                try:
     181                    handlers[message]()
     182                    # Guard against redrawing more than once per
     183                    # call to handle_messages.
     184                    if message == 'redraw':
     185                        del handlers[message]
     186                except KeyError:
     187                    pass
     188        except Empty:
     189            pass
     190        self.root.after(100, self.handle_messages)
     191
     192    def message_redraw(self):
     193        """Re-render and repaint the rendered image.
     194        This function should only be called from the message handler.
     195        Use request_redraw to ask for a redraw"""
     196
     197        for q in self.domain.quantities:
     198            if self.updating[q]:
     199                self.draw_quantity(q)
     200       
     201        self.renderWindow.Render()
     202        self.root.update_idletasks()
     203
     204    def request_redraw(self):
     205        self.messages.put('redraw')
     206
Note: See TracChangeset for help on using the changeset viewer.