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 (in)
    @ivar n: frame counter (in)
    @ivar scalar: scalar data set (in)
    @ivar vector: vector data set (in)
    @ivar tensor: tensor data set (in)
    @ivar dt: increment for output  (in)
    @ivar filename: name of the output file (in)
    """

    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):
       """
       returns True if the time stamp for writing frame is reached.
       """
       out=self.t>=self.__last_t+self.dt
       if out: 
            self.__last_t+=self.dt
            self.n+=1
       return out

    def getFrameCounter(self):
       """
       returns a frame counter
       """
       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():
            if self.debug():
               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)))

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
        @type debug: C{bool}
        """
        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):
        """
        writes 
        do any necessary postprocessing operations after a timestep.

        @param dt: current time increment
        @type dt: C{float}
        """
        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 (in)
19	@ivar n: frame counter (in)
20	@ivar scalar: scalar data set (in)
21	@ivar vector: vector data set (in)
22	@ivar tensor: tensor data set (in)
23	@ivar dt: increment for output (in)
24	@ivar filename: name of the output file (in)
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	"""
50	returns True if the time stamp for writing frame is reached.
51	"""
52	out=self.t>=self.__last_t+self.dt
53	if out:
54	self.__last_t+=self.dt
55	self.n+=1
56	return out
57
58	def getFrameCounter(self):
59	"""
60	returns a frame counter
61	"""
62	return self.n-1
63
64	def getSafeTimeStepSize(self,dt):
65	"""
66	returns new step size
67
68	@param dt: last time step size used
69	@type dt: C{float}
70	@return: time step size that can savely be used
71	@rtype: C{float}
72	"""
73	return self.__last_t+self.dt-self.t
74
75	def doStepPostprocessing(self, dt):
76	"""
77	renders the scene
78
79	@note: to be overwritten
80	"""
81	if self.writeFrame():
82	if self.debug():
83	self.trace("%s-th frame at time %s"%(self.getFrameCounter(),self.t))
84	if not self.scalar==None:
85	self.trace("scalar data: (min,max) =(%s,%s)"%(inf(self.scalar),sup(self.scalar)))
86	if not self.vector==None:
87	self.trace("vector data: (min,max) =(%s,%s)"%(inf(self.vector),sup(self.vector)))
88	if not self.tensor==None:
89	self.trace("tensor data: (min,max) =(%s,%s)"%(inf(self.tensor),sup(self.tensor)))
90
91	class WriteVTK(Visualization):
92	"""
93	Writes data into VTK files for further processing.
94	"""
95
96	def __init__(self, debug=False):
97	"""
98	Initialisation of the WriteVTK object
99
100	@param debug: Debugging flag
101	@type debug: C{bool}
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	writes
127	do any necessary postprocessing operations after a timestep.
128
129	@param dt: current time increment
130	@type dt: C{float}
131	"""
132	if self.writeFrame():
133	kwargs={}
134	if not self.scalar==None: kwargs["scalar"] = self.scalar
135	if not self.vector==None: kwargs["vector"] = self.vector
136	if not self.tensor==None: kwargs["tensor"] = self.tensor
137	saveVTK(self.__filename%self.getFrameCounter(),**kwargs)
138	self.trace("%s-th frame at time %s is writen to %s"%(self.getFrameCounter(),self.t,self.__filename%self.getFrameCounter()))
139
140	class ShadePlot(Visualization):
141	"""
142	Shaded contour plots
143	"""
144
145	def __init(self, debug=False):
146	"""
147	Initialisation
148	"""
149	Visualization.__init__(self, debug)
150	self.declareParameter(filename="shadePlot.%s.png")
151
152	def doStepPostprocessing(self, dt):
153	"""
154	Do any necessary postprocessing operations after a timestep.
155
156	@param dt:
157	"""
158	self.counter += 1
159	if self.counter % self.stride == 0:
160	n = self.counter/self.stride
161
162	# look for a vtk xml file of the right name and plot it
163	dataFname = "data.s.%d.xml" % n
164	if not os.path.exists(dataFname):
165	print "Data file doesn't exist! Skipping frame generation."
166
167	else:
168	import pyvisi
169	import pyvisi.renderers.vtk
170
171	scene = pyvisi.renderers.vtk.Scene()
172	plot = pyvisi.renderers.vtk.ContourPlot(scene)
173	plot.setData(fname=dataFname,
174	format='vtk-xml',
175	scalars='escript_scalar_data')
176	scene.save(fname="shadePlot.%05d.png" % n, format="png")
177
178
179	class ArrowPlot(Visualization):
180	"""
181	Arrow/vector/quiver plots
182	"""
183
184	def __init(self, debug=False):
185	"""
186	Initialisation
187	"""
188	Visualization.__init__(self, debug)
189	self.declareParameter(filename="arrowPlot.%s.png")
190
191	def doStepPostprocessing(self, dt):
192	"""
193	Do any necessary postprocessing operations after a timestep.
194
195	@param dt:
196	"""
197	self.counter += 1
198	if self.counter % self.stride == 0:
199	n = self.counter/self.stride
200
201	# look for a vtk xml file of the right name and plot it
202	dataFname = "data.v.%d.xml" % n
203	if not os.path.exists(dataFname):
204	print "Data file doesn't exist! Skipping frame generation."
205
206	else:
207	import pyvisi
208	import pyvisi.renderers.vtk
209
210	scene = pyvisi.renderers.vtk.Scene()
211	plot = pyvisi.renderers.vtk.ArrowPlot3D(scene)
212	plot.setData(fname=dataFname,
213	format='vtk-xml')
214	scene.save(fname="arrowPlot.%05d.png" % n, format="png")
215
216
217
218	class EllipsoidPlot(Visualization):
219	"""
220	Ellipsoid plots
221	"""
222
223	def __init(self, debug=False):
224	"""
225	Initialisation
226	"""
227	Visualization.__init__(self, debug)
228
229
230	# vim: expandtab shiftwidth=4:
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision