The following is from:
http://vpython.org/contents/docs/visual/curve.html
But edited as an illimath tutorial. Begun 1aug09.
The curve object displays straight lines between points, and if the
points are sufficiently close together you get the appearance of a
smooth curve. In addition to its basic use for displaying curves, the
curve object has powerful capabilities for other uses, such as efficient
plotting of functions.
Some attributes, such as pos and color, can be different for each point
in the curve. These attributes are stored as numpy arrays. The numpy
module for Python provides powerful array processing capabilities; for
example, two entire arrays can be added together. Numpy arrays can be
accessed using standard Python rules for referring to the nth item in a
sequence (that is, seq[0] is the first item in seq, seq[1] is the
second, seq[2] is the third, etc). For example, anycurve.pos[0] is the
position of the first point in anycurve.
You can give curve an explicit list of coordinates enclosed in brackets,
like all Python sequences. Here is an example of a 2D square:
square = curve(pos=[(0,0),(0,1),(1,1),(1,0),(0,0)])
Essentially, (1,1) is shorthand for (1,1,0). However, you cannot mix 2D
and 3D points in one list.
Curves can have thickness, specified by the radius of a cross section of
the curve (the curve has a thickness or diameter that is twice this
radius):
curve(pos=[(0,0,0), (1,0,0), (2,1,0)], radius=0.05)
The default radius is 0, which draws a thin curve. A nonzero radius
makes a "thick" curve, but a very small radius may make a curve that is
too thin to see.
In the following example, the arange() function (provided by the Python
numpy module, which is imported by the Visual module, gives a sequence
of values from 0 to 20 in steps of 0.1 (not including the last value,
20).
c = curve( x = arange(0,20,0.1) ) # Draw a helix c.y = sin( 2.0*c.x )
c.z = cos( 2.0*c.x )
The x, y, and z attributes allow curves to be used to graph functions
easily:
curve( x=arange(100), y=arange(100)**0.5,
color=color.red)
A function grapher looks like this (a complete program!), where
"raw_input" is a Python function that accepts input typed in the Python
Shell window:
eqn = raw_input('Equation in x: ') x = arange( 0, 10, 0.1 ) curve( x=x,
y=eval(eqn) )
Parametric graphing is also easy:
t = arange(0, 10, 0.1) curve( x = sin(t), y = 1.0/(1+t), z = t**0.5,
red = cos(t), green = 0, blue = 0.5*(1-cos(t)) )
Here are the curve attributes:
pos[] Array of position of points in the curve: pos[0], pos[1],
pos[2].... The current number of points is given by len(curve.pos)
x[ ], y[ ], z[ ] Components of pos; each defaults to [0,0,0,0,...]
color[ ] Color of points in the curve
red[ ], green[ ], blue[ ] Color components of points in the curve
radius Radius of cross-section of curve The default radius=0 makes a
thin curve
material Material for a thick curve; see Materials for currently
available options
Currently it is not possible to specify the opacity of a curve object.
Adding more points to a curve
Curves can be created incrementally with the append() function. A new
point by default shares the characteristics of the last point.
spiral = curve( color = color.cyan ) for t in arange(0, 2*pi, 0.1):
spiral.append( pos=(t,sin(t),cos(t)) )
One of the many uses of curves is to leave a trail behind a moving
object. For example, if ball is a moving sphere, this will add a point
to its trail:
trail = curve() ball = sphere() # .... Every time you update the
position of the ball: trail.append(pos=ball.pos)
When appending to a curve, you can optionally choose to retain only the
last N points, including the one you're adding:
trail.append(pos=ball.pos, retain=50) # last 50 points
Interpolation
The curve machinery interpolates from one point to the next. For
example, suppose the first three points are red but the fourth point is
blue, as in the following example. The lines connecting the first three
points are all red, but the line going from the third point (red) to the
fourth point (blue) is displayed with a blend going from red to blue.
c = curve( pos=[(0,0,0), (1,0,0)], color=color.red) c.append(
pos=(1,1,0) ) # add a red point c.append( pos=(0,1,0), color=color.blue)
# add blue point
If you want an abrupt change in color or thickness, add another point at
the same location. In the following example, adding a blue point at the
same location as the third (red) point makes the final line be purely
blue.
c = curve( pos=[(0,0,0), (1,0,0)], color=color.red) c.append(
pos=(1,1,0) ) # add a red point c.append( pos=(1,1,0), color=color.blue)
# same point c.append( pos=(0,1,0) ) # add blue point
Technical note: No matter how many points are in a curve, only 1000 are
displayed, selected evenly over the full set of points, in order that
the display of a very long curve doesn't slow down unacceptably.
See description of Additional Attributes available for all 3D display
objects.