def __init__(self, scene):
"""
Initialisation of LinePlot class
@param scene: the scene with which to associate the LinePlot
@type scene: Scene object
"""
debugMsg("Called LinePlot.__init__()")
Plot.__init__(self, scene)
self.renderer = scene.renderer
self.title = None
self.xlabel = None
self.ylabel = None
self.zlabel = None
self.linestyle = 'lines' # pyvisi-defined linestyle
self._linestyle = None # renderer-specific linestyle
# is the LinePlot data offset (vertically) from each other?
self.offset = False
# now add the object to the scene
scene.add(self)
def save(self, fname, format):
"""
Save the scene to a file
Possible formats are:
- JPEG
- Postscript
- PNG
- PBM
@param fname: Name of output file
@type fname: string
@param format: Graphics format of output file
@type format: Image object or string
"""
debugMsg("Called Scene.save()")
self.renderer.runString("# Scene.save()")
# if the format is passed in as a string or object, react
# appropriately
import types
if type(format) is types.StringType:
fmt = format.lower()
else:
fmt = format.format
# set the output format
if fmt == "ps":
self.renderer.runString(\
"_gnuplot('set terminal postscript color')")
elif fmt == "png":
evalString = "_gnuplot('set terminal png size %d,%d')" % \
(self.xSize, self.ySize)
self.renderer.runString(evalString)
elif fmt == "pbm":
self.renderer.runString(\
"_gnuplot('set terminal pbm color')")
# set the size of the output
# have to scale properly to do this
xScale = float(self.xSize)/640.0
yScale = float(self.ySize)/480.0
evalString = "_gnuplot('set size %f,%f')" % \
(xScale, yScale)
self.renderer.runString(evalString)
elif fmt == "jpeg" or fmt == "jpg":
evalString = "_gnuplot('set terminal jpeg size %d,%d')" % \
(self.xSize, self.ySize)
self.renderer.runString(evalString)
else:
raise ValueError, "Unknown graphics format. I got: %s" % fmt
# set the output filename
evalString = "_gnuplot('set output \"%s\"')" % fname
self.renderer.runString(evalString)
# now render the whole shebang (again)
self.render()
return
def __init__(self):
"""
Initialisation of Renderer() class
"""
debugMsg("Called Renderer.__init__()")
BaseRenderer.__init__(self)
# initialise some attributes
self.renderWindowWidth = 640
self.renderWindowHeight = 480
# what is the name of my renderer?
self.name = _rendererName
# initialise the evalstack
self._evalStack = ""
# the namespace to run the exec code
self.renderDict = {}
# keep the initial setup of the module for later reuse
self._initStack = ""
# initialise the renderer module
self.addToInitStack("# Renderer.__init__()")
self.addToInitStack("import Gnuplot")
# Gnuplot package needs Numeric package
self.addToInitStack("from Numeric import *")
# need to add a check here to see if the Numeric module has been
# imported, and if not, throw an error.
self.addToInitStack("_gnuplot = Gnuplot.Gnuplot()")
def __init__(self, scene):
"""
Initialisation of SurfacePlot class
@param scene: the scene with which to associate the SurfacePlot
@type scene: Scene object
"""
debugMsg("Called SurfacePlot.__init__()")
Plot.__init__(self, scene)
# grab the renderer
self.renderer = scene.renderer
# set up some of the attributes
self.title = None
self.xlabel = None
self.ylabel = None
self.zlabel = None
# to show contours of the surface on the bottom of the axes, set
# this variable to True
self.contours = False
# now add the object to the scene
scene.add(self)
def getElevation(self):
"""
Gets the elevation angle (in degrees) of the Camera
"""
debugMsg("Called Camera.getElevation()")
return self.elevation
def render(self):
"""
Perform Plane object specific (pre)rendering tasks
"""
debugMsg("Called Plane.mapImageToPlane()")
return
def render(self):
"""
Does ContourPlot object specific rendering stuff
"""
debugMsg("Called ContourPlot.render()")
self.renderer.runString("# ContourPlot.render()")
self.renderer.runString("_gnuplot('set contour base')")
self.renderer.runString("_gnuplot('set view 0, 0, 1, 1')")
self.renderer.runString("_gnuplot('set nosurface')") # gnuplot 3.7
# if a title is set, put it here
if self.title is not None:
evalString = "_gnuplot.title(\'%s\')" % self.title
self.renderer.runString(evalString)
# if an xlabel is set, add it
if self.xlabel is not None:
evalString = "_gnuplot.xlabel(\'%s\')" % self.xlabel
self.renderer.runString(evalString)
# if a ylabel is set, add it
if self.ylabel is not None:
evalString = "_gnuplot.ylabel(\'%s\')" % self.ylabel
self.renderer.runString(evalString)
self.renderer.runString("_gnuplot('set pm3d')")
# set up the evalString to use for plotting
evalString = "_gnuplot.splot(_data)"
self.renderer.runString(evalString)
return
def getAzimuth(self):
"""
Get the azimuthal angle (in degrees) of the Camera
"""
debugMsg("Called Camera.getAzimuth()")
return self.azimuth
def render(self):
"""
Does JpegImage object specific (pre)rendering stuff
"""
debugMsg("Called JpegImage.render()")
return
def __init__(self, scene):
"""
Initialisation of the Camera object
@param scene: The Scene object to add the Camera object to
"""
debugMsg("Called Camera.__init__()")
Item.__init__(self)
# default x,y,z positions of Camera (specific to vtk)
self.xPos = 0.0
self.yPos = 0.0
self.zPos = 3.0
# default x,y,z positions of the Camers's focal point (specific to vtk)
self.xFocalPoint = 0.0
self.yFocalPoint = 0.0
self.zFocalPoint = 0.0
# default elevation and azimuth
# these need to be set to the matlab defaults
self.elevation = 30
self.azimuth = 30
# keep a reference to the renderer so we can send stuff to it
self.renderer = scene.renderer
# initialise the position of the Camera
self.setPosition(self.xPos, self.yPos, self.zPos)
self.setFocalPoint(self.xFocalPoint, self.yFocalPoint, self.zFocalPoint)
def render(self):
"""
Does LinePlot object specific rendering stuff
"""
debugMsg("Called LinePlot.render()")
self.renderer.runString("# LinePlot.render()")
# if a title is set, put it here
if self.title is not None:
evalString = "_gnuplot.title(\'%s\')" % self.title
self.renderer.runString(evalString)
# if an xlabel is set, add it
if self.xlabel is not None:
evalString = "_gnuplot.xlabel(\'%s\')" % self.xlabel
self.renderer.runString(evalString)
# if a ylabel is set, add it
if self.ylabel is not None:
evalString = "_gnuplot.ylabel(\'%s\')" % self.ylabel
self.renderer.runString(evalString)
# set up the evalString to use for plotting
evalString = "_gnuplot.plot("
for i in range(self.renderer.numDataObjects-1):
evalString += "_data%d, " % i
evalString += "_data%d)" % (self.renderer.numDataObjects-1,)
self.renderer.runString(evalString)
return
def __init__(self):
"""
Initialisation of the Text object
"""
debugMsg("Called Text.__init__()")
Item.__init__(self)
self.font = "Times"
def getLineStyle(self):
"""
Gets the current linestyle of the LinePlot
@return: the linestyle as a string
"""
debugMsg("Called LinePlot.getLineStyle()")
return self.linestyle
def getPosition(self):
"""
Get the position of Camera within Scene
Returns the position in a tuple of form (xPos, yPos, zPos)
"""
debugMsg("Called Camera.getPosition()")
return (self.xPos, self.yPos, self.zPos)
def load(self, fname):
"""
Loads image data from file.
@param fname: The filename from which to load image data
@type fname: string
"""
debugMsg("Called Image.load()")
fileCheck(fname)
return
def getFocalPoint(self):
"""
Get the position of the focal point of the Camera
Returns the position of the focal point in a tuple of form
(xPos, yPos, zPos)
"""
debugMsg("Called Camera.getFocalPoint()")
return (self.xFocalPoint, self.yFocalPoint, self.zFocalPoint)
def mapImageToPlane(self, image):
"""
Maps an Image object onto a Plane object
"""
debugMsg("Called Plane.mapImageToPlane()")
if image is None:
raise ValueError, "You must specify an image object"
return
def __init__(self, scene):
"""
Initialisation of the Plane object
"""
debugMsg("Called Plane.__init__()")
Item.__init__(self)
self.renderer = scene.renderer
if scene is None:
raise ValueError, "You must specify a scene object"
def setAzimuth(self, azimuth):
"""
Set the azimuthal angle (in degrees) of the Camera
@param azimuth: The azimuthal angle (in degrees) of the Camera
"""
debugMsg("Called Camera.setAzimuth()")
self.azimuth = azimuth
return
def setElevation(self, elevation):
"""
Set the elevation angle (in degrees) of the Camera
@param elevation: The elevation angle (in degrees) of the Camera
"""
debugMsg("Called Camera.setElevation()")
self.elevation = elevation
return
def __init__(self, scene=None):
"""
Initialises the Image class object
@param scene: The Scene object to add to
@type scene: Scene object
"""
debugMsg("Called Image.__init__()")
Item.__init__(self)
if scene is not None:
self.renderer = scene.renderer
def __init__(self):
"""
The init function
"""
debugMsg("Called Scene.__init__()")
BaseScene.__init__(self)
self.renderer = Renderer()
self.objectList = []
self.xSize = 640
self.ySize = 480
def setTitle(self, title):
"""
Set the plot title
@param title: the string holding the title to the plot
@type title: string
"""
debugMsg("Called Plot.setTitle()")
self.title = title
return
def setYLabel(self, label):
"""
Set the label of the y-axis
@param label: the string holding the label of the y-axis
@type label: string
"""
debugMsg("Called Plot.setYLabel()")
self.ylabel = label
return
def place(self, obj):
"""
Place an object within a scene
@param obj: The object to place within the scene
@type obj: object
"""
debugMsg("Called Scene.place()")
if obj is None:
raise ValueError, "You must specify an object to add"
return
def setData(self, *dataList, **options):
"""
Sets the data to the Plot
@param dataList: list of data objects to plot
@type dataList: tuple
@param options: dictionary of extra options
@type options: dict
"""
debugMsg("Called ContourPlot.setData()")
self.renderer.runString("# ContourPlot.setData()")
# this is a really dodgy way to get the data into the renderer
# I really have to find a better, more elegant way to do this
# for the moment, make sure that there are three arrays
if len(dataList) != 3:
raise ValueError, "Must have three arrays as input (at present)"
# do some sanity checks on the data
xData = dataList[0]
yData = dataList[1]
zData = dataList[2]
if len(xData.shape) != 1:
raise ValueError, "x data array is not of correct shape: %s" % \
xData.shape
if len(yData.shape) != 1:
raise ValueError, "y data array is not of correct shape: %s" % \
yData.shape
if len(zData.shape) != 2:
raise ValueError, "z data array is not of correct shape: %s" % \
zData.shape
## the x data
self.renderer.renderDict['_x'] = copy.deepcopy(xData)
## the y data
self.renderer.renderDict['_y'] = copy.deepcopy(yData)
## the z data
self.renderer.renderDict['_z'] = copy.deepcopy(zData)
self.renderer.runString(\
"_data = Gnuplot.GridData(_z, _x, _y, binary=1)")
return
def setLineStyle(self, linestyle):
"""
Sets the linestyle of the LinePlot
Linestyles may be either a word in the Gnuplot style, or a symbol
shortcut in the Matlab style. Some of the options do not have a
Matlab equivalent but do have a Gnuplot equivalent, or vice versa.
What this method does, is take the linestyles possible as defined by
PyVisi, and then does some conversion as best it can to get the
relevant output from (in this case) gnuplot.
Possible linestyles are:
1. lines ('-')
2. points ('o')
3. linespoints ('-o')
4. dots ('.')
5. dotted (':')
6. dashes ('--')
7. dotdashes ('-.')
@param linestyle: the style to use for the lines
@type linestyle: string
"""
debugMsg("Called LinePlot.setLineStyle()")
# now implement the gnuplot-specific way to do this
if linestyle == 'lines' or linestyle == '-':
self._linestyle = 'lines'
elif linestyle == 'points' or linestyle == 'o':
self._linestyle = 'points'
elif linestyle == 'linespoints' or linestyle == '-o':
self._linestyle = 'linespoints'
elif linestyle == 'dots' or linestyle == '.':
self._linestyle = 'dots'
elif linestyle == 'dotted' or linestyle == ':':
print "linestyle = %s" % linestyle
raise NotImplementedError, \
"Sorry, haven't implemented this style yet."
elif linestyle == 'dashes' or linestyle == '--':
print "linestyle = %s" % linestyle
raise NotImplementedError, \
"Sorry, haven't implemented this style yet."
elif linestyle == 'dotdashes' or linestyle == '-.':
print "linestyle = %s" % linestyle
raise NotImplementedError, \
"Sorry, haven't implemented this style yet."
else:
raise ValueError, "Unknown linestyle! I got \'%s\'" % linestyle
return
def setData(self, *dataList, **options):
"""
Sets the data to the given plot object.
@param dataList: list of data objects to plot
@type dataList: tuple
@param options: dictionary of extra options
@type options: dict
"""
debugMsg("Called setData() in SurfacePlot()")
self.renderer.runString("# SurfacePlot.setData()")
# for the moment, make sure that there are three arrays
if len(dataList) != 3:
raise ValueError, "Must have three arrays as input (at present)"
# do some sanity checks on the data
xData = dataList[0]
yData = dataList[1]
zData = dataList[2]
if len(xData.shape) != 1:
raise ValueError, "x data array is not of the correct shape: %s"\
% xData.shape
if len(yData.shape) != 1:
raise ValueError, "y data array is not of the correct shape: %s"\
% yData.shape
if len(zData.shape) != 2:
raise ValueError, "z data array is not of the correct shape: %s"\
% zData.shape
# share around the data
## the x data
self.renderer.renderDict['_x'] = copy.deepcopy(xData)
## the y data
self.renderer.renderDict['_y'] = copy.deepcopy(yData)
## the z data
self.renderer.renderDict['_z'] = copy.deepcopy(zData)
self.renderer.runString(\
"_data = Gnuplot.GridData(_z, _x, _y, binary=1)")
return
def render(self):
"""
Does SurfacePlot object specific rendering stuff
"""
debugMsg("Called SurfacePlot.render()")
self.renderer.runString("# SurfacePlot.render()")
self.renderer.runString("_gnuplot('set surface')")
# if a title is set, put it here
if self.title is not None:
evalString = "_gnuplot.title(\'%s\')" % self.title
self.renderer.runString(evalString)
# if an xlabel is set, add it
if self.xlabel is not None:
evalString = "_gnuplot.xlabel(\'%s\')" % self.xlabel
self.renderer.runString(evalString)
# if a ylabel is set add it
if self.ylabel is not None:
evalString = "_gnuplot.ylabel(\'%s\')" % self.ylabel
self.renderer.runString(evalString)
# if a zlabel is set add it
if self.zlabel is not None:
evalString = "_gnuplot('set zlabel \\'%s\\'')" % self.zlabel
self.renderer.runString(evalString)
# dunno if need this - could be just for gnuplot3
evalString = "_gnuplot('set style data lines')"
self.renderer.runString(evalString)
# makes sure that hidden lines are removed
evalString = "_gnuplot('set hidden3d')"
self.renderer.runString(evalString)
# if contours is true, set the relevant option
if self.contours:
evalString = "_gnuplot('set contour base')"
self.renderer.runString(evalString)
self.renderer.runString("_gnuplot('set pm3d')")
# set up the evalString to use for plotting
evalString = "_gnuplot.splot(_data)"
self.renderer.runString(evalString)
return
def setData(self, *dataList, **options):
"""
Set data to Plot
@param dataList: the data to set to the plot
@type dataList: tuple
@param options: dictionary of extra options
@type options: dict
"""
debugMsg("Called Plot.setData()")
if dataList is None:
raise ValueError, "You must specify a data list"
return