VPython Object

Claimed by Ddebord3 (2015) / Edited by Vnistala3 (2017)

A VPython Object is a representation of data in a specific in VPython both visually and numerically. Each object represents data through its attributes, specific characteristics assigned to each individual object. Objects play an essential role in the necessary knowledge for the coding portion of PHYS 2211 and 2212, as most of your programs will require the extensive usage and manipulation of objects. This page is intended to provide you a background on these objects, especially if you have no prior knowledge of coding or VPython.

The Main Idea

Objects in VPython are intended to represent data in ways that can be easily visualized and understood by both the user and the computer. Each object has a type it belongs to, which determines its default attributes, as well as how the computer will choose to display it when the program runs. Objects must be uniquely named if you wish to refer to them again later in your program, and any graphical object you create (spheres, boxes, curves, arrows, etc.) continue to exist for as long as your program remains running - VPython will continue to display them regardless of where they are positioned. If you change an attribute of an object, such as its position or color, VPython will automatically display the object in its new location and/or with its new color.

For example, let's say you create a sphere called 'ball' - by default, ball has attributes pre-assigned to it, such as ball.pos (the .pos attribute signifies the position of the sphere) or ball.color (the .color attribute allows you to change the color of the sphere). Also, in addition to the preset attributes, you can also create new ones. Besides the position and radius, you can also create attributes for mass (ball.mass), velocity (ball.vel), momentum (ball.momentum), or anything else you see fit. Of course, not all attributes need to be added manually. They can be left blank and filled in with a default value which the program automatically assigns them

The general syntax for creating an object is as follows.

objectName = objectType([insert attributes here])  

Attributes

Many objects in VPython carry common attributes regardless of their type. This section will cover the attributes you will be utilizing the most in this class.

Position

The position attribute is common to almost every single object, and is probably the most important of the attributes. It determines the position of the object's center (in the case of spheres, boxes, etc.) or the object's endpoint (arrows, curves, etc.). It is of the vector type. To access and/or edit this attribute, it can be accessed using objectName.pos. Returning to the example from the above section, we can access the position of our sphere called 'ball' by typing

ball.pos

This would return the position of the ball in vector form, or allow you to refer to said position in calculations.

In addition, the position attribute has three components of its own, which can be accessed by typing

ball.pos.x
ball.pos.y
ball.pos.z

depending on the desired component of the position. The same rules apply as to ball.pos, however they are returned as single numbers instead of as a vector.

To set the position of an object, one must first set the type of the object and then type pos([vector coordinates]). For instance, if we wanted to create an object called ball centered at (4,2,0), we would type

ball = objectType(pos(4,2,0))

Color

The color attribute defines the object's color when it appears in the display window. This attribute is not important for data but more for display - it is simply to distinguish objects from one another, which is especially useful if you are working with a multitude of objects at once.

Color can be assigned in one of two ways. The first way it can be assigned is through a preset color. The preset colors in VPython are blue, orange, green, red, purple, brown, pink, gray, olive, and cyan - any of these can be inserted to create the desired color. For instance, the syntax for creating a red color is:

color = color.red

Another way of assigning color is through an RGB vector, an additive form of assigning color. Red, green and blue layers are added together in various saturations and opacities to reproduce a broad array of colors. The vector contains three numbers from 0 to 255 - The first number represents the red, the second represents the green, and the third represents the blue. The higher the value of the number, the more it resembles that particular color. For instance, if we wanted to assign cyan to color, we would type

color = (0, 255, 255)

To set the color of an object, one must first set the type of the object and then set the color within the parentheses. For instance, if we wanted to create an object called ball which was cyan, we would type either

ball = objectType(color = color(cyan))
ball = objectType(color = (0,255,255))

Axis

The axis attribute is important specifically for arrows, as it determines the direction which the arrow points and how long it is. For instance, if you wanted to create an arrow parallel to the x-axis with a length of 5, the syntax would be

axis = (5,0,0)

meaning the arrow points 5 units along the x axis and is perpendicular to the y and z axes.

The axis attribute also determines orientation of other objects, such as rings or cylinders, but arrows are the only object whose size is specifically tied to the axis attribute.

Other Attributes

There are other attributes which are also important but not as essential (or common) as position/color/axis, such as radius and make_trail, among others. Most of these attributes are self-explanatory or will not be used in the course, so if you would like full descriptions of these attributes, refer to the VPython Documentation.

Common Objects

In order to display and understand your code effectively, there are a certain few objects which will be essential, especially for this class.

Sphere

The example sphere

Spheres are the most basic but also very useful objects. A sphere object is a representation of a sphere with a set radius, position, and color. Spheres are commonly used to represent particles in assignments and labs, and are generally assigned a velocity / momentum / etc. in problems. Spheres generally have three properties which should be set when creating them - radius, position, and color, in any order within the parentheses. Only the position is required - note that the position attribute for a cylinder, arrow, cone, and pyramid corresponds to one end of the object, whereas for a sphere it corresponds to the center of the object. If a radius and color are not specified, VPython will set the radius to 1 and the color to the current foreground color.

For instance, if we wanted to create a yellow sphere at the origin with a radius of ten, we would type

yellowSphere = sphere(radius = 10, pos = vector(0,0,0), color=color.yellow)

Arrow

The example arrow

Arrows are just as multipurpose as spheres, if not more so. In this class, arrows will be used to represent vector quantities visually. For instance, you can use arrows to show the velocity/acceleration/momentum of a particle, the electric field direction around a charged particle, etc. Arrow objects are created with a position which represents the starting point of the arrow - not the center - and an axis which represents the arrow's direction and length. Both the position and the length are vector quantities. The color is again not essential as VPython will set it to a default value if left out. The arrow object itself features a straight box-shaped shaft with a 3d pyramid-shaped arrowhead at one end.

For instance, to create an white arrow based at (4,2,0) pointing in the direction of (-2,2,-4), we would type

nameArrow = arrow(pos=(4,2,0), axis=(-2,2,-4), color=color.white)

Box

The example box

Boxes will feature more in Physics 1 during the kinematics and dynamics sections. While the position attribute is the center of the box as with a sphere, the other attributes of boxes are more complex than spheres or arrows, and particular heed must be paid to the axis attribute, as the box's rotation and orientation depends on it. The axis attribute sets the direction of the length of the box, assuming the length, width and height of the box are set before. If they are not given, the length is automatically set to the magnitude of the axis vector.

To create a green cube with its corner at the origin and a side length of 5 (pictured), we would type

greenbox = box(pos=(2.5, 2.5, 2.5), length=5, height=5, width=5) 

The axis attribute can also be added to tilt the box by changing the angle of the length. For example, this would cause the box from the previous step to be tipped at a 45 degree angle:

tippedbox = box(pos=(2.5, 2.5, 2.5), axis(1,1,0), length=5, height=5, width=5)

The box can also be rotated 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. For instance, this would take the tipped box from the previous step and rotate it so that the top face of the box is perpendicular to the vector in question.

rotatedbox = box(pos=(2.5, 2.5, 2.5), axis(1,1,0), length=5, height=5, width=5, up=(2, 3, 1))

Cylinder

The example cylinder

Cylinders are useful wherever a rod comes into play. For instance, in Physics 2, you may see problems regarding charged rods or something of the sort. The cylinder's attributes are a bit different and incorporate elements of most of the other shapes. As such, knowing cylinder syntax gives you a good basis for any object you need to create. The position vector determines the center of the cylinder's base (similar to a cone's pos attribute) and not the center of the object, while the axis determines the direction and length of the cylinder (similar to the arrow's axis attribute). The radius is self-explanatory.

For example, to make a red cylinder with the base centered at (4,1,3) which is 6 units tall, has a radius of 2, and is laying parallel to the x-axis, you would type

cyl = cylinder(pos=(4,1,3), axis=(6,0,0), radius=2, color=color.red)

Other

Aside from

Examples

Simple

Create a green sphere named "answer" with a radius of .7 located at the origin.

Use the following to create the sphere:

answer = sphere(radius=.7, pos=vector(0,0,0), color=color.green)

Middling

Create two objects. One, a magenta sphere of radius 3.5 named sphereOne at the position (9,0,8). Two, a cyan arrow named arrowTwo that points from the origin to the center of sphereOne.

sphereOne = sphere(radius=3.5, pos=vector(9,0,8), color=color.magenta)
position = vector(0,0,0)
arrowTwo = arrow(pos=position, axis=(sphereOne.pos - position), color = color.cyan)

Note: the position vector is used here because arrowTwo.pos cannot be called yet. The arrow has yet to be created in line 3.

Difficult

Create a two spheres and a red curve. Make the first sphere have a radius of 2 and locate it at (-4,-3,8). Make the second sphere have a radius of 1, and locate it at (6,11,0). Start the curve at the origin, then bring it to the first sphere, and then the second sphere.

sphereOne = sphere(radius = 2, pos=vector(-4,-3,8))
sphereTwo = sphere(radius = 1, pos=vector(6,11,0))
curveOne = curve(color=color.red, pos = (0,0,0))
curveOne.append(sphereOne.pos)
curveOne.append(sphereTwo.pos)

Connectedness

This topic is important because objects are the primary way to visually make sense of data managed by the program. Understanding this process will allow the user to implement physics concepts such as moving charges and electric fields into computer code form.

See Also

VPython

VPython Basics

VPython Functions

References

http://vpython.org/

http://vpython.org/contents/docs/index.html

http://vpython.org/contents/docs/color.html

http://vpython.org/contents/docs/primitives.html

http://guigui.developpez.com/cours/python/vpython/en/?page=object