OpenGLContext.visitor
index
/home/mcfletch/pylive/OpenGLContext/visitor.py

Traversal objects for Contexts and scenegraphs

 
Modules
       
vrml.node
OpenGLContext.scenegraph.nodepath
vrml.vrml97.nodetypes
sys
traceback
types

 
Classes
       
object
Visitor
_Finder

 
class Visitor(object)
    Extremely basic visitor/traversal object for scenegraphs
 
The "visitor" does not actually follow the classic visitor
pattern (where the nodes dispatch the visitor to their
children).  Instead, it is a traversal mechanism that has
four major points of customisation:
 
    vmethods -- virtual methods which are applied to a node
        during traversal.  Each applicable vmethod (is
        registered as a method for one of the node's
        parent classes) is applied _in turn_, so it is
        possible to have large numbers of vmethods called
        for any given node.  Return values are callable
        tokens which perform any state-resetting required
 
        See: buildVMethods
        
    preVisit -- called for _every_ node before visiting, if it
        returns a false value, then the node's vmethods
        and children are _not_ processed.
        
    postVisit -- called for _every_ node where preVisit
        returned a true value as the last customisation point
        before the visitor finished processing the node.
 
Note: For the purposes of the visitor, a Context is just a
node like any other.  It produces a single "child" node which
is either a scenegraph or a special node which calls the Context's
Render method.
 
There is a log associated with the visitors which will log the
particular nodes, their vmethods, and any finalisation tokens
being run.  By default this log is set to WARN level.  You can
set it to INFO to see the verbose trace (warning, this will
seriously slow down your rendering on many systems!)  The
logging calls are eliminated (regardless of the logging setting)
under a python -O or python -OO run.
 
  Methods defined here:
__init__(self)
Initialise the visitor object
 
calls buildVMethods() then builds the current
stack.
 
Attributes:
    currentStack -- nodepath describing the current
        processing stack for this visitor
 
    _vmethods -- mapping from class/superclass to
        methods to be applied on entry to any instance
        of the class, see the vmethods method,
        (multiple match)
buildVMethods(self)
Customization point: Create application-specific type:method-name mapping
 
Basically this lets you call a named method for each
class/base-class in a node's __mro__.  Override this (calling
the base implementation and modifying the resulting dictionary)
to register your particular virtual methods.
 
Format is:
    class-pointer: string-method-name
 
The dictionary is stored as self._vmethods
children(self, node, types=(<class 'vrml.vrml97.nodetypes.Traversable'>, <class 'vrml.vrml97.nodetypes.Children'>, <class 'vrml.node.PrototypedNode'>, <class 'vrml.vrml97.nodetypes.Rendering'>))
Get children to visit for a node
 
Determine the set of children to be visited for
a given node in the node graph.  If the node
has a method renderedChildren, it will be called
with types as an argument and the result returned
as the sequence of children.
visit(self, node)
Visit an individual node, dispatch to methods as necessary
 
The visiting algorithm is fairly involved compared
to the classic computer science Visitor algorithm.
 
First we call preVisit( node ), and if the
result of that is true, we continue processing.
This allows you to use preVisit to do such things
as processing every node in the scenegraph.
 
If we are visiting the node: (preVisit returned true)
 
    * add the node to self.currentStack
    * retrieve the "vmethods" for the node
    * call each vmethod with the node as argument
        o if the vmethod returns a finalization token
            we store that token for finalization
    * we determine the children to visit for the node
    * for each child, we call visit recursively
    * during finalization (after children are finished
        processing)
        o if we have any finalization tokens, we call
            those tokens
        o we call postVisit( node )
        o we restore the previous self.currentStack
        
Note: this is the "production" version of visit
which only logs errors, not "info" level traces,
this avoids the 100's of 1000's of calls generated
by the huge number of iterations.
vmethods(self, obj)
Get all relevant "virtual methods" as unbound methods
 
Returns *all* registered vmethods for the classes in the
given object's class's __mro__
 
This version caches the unbound methods in a per-visitor-
class dictionary, which should make it at least a little
faster.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class _Finder(Visitor)
    Traverse a scenegraph looking for bindable nodes
 
This is a simple implementation of a scenegraph-search
which looks for all nodes which are instances of any of
a given set of classes/types.
 
Attributes:
    result -- the resulting set of node-paths
    desiredTypes -- the node-types being searched for
 
See the find function for the normal usage API
 
 
Method resolution order:
_Finder
Visitor
object

Methods defined here:
__init__(self, desiredTypes=())
Initialize the _Finder object
 
desiredTypes -- sequence of types to be searched for
visit(self, node)
Visit an individual node, search for self.desiredTypes
 
This is a heavily trimmed version of the superclass method

Methods inherited from Visitor:
buildVMethods(self)
Customization point: Create application-specific type:method-name mapping
 
Basically this lets you call a named method for each
class/base-class in a node's __mro__.  Override this (calling
the base implementation and modifying the resulting dictionary)
to register your particular virtual methods.
 
Format is:
    class-pointer: string-method-name
 
The dictionary is stored as self._vmethods
children(self, node, types=(<class 'vrml.vrml97.nodetypes.Traversable'>, <class 'vrml.vrml97.nodetypes.Children'>, <class 'vrml.node.PrototypedNode'>, <class 'vrml.vrml97.nodetypes.Rendering'>))
Get children to visit for a node
 
Determine the set of children to be visited for
a given node in the node graph.  If the node
has a method renderedChildren, it will be called
with types as an argument and the result returned
as the sequence of children.
vmethods(self, obj)
Get all relevant "virtual methods" as unbound methods
 
Returns *all* registered vmethods for the classes in the
given object's class's __mro__
 
This version caches the unbound methods in a per-visitor-
class dictionary, which should make it at least a little
faster.

Data descriptors inherited from Visitor:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
Functions
       
find(sg, desiredTypes=())
Get list of node-paths to instances of desiredTypes
 
desiredTypes -- sequence of desired base types
 
returns node-paths for each node in the scenegraph
of the given types
 
Note:
    The traversal is the same as that used by the
    rendering procedure, so is quite possible for
    non-rendering nodes to be missed by the search.
parents(c, seen=None)
Python class base-finder

 
Data
        DEBUG = 10
DEBUG_VISIT_METHOD = 0
INFO = 20
TRAVERSAL_TYPES = (<class 'vrml.vrml97.nodetypes.Traversable'>, <class 'vrml.vrml97.nodetypes.Children'>, <class 'vrml.node.PrototypedNode'>, <class 'vrml.vrml97.nodetypes.Rendering'>)
__file__ = '/home/mcfletch/pylive/OpenGLContext/visitor.pyc'
__name__ = 'OpenGLContext.visitor'
__package__ = 'OpenGLContext'
visitor_log = <logging.Logger instance at 0x35f8e18>