def PlotSphereEvolution3(f):
data = json.loads(open(f, "r").read())
center = (
(data["SystemSize"][1][0]+data["SystemSize"][0][0])*0.5,
(data["SystemSize"][1][1]+data["SystemSize"][0][1])*0.5,
(data["SystemSize"][1][2]+data["SystemSize"][0][2])*0.5
)
scene = vs.display(title='3D representation',
x=0, y=0, width=1920, height=1080,
center=center,background=(0,0,0)
)
vs.box(pos=center,
length=data["SystemSize"][1][0]-data["SystemSize"][0][0],
height=data["SystemSize"][1][1]-data["SystemSize"][0][1],
width= data["SystemSize"][1][2]-data["SystemSize"][0][2],
opacity=0.2,
color=vs.color.red)
spheres = [vs.sphere(radius=data["SphereSize"],pos=(data["Data"][0][0][i], data["Data"][1][0][i], data["Data"][2][0][i])) for i in range(data["SpheresNumber"])]
nt = 0
while True:
vs.rate(60)
for i in range(data["SpheresNumber"]):
spheres[i].pos = (data["Data"][0][nt][i], data["Data"][1][nt][i], data["Data"][2][nt][i])
if nt + 1 >= data["SavedSteps"]:
nt = 0
else:
nt += 1
def calculate(x, y, z, vx, vy, vz, dt, m, g, B2, S0, omega):
""" Calculate the trajectory of a baseball including air resistance and spin by
repeatedly calling the do_time_step function. Also draw the trajectory using visual python. """
t = 0.0
# Establish lists with initial position and velocity components and time.
x_list = [x]
y_list = [y]
z_list = [z]
vx_list = [vx]
vy_list = [vy]
vz_list = [vz]
t_list = [t]
# Set up visual elements.
mound = visual.box(pos=(0,0,0), length=0.1, width=0.5, height=0.03, color=visual.color.white)
plate = visual.box(pos=(18,0,0), length=0.5, width=0.5, height=0.03, color=visual.color.white)
ball = visual.sphere(pos=(x,y,z), radius=0.05, color=visual.color.white)
ball.trail = visual.curve(color=ball.color)
while y >= 0.0:
visual.rate(100) # Limit to no more than 100 iterations per second.
t, x, y, z, vx, vy, vz = do_time_step(t, dt, x, y, z, vx, vy, vz, m, B2, g, S0, omega)
x_list.append(x)
y_list.append(y)
z_list.append(z)
vx_list.append(vx)
vy_list.append(vy)
vz_list.append(vz)
t_list.append(t)
ball.pos = (x,y,z)
ball.trail.append(pos=ball.pos)
return t_list, x_list, y_list, z_list, vx_list, vy_list, vz_list
def PlotSpheres3(f):
data = json.loads(open(f, "r").read())
scene = vs.display(title='3D representation',
x=0, y=0, width=1920, height=1080,
autocenter=True,background=(0,0,0))
vs.box(pos=(
(data["SystemSize"][1][0]+data["SystemSize"][0][0])*0.5,
(data["SystemSize"][1][1]+data["SystemSize"][0][1])*0.5,
(data["SystemSize"][1][2]+data["SystemSize"][0][2])*0.5
),
length=data["SystemSize"][1][0]-data["SystemSize"][0][0],
height=data["SystemSize"][1][1]-data["SystemSize"][0][1],
width= data["SystemSize"][1][2]-data["SystemSize"][0][2],
opacity=0.2,
color=vs.color.red)
spheres = [vs.sphere(radius=data["SphereSize"],pos=(data["Data"][0][i], data["Data"][1][i], data["Data"][2][i])) for i in range(data["SpheresNumber"])]
vs.arrow(pos=data["SystemSize"][0], axis=(1,0,0), shaftwidth=0.1, color=vs.color.red)
vs.arrow(pos=data["SystemSize"][0], axis=(0,1,0), shaftwidth=0.1, color=vs.color.green)
vs.arrow(pos=data["SystemSize"][0], axis=(0,0,1), shaftwidth=0.1, color=vs.color.blue)
while True:
vs.rate(60)
def __init__(self, room_=1, beam_axis_=0, target_pos_=(0,0,0)): self.labScene = visual.display(title="7Be(d,n)8B Experiment", width=800, height=600, background=GetRGBcode(153,204,255)) axisx = visual.box(pos=(0,0,0), axis=(10.0,0,0), width=0.05, height=0.05, color=visual.color.red) axisy = visual.box(pos=(0,0,0), axis=(0,10.0,0), width=0.05, height=0.05, color=visual.color.blue) axisz = visual.box(pos=(0,0,0), axis=(0,0,10.0), width=0.05, height=0.05, color=visual.color.green) labelx = visual.label(pos=(5.0,0,0), text="Z-Axis") labely = visual.label(pos=(0,5.0,0), text="Y-Axis") labelz = visual.label(pos=(0,0,5.0), text="X-Axis") self.labScene.center = target_pos_ self.labScene.autoscale = False self.room = room_ self.beam_axis = beam_axis_ self.target_pos = target_pos_ self.Floors = [] self.Walls = [] self.Columns = [] self.Others = [] self.BuildRoom() if(self.room == 1 or self.room == 2): chamber_radius = 0.25 self.Beamline1 = visual.cylinder(pos=Translate(self.target_pos,GetCartesianCoords(chamber_radius, math.pi/2.0, DegToRad(180+self.beam_axis))), axis=ConvIM3(71.75,0,-71.75*math.tan(DegToRad(180-self.beam_axis))), radius=ConvIM(1.75), color=visual.color.blue) # East beamline self.Beamline2 = visual.cylinder(pos=Translate(self.target_pos,GetCartesianCoords(chamber_radius, math.pi/2.0, DegToRad(self.beam_axis))), axis=ConvIM3(-217.5,0,217.5*math.tan(DegToRad(180-self.beam_axis))), radius=ConvIM(1.75), color=visual.color.blue) # West beamline self.OneMeterChamber = visual.cylinder(pos=self.target_pos, axis=(0,chamber_radius*2,0), radius=chamber_radius, color=visual.color.blue) self.OneMeterChamber.pos[1] = -0.5
def cubic(self, latticeparameters=(1, 1, 1)):
cube = visual.frame()
visual.box(frame=cube,
pos=(0, 0, 0),
size=latticeparameters,
color=(1, 0.7, 0.2))
visual.arrow(frame=cube,
pos=(latticeparameters[0] / 2, 0, 0),
axis=(1, 0, 0),
shaftwidth=0.1,
color=(1, 0, 0))
visual.arrow(frame=cube,
pos=(0, latticeparameters[0] / 2, 0),
axis=(0, 1, 0),
shaftwidth=0.1,
color=(0, 1, 0))
visual.arrow(frame=cube,
pos=(0, 0, latticeparameters[0] / 2),
axis=(0, 0, 1),
shaftwidth=0.1,
color=(0, 0, 1))
return cube
def __init__(self, pos=(-20,-10,10), axis=(0,5,1), length=8, height=8,\
width=8):
"""
Construct it with a preset or given geometry.
"""
# calibration (see: calibrate(value))
self.zero = None
# color and material
room_color = (1, 1, 1)
wet_color = (0, 0, 1)
room_opacity = 0.5
wet_opacity = 0.5
room_material = materials.diffuse
wet_material = materials.diffuse
## NOTE: do not change the order here, or self.wet will never be
# seen again.. (even with opaque, vpython hides the second cube)
# visualize the humidity
self.wet = box(pos=pos, axis=axis, length=length, height=height,\
width=width, opacity=wet_opacity, color=wet_color,\
material=wet_material)
# visualize the empty space
self.room = box(pos=pos, axis=axis, length=length, height=height,\
width=width, opacity=room_opacity, color=room_color,\
material=room_material)
# add a label
p = self.calc_label_pos(pos)
self.label = label(pos=p, text='H: 100%')
def show_ladybug(self, H=None):
'''Show Ladybug in Visual Python at origin or at the translated position
if parameter is given.
TODO: Implement an additional translation H and show at new position.'''
# vis.ellipsoid(width=0.12, length=0.08, height=0.08,
# color=vis.color.red, opacity=0.2)
vis.arrow(axis=(0.04, 0, 0), color=(1,0,0) )
vis.arrow(axis=(0, 0.04, 0), color=(0,1,0) )
vis.arrow(axis=(0, 0, 0.04), color=(0,0,1) )
colors = [vis.color.red, vis.color.green, vis.color.blue,
vis.color.cyan, vis.color.yellow, vis.color.magenta]
for P in self.LP:
R = P[:3,:3]
pos = dot(P[:3],r_[0,0,0,1])
pos2 = dot(P[:3],r_[0,0,0.01,1])
vis.sphere(pos=pos, radius=0.002, color=colors.pop(0))
vis.box(pos=pos2, axis=dot(R, r_[0,0,1]).flatten(),
size=(0.001,0.07,0.09), color=vis.color.red,
opacity=0.1)
vis.arrow(pos=pos,
axis=dot(R, r_[0.02,0,0]).flatten(),
color=(1,0,0), opacity=0.5 )
vis.arrow(pos=pos,
axis=dot(R, r_[0,0.02,0]).flatten(),
color=(0,1,0), opacity=0.5 )
vis.arrow(pos=pos,
axis=dot(R, r_[0,0,0.02]).flatten(),
color=(0,0,1), opacity=0.5 )
def makeBoard(self):
for i in range(8):
for j in range(8):
if (i+j) % 2 == 1:
sColor = vis.color.blue
else: sColor = vis.color.white
vis.box(frame = self.frame, pos=(i,-0.1,j),length=1,height=0.1,width=1,color=sColor)
def cubic(self, latticeparameters=(1, 1, 1)):
cube = visual.frame()
visual.box(frame=cube
, pos=(0, 0, 0)
, size=latticeparameters
, color=(1, 0.7, 0.2))
visual.arrow(frame=cube
, pos=(latticeparameters[0] / 2, 0, 0)
, axis=(1, 0, 0)
, shaftwidth=0.1
, color=(1, 0, 0))
visual.arrow(frame=cube
, pos=(0, latticeparameters[0] / 2, 0)
, axis=(0, 1, 0)
, shaftwidth=0.1
, color=(0, 1, 0))
visual.arrow(frame=cube
, pos=(0, 0, latticeparameters[0] / 2)
, axis=(0, 0, 1)
, shaftwidth=0.1
, color=(0, 0, 1))
return cube
def run(self):
'''
Run the simulation with racers that had been previously added to the world
by add_racer method.
'''
# create the scene with the plane at the top
visual.scene.center = visual.vector(0,-25,0)
visual.box(pos=(0,0,0), size=(12,0.2,12), color=visual.color.green)
# create the visual objects that represent the racers (balls)
balls = [ visual.sphere(pos=(index,0,0), radius=0.5) for index in xrange(len(self.racers))]
for ball, racer in zip(balls, self.racers):
color = visual.color.blue
try:
# try to set the color given by a string
color = getattr(visual.color, racer.color)
except AttributeError:
pass
ball.trail = visual.curve(color=color)
while not reduce(lambda x, y: x and y, [racer.result for racer in self.racers]):
# slow down the looping - allow only self.time_calibration
# number of loop entries for a second
visual.rate(self.time_calibration)
# move the racers
for racer in self.racers:
self.__move_racer(racer)
for ball, racer in zip(balls, self.racers):
ball.pos.y = -racer.positions[-1][1]
ball.pos.x = racer.positions[-1][0]
ball.trail.append(pos=ball.pos)
self.current_time += self.interval
self.timeline.append(self.current_time)
def addBox(self, box, colour=None, opacity=1.):
if not Visualiser.VISUALISER_ON:
return
if isinstance(box, Box):
if colour is None:
colour = visual.color.red
org = transform_point(box.origin, box.transform)
ext = transform_point(box.extent, box.transform)
print("Visualiser: box origin=%s, extent=%s" % (str(org), str(ext)))
size = np.abs(ext - org)
pos = org + 0.5*size
print("Visualiser: box position=%s, size=%s" % (str(pos), str(size)))
angle, direction, point = tf.rotation_from_matrix(box.transform)
print("colour,", colour)
pos = visual.vec(*pos.tolist())
size = visual.vec(*size.tolist())
try:
colour = visual.vec(*colour)
except:
pass
#visual.box(pos=pos, size=size, opacity=opacity, color=None)
visual.box(pos=pos, size=size, color=colour, opacity=opacity)
def addBox(self, box, colour=None):
if not Visualiser.VISUALISER_ON:
return
if isinstance(box, geo.Box):
if colour == None:
colour = visual.color.red
org = geo.transform_point(box.origin, box.transform)
ext = geo.transform_point(box.extent, box.transform)
print "Visualiser: box origin=%s, extent=%s" % (str(org), str(ext))
size = np.abs(ext - org)
pos = org + 0.5 * size
print "Visualiser: box position=%s, size=%s" % (str(pos),
str(size))
angle, direction, point = tf.rotation_from_matrix(box.transform)
print "colour,", colour
if colour == [0, 0, 0]:
visual.box(pos=pos,
size=size,
opacity=0.3,
material=visual.materials.plastic)
else:
visual.box(pos=pos,
size=size,
color=geo.norm(colour),
opacity=0.5)
def drawCameraFrame(): # create frame and draw its contents
global cam_box, cent_plane, cam_lab, cam_tri, range_lab, linelen, fwd_line
global fwd_arrow, mouse_line, mouse_arrow, mouse_lab, fov, range_x, cam_dist, cam_frame
global ray
cam_frame = vs.frame( pos = vs.vector(0,2,2,), axis = (0,0,1))
# NB: contents are rel to this frame. start with camera looking "forward"
# origin is at simulated scene.center
fov = vs.pi/3.0 # 60 deg
range_x = 6 # simulates scene.range.x
cam_dist = range_x / vs.tan(fov/2.0) # distance between camera and center.
ray = vs.vector(-20.0, 2.5, 3.0).norm() # (unit) direction of ray vector (arbitrary)
# REL TO CAMERA FRAME
cam_box = vs.box(frame=cam_frame, length=1.5, height=1, width=1.0, color=clr.blue,
pos=(cam_dist,0,0)) # camera-box
cent_plane = vs.box(frame=cam_frame, length=0.01, height=range_x*1.3, width=range_x*2,
pos=(0,0,0), opacity=0.5 ) # central plane
cam_lab = vs.label(frame=cam_frame, text= 'U', pos= (cam_dist,0,0), height= 9, xoffset= 6)
cam_tri = vs.faces( frame=cam_frame, pos=[(0,0,0), (0,0,-range_x), (cam_dist,0,0)])
cam_tri.make_normals()
cam_tri.make_twosided()
range_lab = vs.label(frame=cam_frame, text= 'R', pos= (0, 0, -range_x), height= 9, xoffset= 6)
linelen = scene_size + vs.mag( cam_frame.axis.norm()*cam_dist + cam_frame.pos)
# len of lines from camera
fwd_line = drawLine( vs.vector(cam_dist,0,0), linelen, vs.vector(-1,0,0))
fwd_arrow = vs.arrow(frame=cam_frame, axis=(-2,0,0), pos=(cam_dist, 0, 0), shaftwidth=0.08,
color=clr.yellow)
vs.label(frame=cam_frame, text='C', pos=(0,0,0), height=9, xoffset=6, color=clr.yellow)
mouse_line = drawLine ( vs.vector(cam_dist,0,0), linelen, ray )
mouse_arrow = vs.arrow(frame=cam_frame, axis=ray*2, pos=(cam_dist,0,0), shaftwidth=0.08,
color=clr.red)
mouse_lab = vs.label(frame=cam_frame, text= 'M', height= 9, xoffset= 10, color=clr.red,
pos= -ray*(cam_dist/vs.dot(ray,(1,0,0))) + (cam_dist,0,0))
def addBox(self, box, colour=None, opacity=1., material=None):
if not VISUAL_INSTALLED:
return
if isinstance(box, geo.Box):
if colour == None:
colour = visual.color.red
if material is None:
material = visual.materials.plastic
org = geo.transform_point(box.origin, box.transform)
ext = geo.transform_point(box.extent, box.transform)
print "Visualiser: box origin=%s, extent=%s" % (str(org), str(ext))
size = np.abs(ext - org)
pos = org + 0.5 * size
print "Visualiser: box position=%s, size=%s" % (str(pos),
str(size))
angle, direction, point = tf.rotation_from_matrix(box.transform)
print "colour,", colour
if np.allclose(np.array(colour), np.array([0, 0, 0])):
visual.box(pos=pos,
size=size,
material=material,
opacity=opacity)
else:
visual.box(pos=pos,
size=size,
color=colour,
materials=material,
opacity=opacity)
def __init__(self, joint, num, length, height=LEGS_HEIGHT, width=LEGS_WIDTH):
"""
"""
super(Coxa3D, self).__init__(joint, num, length, height, width, (0, 1, 0))
visual.cylinder(frame=self, pos=(0, -(height+5)/2, 0), radius=(height+1)/2, axis=(0, 1, 0), length=height+5, color=visual.color.cyan)
visual.box(frame=self, pos=(length/2, 0, 0), length=length, height=height, width=width , color=visual.color.red)
def __init__(self, joint, num, length, height=LEGS_HEIGHT, width=LEGS_WIDTH):
"""
"""
super(Tibia3D, self).__init__(joint, num, length, height, width, (0, 0, 1))
visual.cylinder(frame=self, pos=(0, 0, -(width+5)/2), radius=(height+1)/2, axis=(0, 0, 1), length=width+5, color=visual.color.cyan)
visual.box(frame=self, pos=(length/2, 0, 0), length=length, height=height, width=width , color=visual.color.blue)
self.rotate(angle=math.radians(180), axis=self._axis)
def AddToQueue(self, ID, In):
InOut = 1
if In == True: InOut = 0
priorSquare = 0
if len(self.NodeList[ID][InOut]) > 0:
priorSquare = self.NodeList[ID][InOut][-1].pos[1]
newY = priorSquare + 1
if In==1: box = v.box(pos=(ID*2+InOut, newY, 0), Length=0.25, Width=0.25, Height=0.25, color=v.color.green)
else: box = v.box(pos=(ID*2+InOut, newY, 0), Length=0.25, Width=0.25, Height=0.25, color=v.color.red)
self.NodeList[ID][InOut].append(box)
def __init__(self):
self._value = random() * 2 * pi
self._model = v.frame()
W = 0.1
v.box(frame=self._model, pos=(+W / 2, 0, 0), size=(W, W, W), color=v.color.red)
v.box(frame=self._model, pos=(-W / 2, 0, 0), size=(W, W, W),
color=v.color.white)
self._model.rotate(angle=self._value, axis=(0, 0, 1))
def visualBrick(brick, opacity = 0.7, offset = (0.0, 0.0, 0.0), material = None, color = visual.color.white):
center_x = (brick.max_x + brick.min_x) / 2 + offset[0]
center_y = (brick.max_y + brick.min_y) / 2 + offset[1]
center_z = (brick.max_z + brick.min_z) / 2 + offset[2]
size_x = brick.max_x - brick.min_x
size_y = brick.max_y - brick.min_y
size_z = brick.max_z - brick.min_z
visual.box(pos = (center_x, center_y, center_z),
length = size_x, height = size_y, width = size_z,
color = color, opacity = opacity,
material = material
)
def hexagonal(self, CAratio=1.6):
hexagonal = visual.frame()
base1 = visual.box(frame=hexagonal,
pos=(0, -CAratio / 2.0, 0),
size=(math.sqrt(3), 0.01, 1),
color=(1, 0.7, 0.2))
base1 = base1.__copy__()
base1.rotate(angle=math.pi * 60 / 180,
axis=(0, 1, 0),
origin=(0, 0, 0))
base1 = base1.__copy__()
base1.rotate(angle=math.pi * 60 / 180,
axis=(0, 1, 0),
origin=(0, 0, 0))
base2 = visual.box(frame=hexagonal,
pos=(0, CAratio / 2.0, 0),
size=(math.sqrt(3), 0.01, 1),
color=(1, 0.7, 0.2))
base2 = base2.__copy__()
base2.rotate(angle=math.pi * 60 / 180,
axis=(0, 1, 0),
origin=(0, 0, 0))
base2 = base2.__copy__()
base2.rotate(angle=math.pi * 60 / 180,
axis=(0, 1, 0),
origin=(0, 0, 0))
face = visual.box(frame=hexagonal,
pos=(math.sqrt(3) / 2.0, 0, 0),
size=(0.01, CAratio, 1),
color=(1, 0.7, 0.2))
for _i in range(6):
face = face.__copy__()
face.rotate(angle=math.pi * 60 / 180,
axis=(0, 1, 0),
origin=(0, 0, 0))
visual.arrow(frame=hexagonal,
pos=(0, CAratio / 2, 0),
axis=(0, 0.5, 0),
shaftwidth=0.1,
color=(1, 0, 0))
visual.arrow(frame=hexagonal,
pos=(CAratio / 2, 0, 0),
axis=(0.5, 0, 0),
shaftwidth=0.1,
color=(0, 1, 0))
return hexagonal
def addFinitePlane(self, plane, colour=None, opacity=0.):
if not Visualiser.VISUALISER_ON:
return
if isinstance(plane, geo.FinitePlane):
if colour == None:
colour = visual.color.blue
# visual doesn't support planes, so we draw a very thin box
H = .001
pos = (plane.length / 2, plane.width / 2, H / 2)
pos = geo.transform_point(pos, plane.transform)
size = (plane.length, plane.width, H)
axis = geo.transform_direction((0, 0, 1), plane.transform)
visual.box(pos=pos, size=size, color=colour, opacity=0)
def addFinitePlane(self, plane, colour=None, opacity=0.):
if not Visualiser.VISUALISER_ON:
return
if isinstance(plane, geo.FinitePlane):
if colour == None:
colour = visual.color.blue
# visual doesn't support planes, so we draw a very thin box
H = .001
pos = (plane.length/2, plane.width/2, H/2)
pos = geo.transform_point(pos, plane.transform)
size = (plane.length, plane.width, H)
axis = geo.transform_direction((0,0,1), plane.transform)
visual.box(pos=pos, size=size, color=colour, opacity=0)
def addFinitePlane(self, plane, colour=None, opacity=1., material=None):
if not VISUAL_INSTALLED:
return
if isinstance(plane, geo.FinitePlane):
if material is None:
material = visual.materials.plastic
if colour == None:
colour = visual.color.blue
# visual doesn't support planes, so we draw a very thin box
H = .001
pos = (plane.length/2, plane.width/2, H/2)
pos = geo.transform_point(pos, plane.transform)
size = (plane.length, plane.width, H)
axis = geo.transform_direction((0,0,1), plane.transform)
visual.box(pos=pos, size=size, color=colour, opacity=opacity, material=material)
def addFinitePlane(self, plane, colour=None, opacity=1., material=None):
if not VISUAL_INSTALLED:
return
if isinstance(plane, geo.FinitePlane):
if material is None:
material = visual.materials.plastic
if colour is None:
colour = visual.color.blue
# visual doesn't support planes, so we draw a very thin box
H = .001
pos = (plane.length/2, plane.width/2, H/2)
pos = geo.transform_point(pos, plane.transform)
size = (plane.length, plane.width, H)
axis = geo.transform_direction((0,0,1), plane.transform)
visual.box(pos=pos, size=size, color=colour, opacity=opacity, material=material)
def sCaidalibre(self):
self.alturaCL=self.alturaCL.get()
self.velocidadX=self.velocidadX.get()
try:
self.alturaCL=float(self.alturaCL)
self.velocidadX=float(self.velocidadX)
except:
self.alerta()
gdpos=vgraph.gdisplay(x=600,y=0,xtitle='Tiempo',ytitle='Posicion(y)')
plotpos=vgraph.gcurve(gdisplay=gdpos,color=vs.color.red)
gdvel=vgraph.gdisplay(x=600,y=600,xtitle='Velocidad',ytitle='Tiempo')
plotvel=vgraph.gcurve(gdisplay=gdvel,color=vs.color.blue)
gdacl=vgraph.gdisplay(x=0,y=900,xtitle='Aceleracion',ytitle='Tiempo')
plotacl=vgraph.gcurve(gdisplay=gdacl,color=vs.color.blue)
suelo=vs.box(pos=(0,-5,0),length=30,height=0.1,width=1,color=vs.color.blue)
esferaC=vs.sphere(pos=(0,self.alturaCL,-2),radius=1,color=vs.color.red)
T=np.sqrt(2*(self.alturaCL+5)/9.8)
t=0
while t<T:
esferaC.pos=(self.velocidadX*t,self.alturaCL-9.8*t**2/2,-2)
plotpos.plot(pos=(t,self.alturaCL-9.8*t**2/2))
plotvel.plot(pos=(t,-9.8*t))
plotacl.plot(pos=(t,-9.8))
t+=0.001
vs.rate(100)
def addcar(self, pos, color=v.color.green, name="v"):
# Creating car
car = v.frame()
car.start = pos
car.pos = car.start
car.vector = v.vector(0.05, 0, 0)
car.color = color
car.colorori = car.color
body = v.box(frame = car, pos = (0,0,0), size = (2.4*self.thk, 0.6*self.thk, 1.4*self.thk), color = car.colorori)
wheel1 = v.cylinder(frame=car, pos=(0.8*self.thk,-0.2*self.thk,0.8*self.thk), axis=(0,0,-1.6*self.thk), radius=0.25*self.thk, color=(0.6,0.6,0.6))
wheel2 = v.cylinder(frame=car, pos=(-0.8*self.thk,-0.2*self.thk,0.8*self.thk), axis=(0,0,-1.6*self.thk), radius=0.25*self.thk, color=(0.6,0.6,0.6))
head = v.convex(frame=car, color=car.colorori)
head.append(pos=v.vector(0.6, 0.3, -0.7)*self.thk)
head.append(pos=v.vector(0.6, 0.3, 0.7)*self.thk)
head.append(pos=v.vector(-1.2, 0.3, -0.7)*self.thk)
head.append(pos=v.vector(-1.2, 0.3, 0.7)*self.thk)
head.append(pos=v.vector(0.4, 0.7, -0.6)*self.thk)
head.append(pos=v.vector(0.4, 0.7, 0.6)*self.thk)
head.append(pos=v.vector(-0.8, 0.7, -0.6)*self.thk)
head.append(pos=v.vector(-0.8, 0.7, 0.6)*self.thk)
# Creating Label
car.vlabel = v.label(justify='center', pos=car.pos, xoffset=3*self.thk, yoffset=39*self.thk, space=3*self.thk, text=name,height=15, line=0,border=3)
self.cars[name] = car
self.labels[name] = car.vlabel
def draw_world(world_data): """ Draws a world in 3D """ for obj in vpy.scene.objects: del obj box_width = WIDTH // len(world_data[0]) box_length = LENGTH // len(world_data) for row_i, row in enumerate(world_data): for col_i, col in enumerate(row): color = terrain_key.get(row[col_i], None) if color is not None: vpy.box(pos=(col_i*box_width, 0, row_i*box_length), length=box_length, height=box_width, width=1, color=color)
def __init__(self, ini=None):
wx.Frame.__init__(self, None)
self.Splitter = wx.SplitterWindow(self)
self.p1 = wx.Panel(self.Splitter)
self.p2 = wx.Panel(self.Splitter)
self.Splitter.SplitVertically(self.p1, self.p2)
self.Splitter.SetMinimumPaneSize(20)
Sizer = wx.BoxSizer()
Sizer.Add(self.Splitter, 1, wx.EXPAND)
self.SetSizer(Sizer)
# create a VPython application, just an copy of the Ball-demo
floor = visual.box(pos=(0, 0, 0),
length=4,
height=0.5,
width=4,
color=visual.color.blue)
ball = visual.sphere(pos=(0, 4, 0), radius=1, color=visual.color.red)
ball.velocity = visual.vector(0, -1, 0)
dt = 0.01
# initialize the State_Machine and start the timer
self.VP_State = 0
self.Old_Size = (0, 0)
self.Timer = wx.Timer(self)
# the third parameter is essential to allow other timers
self.Bind(wx.EVT_TIMER, self._On_Timer, self.Timer)
self.Timer.Start(100)
def init_visual(self, only_wiiobj=False):
if not only_wiiobj:
# vpython
visual.scene.width = self.param["width"]
visual.scene.height = self.param["height"]
visual.scene.title = "3D WiiMote Simulation"
visual.scene.forward = visual.vector(1, 0, 0) # not to error ?
visual.scene.up = visual.vector(0, 0, 1)
visual.scene.forward = visual.vector(-1, 1, -1)
visual.scene.autoscale = 0
visual.scene.x = 0
visual.scene.y = 30
self.visual["axis"][0] = visual.arrow(
color=visual.color.red, axis=(3, 0, 0), headwidth=1, shaftwidth=0.5, fixedwidth=1
)
self.visual["axis"][1] = visual.arrow(
color=visual.color.green, axis=(0, 3, 0), headwidth=1, shaftwidth=0.5, fixedwidth=1
)
self.visual["axis"][2] = visual.arrow(
color=visual.color.blue, axis=(0, 0, 3), headwidth=1, shaftwidth=0.5, fixedwidth=1
)
self.visual["wiiobj"] = visual.box(
pos=(0, 0, 0), length=2, height=6, width=1, color=visual.color.white, axis=(2, 0, 0)
)
return
def __init__(self,num_of_disks,num_of_rods):
self.max_disk_radius = 1.0
self.disk_thickness = 0.2
self.rod_height = self.disk_thickness * (num_of_disks + 1)
self.disks = [visual.cylinder(radius=self.max_disk_radius*(i+2)/(num_of_disks+1),
length=self.disk_thickness,
axis=(0,0,1),
color=(0.0,0.5,1.0),
material=visual.materials.wood) \
for i in range(num_of_disks)]
self.rods = [visual.cylinder(radius=self.max_disk_radius*1.0/(num_of_disks+1),
material=visual.materials.plastic,
color=(1.0,0.5,0.3),
length=self.rod_height,
axis=(0,0,1)) for i in range(num_of_rods)]
for i in range(num_of_rods):
self.rods[i].pos.x = self.max_disk_radius*2*(i-(num_of_rods-1)*0.5)
for i in range(num_of_disks):
self.set_disk_pos(disk=i,rod=0,z_order=num_of_disks-i-1)
self.base = visual.box(
pos=(0,0,-self.disk_thickness*0.5),
length=(num_of_rods+0.5)*self.max_disk_radius*2,
width=self.disk_thickness,
height=self.max_disk_radius*2.5,
color=(0.2,1.0,0.2),
material=visual.materials.wood)
def golf_ball_calc(x,y,z,vx,vy,vz,dt,m,g,B2,S0,w,w_vector):
t = 0.0
x_list = [x]
y_list = [y]
z_list = [z]
vx_list = [vx]
vy_list = [vy]
vz_list = [vz]
t_list = [t]
v_vector = visual.vector(vx,vy,vz)
tee = visual.box(pos=(0,0,0), length=0.05, width=0.05, height=0.5,color=visual.color.white)
ball = visual.sphere(pos=(x,y,z), radius = 0.25, color = visual.color.white)
ball.trail = visual.curve(color = visual.color.red)
while y > 0.0:
visual.rate(100)
t,x,y,z,vx,vy,vz = golfball_step(t,x,y,z,vx,vy,vz,m,g,B2,S0,w,dt,w_vector,v_vector)
x_list.append(x)
y_list.append(y)
z_list.append(z)
vx_list.append(vx)
vy_list.append(vy)
vz_list.append(vz)
t_list.append(t)
v_vector = visual.vector(vx,vy,vz)
ball.pos = (x,y,z)
ball.trail.append(pos=ball.pos)
return t_list,x_list,y_list,z_list,vx_list,vy_list,vz_list
def main():
scene = visual.display(width=settings.SCENE_WIDTH, height=settings.SCENE_HEIGHT)
ground = visual.box(axis=(0, 1, 0), pos=(0, 0, 0), length=0.1, height=500, width=500, color=visual.color.gray(0.75), opacity=0.5)
def addGait(gaitClass, gaitName):
gait = gaitClass(gaitName, settings.GAIT_LEGS_GROUPS[gaitName], settings.GAIT_PARAMS[gaitName])
GaitManager().add(gait)
addGait(GaitTripod, "tripod")
addGait(GaitTetrapod, "tetrapod")
addGait(GaitRiple, "riple")
addGait(GaitWave, "metachronal")
addGait(GaitWave, "wave")
GaitManager().select("riple")
robot = Hexapod3D()
remote = Gamepad(robot)
GaitSequencer().start()
remote.start()
robot.setBodyPosition(z=30)
robot.mainLoop()
remote.stop()
remote.join()
GaitSequencer().stop()
GaitSequencer().join()
def init_visual(self, only_wiiobj=False):
visual_pos = ((0, 0, 0), (7,7,0), (14,14,0))
if not only_wiiobj:
#vpython
visual.scene.width=self.param["width"] * 3
visual.scene.height=self.param["height"]
visual.scene.title = "3D WiiMote Simulation"
visual.scene.forward = visual.vector(1,0,0) # not to error ?
visual.scene.up = visual.vector(0,0,1)
visual.scene.forward = visual.vector(-1,1,-1)
visual.scene.center = (7,7,0)
visual.scene.scale = (0.07, 0.07, 0.07)
visual.scene.autoscale = 0
visual.scene.x = 0
visual.scene.y = 30
self.visual["axis"] = [(visual.arrow(pos=visual_pos[i], color=visual.color.red, axis=(3,0,0), headwidth=1, shaftwidth=0.5, fixedwidth=1),
visual.arrow(pos=visual_pos[i], color=visual.color.green, axis=(0,3,0), headwidth=1, shaftwidth=0.5, fixedwidth=1),
visual.arrow(pos=visual_pos[i], color=visual.color.blue, axis=(0,0,3), headwidth=1, shaftwidth=0.5, fixedwidth=1))
for i in xrange(3)]
self.visual["text"] = [visual.label(text="accel", pos=(1, -1, -4), color=visual.color.white),
visual.label(text="gyro", pos=(8, 6, -4), color=visual.color.white),
visual.label(text="accel + gyro", pos=(15, 13, -4), color=visual.color.white),]
self.visual["wiiobj"] = [visual.box(pos=visual_pos[i], length=2, height=6, width=1, color=visual.color.white, axis=(1,0,0)) #x=length, y=height, z=width
for i in xrange(3)]
return
def DefineBox(self,
Density,
SizeX,
SizeY,
SizeZ,
colour,
position=(0, 0, 0)):
"""Define this element as a ode Box."""
if self._hasGeom:
self._geom = ode.GeomBox(
_bigSpace,
(SizeX, SizeY,
SizeZ)) # BigSpace was None, problem with local body spaces
DisplayElement.SetDisplayObject(
self,
visual.box(length=SizeX,
height=SizeY,
width=SizeZ,
color=colour,
pos=position))
self._mass = ode.Mass()
self._mass.setBox(Density, SizeX, SizeY, SizeZ)
return self
def addCSGvoxel(self, box, colour):
"""
16/03/10: To visualise CSG objects
"""
if colour == None:
colour = visual.color.red
org = box.origin
ext = box.extent
size = np.abs(ext - org)
pos = org + 0.5 * size
visual.box(pos=pos, size=size, color=colour, opacity=0.2)
def addCSGvoxel(self, box, colour):
"""
16/03/10: To visualise CSG objects
"""
if colour == None:
colour = visual.color.red
org = box.origin
ext = box.extent
size = np.abs(ext - org)
pos = org + 0.5*size
visual.box(pos=pos, size=size, color=colour, opacity=0.2)
def __init__( self, NCellsPerDimension, Length, E0 ):
self.n = NCellsPerDimension
self.L = Length
self.V = self.L**3
self.N = 4 * self.n**3
self.a = self.L / self.n
self.E0 = E0
self.E = E0
self.U = 0
self.dU = 0
self.ddU = 0
self.particles = []
self.index = 0
self.dt = 1e-2
self.dt_2 = self.dt * 0.5
self.dt2_2 = self.dt * self.dt_2
self.scene = visual.display( title = 'System',
x=800, y=0,
width=800, height=800,
center = visual.vector(0.5,0.5,0.5) * self.L,
autoscale = False,
range = 1.5 * self.L)
self.box = visual.box( pos = visual.vector(0.5,0.5,0.5) * self.L,
length = self.L,
height = self.L,
width = self.L,
color = visual.color.green,
opacity = 0.2 )
def __init__(self, filepath, pos=(0,0,0), effect=fade_in):
texture = file_to_texture(filepath)
self.card = box(axis = (0,0,1),
size = (.01, 25, 50),
pos = pos,
opacity = 0,
material=texture)
effect(self.card)
def __init__(self, **kwargs):
super(Board, self).__init__(**kwargs)
visual.box(pos = (9, 9, -1),
size = (20, 20, 1),
color = (1, 0.75, 0),
material = visual.materials.wood,
frame = self)
# lines
params = dict(color = (.5, .5, .5), frame = self)
for i in range(19):
visual.curve(pos = [(0, i, 0), (18, i, 0)], radius = .05, **params)
for i in range(19):
visual.curve(pos=[(i, 0, 0), (i, 18, 0)], radius = .05, **params)
self.stones, self.star = [], []
for x in itertools.product((4, 10, 16), (4, 10, 16)): self.star.append(x[:])
def addCSGvoxel(self, box, colour, material=None, opacity=1.):
"""
16/03/10: To visualise CSG objects
"""
if not VISUAL_INSTALLED:
return
if colour == None:
colour = visual.color.red
org = box.origin
ext = box.extent
size = np.abs(ext - org)
pos = org + 0.5*size
visual.box(pos=pos, size=size, color=colour, opacity=opacity, material=material)
def __init__(self, stacks, position):
"""
Pass a reference to the stacks object that holds all the blocks
and the index of the initial stack of the block
"""
Block.__init__(self, stacks, position)
self.box = box(pos=(position-(stacks.blockCount/2), 0, 0), size=(.9,.9,.9), color=color.blue)
self.label = label(pos=array(self.box.pos) + array([0,0,1]), text=str(position), opacity=0, box=0, line=0)
def addCSGvoxel(self, box, colour, material=None, opacity=1.):
"""
16/03/10: To visualise CSG objects
"""
if not VISUAL_INSTALLED:
return
if colour is None:
colour = visual.color.red
org = box.origin
ext = box.extent
size = np.abs(ext - org)
pos = org + 0.5*size
visual.box(pos=pos, size=size, color=colour, opacity=opacity, material=material)
def load_from_file(filepath, pos=(0,0,0), effect=fade_in):
texture = file_to_texture(filepath)
card = box(axis = (0,0,1),
size = (.01, 25, 50),
pos = pos,
opacity = 0,
material=texture)
effect(card)
return card
def __init__(self, **kwargs):
super(Board, self).__init__(**kwargs)
visual.box(pos=(9, 9, -1),
size=(20, 20, 1),
color=(1, 0.75, 0),
material=visual.materials.wood,
frame=self)
# lines
params = dict(color=(.5, .5, .5), frame=self)
for i in range(19):
visual.curve(pos=[(0, i, 0), (18, i, 0)], radius=.05, **params)
for i in range(19):
visual.curve(pos=[(i, 0, 0), (i, 18, 0)], radius=.05, **params)
self.stones, self.star = [], []
for x in itertools.product((4, 10, 16), (4, 10, 16)):
self.star.append(x[:])
def visualBrick(brick,
opacity=0.7,
offset=(0.0, 0.0, 0.0),
material=None,
color=visual.color.white):
center_x = (brick.max_x + brick.min_x) / 2 + offset[0]
center_y = (brick.max_y + brick.min_y) / 2 + offset[1]
center_z = (brick.max_z + brick.min_z) / 2 + offset[2]
size_x = brick.max_x - brick.min_x
size_y = brick.max_y - brick.min_y
size_z = brick.max_z - brick.min_z
visual.box(pos=(center_x, center_y, center_z),
length=size_x,
height=size_y,
width=size_z,
color=color,
opacity=opacity,
material=material)
def InitVisuals():
from visual import display, points, box
window = display(title="F16 Simulation",
width=Resolution[0],
height=Resolution[1])
window.up = np.identity(3)[2]
window.forward = -np.ones(3)
window.center = pos
if FPV:
window.range = 15 * 3 #2
if stereo is not None:
window.stereo = stereo
D = 2500 #5000#2500
#--- CS ---
for i in range(3):
arrow(axis=np.identity(3)[i] * 1000,
color=np.identity(3)[i],
opacity=0.75)
#--- Point Cloud ---
if 1:
Points = []
d = 500 #100
n = int(D / d)
for i in range(-n, n + 1):
for j in range(-n, n + 1):
for k in range(0, n + 1):
p = np.array([i, j, k]).astype(float) * d
Points.append(tuple(p)) #+=list(p)
points(pos=Points)
if 1:
box(width=D * 2,
height=D * 2,
depth=10,
axis=-np.identity(3)[2],
color=[0.6, 0.3, 0.15])
return window
def gettile(cpos=None):
if cpos is None:
cpos = visual.vector((0, 0, 0))
elif type(cpos) == tuple:
cpos = visual.vector(cpos)
dip_sep = 1.10 # dipole separations in meters
xoffsets = [0.0] * 16 # offsets of the dipoles in the W-E 'x' direction
yoffsets = [0.0] * 16 # offsets of the dipoles in the S-N 'y' direction
xoffsets[0] = -1.5 * dip_sep
xoffsets[1] = -0.5 * dip_sep
xoffsets[2] = 0.5 * dip_sep
xoffsets[3] = 1.5 * dip_sep
xoffsets[4] = -1.5 * dip_sep
xoffsets[5] = -0.5 * dip_sep
xoffsets[6] = 0.5 * dip_sep
xoffsets[7] = 1.5 * dip_sep
xoffsets[8] = -1.5 * dip_sep
xoffsets[9] = -0.5 * dip_sep
xoffsets[10] = 0.5 * dip_sep
xoffsets[11] = 1.5 * dip_sep
xoffsets[12] = -1.5 * dip_sep
xoffsets[13] = -0.5 * dip_sep
xoffsets[14] = 0.5 * dip_sep
xoffsets[15] = 1.5 * dip_sep
yoffsets[0] = 1.5 * dip_sep
yoffsets[1] = 1.5 * dip_sep
yoffsets[2] = 1.5 * dip_sep
yoffsets[3] = 1.5 * dip_sep
yoffsets[4] = 0.5 * dip_sep
yoffsets[5] = 0.5 * dip_sep
yoffsets[6] = 0.5 * dip_sep
yoffsets[7] = 0.5 * dip_sep
yoffsets[8] = -0.5 * dip_sep
yoffsets[9] = -0.5 * dip_sep
yoffsets[10] = -0.5 * dip_sep
yoffsets[11] = -0.5 * dip_sep
yoffsets[12] = -1.5 * dip_sep
yoffsets[13] = -1.5 * dip_sep
yoffsets[14] = -1.5 * dip_sep
yoffsets[15] = -1.5 * dip_sep
gp = visual.box(pos=visual.vector(0, 0, 0) + cpos,
axis=(0, 0, 1),
height=5.0,
width=5.0,
length=0.05,
color=color.gray(0.5),
visible=False)
olist = [gp]
for i in range(16):
dlist = getdipole(cpos=visual.vector(xoffsets[i], yoffsets[i], 0) +
cpos)
olist += dlist
return olist
def draw_world(world_data):
"""
Draws a world in 3D
"""
for obj in vpy.scene.objects:
del obj
box_width = WIDTH // len(world_data[0])
box_length = LENGTH // len(world_data)
for row_i, row in enumerate(world_data):
for col_i, col in enumerate(row):
color = terrain_key.get(row[col_i], None)
if color is not None:
vpy.box(pos=(col_i * box_width, 0, row_i * box_length),
length=box_length,
height=box_width,
width=1,
color=color)
def __init__(self, Stable, wm, quad_pos=(0, 0, 0)):
self.world = World()
self.world.setGravity((0, -9.81, 0))
self.space = Space()
self.contactgroup = JointGroup()
self.wm = wm
# draw floor
self.floor = GeomPlane(self.space, (0, 1, 0), -1)
box(pos=(0, -1, 0), width=2, height=0.01, length=2)
# Draw Quad
self.quad = Quad(self.world, self.space, pos=quad_pos)
# Init Algorithm
self.stable = Stable(self.quad)
# stop autoscale of the camera
scene.autoscale = False
def getxmas():
"""Creates a complete Christmas Tree dipole assembly (minus base) at (0,0,0)
Returned value is a tuple of (xmas, olist), where xmas is the frame containing the
complete Christmas Tree dipoles, and olist is a list of all of the component objects."""
xmas = visual.frame()
olist = []
for direction in ['E', 'W', 'N', 'S']: # Create the four dipole arms
ef, elist = getelement(frame=xmas, which=direction)
olist.append(ef)
olist.append(elist)
# These objects (s1-s3) are the white plastic space assembly
s1 = visual.curve(pos=[
V(-0.233, -0.233, 0.59),
V(0.233, -0.233, 0.59),
V(0.233, 0.233, 0.59),
V(-0.233, 0.233, 0.59),
V(-0.233, -0.233, 0.59)
],
frame=xmas,
radius=0.02,
material=SPACERMAT,
color=color.white)
s2 = visual.curve(pos=[V(-0.233, 0, 0.59),
V(0.233, 0, 0.59)],
frame=xmas,
radius=0.02,
material=SPACERMAT,
color=color.white)
s3 = visual.curve(pos=[V(0, -0.233, 0.59),
V(0, 0.233, 0.59)],
frame=xmas,
radius=0.02,
material=SPACERMAT,
color=color.white)
# This is an approximation to the LNA and feedhorn at the top of the tree
lna = visual.box(pos=V(0, 0, 1.63),
frame=xmas,
height=0.03,
length=0.03,
width=0.08,
material=SPACERMAT,
color=color.white)
# This is the cable duct going vertically down the centre of the tree from the LNA
pole = visual.curve(pos=[V(0, 0, 0.38), V(0, 0, 1.73)],
frame=xmas,
radius=POLER,
material=POLEMAT,
color=color.white)
olist.append([s1, s2, s3, lna, pole])
return xmas, olist
def AddToQueue(self, ID, In):
InOut = 1
if In == True: InOut = 0
priorSquare = 0
if len(self.NodeList[ID][InOut]) > 0:
priorSquare = self.NodeList[ID][InOut][-1].pos[1]
newY = priorSquare + 1
if In == 1:
box = v.box(pos=(ID * 2 + InOut, newY, 0),
Length=0.25,
Width=0.25,
Height=0.25,
color=v.color.green)
else:
box = v.box(pos=(ID * 2 + InOut, newY, 0),
Length=0.25,
Width=0.25,
Height=0.25,
color=v.color.red)
self.NodeList[ID][InOut].append(box)
def init_gui(self):
# Is the orientation matrix missing here????
self.length = 100
wallR = box(pos=vector(self.length / 2., 0, 0),
size=(0.2, self.length, self.length),
color=color.green)
wallB = box(pos=vector(0, 0, -self.length / 2.),
size=(self.length, self.length, 0.2),
color=color.white)
wallDown = box(pos=vector(0, -self.length / 2., 0),
size=(self.length, 0.2, self.length),
color=color.red)
wallUp = box(pos=vector(0, self.length / 2., 0),
size=(self.length, 0.2, self.length),
color=color.white)
wallL = box(pos=vector(-self.length / 2., 0, 0),
size=(0.2, self.length, self.length),
color=color.blue)
self.unit_target = self.target_vector / np.linalg.norm(
self.target_vector)
self.target_position = np.array(
self.unit_target) * self.max_factor * self.force_scale
self.ball = sphere(pos=[0, 0, 0],
radius=self.ball_rad,
color=self.ball_color)
self.target = sphere(pos=self.target_position,
radius=self.target_rad,
color=self.target_color)
self.shadow_cursor = ring(pos=[0, -self.length / 2, 0],
axis=(0, 10, 0),
radius=self.ball_rad,
thickness=1,
color=[0.25, 0.25, 0.25])
self.shadow_target = ring(pos=[
self.target_position[0], -self.length / 2, self.target_position[2]
],
axis=(0, 10, 0),
radius=self.ball_rad,
thickness=1,
color=[0.25, 0.25, 0.25])
def DefineBoxTotal(self, TotalMass, SizeX, SizeY, SizeZ):
"""Define this element as an ode BoxTotal."""
if self._hasGeom:
self._geom = ode.GeomBox(_bigSpace, (SizeX, SizeY, SizeZ))
DisplayElement.SetDisplayObject(
self, visual.box(length=SizeX, height=SizeY, width=SizeZ))
self._mass = ode.Mass()
self._mass.setBoxTotal(TotalMass, SizeX, SizeY, SizeZ)
self._mass.mass = TotalMass # Bug workaround?
return self
def draw_camera_frame():
"""Create frame and draw its contents."""
global CAM_BOX, CENT_PLANE, CAM_LAB, CAN_TRI, RANGE_LAB, LINELEN, FWD_LINE
global FWR_ARROW, MOUSE_LINE, MOUSE_ARROW, MOUSE_LAB, FOV, RANGE_X, CAM_DIST, CAM_FRAME
global RAY
CAM_FRAME = vs.frame(pos=vs.vector(0, 2, 2, ), axis=(0, 0, 1))
# NB: contents are rel to this frame. start with camera looking "forward"
# origin is at simulated scene.center
FOV = vs.pi/3.0 # 60 deg
RANGE_X = 6 # simulates scene.range.x
CAM_DIST = RANGE_X / vs.tan(FOV/2.0) # distance between camera and center.
RAY = vs.vector(-20.0, 2.5, 3.0).norm() # (unit) direction of ray vector (arbitrary)
# REL TO CAMERA FRAME
CAM_BOX = vs.box(frame=CAM_FRAME, length=1.5, height=1, width=1.0,
color=CLR.blue, pos=(CAM_DIST, 0, 0)) # camera-box
CENT_PLANE = vs.box(frame=CAM_FRAME, length=0.01, height=RANGE_X*1.3,
width=RANGE_X*2, pos=(0, 0, 0), opacity=0.5) # central plane
CAM_LAB = vs.label(frame=CAM_FRAME, text='U', pos=(CAM_DIST, 0, 0),
height=9, xoffset=6)
CAN_TRI = vs.faces(frame=CAM_FRAME, pos=[
(0, 0, 0), (0, 0, -RANGE_X), (CAM_DIST, 0, 0)])
CAN_TRI.make_normals()
CAN_TRI.make_twosided()
RANGE_LAB = vs.label(frame=CAM_FRAME, text='R', pos=(0, 0, -RANGE_X),
height=9, xoffset=6)
LINELEN = SCENE_SIZE + vs.mag(
CAM_FRAME.axis.norm()*CAM_DIST + CAM_FRAME.pos) # len of lines from camera
FWD_LINE = draw_line(vs.vector(CAM_DIST, 0, 0), LINELEN, vs.vector(-1, 0, 0))
FWR_ARROW = vs.arrow(frame=CAM_FRAME, axis=(-2, 0, 0), pos=(CAM_DIST, 0, 0),
shaftwidth=0.08, color=CLR.yellow)
vs.label(frame=CAM_FRAME, text='C', pos=(0, 0, 0), height=9, xoffset=6,
color=CLR.yellow)
MOUSE_LINE = draw_line(vs.vector(CAM_DIST, 0, 0), LINELEN, RAY)
MOUSE_ARROW = vs.arrow(frame=CAM_FRAME, axis=RAY*2, pos=(CAM_DIST, 0, 0),
shaftwidth=0.08, color=CLR.red)
MOUSE_LAB = vs.label(
frame=CAM_FRAME, text='M', height=9, xoffset=10,
color=CLR.red,
pos=-RAY*(CAM_DIST/vs.dot(RAY, (1, 0, 0))) + (CAM_DIST, 0, 0))
def setup_base():
'''
Creates a visual for the ground, the construction area, and the home area
'''
# Setup the ground
dim = WORLD['properties']['dim_x'], WORLD['properties'][
'dim_y'], PROGRAM['epsilon'] / 2
center = tuple([v / 2 for v in dim])
temp = visual.box(pos=center, length=dim[0], height=dim[1], width=0.05)
temp.color = (1, 1, 1)
# Setup the Home Plate
dim = HOME['size']
center = HOME['center']
temp = visual.box(pos=center, length=dim[0], height=dim[1], width=0.1)
temp.color = (1, 0, 0)
# Setup the construction plate
dim = CONSTRUCTION['size']
center = CONSTRUCTION['center']
temp = visual.box(pos=center, length=dim[0], height=dim[1], width=0.1)
temp.color = (0, 1, 0)
def animate( self, sleeptime=1.0, transparent=True, blur=False ):
""" display the reaction-diffusion grid using vpytyon
transparent: use transparent background instead of black
blur: produce fuzzy borders between cells on the grid
"""
import visual as vpy
self.computeTextureMatrix(transparent)
self.texture = vpy.materials.texture(data=self.texmat, \
mapping='sign', interpolate=blur)
self.plate = vpy.box(axis=(0,0,1), width=2, height=2, \
length=0.1, material=self.texture)
# TODO: how to reuse existing box and texture???
print "animate t=", self.time
vpy.sleep(sleeptime)
def __init__(self, stacks, position):
"""
Pass a reference to the stacks object that holds all the blocks
and the index of the initial stack of the block
"""
Block.__init__(self, stacks, position)
self.box = box(pos=(position - (stacks.blockCount / 2), 0, 0),
size=(.9, .9, .9),
color=color.blue)
self.label = label(pos=array(self.box.pos) + array([0, 0, 1]),
text=str(position),
opacity=0,
box=0,
line=0)
def __init__(self, **kwargs):
self.container = visual.frame(**kwargs)
self.box = visual.box(frame=self.container,
length=self.size[0],
width=self.size[1],
height=self.size[2],
color=(0, 0, 0.7))
self.lidarframe = visual.frame(frame=self.container,
pos=(self.size[0] / 2.0,
self.size[1] / 2.0, self.size[2]))
self.lidarpoints = visual.points(pos=[(0, 0, 0) for i in range(360)],
frame=self.lidarframe,
size=5,
color=(0, 1, 0))
print(repr(self.lidarpoints))
def show_ladybug(self, H=None):
'''Show Ladybug in Visual Python at origin or at the translated position
if parameter is given.
TODO: Implement an additional translation H and show at new position.'''
# vis.ellipsoid(width=0.12, length=0.08, height=0.08,
# color=vis.color.red, opacity=0.2)
vis.arrow(axis=(0.04, 0, 0), color=(1, 0, 0))
vis.arrow(axis=(0, 0.04, 0), color=(0, 1, 0))
vis.arrow(axis=(0, 0, 0.04), color=(0, 0, 1))
colors = [
vis.color.red, vis.color.green, vis.color.blue, vis.color.cyan,
vis.color.yellow, vis.color.magenta
]
for P in self.LP:
R = P[:3, :3]
pos = dot(P[:3], r_[0, 0, 0, 1])
pos2 = dot(P[:3], r_[0, 0, 0.01, 1])
vis.sphere(pos=pos, radius=0.002, color=colors.pop(0))
vis.box(pos=pos2,
axis=dot(R, r_[0, 0, 1]).flatten(),
size=(0.001, 0.07, 0.09),
color=vis.color.red,
opacity=0.1)
vis.arrow(pos=pos,
axis=dot(R, r_[0.02, 0, 0]).flatten(),
color=(1, 0, 0),
opacity=0.5)
vis.arrow(pos=pos,
axis=dot(R, r_[0, 0.02, 0]).flatten(),
color=(0, 1, 0),
opacity=0.5)
vis.arrow(pos=pos,
axis=dot(R, r_[0, 0, 0.02]).flatten(),
color=(0, 0, 1),
opacity=0.5)
