def __init__(self, graph=None, camera=None, orthocamera=None, netcli=False):
print "Calling graph context init"
#
# Cacheable: Keep track of observers
#
self.__dict__['observers'] = []
if not config.current['global:highlight']:
self.highLight = False
else:
self.highLight = True
self.highLightNow = True
self.ready = False
if not graph:
print "Making a graph object"
self.graph = Graph(parent=self)
else:
self.graph = graph
if netcli:
self.UndoStack = undo.DummyStack(self)
self.RedoStack = undo.DummyStack(self)
else:
self.UndoStack = undo.UndoStack(self)
self.RedoStack = undo.RedoStack(self)
self.graphgl = graphgl.GraphGL(self.graph)
self.decor = interfacegl.InterfaceGL()
if not camera:
self.camera = Camera()
self.camera.lookAt = (0.0, 0.0, 0.0)
else:
self.camera = camera
if not orthocamera:
self.orthocamera = OrthoCamera()
else:
self.orthocamera = orthocamera
self.cursor = Cursor()
self.path = None
# This should default to False and turn on automatically
# when you have a 3D input device.
# XXX#
self.showCursor = False
# The drawList should be a dictionary of Drawables,
# used by the InputManager to enable transient objects,
# menus, etc to be drawn.
self.drawList = {}
self.orthoMode = None
self.showAxes = config.current['default:show-axes']
self.showLocalAxes = config.current['default:show-local-axes']
self.showHUD = config.current['default:show-hud']
self.showGrid = config.current['default:show-grid']
self.showGridLines = config.current['default:show-grid-lines']
self.showPlane = config.current['default:show-plane']
self.planeColor = config.current['default:plane-color']
self.bgColor = config.current['default:background-color']
self.showVertexLabels = config.current['default:show-vertex-labels']
self.showDummyLabels = config.current['default:show-dummy-labels']
self.vertexLabelName = config.current['default:vertex-label-name']
self.vertexLabelColor = config.current['default:vertex-label-color']
self.vertexShadowColor = config.current['default:vertex-shadow-color']
self.vertexLabelStroke = config.current['default:vertex-label-stroke']
self.showGridPlane = "XZ"
self.pos = (0.0, 0.0, 0.0)
self.sizeX = 5
self.sizeY = 5
self.sizeZ = 5
self.spacing = 2.0
# The HUD status text line.
self.HUDstatus = ''
#If no highlight object exists, create one.
if self.highLight:
print "Creating highlight for active context"
self.highLight = True
from interfacegl import DrawObjectHighLight
self.setDraw('wandaHighLight',
DrawObjectHighLight(
ctx=self,
tolerance=5.0,
restrict=None,
)
)
class GraphContext(pb.Cacheable):
"""
GraphContext binds together the elements required to present a Graph
in an OpenGL environment. It includes:
- The graph
- The primary camera
- The orthogonal camera
- Display settings:
- ortho vs. standard camera
- whether to show local axes
- whether to show ground plane
- whether to show HUD
- whether to show, and color of, ground plane
- color of background
- whether to show vertex labels (IDs or names) and whether to show labels for bendpoints
- colors for vertex labels and their shadows, and the stroke width for drawing labels
"""
def __setattr__(self, name, value):
# Don't update the remote 'ready' state; it's a local flag.
if name != 'observers' and name != 'ready':
for o in self.observers:
o.callRemote('setattr', {name: value}).addErrback(connectionError, 'context setattr')
self.__dict__[name] = value
def __init__(self, graph=None, camera=None, orthocamera=None, netcli=False):
print "Calling graph context init"
#
# Cacheable: Keep track of observers
#
self.__dict__['observers'] = []
if not config.current['global:highlight']:
self.highLight = False
else:
self.highLight = True
self.highLightNow = True
self.ready = False
if not graph:
print "Making a graph object"
self.graph = Graph(parent=self)
else:
self.graph = graph
if netcli:
self.UndoStack = undo.DummyStack(self)
self.RedoStack = undo.DummyStack(self)
else:
self.UndoStack = undo.UndoStack(self)
self.RedoStack = undo.RedoStack(self)
self.graphgl = graphgl.GraphGL(self.graph)
self.decor = interfacegl.InterfaceGL()
if not camera:
self.camera = Camera()
self.camera.lookAt = (0.0, 0.0, 0.0)
else:
self.camera = camera
if not orthocamera:
self.orthocamera = OrthoCamera()
else:
self.orthocamera = orthocamera
self.cursor = Cursor()
self.path = None
# This should default to False and turn on automatically
# when you have a 3D input device.
# XXX#
self.showCursor = False
# The drawList should be a dictionary of Drawables,
# used by the InputManager to enable transient objects,
# menus, etc to be drawn.
self.drawList = {}
self.orthoMode = None
self.showAxes = config.current['default:show-axes']
self.showLocalAxes = config.current['default:show-local-axes']
self.showHUD = config.current['default:show-hud']
self.showGrid = config.current['default:show-grid']
self.showGridLines = config.current['default:show-grid-lines']
self.showPlane = config.current['default:show-plane']
self.planeColor = config.current['default:plane-color']
self.bgColor = config.current['default:background-color']
self.showVertexLabels = config.current['default:show-vertex-labels']
self.showDummyLabels = config.current['default:show-dummy-labels']
self.vertexLabelName = config.current['default:vertex-label-name']
self.vertexLabelColor = config.current['default:vertex-label-color']
self.vertexShadowColor = config.current['default:vertex-shadow-color']
self.vertexLabelStroke = config.current['default:vertex-label-stroke']
self.showGridPlane = "XZ"
self.pos = (0.0, 0.0, 0.0)
self.sizeX = 5
self.sizeY = 5
self.sizeZ = 5
self.spacing = 2.0
# The HUD status text line.
self.HUDstatus = ''
#If no highlight object exists, create one.
if self.highLight:
print "Creating highlight for active context"
self.highLight = True
from interfacegl import DrawObjectHighLight
self.setDraw('wandaHighLight',
DrawObjectHighLight(
ctx=self,
tolerance=5.0,
restrict=None,
)
)
def getStateToCacheAndObserveFor(self, perspective, observer):
"""
Add an observer to the list, and return our current
state with the observer list stripped out.
"""
print "adding observer to GraphContext:", perspective, observer
self.observers.append(observer)
d = self.__dict__.copy()
# XXX# What other Cacheable-specific data do we have to remove?
if 'parent' in d:
d['parent'] = None
del d['observers']
del d['graphgl']
del d['decor']
del d['UndoStack']
del d['RedoStack']
return d
def stoppedObserving(self, perspective, observer):
"""
Remove an observer from the list.
"""
self.observers.remove(observer)
print "stopped observing:", perspective, observer
def init(self):
"""
Should be called the first time this context is drawn, after OpenGL
has been set up. It ensures that the initial viewpoint reflects
the initial camera.
"""
glEnable(GL_COLOR_MATERIAL)
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE)
glEnable(GL_LIGHT0)
if self.orthoMode:
self.orthocamera.use()
else:
self.camera.use()
# glLightfv(GL_LIGHT0, GL_POSITION, (-0.1, 1.0, 0.1, 0.0))
self.graphgl.init()
self.decor.init()
self.ready = True
def loadFromFile(self, filename, format, queryCallback=None, warningCallback=None):
"""Loads a graph into this context. Sets up defaults for ground plane
and camera."""
filepath = path.realpath(filename)
(dir, basename) = path.split(filepath)
(prefix, ext) = path.splitext(basename)
fobj = file(filepath, 'rU')
format.load(self.graph, fobj, queryCallback=queryCallback, warningCallback=warningCallback)
fobj.close()
self.graph.new = False
self.graph.change(False)
# Set this to force a rendering update of the graph - maybe there's
# a better way to do it? It hasn't been changed (for saving purposes)
# but the graph object itself has changed (for display purposes).
self.graph.dirty = True
# Store the path
self.path = filename
# These should be user preferences.Cursor()
self.showAxes = config.current['default:show-axes']
self.showLocalAxes = config.current['default:show-local-axes']
self.showPlane = config.current['default:show-plane']
self.showHUD = config.current['default:show-hud']
self.showGrid = config.current['default:show-grid']
self.showGridLines = config.current['default:show-grid-lines']
self.planeColor = config.current['default:plane-color']
self.bgColor = config.current['default:background-color']
self.showVertexLabels = config.current['default:show-vertex-labels']
self.showDummyLabels = config.current['default:show-dummy-labels']
self.vertexLabelName = config.current['default:vertex-label-name']
self.vertexLabelColor = config.current['default:vertex-label-color']
self.vertexShadowColor = config.current['default:vertex-shadow-color']
self.vertexLabelStroke = config.current['default:vertex-label-stroke']
self.orthoMode = None
# Cacheable: Send all these parameters across the wire
if self.observers:
d = self.__dict__.copy()
del d['observers']
del d['graphgl']
del d['decor']
for o in self.observers: o.callRemote('setattr', d).addErrback(connectionError, 'context loadfromfile')
# Update the graph edge and vertex lists.
for o in self.graph.observers:
o.callRemote('setattr', {
'vertices': self.graph.vertices,
'vertices_selected': self.graph.vertices_selected,
'edges': self.graph.edges,
'edges_selected': self.graph.edges_selected,
})
o.callRemote('change', True)
self.camera.lookAtGraph(self.graph, self.graph.centerOfMass(), offset=self.graph.viewpoint())
def writeToFile(self, format=None, filename=None, options={}):
"""GraphContext.writeToFile(filename = None) -> void
Writes the graph in this context out to a file, autodetecting
the filetype from the name of the file. If filename == None,
will attempt to use self.path. If self.path == None and
filename == None, raises ExportError."""
# Detect what kind of file we're loading and
# call a specialized loader
if filename == None or format == None:
if not self.path == None:
filename = self.path
filepath = path.realpath(filename)
(dir, basename) = path.split(filepath)
(prefix, ext) = path.splitext(basename)
if not ext == '.mg' and not ext == '.mg2':
raise ExportError, "Couldn't save into exported type."
format = formatmanager.formats[ext[1:]]
else:
raise ExportError, "Couldn't save new file without filename."
filepath = path.realpath(filename)
format.write(self.graph, filepath, options=options)
self.path = filename
self.graph.change(False)
def exportToFile(self, filename, format, options={}):
"""GraphContext.exportToFile(filename) -> void
Writes the graph in this context out to a file, autodetecting
the filetype from the name of the file. Will not change the path
or reset the changed flag."""
filepath = path.realpath(filename)
format.write(self.graph, filepath, options=options)
def writeToPOVRay(self, filename, options={}):
"""Draw the graph to a .pov POVRay file
Arguments:
filename -- name of the file with path and extension
options -- a dictionary of POVRay options
"""
filepath = path.realpath(filename)
if 'skyColor' not in options:
options['skyColor'] = self.bgColor
if 'planeColor' not in options:
options['planeColor'] = self.planeColor
if self.orthoMode:
formatmanager.formats['pov'].write(self.graph, filepath,
self.orthocamera,
options=options)
else:
formatmanager.formats['pov'].write(self.graph, filepath,
self.camera,
options=options)
def revert(self):
"""GraphContext.revert() -> void
Reloads a context from the last saved state.
Raises ImportError if there is no last saved state."""
if self.path == None:
raise ImportError, "Can't revert an unsaved context."
filepath = path.realpath(self.path)
(dir, basename) = path.split(filepath)
(prefix, ext) = path.splitext(basename)
self.graph.clear()
self.loadFromFile(self.path, formatmanager.formats[ext[1:]])
def setDraw(self, slot, drawable):
self.drawList[slot] = drawable
for o in self.observers:
o.callRemote('setattr', {'drawList': self.drawList}).addErrback(connectionError, 'context setDraw')
def delDraw(self, slot):
if slot in self.drawList:
del self.drawList[slot]
for o in self.observers:
o.callRemote('setattr', {'drawList': self.drawList}).addErrback(connectionError, 'context removeDraw')
def getDraw(self, slot):
return self.drawList[slot]
def draw(self, edgeNameBase=None, vertNameBase=None):
"""Draw the elements of this context on the current GL canvas."""
if not self.ready:
self.init()
# Set up the camera
if self.orthoMode:
activecam = self.orthocamera
else:
activecam = self.camera
activecam.use()
# Apply the tracker offsets.
activecam.useTracker()
if self.graph.vertices_selected:
orbitCentre = self.graph.vertices_selected[0]
else:
orbitCentre = self.graph.centerOfMass()
# Multiply points if snapping to grid
if self.showGrid:
ocp = utilities.mult3D(orbitCentre.pos, self.spacing)
else:
ocp = orbitCentre.pos
if config.current['global:camera-orbit'] == "cw":
self.camera.absorbit(ocp, Y_AXIS, -1)
elif config.current['global:camera-orbit'] == "ccw":
self.camera.absorbit(ocp, Y_AXIS, 1)
# Only draw decorations if we're in render mode - not in
# selection mode.
if glGetInteger(GL_RENDER_MODE) == GL_RENDER:
# Draw the ground plane if it's enabled, but not when we're
# using ortho mode
glEnable(GL_CULL_FACE)
if self.showPlane and not self.orthoMode:
self.decor.drawGroundPlane(height=self.graph.findGroundPlane(), color=self.planeColor,
reference=self.camera.pos)
#
# Draw the graph
#
glEnable(GL_TEXTURE_2D)
self.graphgl.draw(edgeNameBase=edgeNameBase, vertNameBase=vertNameBase)
#
# Draw A grid if the user wants one
#
if self.showGridLines:
self.decor.drawGrid(parent=self, pos=self.pos, sizeX=self.sizeX, sizeY=self.sizeY, sizeZ=self.sizeZ,
spacing=self.spacing)
# Only draw decorations if we're in render mode - not in
# selection mode.
if glGetInteger(GL_RENDER_MODE) == GL_RENDER:
glEnable(GL_CULL_FACE)
# Draw the coordinate axes if they're enabled
if self.showAxes:
self.decor.drawAxes()
# Draw local axes if required
# print "window:",wx.Window.FindFocus(), "\n canvas:", self.parent.canvas
showA = False
if not self.parent == None:
if wx.Window.FindFocus() == self.parent.canvas:
showA = True
if self.showLocalAxes and showA:
localAxes = (X_AXIS, Y_AXIS, Z_AXIS)
labels = ('Q', 'A', 'W', 'S', 'E', 'D')
if self.orthoMode:
if self.orthoMode[0] == X_AXIS:
localAxes = (Y_AXIS, Z_AXIS)
if self.orthoMode[1] > 0:
labels = (None, None, 'W', 'S', 'D', 'A')
else:
labels = (None, None, 'W', 'S', 'A', 'D')
elif self.orthoMode[0] == Y_AXIS:
localAxes = (X_AXIS, Z_AXIS)
if self.orthoMode[1] > 0:
labels = ('A', 'D', None, None, 'S', 'W')
else:
labels = ('D', 'A', None, None, 'S', 'W')
elif self.orthoMode[0] == Z_AXIS:
localAxes = (X_AXIS, Y_AXIS)
if self.orthoMode[1] > 0:
labels = ('A', 'D', 'W', 'S', None, None)
else:
labels = ('D', 'A', 'W', 'S', None, None)
for v in self.graph.vertices_selected:
if v.hidden:
continue
self.decor.draw_localaxes(self, v, axes=localAxes, labels=labels)
# Draw vertex labels if selected.
if self.showVertexLabels:
if self.showDummyLabels:
vxlist = self.graph.vertices
else:
vxlist = [x for x in self.graph.vertices if not isinstance(x, DummyVertex)]
if len(vxlist) > 0:
if self.vertexLabelName:
labelFunc = lambda v: str(v.name)
else:
labelFunc = lambda v: str(v.id)
self.decor.drawVertexLabels(parent=self, vxlist=vxlist, labelFunc=labelFunc,
labelStrokeWidth=self.vertexLabelStroke,
labelColor=self.vertexLabelColor, shadowColor=self.vertexShadowColor)
if self.showHUD:
if self.showCursor:
self.decor.drawHUD(activecam, self.graph.vertices_selected, pos=self.cursor.realPosition(activecam),
status=self.HUDstatus)
else:
self.decor.drawHUD(activecam, self.graph.vertices_selected, status=self.HUDstatus)
if self.showCursor:
# First, draw the local grid around the cursor position.
# self.decor.drawLocalGrid(pos = self.cursor.realPosition(activecam), size=1, spacing=5.0, snap=5.0)
glEnable(GL_CULL_FACE)
glDisable(GL_TEXTURE_2D)
glDisable(GL_POLYGON_SMOOTH)
self.decor.drawCursor(camera=activecam, cursor=self.cursor)
for d in self.drawList.values():
d.draw()
def goPersp(self):
"""
Restore and unlock the perspective camera in this context.
"""
self.orthoMode = None
for o in self.observers: o.callRemote('setOrtho', None).addErrback(connectionError, 'abc')
def goOrtho(self, axis, look):
"""
Align and lock in this context for orthographic movement.
axis and side specify the alignment of the camera.
eg. goOrtho(Y_AXIS, -1) will place the camera on the Y axis
looking in the negative direction with movement restricted
to the XZ plane.
"""
self.orthoMode = (axis, look)
for o in self.observers: o.callRemote('setOrtho', self.orthoMode).addErrback(connectionError, 'abc')
self.orthocamera.setOnAxis(axis, look * -20.0)
def vertexWarp(self, vertex, refresh=None):
"""
Warp to vertex, using the Animator.
"""
from utilities import add3D, diff3D, mult3D
offset = add3D(mult3D(self.camera.vpn, -10.0), (0.0, vertex.radius * 3.0, 0.0))
if self.showGrid:
npos = utilities.mult3D(vertex.pos, self.spacing)
else:
npos = vertex.pos
targetpos = add3D(npos, offset)
self.parent.animator.perspCameraMove(self.camera, newPos=targetpos, newLook=npos, duration=1.0)
def lookAt(self, target, refresh=None):
"""
Re-point the current camera to look at some object in the graph.
Target can be:
- a position in 3-space expressed as a 3-tuple of floats
- a Vertex object
- an Edge object (will look at the midpoint)
"""
if isinstance(target, Vertex):
if self.showGrid:
tgt = target
tgt.pos = utilities.mult3D(target.pos, self.spacing)
else:
tgt = target
elif isinstance(target, Edge):
if self.showGrid:
tgt = target
tgt.source.pos = utilities.mult3D(target.source.pos, self.spacing)
tgt.target.pos = utilities.mult3D(target.target.pos, self.spacing)
else:
tgt = target
elif self.showGrid:
tgt = utilities.mult3D(target, self.spacing)
else:
tgt = target
if self.orthoMode:
# XXX# Do something
pass
else:
self.parent.animator.perspCameraMove(
camera=self.camera,
newLook=tgt,
duration=1.2,
)