IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

The Visual Module of VPython - Reference Manual

Date de publication : 4 février 2009


3D objects
arrow
box
cone
convex
curve
cylinder
ellipsoid
faces
frame
helix
label
points
pyramid
ring
sphere


3D objects


arrow

The arrow object has a straight box-shaped shaft with an arrowhead at one end. The following statement will display an arrow pointing parallel to the x axis:


pointer = arrow(pos=(0,2,1), axis=(5,0,0), shaftwidth=1)
The arrow object has the following attributes and default values, like those for cylinders: pos (0,0,0), x (0), y(0), z(0), axis (1,0,0), length (1), color (1,1,1) which is color.white, red (1), green (1), blue (1), opacity (1), material, and up (0,1,0). As with box, the up attribute is significant for arrow because the shaft and head have square cross sections, and setting the up attribute rotates the arrow about its axis. Additional arrow attributes:

shaftwidth By default, shaftwidth = 0.1*(length of arrow)

headwidth By default, headwidth = 2*shaftwidth

headlength By default, headlength = 3*shaftwidth

Assigning any of these attributes to 0 makes it use defaults based on the size of the arrow. If headlength becomes larger than half the length of the arrow, or the shaft becomes thinner than 1/50 the length, the entire arrow is scaled accordingly.

This default behavior makes the widths of very short arrows shrink, and the widths of very long arrows grow (while displaying the correct total length). If you prefer that shaftwidth and headwidth not change as the arrow gets very short or very long, set fixedwidth = 1. In this case the only adjustment that is made is that headlength is adjusted so that it never gets longer than half the total length, so that the total length of the arrow is correct. This means that very short, thick arrows look similar to a thumbtack, with a nearly flat head.

Note that the pos attribute for cylinder, arrow, cone, and pyramid corresponds to one end of the object, whereas for a box, sphere, or ring it corresponds to the center of the object.

See description of Additional Attributes available for all 3D display objects.


box

In the first diagram we show a simple example of a box object:


mybox = box(pos=(x0,y0,z0), length=L, height=H, width=W) 
The given position is in the center of the box, at (x0, y0, z0). This is different from cylinder, whose pos attribute is at one end of the cylinder. Just as with a cylinder, we can refer to the individual vector components of the box as mybox.x, mybox.y, and mybox.z. The length (along the x axis) is L , the height (along the y axis) is H , and the width is W (along the z axis). For this box, we have mybox.axis = (L, 0, 0) . Note that the axis of a box is just like the axis of a cylinder.

For a box that isn't aligned with the coordinate axes, additional issues come into play. The orientation of the length of the box is given by the axis (see second diagram):

mybox = box(pos=(x0,y0,z0), axis=(a,b,c), length=L, height=H, width=W) 
The axis attribute gives a direction for the length of the box, and the length, height, and width of the box are given as before (if a length attribute is not given, the length is set to the magnitude of the axis vector).

There remains the issue of how to orient the box rotationally around the specified axis. The rule that Visual uses is to orient the width to lie in a plane perpendicular to the display "up" direction, which by default is the y axis. Therefore in the diagram you see that the width lies parallel to the x-z plane. The height of the box is oriented perpendicular to the width, and to the specified axis of the box. It helps to think of length initially as going along the x axis, height along the y axis, and width along the z axis, and when the axis is tipped the width stays in the x-z plane.

You can rotate the box around its own axis by changing which way is "up" for the box, by specifying an up attribute for the box that is different from the up vector of the coordinate system:

mybox = box(pos=(x0,y0,z0), axis=(a,b,c), length=L, height=H, width=W, up=(q,r,s))
With this statement, the width of the box will lie in a plane perpendicular to the (q,r,s) vector, and the height of the box will be perpendicular to the width and to the (a,b,c) vector.

The box object has the following attributes and default values, like those for cylinders: pos (0,0,0), x (0), y(0), z(0), axis (1,0,0), length (1), color (1,1,1) which is color.white, red (1), green (1), blue (1), opacity (1), material, and up (0,1,0). Additional box attributes:

height In the y direction in the simple case, default is 1

width In the z direction in the simple case, default is 1

size (length, height, width), default is (1,1,1)
      mybox.size=(20,10,12) sets length=20, height=10, width=12

Note that the pos attribute for cylinder, arrow, cone, and pyramid corresponds to one end of the object, whereas for a box, sphere, or ring it corresponds to the center of the object.

See description of Additional Attributes available for all 3D display objects.


cone

The cone object has a circular cross section and tapers to a point. The following statement will display a cone with the center of its circular base at (5,2,0), pointing parallel to the x axis with length 12; the wide end of the cone has radius 1:

cone(pos=(5,2,0), axis=(12,0,0), radius=1)
The cone object has the following attributes and default values, like those for cylinders: pos (0,0,0), x (0), y(0), z(0), axis (1,0,0), length (1), color (1,1,1) which is color.white, red (1), green (1), blue (1), opacity (1), material, and up (0,1,0). As with cylinders, up has only a subtle effect on the 3D appearance of a cone unless a non-smooth material is specified. Additional cone attribute:

radius Radius of the wide end of the cone, default = 1

Note that the pos attribute for cylinder, arrow, cone, and pyramid corresponds to one end of the object, whereas for a box, sphere, or ring it corresponds to the center of the object.

See description of Additional Attributes available for all 3D display objects.


convex

The convex object takes a list of points for pos, like the curve object. An object is generated that is everywhere convex (that is, bulges outward). Any points that would make a portion of the object concave (bulge inward) are discarded. If all the points lie in a plane, the object is a flat surface.

Currently it is not possible to specify the opacity of a convex object.

See description of Additional Attributes available for all 3D display objects.


curve

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.


cylinder

Studying this description of the cylinder object provides an overview of important aspects common to all of the Visual 3D objects, box, sphere, pyramid, etc.

Here is an example of how to make a cylinder, naming it "rod" for future reference:

rod = cylinder(pos=(0,2,1), axis=(5,0,0), radius=1)
The center of one end of this cylinder is at x=0, y=2, and z=1. Its axis lies along the x axis, with length 5, so that the other end of the cylinder is at (5,2,1), as shown in the accompanying diagram.

You can modify the position of the cylinder after it has been created, which has the effect of moving it immediately to the new position:

rod.pos = (15,11,9) # change (x,y,z)
rod.x = 15 # only change pos.x
If you create an object such as a cylinder but without giving it a name such as rod, you can't refer to it later. This doesn't matter if you never intend to modify the object.

Since we didn't specify a color, the cylinder will be the current "foreground" color (see Controlling One or More Visual Display Windows). The default foreground color is white. After creating the cylinder, you can change its color:

rod.color = (0,0,1) # make rod be blue
This will make the cylinder suddenly turn blue, using the so-called RGB system for specifying colors in terms of fractions of red, green, and blue. (For details on choosing colors, see Specifying Colors.) You can set individual amounts of red, green, and blue like this:

rod.red = 0.4
rod.green = 0.7
rod.blue = 0.8
The cylinder object can be created with other, optional attributes, which can be listed in any order. Here is a full list of attributes, most of which also apply to other objects:

pos Position: the center of one end of the cylinder; default = (0,0,0)
A triple, in parentheses, such as (3,2,5)

axis The axis points from pos to the other end of the cylinder, default = (1,0,0)

x, y, z Essentially the same as pos.x, pos.y, pos.z, defaults are all 0

radius The radius of the cylinder, default = 1

length Length of axis; if not specified, axis determines the length, default = 1
If length is specified, it overrides the length given by axis

color Color of object, as a red-green-blue (RGB) triple: (1,0,0) is pure red, default = (1,1,1), which is color.white

red, green, blue (can set these color attributes individually), defaults are all 1

opacity Opacity of object, default = 1; 0 is completely transparent

material Material of object; see Materials for currently available options

up Which side of the cylinder is "up"; this has only a subtle effect on the 3D appearance of the cylinder unless a non-smooth material is specified; default (0,1,0)

Note that the pos attribute for cylinder, arrow, cone, and pyramid corresponds to one end of the object, whereas for a box, sphere, or ring it corresponds to the center of the object.

See description of Additional Attributes available for all 3D display objects.

When you start a VPython program, for convenience Visual creates a display window and names it scene. By default, objects that you create go into that display window. See Controlling One or More Visual Display Windows later in this reference for how you can create additional display windows and place objects in them.


ellipsoid

A long ellipsoid object looks like a cigar; a short one looks like somewhat like a pill. Its cross sections are circles or ellipses. The elllipsoid object has the same attributes as the box object and it can be thought of as fitting inside a box of the same dimensions:

myell = ellipsoid(pos=(x0,y0,z0), length=L, height=H, width=W) 
The given position is in the center of the ellipsoid, at (x0, y0, z0). This is different from cylinder, whose pos attribute is at one end of the cylinder. Just as with a cylinder, we can refer to the individual vector components of the ellipsoid as myell.x, myell.y, and myell.z. The length from end to end (along the x axis) is L , the height (along the y axis) is H , and the width is W (along the z axis). For this ellipsoid, we have myell.axis = (L, 0, 0) . Note that the axis of an ellipsoid is just like the axis of a cylinder.

For an ellipsoid that isn't aligned with the coordinate axes, additional issues come into play. The orientation of the length of the ellipsoid is given by the axis (see diagrams shown with the documentation on the box object):

myell = ellipsoid(pos=(x0,y0,z0), axis=(a,b,c), length=L, height=H, width=W) 
The axis attribute gives a direction for the length of the ellipsoid, and the length, height, and width of the ellipsoid are given as before (if a length attribute is not given, the length is set to the magnitude of the axis vector).

The ellipsoid object has the following attributes and default values, like those for cylinders: pos (0,0,0), x (0), y(0), z(0), axis (1,0,0), length (1), color (1,1,1) which is color.white, red (1), green (1), blue (1), opacity (1), material, and up (0,1,0). Additional attributes, similar to those for a box:

height In the y direction in the simple case, default is 1

width In the z direction in the simple case, default is 1

size (length, height, width), default is (1,1,1)
myell.size=(20,10,12) sets length=20, height=10, width=12

Note that the pos attribute for cylinder, arrow, cone, and pyramid corresponds to one end of the object, whereas for an ellipsoid, box, sphere, or ring it corresponds to the center of the object.

See description of Additional Attributes available for all 3D display objects.


faces

The "faces" primitive takes a list of triangles (position, color, and normal for each vertex). This is useful for writing routines in Python to import 3D models made with other 3D modeling tools. You would still need to do lots of calculations of normals and so on, but you would not need to do C coding to import an arbitrary model file.

The faces object is an array primitive (like curve, convex, etc), so you have to use a frame to move it around. It consists of a set of one-sided triangles with user-specified vertices, colors, and normals. The pos, color, and normal attributes look like this:

pos = [ t0v0, t0v1, t0v2, 
        t1v0, t1v1, t1v2, 
        t2v0, t2v1, t2v2, ... ] 
where t0v0 is the position of vertex 0 of triangle 0, t0v1 is vertex 1 of triangle 0, etc.

Each face is a one-sided surface. Which side is illuminated is determined by the "winding" order of the face. When you are looking at a face, it is illuminated if the order of the vertices in the pos list goes counter-clockwise. If you need the triangle to be visible from either side, you must create another triangle with the opposite winding order.

If you don't specify normals at the vertices, the face is illuminated only by "ambient" light. In order for the main lighting to affect the appearance, you must specify normals to the surface at the vertices. In the simplest case, a normal at a vertex is perpendicular to the face, and adjoining faces have a hard edge where they join. A soft edge can be produced by averaging the normals to the two faces at their common vertices. The brightness of a face is proportional to the cosine of the angle between the normal and the light.

If you specify different colors at the vertices of one triangular face, VPython interpolates across the face, in which case the face is not all one color. There is a similar interpolation for normals if there are different normals at the vertices, in which case the face is not all one brightness.

The faces object is intended to help with writing model importers and other new primitives in Python, not for direct manipulation by normal programs. It is considerably lower-level than any of the other objects in Visual (although it is not necessarily any faster, at least right now). It is flexible enough to implement smooth or facet shading, per-vertex coloration, two-sided or one-sided lighting, etc, but all of these calculations must be made by the programmer (when setting up pos, color, normal).

You can specify a material, but currently you can not specify opacity for faces.

See description of Additional Attributes available for all 3D display objects.

For examples of the use of the faces object, see the faces demo programs.


frame

Composite Objects with frame

You can group objects together to make a composite object that can be moved and rotated as though it were a single object. Create a frame object, and associate objects with that frame:

f = frame()
cylinder(frame=f, pos=(0,0,0), radius=0.1, length=1, color=color.cyan)
sphere(frame=f, pos=(1,0,0), radius=0.2, color=color.red)
f.axis = (0,1,0) # change orientation of both objects
f.pos = (-1,0,0) # change position of both objects
By default, frame() has a position of (0,0,0) and axis in the x direction (1,0,0). The cylinder and sphere are created within the frame. When any of the frame attributes are changed (pos, x, y, z, axis, or up), the composite object is reoriented and repositioned.

You can make all the objects in a frame invisible or visible by setting the frame's visible attribute.

Another frame attribute is objects, which is a list of currently visible objects contained in the frame (the list does not include objects that are currently invisible, not lights, which are found in scene.lights). If you want to make all the objects in a frame be red, do the following (assume the frame is named f):

for obj in f.objects:
    obj.color = color.red
If you use this method to make all the objects invisible, the f.objects list will be empty. If you need a list containing all the objects, both visible and invisible, you need to maintain your own list of objects.

If ball is an object in a frame, ball.pos is the position local to the frame, not the actual position in "world space". Here is a routine that will calculate the position of a vector such as ball.pos in world space:

def world_space_pos(frame, local):
"""Returns the position of local in world space."""
    x_axis = norm(frame.axis)
    z_axis = norm(cross(frame.axis, frame.up))
    y_axis = norm(cross(z_axis, x_axis))
    return

frame.pos+local.x*x_axis+local.y*y_axis+local.z*z_axis


helix

The following statement will display a helix that is parallel to the x axis:

spring = helix(pos=(0,2,1), axis=(5,0,0), radius=0.5)
The helix object has the following attributes and default values: pos (0,0,0), x (0), y(0), z(0), axis (1,0,0), length (1), radius (1), coils (5), thickness (radius/20), color (1,1,1) which is color.white, red (1), green (1), blue (1), material, and up (0,1,0).

Note that the pos attribute for cylinder, arrow, cone, pyramid, and helix corresponds to one end of the object, whereas for a box, sphere, or ring it corresponds to the center of the object.

Currently it is not possible to specify the opacity of a helix object, which is based on the curve object.

See description of Additional Attributes available for all 3D display objects.


label

With the label object you can display text in a box. Here are simple examples (in the second label statement, note the standard Python scheme for formatting numerical values, where 1.5f means 1 figure before the decimal point and 5 after):

box(pos=(0,0,0), color=color.red)
label(pos=(0,0.25,0), text='This is a box')
label(pos=(0,-0.25,0), text='pi = %1.5f' % pi) 
There are many additional label options. In the accompanying diagram, a sphere representing the Earth (whose center is at earth.pos) has an associated label with the text "Earth" in a box, connected to the sphere by a line which stops at the surface of the sphere:

earthlabel = label(pos=earth.pos, text='Earth', xoffset=20, yoffset=12, space=earth.radius, height=10, border=6, font='sans')
A unique feature of the label object is that several attributes are given in terms of screen pixels instead of the usual "world-space" coordinates. For example, the height of the text is given in pixels, with the result that the text remains readable even when the sphere object is moved far away. Other pixel-oriented attributes include xoffset, yoffset, and border. Here are the label attributes:

pos; x,y,z The point in world space being labeled. If there are no offsets (see diagram), the center of the text is at pos

xoffset, yoffset The x and y components of the line, in pixels (see diagram). You can left justify text by setting xoffset = 1 and line = 0 (so the 1-pixel line doesn't show), or right-justify text by setting xoffset = -1 and line = 0. text The text to be displayed, such as 'Earth'
(Line breaks can be included as \n, as in label.text = "Three\nlines\nof text")

font Name of the desired font; for example, 'sans', or 'serif', or 'monospace' (fixed-width)
Python Unicode strings are supported.

height Height of the font in pixels; default is 13 pixels

color, red, green, blue Color of the text

opacity Opacity of the background of the box, default 0.66
(0 transparent, 1 opaque, for objects behind the box)

border Distance in pixels from the text to the surrounding box; default is 5 pixels

box 1 if the box should be drawn (default), else 0

line 1 if the line from the box to pos should be drawn (default), else 0

linecolor Color of the line and box

space World-space radius of a sphere surrounding pos,
into which the connecting line does not go

See description of Additional Attributes available for all 3D display objects.


points

The points object takes a list of points for pos, like the curve object. The following statement will display two points, each of radius 50 pixels:

points(pos=[(-1,0,0), (1,0,0)], size=50, color=color.red)
A new points object is similar to a curve, but with disconnected points. As with curve, the pos attribute is an array of points, and color can also be an array. If you say shape="round", the points are round, which is the default; shape="square" makes square points. The size of the points is specified by size, and the default size is 5 (meaning a square 5 by 5, or a circular disk bounded by a 5 by 5 square). The size attribute is in screen pixels if size_units="pixels" (the default), but if size_units="world", the size is in the usual coordinates. The maximum size of a point is about 50 by 50 pixels; specifying a larger size than the maximum does not increase the size.

Lighting does not affect the appearance, which is determined solely by the color. You cannot specify a material for points, and currently it is not possible to specify the opacity of a points object.

See description of Additional Attributes available for all 3D display objects.

Technical caveat: size_units="world" may not work on very old video drivers which do not support OpenGL 1.4 or the ARB_POINT_PARAMETERS extension. If you have problems, upgrade your video driver.


pyramid

The pyramid object has a rectangular cross section and tapers to a point. The following statement will display a pyramid with the center of the rectangular base at (5,2,0), pointing parallel to the x axis with a base that is 6 high (in y), 4 wide (in z), and with a length 12 from base to tip:

pyramid(pos=(5,2,0), size=(12,6,4))
The pyramid object has the following attributes and default values, like those for cylinders: pos which is the center of the rectangular base (0,0,0), x (0), y(0), z(0), axis (1,0,0), length (1), color (1,1,1) which is color.white, red (1), green (1), blue (1), opacity (1), material, and up (0,1,0). Additional pyramid attributes:

height In the y direction in the simple case, default is 1

width In the z direction in the simple case, default is 1

size (length, height, width), default is (1,1,1)
mypyramid.size=(20,10,12) sets length=20, height=10, width=12

Note that the pos attribute for cylinder, arrow, cone, and pyramid corresponds to one end of the object, whereas for a box, sphere, or ring it corresponds to the center of the object.

See description of Additional Attributes available for all 3D display objects.


ring

The ring object is circular, with a specified radius and thickness and with its center given by the pos attribute:

ring(pos=(1,1,1), axis=(0,1,0), radius=0.5, thickness=0.1)
The ring object has the following attributes and default values, like those for cylinders: pos (0,0,0), x (0), y(0), z(0), axis (1,0,0), length (1), color (1,1,1) which is color.white, red (1), green (1), blue (1), opacity (1), material, and up (0,1,0). As with cylinders, up has a subtle effect on the 3D appearance of a ring unless a non-smooth material is specified. The axis attribute only affects the orientation of the ring; the magnitude of the axis attribute is irrelevant. Additional ring attributes:

radius Radius of the central part of the ring, default = 1, so
        outer radius = radius+thickness
        inner radius = radius-thickness

thickness The radius of the cross section of the ring (1/10th of radius if not specified), not the full diameter as you might expect.

Note that the pos attribute for cylinder, arrow, cone, and pyramid corresponds to one end of the object, whereas for a ring, sphere, and box it corresponds to the center of the object.

See description of Additional Attributes available for all 3D display objects.


sphere

Here is an example of how to make a sphere:

ball = sphere(pos=(1,2,1), radius=0.5)
This produces a sphere centered at location (1,2,1) with radius = 0.5, with the current foreground color.

The sphere object has the following attributes and default values, like those for cylinders except that there is no length attribute: pos (0,0,0), x (0), y(0), z(0), axis (1,0,0), color (1,1,1) which is color.white, red (1), green (1), blue (1), opacity (1), material, and up (0,1,0). As with cylinders, up and axis attributes affect the orientation of the sphere but have only a subtle effect on appearance unless a non-smooth material is specified. The magnitude of the axis attribute is irrelevant. Additional sphere attributes:

radius Radius of the sphere, default = 1

Note that the pos attribute for cylinder, arrow, cone, and pyramid corresponds to one end of the object, whereas for a sphere it corresponds to the center of the object.

See description of Additional Attributes available for all 3D display objects.

 

Valid XHTML 1.1!Valid CSS!