modellib/py_src/visualization.py

# $Id$

__copyright__="""  Copyright (c) 2006 by ACcESS MNRF
                    http://www.access.edu.au
                Primary Business: Queensland, Australia"""
__license__="""Licensed under the Open Software License version 3.0
             http://www.opensource.org/licenses/osl-3.0.php"""

from esys.escript.modelframe import Model
from esys.escript import saveVTK
import os

class Visualization(Model):
    """
    Generic visualization of scalar, vector and tensorial data 
    (not implemeted yet)

    @ivar t: current time
    @ivar n: frame counter
    @ivar scalar: scalar data set
    @ivar vector: vector data set
    @ivar tensor: tensor data set
    @ivar dt: increment for output 
    @ivar filename: name of the output file
    """

    def __init__(self, debug=False):
        """
        Initialisation of the visualisation model object

        @param debug: Debugging flag
        """
        super(Visualization,self).__init__(debug=debug)
        self.declareParameter(t=0.,
                              n=0,
                              scalar=None,
                              vector=None,
                              tensor=None,
                              dt=1,
                              filename="movie.mpg")

    def doInitialization(self):
        """
        Does some kind of initialisation
        """
        self.__last_t=self.t

    def writeFrame(self):
       out=self.t>=self.__last_t+self.dt
       if out: 
            self.__last_t+=self.dt
            self.n+=1
       return out

    def getFrameCounter(self):
        return self.n-1

    def getSafeTimeStepSize(self,dt):
           """
           returns new step size
                                                                                                                                                                                                    
           @param dt: last time step size used
           @type dt: C{float}
           @return: time step size that can savely be used
           @rtype: C{float}
           """
           return self.__last_t+self.dt-self.t

    def doStepPostprocessing(self, dt):
        """
        renders the scene

        @note: to be overwritten
        """
        if self.writeFrame():
            self.trace("%s-th frame at time %s"%(self.getFrameCounter(),self.t))
            if not self.scalar==None:
               self.trace("scalar data: (min,max) =(%s,%s)"%(inf(self.scalar),sup(self.scalar)))
            if not self.vector==None:
               self.trace("vector data: (min,max) =(%s,%s)"%(inf(self.vector),sup(self.vector)))
            if not self.tensor==None:
               self.trace("tensor data: (min,max) =(%s,%s)"%(inf(self.tensor),sup(self.tensor)))
           
    def doFinalization(self):
        """
        Finalises the visualisation.  For instance, makes a movie of the image files.

        @note: to be overwritten
        """
        pass

class WriteVTK(Visualization):
    """
    Writes data into VTK files for further processing. 
    """

    def __init__(self, debug=False):
        """
        Initialisation of the WriteVTK object

        @param debug: Debugging flag
        """
        super(WriteVTK,self).__init__(debug=debug)

    def doInitialization(self):
        """
        Does some kind of initialisation
        """
        super(WriteVTK,self).doInitialization()
        fnc=self.filename.split('.')
        if len(fnc)==0:
           self.__filename="data.%s.xml"
        else:
           n=fnc[0]
           for i in range(1,len(fnc)-1):
              n+="."+fnc[i]
           if len(fnc)==1:
              self.__filename=n+".%s"
           else:
              self.__filename=n+".%s."+fnc[-1]
        self.trace("output filename is %s."%self.__filename)
       

    def doStepPostprocessing(self, dt):
        """
        Do any necessary postprocessing operations after a timestep.

        @param dt:
        """
        if self.writeFrame():
            kwargs={}
            if not self.scalar==None: kwargs["scalar"] = self.scalar
            if not self.vector==None: kwargs["vector"] = self.vector
            if not self.tensor==None: kwargs["tensor"] = self.tensor
            saveVTK(self.__filename%self.getFrameCounter(),**kwargs)
            self.trace("%s-th frame at time %s is writen to %s"%(self.getFrameCounter(),self.t,self.__filename%self.getFrameCounter()))

class ShadePlot(Visualization):
    """
    Shaded contour plots
    """
    
    def __init(self, debug=False):
        """
        Initialisation
        """
        Visualization.__init__(self, debug)
        self.declareParameter(filename="shadePlot.%s.png")

    def doStepPostprocessing(self, dt):
        """
        Do any necessary postprocessing operations after a timestep.

        @param dt:
        """
        self.counter += 1
        if self.counter % self.stride == 0:
            n = self.counter/self.stride

            # look for a vtk xml file of the right name and plot it
            dataFname = "data.s.%d.xml" % n
            if not os.path.exists(dataFname):
                print "Data file doesn't exist!  Skipping frame generation."

            else:
                import pyvisi
                import pyvisi.renderers.vtk
    
                scene = pyvisi.renderers.vtk.Scene()
                plot = pyvisi.renderers.vtk.ContourPlot(scene)
                plot.setData(fname=dataFname, 
                        format='vtk-xml', 
                        scalars='escript_scalar_data')
                scene.save(fname="shadePlot.%05d.png" % n, format="png")


class ArrowPlot(Visualization):
    """
    Arrow/vector/quiver plots
    """
    
    def __init(self, debug=False):
        """
        Initialisation
        """
        Visualization.__init__(self, debug)
        self.declareParameter(filename="arrowPlot.%s.png")

    def doStepPostprocessing(self, dt):
        """
        Do any necessary postprocessing operations after a timestep.

        @param dt:
        """
        self.counter += 1
        if self.counter % self.stride == 0:
            n = self.counter/self.stride

            # look for a vtk xml file of the right name and plot it
            dataFname = "data.v.%d.xml" % n
            if not os.path.exists(dataFname):
                print "Data file doesn't exist!  Skipping frame generation."

            else:
                import pyvisi
                import pyvisi.renderers.vtk
    
                scene = pyvisi.renderers.vtk.Scene()
                plot = pyvisi.renderers.vtk.ArrowPlot3D(scene)
                plot.setData(fname=dataFname, 
                        format='vtk-xml')
                scene.save(fname="arrowPlot.%05d.png" % n, format="png")


class EllipsoidPlot(Visualization):
    """
    Ellipsoid plots
    """
    
    def __init(self, debug=False):
        """
        Initialisation
        """
        Visualization.__init__(self, debug)


# vim: expandtab shiftwidth=4:
1	# $Id$
2
3	__copyright__=""" Copyright (c) 2006 by ACcESS MNRF
4	http://www.access.edu.au
5	Primary Business: Queensland, Australia"""
6	__license__="""Licensed under the Open Software License version 3.0
7	http://www.opensource.org/licenses/osl-3.0.php"""
8
9	from esys.escript.modelframe import Model
10	from esys.escript import saveVTK
11	import os
12
13	class Visualization(Model):
14	"""
15	Generic visualization of scalar, vector and tensorial data
16	(not implemeted yet)
17
18	@ivar t: current time
19	@ivar n: frame counter
20	@ivar scalar: scalar data set
21	@ivar vector: vector data set
22	@ivar tensor: tensor data set
23	@ivar dt: increment for output
24	@ivar filename: name of the output file
25	"""
26
27	def __init__(self, debug=False):
28	"""
29	Initialisation of the visualisation model object
30
31	@param debug: Debugging flag
32	"""
33	super(Visualization,self).__init__(debug=debug)
34	self.declareParameter(t=0.,
35	n=0,
36	scalar=None,
37	vector=None,
38	tensor=None,
39	dt=1,
40	filename="movie.mpg")
41
42	def doInitialization(self):
43	"""
44	Does some kind of initialisation
45	"""
46	self.__last_t=self.t
47
48	def writeFrame(self):
49	out=self.t>=self.__last_t+self.dt
50	if out:
51	self.__last_t+=self.dt
52	self.n+=1
53	return out
54
55	def getFrameCounter(self):
56	return self.n-1
57
58	def getSafeTimeStepSize(self,dt):
59	"""
60	returns new step size
61
62	@param dt: last time step size used
63	@type dt: C{float}
64	@return: time step size that can savely be used
65	@rtype: C{float}
66	"""
67	return self.__last_t+self.dt-self.t
68
69	def doStepPostprocessing(self, dt):
70	"""
71	renders the scene
72
73	@note: to be overwritten
74	"""
75	if self.writeFrame():
76	self.trace("%s-th frame at time %s"%(self.getFrameCounter(),self.t))
77	if not self.scalar==None:
78	self.trace("scalar data: (min,max) =(%s,%s)"%(inf(self.scalar),sup(self.scalar)))
79	if not self.vector==None:
80	self.trace("vector data: (min,max) =(%s,%s)"%(inf(self.vector),sup(self.vector)))
81	if not self.tensor==None:
82	self.trace("tensor data: (min,max) =(%s,%s)"%(inf(self.tensor),sup(self.tensor)))
83
84	def doFinalization(self):
85	"""
86	Finalises the visualisation. For instance, makes a movie of the image files.
87
88	@note: to be overwritten
89	"""
90	pass
91
92	class WriteVTK(Visualization):
93	"""
94	Writes data into VTK files for further processing.
95	"""
96
97	def __init__(self, debug=False):
98	"""
99	Initialisation of the WriteVTK object
100
101	@param debug: Debugging flag
102	"""
103	super(WriteVTK,self).__init__(debug=debug)
104
105	def doInitialization(self):
106	"""
107	Does some kind of initialisation
108	"""
109	super(WriteVTK,self).doInitialization()
110	fnc=self.filename.split('.')
111	if len(fnc)==0:
112	self.__filename="data.%s.xml"
113	else:
114	n=fnc[0]
115	for i in range(1,len(fnc)-1):
116	n+="."+fnc[i]
117	if len(fnc)==1:
118	self.__filename=n+".%s"
119	else:
120	self.__filename=n+".%s."+fnc[-1]
121	self.trace("output filename is %s."%self.__filename)
122
123
124	def doStepPostprocessing(self, dt):
125	"""
126	Do any necessary postprocessing operations after a timestep.
127
128	@param dt:
129	"""
130	if self.writeFrame():
131	kwargs={}
132	if not self.scalar==None: kwargs["scalar"] = self.scalar
133	if not self.vector==None: kwargs["vector"] = self.vector
134	if not self.tensor==None: kwargs["tensor"] = self.tensor
135	saveVTK(self.__filename%self.getFrameCounter(),**kwargs)
136	self.trace("%s-th frame at time %s is writen to %s"%(self.getFrameCounter(),self.t,self.__filename%self.getFrameCounter()))
137
138	class ShadePlot(Visualization):
139	"""
140	Shaded contour plots
141	"""
142
143	def __init(self, debug=False):
144	"""
145	Initialisation
146	"""
147	Visualization.__init__(self, debug)
148	self.declareParameter(filename="shadePlot.%s.png")
149
150	def doStepPostprocessing(self, dt):
151	"""
152	Do any necessary postprocessing operations after a timestep.
153
154	@param dt:
155	"""
156	self.counter += 1
157	if self.counter % self.stride == 0:
158	n = self.counter/self.stride
159
160	# look for a vtk xml file of the right name and plot it
161	dataFname = "data.s.%d.xml" % n
162	if not os.path.exists(dataFname):
163	print "Data file doesn't exist! Skipping frame generation."
164
165	else:
166	import pyvisi
167	import pyvisi.renderers.vtk
168
169	scene = pyvisi.renderers.vtk.Scene()
170	plot = pyvisi.renderers.vtk.ContourPlot(scene)
171	plot.setData(fname=dataFname,
172	format='vtk-xml',
173	scalars='escript_scalar_data')
174	scene.save(fname="shadePlot.%05d.png" % n, format="png")
175
176
177	class ArrowPlot(Visualization):
178	"""
179	Arrow/vector/quiver plots
180	"""
181
182	def __init(self, debug=False):
183	"""
184	Initialisation
185	"""
186	Visualization.__init__(self, debug)
187	self.declareParameter(filename="arrowPlot.%s.png")
188
189	def doStepPostprocessing(self, dt):
190	"""
191	Do any necessary postprocessing operations after a timestep.
192
193	@param dt:
194	"""
195	self.counter += 1
196	if self.counter % self.stride == 0:
197	n = self.counter/self.stride
198
199	# look for a vtk xml file of the right name and plot it
200	dataFname = "data.v.%d.xml" % n
201	if not os.path.exists(dataFname):
202	print "Data file doesn't exist! Skipping frame generation."
203
204	else:
205	import pyvisi
206	import pyvisi.renderers.vtk
207
208	scene = pyvisi.renderers.vtk.Scene()
209	plot = pyvisi.renderers.vtk.ArrowPlot3D(scene)
210	plot.setData(fname=dataFname,
211	format='vtk-xml')
212	scene.save(fname="arrowPlot.%05d.png" % n, format="png")
213
214
215
216	class EllipsoidPlot(Visualization):
217	"""
218	Ellipsoid plots
219	"""
220
221	def __init(self, debug=False):
222	"""
223	Initialisation
224	"""
225	Visualization.__init__(self, debug)
226
227
228	# vim: expandtab shiftwidth=4:
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision