Example #1
0
 def sand(self):
     self.top = cone(pos=(0, self.time * 1.1, 0), axis=(0, -1, 0), color=(1, 1, 0))
     self.bottom = cone(pos=(0, -self.time * 1.1, 0), axis=(0, 1, 0), color=(0.5, 0.5, 0))
     self.falling = cylinder(
         pos=(0, self.time * 0.125, 0), axis=(0, -1, 0), color=(0.5, 0.5, 0), radius=self.time * 0.035
     )
     self.countdown = sphere(pos=(0, self.time * 1.5, 0), radius=0)
Example #2
0
def animate_motion(x, k):
    # Animate using Visual-Python
    CO = zeros((n, 3))
    B2 = zeros((n, 3))
    C1 = zeros((n, 3))
    C3 = zeros((n, 3))
    CN = zeros((n, 3))

    for i, state in enumerate(x[:,:5]):
        CO[i], B2[i], C1[i], C3[i] = rd.anim(state, r)
        # Make the out of plane axis shorter since this is what control the height
        # of the cone
        B2[i] *= 0.001
        C1[i] *= r
        C3[i] *= r
        CN[i, 0] = state[3]
        CN[i, 1] = state[4]

    from visual import display, rate, arrow, curve, cone, box
    black = (0,0,0)
    red = (1, 0, 0)
    green = (0, 1, 0)
    blue = (0, 0, 1)
    white = (1, 1, 1)
    NO = (0,0,0)
    scene = display(title='Rolling disc @ %0.2f realtime'%k, width=800,
            height=800, up=(0,0,-1), uniform=1, background=white, forward=(1,0,0))
    # Inertial reference frame arrows
    N = [arrow(pos=NO,axis=(.001,0,0),color=red),
         arrow(pos=NO,axis=(0,.001,0),color=green),
         arrow(pos=NO,axis=(0,0,.001),color=blue)]
    # Two cones are used to look like a thin disc
    body1 = cone(pos=CO[0], axis=B2[0], radius=r, color=blue)
    body2 = cone(pos=CO[0], axis=-B2[0], radius=r, color=blue)
    # Body fixed coordinates in plane of disc, can't really be seen through cones
    c1 = arrow(pos=CO[0],axis=C1[0],length=r,color=red)
    c3 = arrow(pos=CO[0],axis=C3[0],length=r,color=green)
    trail = curve()
    trail.append(pos=CN[0], color=black)
    i = 1
    while i<n:
        rate(k/ts)
        body1.pos = CO[i]
        body1.axis = B2[i]
        body2.pos = CO[i]
        body2.axis = -B2[i]
        c1.pos = body1.pos
        c3.pos = body1.pos
        c1.axis = C1[i]
        c3.axis = C3[i]
        c1.up = C3[i]
        c3.up = C1[i]
        trail.append(pos=CN[i])
        i += 1
Example #3
0
 def sand(self):
     self.top = cone(pos=(0, self.time * 1.1, 0),
                     axis=(0, -1, 0),
                     color=(1, 1, 0))
     self.bottom = cone(pos=(0, -self.time * 1.1, 0),
                        axis=(0, 1, 0),
                        color=(.5, .5, 0))
     self.falling = cylinder(pos=(0, self.time * 0.125, 0),
                             axis=(0, -1, 0),
                             color=(.5, .5, 0),
                             radius=self.time * 0.035)
     self.countdown = sphere(pos=(0, self.time * 1.5, 0), radius=0)
Example #4
0
    def __init__(self, w):
        """Store walker being displayed.
	Set up stanceLeg and swingLeg to be cylinders.
	stanceLeg extends from stance foot position to body position.
	swingLeg extends from body position to swing foot position."""
    	self.w = w # the walker being displayed
	d = 0.06   # thickness of legs
	self.stanceLeg = V.cone(pos=w.GetBodyPos(), radius = d, 
                                color = V.color.red,
                                axis = -w.GetBodyPos()+w.GetStanceFootPos())
	self.swingLeg = V.cone(pos=w.GetBodyPos(), radius = d, 
                               color = V.color.orange,
                               axis = w.GetSwingFootPos()-w.GetBodyPos())
Example #5
0
 def draw_at(self, P, step):
     """Draw the field vector at the given point."""
     B = self[P]
     if self.avg_mag == 0:
         val = 0
     else:
         #get value in between smallest and largest
         val = 1-((B.mag-self.smallest_mag)\
                  /(self.largest_mag-self.smallest_mag))
     #set size of pointers, radius = step/rad
     rad = 15
     cone(pos = P, axis = B.norm(), radius=step/rad, length=step,
             display = self.scene, color = interpolate(self.color, val),
             opacity = val)
    def __init__(self, w):
        """Store walker being displayed.
	Set up stanceLeg and swingLeg to be cylinders.
	stanceLeg extends from stance foot position to body position.
	swingLeg extends from body position to swing foot position."""
        self.w = w  # the walker being displayed
        d = 0.06  # thickness of legs
        self.stanceLeg = V.cone(pos=w.GetBodyPos(),
                                radius=d,
                                color=V.color.red,
                                axis=-w.GetBodyPos() + w.GetStanceFootPos())
        self.swingLeg = V.cone(pos=w.GetBodyPos(),
                               radius=d,
                               color=V.color.orange,
                               axis=w.GetSwingFootPos() - w.GetBodyPos())
Example #7
0
def my_arrow(pos, axis, proportion=True,
  shaftwidth=0.1, headwidth=2, headlength=3, color=[1.0, 1.0, 1.0]):
  px, py, pz = pos
  x, y, z = axis
  sw = shaftwidth
  length = math.sqrt(x*x + y*y + z*z)
  if proportion: sw *= length
  hl = sw*headlength/length
  l = 1.0 - hl
  lx = l*x; ly = l*y; lz = l*z
  cylinder_axis = [lx, ly, lz]
  cone_pos = [px+lx, py+ly, pz+lz]
  cone_axis = [hl*x, hl*y, hl*z]
  cone_radius = sw*headwidth
  visual.cylinder(pos=pos, axis=cylinder_axis, radius=sw, color=color)
  visual.cone(pos=cone_pos, axis=cone_axis, radius=cone_radius, color=color)
Example #8
0
def my_arrow(pos, axis, proportion=True, shaftwidth=0.1, headwidth=2, headlength=3, color=[1.0, 1.0, 1.0]):
    px, py, pz = pos
    x, y, z = axis
    sw = shaftwidth
    length = math.sqrt(x * x + y * y + z * z)
    if proportion:
        sw *= length
    hl = sw * headlength / length
    l = 1.0 - hl
    lx = l * x
    ly = l * y
    lz = l * z
    cylinder_axis = [lx, ly, lz]
    cone_pos = [px + lx, py + ly, pz + lz]
    cone_axis = [hl * x, hl * y, hl * z]
    cone_radius = sw * headwidth
    visual.cylinder(pos=pos, axis=cylinder_axis, radius=sw, color=color)
    visual.cone(pos=cone_pos, axis=cone_axis, radius=cone_radius, color=color)
Example #9
0
 def draw_at(self, P, step):
     """Draw the field vector at the given point."""
     B = self[P]
     if self.avg_mag == 0:
         val = 0
     else:
         #get value in between smallest and largest
         val = 1-((B.mag-self.smallest_mag)\
                  /(self.largest_mag-self.smallest_mag))
     #set size of pointers, radius = step/rad
     rad = 15
     cone(pos=P,
          axis=B.norm(),
          radius=step / rad,
          length=step,
          display=self.scene,
          color=interpolate(self.color, val),
          opacity=val)
Example #10
0
 def setup_body(self):
     frame = visual.frame()
     self.parts = Bunch()
     self.parts.body = visual.cone(
         color=visual.color.white, length=.8, radius=.2,
         pos=(-.4, 0, 0), frame=frame)
     self.parts.l_ear = visual.cone(
         color=visual.color.white, length=.1, radius=.02,
         pos=(.05, .04, .06), axis=self.zaxis, frame=frame)
     self.parts.r_ear = visual.cone(
         color=visual.color.white, length=.1, radius=.02,
         pos=(.05, -.04, .06), axis=self.zaxis, frame=frame)
     self.parts.l_eye = visual.sphere(
         color=visual.color.red, radius=.03,
         pos=(.1, .04, .06), frame=frame)
     self.parts.r_eye = visual.sphere(
         color=visual.color.red, radius=.03,
         pos=(.1, -.04, .06), frame=frame)
     self.rat = frame
Example #11
0
 def show(self):
     """
     Create and show the blob
     """
     c = (1, 0, 0) if self.color == 1 else (
         1, 0.5,
         0)  #change colors here: (1, 0, 0) for red, (1, 0.5, 0) for gold
     if self.shape == 1:
         blob = sphere(pos=(self.x, self.y, 0.0),
                       radius=object_side / 2,
                       color=c)
     else:
         blob = cone(pos=(self.x, self.y, -object_side / 2),
                     axis=(0, 0, object_side),
                     radius=object_side / 2,
                     color=c)
     blob.visible = True
     self.b = blob
     self.visible = True
        velocity += h*Acc_A1(t)
        height += h*velocity
        temp = Temp(height)
        g = Grav(height)
        press = Press(temp,g)
        air_resis = Air_Resistance(press, temp)
    else:									# if t is greater than 100s, the fuel is used up; velocity does not change.
        height_points.append(height)
        velocity_sync = velocity + 0.5*h*Acc_A2(t)	# velocity is half-step off, so to plot the correct velocity for the correct times we need to append the synced velocity
        velocity_points.append(velocity_sync)
        velocity += h*Acc_A2(t)
        height += h*velocity
        temp = Temp(height)
        g = Grav(height)
        press = Press(temp,g)
        air_resis = Air_Resistance(press, temp)

#----------------------------- Part 4: VPython -----------------------------------------------------------------------------------------------------------------------------------------------------------
# Create an animation for the launched rocket reaching the ISS 
scene1 = vis.display (title = 'Animation of Launched Rocket to the ISS: Max Payload')

# create three objects: Earth, the International Space Station, and the rocket.
Earth = vis.sphere(pos=[0.0, -250.0, 0.0], radius = 50.0, color=vis.color.green)
ISS = vis.sphere(pos = [0.0, 160.0, 0.0], radius = 5.0, color=vis.color.magenta)
rocket = vis.cone(pos=[0.0, -200.0, 0.0], axis = (0.0, 10.0, 0.0), radius = 2.0, color=vis.color.cyan)

# define the rate of the animation and the height of the rocket using the data from the previous parts (heigh_points)
for item in height_points:
    vis.rate (500)
    rocket.pos.y = (item/1000.0) - 200.0
Example #13
0
 def __init__(self,spos,sColor, fr):
     self.base = vis.cone(frame=fr, pos=spos,radius=0.4,axis=(0,1,0),color=sColor)
Example #14
0
 def __init__(self,spos,sColor, fr):
     self.base = vis.frame(pos=spos, frame=fr)
     vis.cylinder(frame=self.base,pos=(0,0,0),radius=0.2,length=0.8,axis=(0,1,0),color=sColor)
     vis.cone(frame=self.base,pos=(0,0.8,0),radius=0.2,axis=(0,1,0),color=sColor)
Example #15
0
 def __init__(self,spos,sColor, fr):
     self.base = vis.frame(frame = fr, sepos=spos)
     vis.box(frame=self.base,pos=(0,0.4,0),width=0.4,length=0.8,height=0.4,axis=(0,1,0),color=sColor)
     vis.cone(frame=self.base,pos=(0,0.6,0),radius=0.2,axis=(0,1,0),color=sColor)
Example #16
0
#
# See the exercise "Pendulum.pdf" from Pendulum.html
# in  http://www.physics.cornell.edu/sethna/StatMech/ComputerExercises/
#
"""Simple example animating the motion of a pendulum."""

# The "visual" module can create 3D objects (such as spheres, curves, etc.)
# and animate their motions in space.
# See www.vpython.org
import visual
# kludge required to get visual window up and running before import scipy/numpy
scene2 = visual.display()
c = visual.cone(radius=1.0e-10)
c.visible = 0

# numpy allows us to use "array", "sin", "cos" etc.
# numpy is also imported in "visual"
from numpy import *

# Physical properties and initial conditions for pendulum

g = 9.8
L = 1.0  # physical length of bar
d = 0.02  # thickness of bar: needed for graphics
theta = 2. * pi / 3.  # initial upper angle (from vertical)
thetaDot = 0.  # start pendulum at rest

# Set up graphics display

visual.scene.title = 'Pendulum'
visual.scene.height = visual.scene.width = 800
Example #17
0
################################

#########################################
# Import the library(s)
#########################################
# Windows
#import pylab
#pylab.plot([1,2],[3,4])
#pylab.show()
#import visual as vi
#import numpy

# Linux
import visual as vi
# kludge required to get visual window up and running before import scipy/numpy
c = vi.cone(radius=1.0e-10)
c.visible = 0

import numpy
import pylab
import RandomArray
#import psyco
#psyco.full()

#########################################
# ListOfAtoms
#########################################


class ListOfAtoms:
    #
Example #18
0
 def __init__(self, *a):
     super().__init__(*a)
     self.cone = v.cone(pos=self.pos, axis=(self.get_end(10)-self.pos))
     self.trail = v.points(pos=[(0, 0, 0)])
Example #19
0
    print 'Using default v0 =', v0, 'm/s.'

# Build 3d world

# Define the line of sight
sight = V.vector(cos(theta), sin(theta), 0)

# The floor is just a thin box
floor = V.box(pos=(D / 2., 0, 0),
              length=D,
              height=0.5,
              width=D,
              color=V.color.blue)

# Use a cone for our 'arrow'
arrow = V.cone(pos=(0, 0, 0), radius=0.9, axis=sight, color=V.color.red)
arrow.velocity = v0 * sight

# The target is a sphere
target = V.sphere(pos=(D, H, 0), radius=1, color=V.color.yellow)
target.velocity = V.vector(0, 0, 0)

# The 'dart gun' is just a cylinder.
gun = V.cylinder(pos=(0, 0, 0),
                 axis=gun_len * sight,
                 radius=1,
                 color=V.color.green)

# Run simulation

print 'Starting simulation...'
 def show(self, window):
     self.object = visual.cone(pos = tuple(self.point2),
                               axis = tuple(self.point1-self.point2),
                               radius = self.radius)
Example #21
0
# See the exercise "Walker.pdf" from Walker.html
# in  http://www.physics.cornell.edu/~myers/teaching/ComputationalMethods/ComputerExercises/
#
import visual as V

V.scene.title = 'Walker'
V.scene.height = V.scene.width = 600
# Follow walker as it moves forward
V.scene.autocenter = 1
# Scale set automatically by system, but don't keep rescaling as walker moves
V.scene.autoscale = 1
# Slow down walker to reasonable speed
framesPerSecond = 120

# kludge required to get visual window up and running before import scipy/numpy
c = V.cone(radius=1.0e-10)
c.visible = 0

import Walker as W
reload(W)	# for ipython to reload properly after changes in Walker
import scipy

# Walker Display

class WalkerDisplay:
    """Defines VPython cylinders for stanceLeg, swingLeg."""
    def __init__(self, w):
        """Store walker being displayed.
	Set up stanceLeg and swingLeg to be cylinders.
	stanceLeg extends from stance foot position to body position.
	swingLeg extends from body position to swing foot position."""
 def show(self, window):
     self.object = visual.cone(pos = tuple(self.point2),
                               axis = tuple(self.point1-self.point2),
                               radius = self.radius)
Example #23
0
            height_points.append(height)
            velocity_sync = velocity + 0.5*h*Acc_A2(t)	# velocity is half-step off, so to plot the correct velocity for the correct times we need to append the synced velocity
            velocity_points.append(velocity_sync)
            velocity += h*Acc_A2(t)
            height += h*velocity
            temp = Temp(height)
            g = Grav(height)
            press = Press(temp,g)
            air_resis = Air_Resistance(press, temp)
    print np.max(height_points)
'''


#----------------------------- Part 4: VPython -----------------------------------------------------------------------------------------------------------------------------------------------------------
# Create an animation for the launched rocket reaching the ISS 
scene1 = vis.display (title = 'Animation of Launched Rocket to the ISS (payload = 0)')

# create three objects: Earth, the International Space Station, and the rocket.
Earth = vis.sphere(pos=[0,-250,0], radius = 50, color=vis.color.green)
ISS = vis.sphere(pos = [0, 160, 0], radius = 5, color=vis.color.magenta)
rocket = vis.cone(pos=[0, -200, 0], axis = (0, 10, 0), radius = 2, color=vis.color.cyan)

# define the rate of the animation and the height of the rocket using the data from the previous parts (heigh_points)
for item in height_points:
    vis.rate (500)
    rocket.pos.y = (item/1000) - 200
    if rocket.pos.y >= 160:
        break
    

Example #24
0
try:
    v0 = float(sys.argv[1])
except:
    v0 = v0_default
    print 'Using default v0 =',v0,'m/s.'

# Build 3d world

# Define the line of sight
sight = V.vector(cos(theta),sin(theta),0)

# The floor is just a thin box
floor = V.box(pos=(D/2.,0,0), length=D, height=0.5, width=D, color=V.color.blue)

# Use a cone for our 'arrow'
arrow = V.cone(pos=(0,0,0), radius=0.9, axis=sight,color=V.color.red)
arrow.velocity = v0*sight

# The target is a sphere
target = V.sphere(pos=(D,H,0), radius=1, color=V.color.yellow)
target.velocity = V.vector(0,0,0)

# The 'dart gun' is just a cylinder.
gun = V.cylinder(pos=(0,0,0), axis=gun_len*sight, radius=1,
                 color = V.color.green)

# Run simulation

print 'Starting simulation...'

# Put a little delay to give all the OpenGL stuff time to initialize nicely.
Example #25
0
# 
# See the exercise "Pendulum.pdf" from Pendulum.html 
# in  http://www.physics.cornell.edu/~myers/teaching/ComputationalMethods/ComputerExercises/
#
"""Simple example animating the motion of a pendulum."""

# The "visual" module can create 3D objects (such as spheres, curves, etc.)
# and animate their motions in space.
# See www.vpython.org
import visual
# kludge required to get visual window up and running before import scipy
scene2 = visual.display()
c = visual.cone(radius=1.0e-10)
c.visible = 0

# scipy allows us to use "array", "sin", "cos" etc.
# scipy is also imported in "visual"
from scipy import *	

# Physical properties and initial conditions for pendulum

g = 9.8
L = 1.0				# physical length of bar
d = 0.02 			# thickness of bar: needed for graphics
theta = 1.*pi/6. 		# initial upper angle (from vertical)
thetaDot = 0. 			# start pendulum at rest

# Set up graphics display

visual.scene.title = 'Pendulum'
visual.scene.height = visual.scene.width = 800
Example #26
0
def game():
    global player
    global target
    global missile
    global planets
    global barriers
    global scene
    global arrow
    global win
    global wintext
    
    
    ConfigureLevel()

    ### Player planet
    player =  visual.sphere( pos = player_position,
                            radius = player_radius,
                            mass  = player_mass,
                            color = visual.color.green )

    target = visual.sphere( pos = target_position,
                            radius = target_radius,
                            mass = target_mass,
                            color = visual.color.red )

    planets  = [ visual.sphere(**planet ) for planet  in planets_properties ]
    barriers = [ visual.curve (**barrier) for barrier in barriers_properties]

    scene.center = tuple(ComputeCenter( player, target, *(planets + barriers) ) )
    scene.range  = ComputeRange( player, target, *(planets + barriers) )

    arrow = visual.arrow( pos = player_position,
                          axis = (target.pos-player.pos).norm() * player_radius * 10,
                          shaftwidth = player_radius * 0.5,
                          headwidth  = player_radius,
                          headlength = player_radius,
                          color = visual.color.cyan)

    scene.bind('mousemove',ChangeArrow)
    click = scene.waitfor('click')
    missile_direction = click.pos - player.pos
    missile = visual.cone( pos = missile_position(target),
                           axis = missile_direction.norm() * missile_length,
                           radius = missile_radius,
                           mass = missile_mass,
                           p = missile_direction * missile_momentum,
                           color = visual.color.yellow,
                           make_trail = True)
    scene.unbind('mousemove',ChangeArrow)
    arrow.visible = False
    del arrow

    while not Game_over():
        visual.rate(100)
        missile.p   += ComputeForce( player, target, *planets ) * time_step
        missile.pos += missile.p * time_step
        missile.axis = missile.p.norm() * missile_length

        if win:
            wintext = visual.text( text='You win', pos = scene.center + visual.vector(0,0,1e8), height = 1e7, align='center', font = 'Times', color=visual.color.green)
#            wintext.up = True

            break
Example #27
0
# See the exercise "Walker.pdf" from Walker.html
# in  http://www.physics.cornell.edu/sethna/StatMech/ComputerExercises/
#
import visual as V

V.scene.title = 'Walker'
V.scene.height = V.scene.width = 600
# Follow walker as it moves forward
V.scene.autocenter = 1
# Scale set automatically by system, but don't keep rescaling as walker moves
V.scene.autoscale = 1
# Slow down walker to reasonable speed
framesPerSecond = 120

# kludge required to get visual window up and running before import scipy/numpy
c = V.cone(radius=1.0e-10)
c.visible = 0

import Walker as W
reload(W)  # for ipython to reload properly after changes in Walker
import scipy

# Walker Display


class WalkerDisplay:
    """Defines VPython cylinders for stanceLeg, swingLeg."""
    def __init__(self, w):
        """Store walker being displayed.
	Set up stanceLeg and swingLeg to be cylinders.
	stanceLeg extends from stance foot position to body position.
Example #28
0
 def __init__(self, *a):
     super().__init__(*a)
     self.cone = v.cone(pos=self.origin, axis=(self.end-self.origin),
                        radius=self.thickness, color=(0.6,0.4,0))
Example #29
0
def animate_motion(x, k):
    # Animate using Visual-Python
    CO = zeros((n, 3))
    B2 = zeros((n, 3))
    C1 = zeros((n, 3))
    C3 = zeros((n, 3))
    CN = zeros((n, 3))

    for i, state in enumerate(x[:, :5]):
        CO[i], B2[i], C1[i], C3[i] = rd.anim(state, r)
        # Make the out of plane axis shorter since this is what control the height
        # of the cone
        B2[i] *= 0.001
        C1[i] *= r
        C3[i] *= r
        CN[i, 0] = state[3]
        CN[i, 1] = state[4]

    from visual import display, rate, arrow, curve, cone, box
    black = (0, 0, 0)
    red = (1, 0, 0)
    green = (0, 1, 0)
    blue = (0, 0, 1)
    white = (1, 1, 1)
    NO = (0, 0, 0)
    scene = display(title='Rolling disc @ %0.2f realtime' % k,
                    width=800,
                    height=800,
                    up=(0, 0, -1),
                    uniform=1,
                    background=white,
                    forward=(1, 0, 0))
    # Inertial reference frame arrows
    N = [
        arrow(pos=NO, axis=(.001, 0, 0), color=red),
        arrow(pos=NO, axis=(0, .001, 0), color=green),
        arrow(pos=NO, axis=(0, 0, .001), color=blue)
    ]
    # Two cones are used to look like a thin disc
    body1 = cone(pos=CO[0], axis=B2[0], radius=r, color=blue)
    body2 = cone(pos=CO[0], axis=-B2[0], radius=r, color=blue)
    # Body fixed coordinates in plane of disc, can't really be seen through cones
    c1 = arrow(pos=CO[0], axis=C1[0], length=r, color=red)
    c3 = arrow(pos=CO[0], axis=C3[0], length=r, color=green)
    trail = curve()
    trail.append(pos=CN[0], color=black)
    i = 1
    while i < n:
        rate(k / ts)
        body1.pos = CO[i]
        body1.axis = B2[i]
        body2.pos = CO[i]
        body2.axis = -B2[i]
        c1.pos = body1.pos
        c3.pos = body1.pos
        c1.axis = C1[i]
        c3.axis = C3[i]
        c1.up = C3[i]
        c3.up = C1[i]
        trail.append(pos=CN[i])
        i += 1