OpenGLContext.browser.visual
index
/home/mcfletch/pylive/OpenGLContext/browser/visual.py

VPython as a target:
 
Documentation on which we're basing our implementation:
        http://www.vpython.org/webdoc/visual/index.html
 
What are the key determinants in the visual python
API's success:
 
        geometry is simply created
 
        system has interactive operation (shell)
 
        flat hierarchies used throughout
 
        multiple mechanisms mapped to the same features
 
        use of "vector"-based orientation?
 
        simplified scripting APIs
 
        assumptions about application operation
 
        intuitive

 
Modules
       
colorsys
numpy.add_newdocs
numpy.core.defchararray
numpy.ctypeslib
numpy.lib.scimath
numpy.fft
vrml.field
vrml_accelerate.frustcullaccelnumpy
OpenGLContext.browser.geometry
numpy.linalg
numpy.ma
math
vrml.node
numpy.random
numpy.core.records
threading
time
vrml_accelerate.tmatrixaccelnumpy

 
Classes
       
Node(object)
Display

 
class Display(Node)
    Proxy object for the "display" (context)
 
Visual puts a lot of functionality into this object,
with most of the fields being "trigger something on set"
fields, rather than "normal" fields that just store
values.
 
 
Method resolution order:
Display
Node
object

Methods defined here:
create(self, event)
Create rendering context for this display
 
Create the application if necessary, then the
frame, and return only after the frame has been
created.
createFrame(self)
Create a new rendering frame
select(self)
Makes this the currently-rendering context
set_autocenter = f(self, value, *arguments, **named)
set_autoscale = f(self, value, *arguments, **named)
set_background(self, value, field, *arguments, **named)
Set the scenegraph background attribute
set_center = f(self, value, *arguments, **named)
set_fov = f(self, value, *arguments, **named)
set_height = set_size(self, value, field, *arguments, **named)
set_objects = set_background(self, value, field, *arguments, **named)
set_pos(self, value, field, *arguments, **named)
set_range = f(self, value, *arguments, **named)
set_scale(self, value, field, *arguments, **named)
Scale is just a 1/range thing, so update range instead
set_size(self, value, field, *arguments, **named)
set_title(self, value, *arguments, **named)
set_uniform = f(self, value, *arguments, **named)
set_up = f(self, value, *arguments, **named)
set_visible(self, value, fieldObject, *arguments, **named)
Visibility has changed, either hide or show
set_width = set_size(self, value, field, *arguments, **named)
set_x = set_pos(self, value, field, *arguments, **named)
set_y = set_pos(self, value, field, *arguments, **named)

Data descriptors defined here:
ambient
Wrapper for a field
autocenter
Wrapper for a field
autoscale
Wrapper for a field
background
Wrapper for a field
center
Wrapper for a field
cursor
Wrapper for a field
exit
Wrapper for a field
foreground
Wrapper for a field
forward
Wrapper for a field
fov
Wrapper for a field
height
Wrapper for a field
lights
Wrapper for a field
objects
Wrapper for a field
range
Wrapper for a field
scale
Wrapper for a field
title
Wrapper for a field
uniform
Wrapper for a field
up
Wrapper for a field
userspin
Wrapper for a field
userzoom
Wrapper for a field
visible
Wrapper for a field
width
Wrapper for a field
x
Wrapper for a field
y
Wrapper for a field

Methods inherited from Node:
__init__(self, **namedarguments)
Initialise the node with appropriate named args
 
All properties/attributes must be specified with
named arguments, and the property/attribute must
exist within the Node's class/prototype.
 
This will raise AttributeError/ValueError/TypeError
if the values or the property names are inappropriate.
 
Note that all Node objects have the attribute/property
        exposedField SFString DEF ""
defined.  You may therefore specify a DEF name by
passing it as a named argument.
__repr__(self)
Get a code-like representation of the Node
 
Basically every attribute except for sub-nodes values
are returned as a full representation.
__str__(self)
Get a friendly representation of the Node
copy(self, copier=None)
Copy this node for copier
toString(self, **namedargs)
Generate a VRML 97-syntax string representing this Prototype
**namedargs -- key:value
        passed arguments for the linearisation object
see lineariser4.Lineariser

Data descriptors inherited from Node:
DEF
exposedField SFString  DEF
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)
externalURL
exposedField MFString externalURL <type 'list'>
rootSceneGraph
exposedField RootScenegraphNode  root NULL

Data and other attributes inherited from Node:
PROTO = ''

 
Functions
       
_newNode(cls, named)
Construct new instance of cls, set proper color, and add to objects
box(**named)
Create a box, adding to current scene
callInGUIThread(callable, *arguments, **named)
Call the callable object in the GUI thread
 
This adds a record to the eventCascadeQueue, which will
executed during the standard DoEventCascade method.
 
Note: the callable will be called in the event Cascade
of the first valid scene context.
cone(**named)
Create a cone, adding to current scene
curve(**named)
Create a new curve, adding to the current scene
cylinder(**named)
Create a cylinder, adding to current scene
display(**named)
Create a new display for the system
hsv_to_rgb(T)
Convert HSV tuple to RGB value
rate(framesPerSecond=30)
Allow animation to continue at given rate
rgb_to_hsv(T)
Convert RGB tuple to HSV value
select(display)
Make the given display the "current" display (global scene)
sphere(**named)
Create a sphere, adding to current scene

 
Data
        _GUIThread = None
__file__ = '/home/mcfletch/pylive/OpenGLContext/browser/visual.pyc'
__name__ = 'OpenGLContext.browser.visual'
__package__ = 'OpenGLContext.browser'
_application = None
color = <OpenGLContext.browser.crayola._ColorSystem object at 0x5a08a90>
divide_safe = <ufunc 'divide'>
implementation_name = 'numpy'
scene = Display( DEF = 'Primary Window' )
scenes = [Display( DEF = 'Primary Window' )]