def step1(self):
self.text = """\
<h3><center>Command Lists</center></h3>
<p>Demos the use of command lists to perform complicated oribtal manouvers.</p>
<p>Available commands are (one per line):</p>
<ul>
<li>wait(t) - waits for <em>t<em> seconds</li>
<li>at(t) - waits until time <em>t<em></li>
<li>prograde() - returns <em>prograde<em> unit vector</li>
<li>retrograde() - returns <em>retrograde<em> unit vector</li>
<li>normal() - returns <em>orbit-normal<em> unit vector</li>
<li>antinormal() - returns <em>orbit-antinormal<em> unit vector</li>
<li>dv(dv) - applies <em>dv<em> change of velocity</li>
</ul>
<p>An example command list:</p>
<pre>
wait(10) # wait 10 seconds
dv(prograde() * 100) # prograde burn, 100 m/s
at(100) # wait until time=100 seconds
dv(prograde() * 200) # prograde burn, 200 m/s
</pre>
"""
self.sim.__init__(0)
self.sim.bodies = [Body.generate_circular_equatorial_orbit(1.0E7),
Body.generate_circular_equatorial_orbit(1.0E6, (0.0, 1.0, 1.0, 1.0))]
self.sim.bodies[0].pos_viz_mode = Body.POSITION_VISUALISATIONS['rv']
self.sim.bodies[1].pos_viz_mode = Body.POSITION_VISUALISATIONS['rv']
self.reset_sim()
self.viz_window.switch_view_north(12.0)
def test_do_exception(self):
from database import AbilityRecord,WordRecord
from body import Body,BodyException
b = Body()
with self.assertRaises(BodyException):
b.do([AbilityRecord("[0]")])
with self.assertRaises(BodyException):
self.b.do([AbilityRecord("[1]")])
def step1(self):
self.text = """\
<h3><center>Hohman Transfers</center></h3>
<p>Hohman transfer orbits are used to transfer between two circular orbits in the same plane.</p>
<p>Let's start with a circular orbit at altitude of 1,000 km above Earth, and a target orbit that is also circular
at an altitude of 10,000 km. Both orbits are equatorial.</p>
"""
self.sim.__init__(0)
self.sim.bodies = [Body.generate_circular_equatorial_orbit(1.0E6, (0.0, 1.0, 1.0, 1.0)),
Body.generate_circular_equatorial_orbit(1.0E7)]
self.reset_sim()
self.viz_window.switch_view_north(12.0)
class System:
def __init__(self):
self.sun = Body(0, 0, 0)
self.p1 = Body(500,90,-1)
self.p2 = Body(1000,90,5)
self.p3 = Body(2000,90,-3)
self.sun.setDay(0)
def setDay(self,day):
self.p1.setDay(day)
self.p2.setDay(day)
self.p3.setDay(day)
return self.getWeather()
# -2 sequia
# -1 buen clima
# >0 grado de lluvia
def getWeather(self):
if(Helpers.isAligned(self.p1,self.p2,self.p3)):
if(Helpers.isAligned(self.p1,self.p2,self.sun)):
# print 'sequia ' + str(self.p1) + str(self.p2) + str(self.p3)+ ' - ' + str(self.p1.day)
return -2
print 'buen clima ' + str(self.p1) + str(self.p2) + str(self.p3)
return -1
if(Helpers.inTriangle(self.sun,self.p1,self.p2,self.p3)):
#print 'lluvia ' + str(self.p1) + str(self.p2) + str(self.p3)
return Helpers.perimeter(self.p1,self.p2,self.p3)
# print 'invalido ' + str(self.p1) + str(self.p2) + str(self.p3) + ' - ' + str(self.p1.day)
return -3
def __str__(self):
return str(self.p1) + str(self.p2) + str(self.p3) + ' - ' + str(self.p1.day)
def __init__(self, num_random_objs):
self.bodies = []
self.selected_body = None
if num_random_objs > 0:
self.selected_body = 0
self.bodies.append(Body.generate_circular_equatorial_orbit(6.0E5, (0.0, 1.0, 1.0, 1.0)))
self.bodies.append(Body.generate_circular_equatorial_orbit(1.2E6))
for x in xrange(num_random_objs - 2):
self.bodies.append(Body.generate_random_orbit())
self.pos_viz_mode = Body.POSITION_VISUALISATIONS['symbol']
self.orbit_viz_mode = Body.ORBIT_VISUALISATIONS['all']
self.set_defaults()
def test_will_out_of_border(self):
bodyA = Body(BodyGeometry(15, 5, 10, 10)) #10,0
bodyB = Body(BodyGeometry(25, 5, 10, 10)) #20,0
bodyC = Body(BodyGeometry(35, 5, 10, 10)) #30,0
bodyD = Body(BodyGeometry(45, 5, 10, 10)) #40,0 50,10
snake = BaseSnake()
snake.add_head(bodyA)
snake.add_head(bodyB)
snake.add_head(bodyC)
snake.add_head(bodyD)
self.assertFalse(snake.is_will_out_of_border(Direction.RIGHT, 10))
self.assertFalse(snake.is_will_out_of_border(Direction.DOWN, 10))
snake.set_border(0, 0, 50, 20)
self.assertTrue(snake.is_will_out_of_border(Direction.RIGHT, 10))
self.assertFalse(snake.is_will_out_of_border(Direction.DOWN, 10))
def add_particle(self, position):
r = abs(normal(1e9, 1e8, 1))
vx, vy, vz = normal(0, 1e7, 1), normal(0, 1e7, 1), normal(0, 1e7, 1)
add = Body(radius=r[0],
pos=vector(position),
velocity=vector(vx[0], vy[0], vz[0]))
self.bodies.append(add)
def activate(self, x, y, gamma, target, bullets):
self.time -= self.cooldown_time
xo, yo = x + 80 * cos(gamma), y - 80 * sin(gamma)
angle = calculate_angle(xo, yo, *target)
pos = (xo + 34 * cos(angle), yo - 34 * sin(angle))
bullets.append(
b.RegularBullet(*pos, 0, 0.7, angle, Body(STICKY_BUL_BODY)))
def __init__(self):
self.root = Tk()
self.root.title("IRCTC TRAIN")
self.root.minsize(800, 600)
self.root.maxsize(800, 600)
self.root.configure(background="#222")
# # self.l = Label(self.root,text="LABEL ROOT").pack()
# Trainroute(self.root)
# # self.f1.pack()
self.hdr = Header(self.root)
self.hdr.pack(side=TOP)
self.bdy = Body(self.root)
self.bdy.pack(side=TOP)
self.hdr.send_body(self.bdy)
def release(x, y):
global solar, press_time, pressed, press_coords
pressed = False
mass = 3.30e23 * (10 ** (new_planet_size / 6)) # trial and error
distance_from_sun = sqrt((x - (WINDOW_WIDTH / 2)) ** 2 + (y - (WINDOW_HEIGHT / 2)) ** 2) / PIXELS_PER_METER
dy = ((y - (WINDOW_HEIGHT / 2)) / PIXELS_PER_METER)
dx = ((x - (WINDOW_WIDTH / 2)) / PIXELS_PER_METER)
sin = dy / distance_from_sun
cos = dx / distance_from_sun
speed = sqrt((GRAVITY * sun.mass) / distance_from_sun) # got this orbital speed equation from Wikipedia
# randomize color but don't allow for colors that are too dark
r = randint(10, 100) / 100
g = randint(10, 100) / 100
b = randint(10, 100) / 100
new_body = Body(mass, dx, dy, speed * sin, -speed * cos, new_planet_size, r, g, b)
solar.bodies.append(new_body)
def spawn(self):
# fire gun, only if cooldown has been 0.5 seconds since last
now = pygame.time.get_ticks()
if (self.limit == -1) or (self.counter < self.limit):
if now - self.last >= self.cooldown:
self.last = now
n1 = Near(self.p1)
self.near_sect.add(n1)
b1 = Body(self.destination, road_watcher)
self.body_sect.add(b1)
f1 = Far(self.p1)
self.far_sect.add(f1)
car = CarSingle()
car.add(b1)
car.add(n1)
car.add(f1)
car_group.add(car)
self.counter += 1
def activate(self, pos, bullets, health, beta=0):
self.time = 0
missiles_coords = self.get_missiles_coords(pos, health, beta)
for pos in missiles_coords:
bullets.append(
b.HomingMissile(*pos, 7, -5, 0.55,
Body(HOMING_MISSILE_BODY_1)))
def main():
args = get_option()
if args.object_detection:
rpn = ssd_setting.build_ssd('test', 300, 21)
rpn.load_weights(args.ssd_weight_path)
from ssd.data import VOC_CLASSES as labels
else:
rpn = False
#model load
model = init_detector(args.config_file, args.weight_file, device="cuda:0")
hand_estimation = Hand(args.hand_weight_path)
if args.mode == "openpose":
body_estimation = Body(args.body_weight_path)
else:
body_estimation = False
files = sorted(glob.glob('./demo/input/*.jpg'))
count = 1
for i, file in enumerate(files):
img_name = os.path.split(file)[1]
image = cv2.imread(file, cv2.IMREAD_COLOR)
detect(image, img_name, args.mode, model, hand_estimation,
body_estimation, rpn, labels)
print(count)
count += 1
def randomBodies(max):
arr = []
for i in range(max):
props = randomProperties()
newBody = Body(i, props[0], props[1], props[2], props[3], props[4],
props[5])
arr.append(newBody)
return arr
def generate_bullets(self, x, y, target, gamma):
angle = calculate_angle(x, y, *target)
coords = self.get_reference_point(x, y, angle)
return [
RegularBullet(*coords, self.bul_dmg, self.bul_vel, angle,
Body(self.bul_body))
]
def generate_bullets(self, x, y, target, gamma):
xo, yo = x + 90 * cos(gamma + 0.75 * pi), y - 90 * sin(gamma +
0.75 * pi)
angle_0 = calculate_angle(xo, yo, *target)
pos_0 = (xo + 40 * cos(angle_0), yo - 40 * sin(angle_0))
xo, yo = x + 90 * cos(gamma - 0.75 * pi), y - 90 * sin(gamma -
0.75 * pi)
angle_1 = calculate_angle(xo, yo, *target)
pos_1 = (xo + 40 * cos(angle_1), yo - 40 * sin(angle_1))
return [
RegularBullet(*pos_0, self.bul_dmg, self.bul_vel, angle_0,
Body(self.bul_body)),
RegularBullet(*pos_1, self.bul_dmg, self.bul_vel, angle_1,
Body(self.bul_body))
]
def generate_bullets(self, x, y, target, gamma):
angle = calculate_angle(x, y, *target)
xo, yo = self.get_reference_point(x, y, angle)
pos_0 = (xo, yo)
pos_1 = (xo + 15 * sin(angle - 0.17 * pi),
yo + 15 * cos(angle - 0.17 * pi))
pos_2 = (xo - 15 * sin(angle + 0.17 * pi),
yo - 15 * cos(angle + 0.17 * pi))
return [
RegularBullet(*pos_0, self.bul_dmg, self.bul_vel, angle,
Body(self.bul_body)),
RegularBullet(*pos_1, self.bul_dmg, self.bul_vel,
angle - 0.17 * pi, Body(self.bul_body)),
RegularBullet(*pos_2, self.bul_dmg, self.bul_vel,
angle + 0.17 * pi, Body(self.bul_body))
]
def __init__(self, ip, port):
self.ip = ip
self.port = port
self.name = self.set_name()
self.face = self.init_face()
self.body = Body(self, ALProxy("ALMotion", ip, port),
ALProxy("ALAutonomousMoves", IP, port))
self.brain = Brain(self)
def ellipsoid(geom=Geometry(), sigma=DEFAULT_SIGMA):
rnd = rand.Gauss(sigma)
body = Body(geom)
body.name = "Ellipsoid"
p = body.p
ey = body.e[1]
ez = body.e[2]
for ui in xrange(len(body.x_marks)):
x = body.x_marks[ui]
r = np.sqrt(0.5**2- x**2) #TODO voll falsch, is kugel bisher
for vi in xrange(body.n_alpha):
my, mz = body.slope_marks[vi, :]
y = r*my
z = r*mz
x, y, z = rnd(x), rnd(y), rnd(z)
p[ui, vi] = [x, y, z]
return body
def append_bullet_2(self, x, y, bullets, target, gamma):
pos = [x - 35 * cos(gamma), y + 35 * sin(gamma)]
angle = calculate_angle(*pos, *target)
pos[0] += 35 * cos(angle)
pos[1] -= 35 * sin(angle)
bullets.append(
RegularBullet(*pos, self.bul_dmg, self.bul_vel, angle,
Body(self.bul_body)))
def __sub__(self, amount):
self.score -= amount
# Due to a strange positioning bug that refuses to go away,
# the tail will only connect if we remove an extra segment and recreate it
for x in range(amount + 1):
self.segments[-1].destroy()
self.segments.append(Body(self.screen, self, self.gv, self.score))
return self
def append_small_bullet(x, y, bullets, gamma, target):
x = x + 12 * cos(gamma)
y = y - 12 * sin(gamma)
angle = calculate_angle(x, y, *target)
x += 24 * cos(angle)
y -= 24 * sin(angle)
bullets.append(
RegularBullet(x, y, -2, 0.55, angle, Body(SMALL_BUL_BODY_2)))
def append_big_bullet(x, y, bullets, gamma, target):
x = x - 70 * cos(gamma)
y = y + 70 * sin(gamma)
angle = calculate_angle(x, y, *target)
x += 44 * cos(angle)
y -= 44 * sin(angle)
bullets.append(
RegularBullet(x, y, -15, 0.55, angle, Body(BIG_BUL_BODY_2)))
def __init__(self):
pygame.init()
self.window = pygame.display.set_mode((500, 500))
self.clock = pygame.time.Clock()
self.player = Player(Body(Rect(Vec(30, 20), 20, 20)))
self.load_level("start.lvl")
self.respawn_timer = 0
class Brain(object):
""" Control of the robot """
def __init__(self, config):
super(Brain, self).__init__()
self.body = Body(config) # acknowledge mortality
self.body.start() # begin lifelong struggle against gravity
def run(self, manual=False):
while True:
next_states = self.body.possible_next_states()
if manual:
print next_states
joint, move = raw_input("joint, move: ").split()
joint = int(joint)
move = int(move)
if joint == -1:
break
else:
break
self.body.make_move(joint, move)
sleep(0.1)
def stop(self):
self.body.stop()
def main():
earth = Body(5.9736e24, 0, 0, 0, 0, 24, 0, 0, 1) # blue earth
moon = Body(7.3477e22, 3.84403e8, 0, 0, 1022, 4, 1, 1, 1) # white moon
earth_moon = System([earth, moon])
set_clear_color(0, 0, 0) # black background
enable_smoothing()
while not window_closed():
clear()
moon.update_velocity(
-0.25, -0.00004, TIMESTEP * TIME_SCALE
) # This is my new addition. I update the moon's velocity and position
moon.update_position(
TIMESTEP * TIME_SCALE
) # so that the moon moves and I can check the body class' methods
# Draw the system in its current state.
earth_moon.draw(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2, PIXELS_PER_METER)
# Update the system for its next state.
# earth_moon.update(TIMESTEP * TIME_SCALE)
# Draw the frame and take a brief nap.
request_redraw()
sleep(TIMESTEP)
def generate_bullets(self, x, y, target, gamma):
angle = 0.61 * pi if self.missile_switch == 1 else 0.39 * pi
xo = x + self.radius * cos(angle)
yo = y - self.radius * sin(angle)
return [
HomingMissile(xo, yo, 20, self.bul_dmg, self.bul_vel,
Body(self.bul_body))
]
def generate_bullets(self, x, y, target, gamma):
xo, yo = x, y + 210
angle = calculate_angle(xo, yo, *target)
coords = (xo + self.radius * cos(angle), yo - self.radius * sin(angle))
return [
RegularBullet(*coords, self.bul_dmg, self.bul_vel, angle,
Body(self.bul_body))
]
def start_the_bodies(self, n: int):
# Parent Body
self.bodies.append(Body(0, 0, 0, 0, 1e6 * self.solar_mass))
# Child body
px = (self.radius + 1e8) * exp(-1.8) * (.5)
py = (self.radius + 1e8) * exp(-1.8) * (.5)
magv = self.circular_velocity(px, py) * 0.6
absangle = atan(abs(py / px))
thetav = pi / 2 - absangle
# https://finnaarupnielsen.wordpress.com/2011/05/18/where-is-the-sign-function-in-python/
vx = copysign(1, py) * cos(thetav) * magv
vy = -1 * copysign(1, px) * sin(thetav) * magv
mass = self.solar_mass * 1 + 1e20
self.bodies.append(Body(px, py, vx, vy, mass))
def grow(self):
loc = self.coordinate_to_pixel(self.tail.prev_loc)
if len(loc) == 0:
loc = self.coordinate_to_pixel(self.head.prev_loc)
# remember last move, so that it can take it at time t+1
ligament = Body(loc[0], loc[1], self.head.exectued_move, self)
self.body.append(ligament)
self.tail = ligament
def start_the_bodies(self, n: int):
# Parent Body
self.bodies.append(Body(0, 0, 0, 0, 1e6 * self.solar_mass))
# Child body
px = -4.331161870491374e+16
py = -1.3449882048469356e+16
magv = self.circular_velocity(px, py)
absangle = atan(abs(py / px))
thetav = pi / 2 - absangle
# https://finnaarupnielsen.wordpress.com/2011/05/18/where-is-the-sign-function-in-python/
vx = copysign(1, py) * cos(thetav) * magv
vy = -1 * copysign(1, px) * sin(thetav) * magv
mass = self.solar_mass * 10
self.bodies.append(Body(px, py, vx, vy, mass))
def append_bullets(self, x, y, target, bullets, gamma):
if self.time >= 0:
self.time -= self.cooldown_time
for i in range(10):
angle = gamma + i * 0.2 * pi
xo, yo = x + 38 * cos(angle), y - 38 * sin(angle)
bullets.append(
RegularBullet(xo, yo, self.bul_dmg, self.bul_vel, angle,
Body(self.bul_body)))
def __init__(self, x, y, angle):
super().__init__(x, y, -20, 0.7, angle, Body(BIG_BUL_BODY_1))
# bullet switches colors periodically
self.exploding = True
self.colors = {1: DARK_RED, -1: LIGHT_RED}
self.color_switch = 1
self.T = 80
self.color_time = 0
def get_test_Space_simple_solar():
"""
Generates a simple test Space object. It is filled with the 8 plannets of the solar system (and the moon). They are position in a way that doesn't 100% correspond to reality.
"""
bodies = []
mass_orbit = 1.988435 * (10**30)
# The most important bodies.
bodies.append(Body(np.array([0.0, 0.0, 0.0]), np.array([0.0, 0.0, 0.0]), 1.988435 * (10**30), 695700000, 'Sun', True, 'tab:orange'))
position_earth, velocity_earth = get_coordinates_from_Kepler(1.0*1.496*10**11, 0.01671, (5*10**(-5))*np.pi/180, 0, 0, 190*np.pi/180, 29300, mass_orbit)
bodies.append(Body(position_earth, velocity_earth, 5.97 * (10**24), 6371009, 'Earth', True, 'tab:blue'))
position, velocity = get_coordinates_from_Kepler(384400*1000, 0.0554, 5.16*np.pi/180, 125*np.pi/180, 318.15*np.pi/180, 213*np.pi/180, 1020, bodies[1].mass)
position = position + position_earth
velocity = velocity + velocity_earth
bodies.append(Body(position,velocity, 7.349 * (10**22), 1737400, 'Moon', True, 'darkgrey'))
# Other inner plannets.
position, velocity = get_coordinates_from_Kepler(0.38709893*1.496*10**11, 0.20563069, 7.00487*np.pi/180, 48.33*np.pi/180, 29.12*np.pi/180, 269*np.pi/180, 45810, mass_orbit)
bodies.append(Body(position, velocity, 3.301 * (10**23), 2440000, 'Mercury', True, 'lightsteelblue'))
position, velocity = get_coordinates_from_Kepler(0.72333199*1.496*10**11, 0.00677, 3.39471*np.pi/180, 76.68069*np.pi/180, 54.85*np.pi/180, 187*np.pi/180, 34790, mass_orbit)
bodies.append(Body(position, velocity, 4.867 * (10**24), 6050000, 'Venus', True, 'goldenrod'))
position, velocity = get_coordinates_from_Kepler(1.52366*1.496*10**11, 0.09341, 1.85061*np.pi/180, 49.57*np.pi/180, 286*np.pi/180, 349*np.pi/180, 26450, mass_orbit)
bodies.append(Body(position, velocity, 6.417 * (10**23), 3390000, 'Mars', True, 'sandybrown'))
# Outer planets.
position_jupiter, velocity_jupiter = get_coordinates_from_Kepler(5.2033*1.496*10**11, 0.04839, 1.3053*np.pi/180, 100.556*np.pi/180, -85.80*np.pi/180, 283*np.pi/180, 13170, mass_orbit)
bodies.append(Body(position_jupiter, velocity_jupiter, 1.898 * (10**27), 69950000, 'Jupiter', True, 'darkorange'))
position_saturn, velocity_saturn = get_coordinates_from_Kepler(9.537*1.496*10**11, 0.0541, 2.48446*np.pi/180, 113.715*np.pi/180, -21.2831*np.pi/180, 207*np.pi/180, 91590, mass_orbit)
bodies.append(Body(position_saturn, velocity_saturn, 5.683 * (10**26), 58300000, 'Saturn', True, 'navajowhite'))
position_uranus, velocity_uranus = get_coordinates_from_Kepler(19.1912*1.496*10**11, 0.0471771, 0.76986*np.pi/180, 74.22988*np.pi/180, 96.73436*np.pi/180, 229*np.pi/180, 6578, mass_orbit)
bodies.append(Body(position_uranus, velocity_uranus, 8.681 * (10**25), 25360000, 'Uranus', True, 'powderblue'))
position_neptune, velocity_neptune = get_coordinates_from_Kepler(30.06896*1.496*10**11, 0.00858587, 1.76917*np.pi/180, 131.72169*np.pi/180, -86.75*np.pi/180, 301*np.pi/180, 5449, mass_orbit)
bodies.append(Body(position_neptune, velocity_neptune, 1.024 * (10**26), 24600000, 'Neptune', True, 'dodgerblue'))
return bodies
def main():
sun = Body(1.98892e30, 0, 0, 0, 0, 15, 1, 1, 0)
mercury = Body(3.295e23, 5.791e7 * 1000, 0, 0, 47890, 2, .596, .596, .596)
venus = Body(4.867e24, 1.082e8 * 1000, 0, 0, 35040, 4, 1, .5, 0)
earth = Body(5.972e24, 1.496e8 * 1000, 0, 0, 29790, 5, 0, 0, 1)
mars = Body(6.39e23, 2.279e8 * 1000, 0, 0, 24140, 3, 1, 0, 0)
solar_system = System([sun, mercury, venus, earth, mars])
set_clear_color(0, 0, 0)
enable_smoothing()
while not window_closed():
clear()
solar_system.draw(WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2,
PIXELS_PER_METER)
solar_system.update(TIMESTEP * TIME_SCALE)
request_redraw()
sleep(TIMESTEP)
def setUp(self):
from body import Body
from database import AbilitiesDataBase
from abilities import a_test
ab_db = AbilitiesDataBase()
ab_db.addAbility(0,a_test.Test())
self.b = Body()
self.b.abilitiesDataBase(ab_db)
class BodyTest(unittest.TestCase):
def setUp(self):
from body import Body
from database import AbilitiesDataBase
from abilities import a_test
ab_db = AbilitiesDataBase()
ab_db.addAbility(0,a_test.Test())
self.b = Body()
self.b.abilitiesDataBase(ab_db)
def test_abilitiesDataBase(self):
from database import AbilitiesDataBase
ab_db = AbilitiesDataBase()
self.b.abilitiesDataBase(ab_db)
def test_do_empty(self):
data = self.b.do([])
self.assertEqual(data,[])
def test_do(self):
from database import AbilityRecord,WordRecord
answer = self.b.do([AbilityRecord("[0]")])
for word in answer:
self.assertIsInstance(word,WordRecord)
answer = self.b.do([WordRecord("aaa"),WordRecord("bbb")])
self.assertIsInstance(answer[0],WordRecord)
self.assertIsInstance(answer[1],WordRecord)
self.assertEqual(answer[0],WordRecord("aaa"))
self.assertEqual(answer[1],WordRecord("bbb"))
def test_do_exception(self):
from database import AbilityRecord,WordRecord
from body import Body,BodyException
b = Body()
with self.assertRaises(BodyException):
b.do([AbilityRecord("[0]")])
with self.assertRaises(BodyException):
self.b.do([AbilityRecord("[1]")])
def bodys(self,
body_id,
name,
value_type,
value,
it_id,
body_type,
desc=None):
body = Body(body_id, name, value_type, value, it_id, body_type, desc)
self.bodys.append(body)
def grow(self):
"""
n precisa se preocupar com a posicao dessa nova parte do corpo, pois o metodo de movimento pega a ultima parte do corpo e coloca na frente
"""
# cria a nova parte do corpo
new_body = Body()
# adicina na lista de partes do corpo
self.body.append(new_body)
# adicina a lista de sprites
self.body_sprites.add(new_body)
def cuboid(geom=Geometry(), sigma=DEFAULT_SIGMA):
rnd = rand.Gauss(sigma)
body = Body(geom)
body.name = "Cuboid"
p = body.p
ey = body.e[1]
ez = body.e[2]
sy = [1, -1, -1, 1]
sz = [1, 1, -1, -1]
rad_bnd = [np.arctan2(sz[i]*ez, sy[i]*ey) for i in range(4)]
for i in range(4):
if rad_bnd[i] < 0:
rad_bnd[i] += 2*np.pi
for vi in xrange(body.n_alpha):
rad = body.rad_marks[vi]
my, mz = body.slope_marks[vi, :]
quadrant = np.argmax(rad < rad_bnd)
if quadrant == 0:
y = ey
z = ey * mz/my
elif quadrant == 1:
y = ez * my/mz
z = ez
elif quadrant == 2:
y = -ey
z = -ey * mz/my
elif quadrant == 3:
y = -ez * my/mz
z = -ez
else:
raise UnboundLocalError
for ui in xrange(len(body.x_marks)):
x = body.x_marks[ui]
x, y, z = rnd(x), rnd(y), rnd(z)
p[ui, vi] = [x, y, z]
return body
def __init__(self):
from neural import LookUpTableBrain
from body import Body
from voice import Voice
from neural import InnerVoice
import threading
self._brain = LookUpTableBrain()
self._body = Body()
self._voice = Voice()
self._inner_voices = InnerVoice()
self._inner_voices.jarvis(self)
self._word_db = None
self._traning_db = None
self._stop_event = threading.Event()
def __init__(self, field, cellid, x=None, y=None, vx=None, vy=None, major=None,
minor=None, gid=None, gsize=None, visible=None, frame=None):
# passed params
self.m_field = field
self.m_id = cellid
self.m_x = x
self.m_y = y
self.m_vx = vx
self.m_vy = vy
if major is None:
self.m_major = config.default_diam
self.m_body_diam = config.default_diam
self.m_diam = config.default_diam + config.diam_padding
else:
self.m_major = major
self.m_body_diam = major
self.m_diam = major + config.diam_padding
self.m_minor = minor
self.m_gid = gid
self.m_gsize = gsize
#TODO: Move this to graphics engine
self.m_diam = self.m_body_diam + config.diam_padding
if visible is None:
self.m_visible = True
#
# init vars
self.m_attr_dict = {}
self.m_conx_dict = {}
self.m_body = Body(field, cellid)
# create an array of leg instances
self.m_leglist = []
for i in range(config.max_legs):
self.m_leglist.append(Leg(field, cellid, i))
self.m_fromcenter = 0
self.m_fromnearest = 0
self.m_fromexit = 0
self.m_createtime = time()
self.m_updatetime = time()
self.m_frame = frame
self.m_history = []
def create_new_dict(name): datadict = Body.create_new_dict(name) datadict[Shot.FRAME_RANGE] = 0 return datadict
def __init__(self, config):
super(Brain, self).__init__()
self.body = Body(config) # acknowledge mortality
self.body.start() # begin lifelong struggle against gravity
def __init__(self):
self.sun = Body(0, 0, 0)
self.p1 = Body(500,90,-1)
self.p2 = Body(1000,90,5)
self.p3 = Body(2000,90,-3)
self.sun.setDay(0)
scheduler = Scheduler.getInstance()
# Start up the scheduling system with one worker per local core
for i in range(0, multiprocessing.cpu_count()):
scheduler.registerWorker(LocalWorker(i, 'wrk%i' % i))
scheduler.start()
movie_index = before_index
while movie_index < num_movie:
# If some images wsn't rendered, this script destructs this image series and re_rendering
fail_flag = False
# create a queue for tracking render jobs
queue = RenderQueue()
body = Body(Point(0, 9, 0), lower_body_flag)
shoulder_limits = {
'p': [-180, 25],
'y': [-90, 30],
'r': [-180 , 180]
}
elbow_limits = [0, 135]
hip_limits = {
'p': [-125, 15],
'y': [-90, 60],
'r': [-30, 70]
}
'type' : 'directional',
'direction' : Vector(0, 0, -1),
'irradiance' : Spectrum(50)
}
scheduler = Scheduler.getInstance()
# Start up the scheduling system with one worker per local core
for i in range(0, multiprocessing.cpu_count()):
scheduler.registerWorker(LocalWorker(i, 'wrk%i' % i))
scheduler.start()
# create a queue for tracking render jobs
queue = RenderQueue()
body = Body(Point(0, 9, 0))
shoulder_limits = {
'p': [-180, 25],
'y': [-90, 30],
'r': [-180 , 180]
}
elbow_limits = [0, 135]
hip_limits = {
'p': [-125, 15],
'y': [-90, 60],
'r': [-30, 70]
}
class Jarvis(object):
"""
Main Jarivs class
Attributes:
_brain - Brain object
_body - Body object
_word_db - Words database
_traning_db - Training database
_stop_event - Stop event
"""
def __init__(self):
from neural import LookUpTableBrain
from body import Body
from voice import Voice
from neural import InnerVoice
import threading
self._brain = LookUpTableBrain()
self._body = Body()
self._voice = Voice()
self._inner_voices = InnerVoice()
self._inner_voices.jarvis(self)
self._word_db = None
self._traning_db = None
self._stop_event = threading.Event()
def respond(self,request):
"""
This method responds to request
Input:
request - Request (string)
Returns:
answer
"""
from database import DataBaseException
from database import WordParser
from body import BodyException
from neural import BrainException
if self._word_db == None: raise JarvisException("Don't have dictionary.")
try:
request_coded = tuple(self._word_db.multipleWordId(WordParser(request).wordsList()))
except DataBaseException as error: raise JarvisException("Don't understand: " + request + " . Error: " + str(error))
try:
thought_coded = self._brain.think(request_coded)
except BrainException as error: raise JarvisException("Cannot replay to this request: " + request + " . Error: " + str(error))
try:
thought_tuple = self._word_db.multipleIdWord(thought_coded)
except DataBaseException as error: raise JarvisException("Cannot replay to this request: " + request + " . Error: " + str(error))
try:
answer_tuple = self._body.do(thought_tuple)
except BodyException as error: raise JarvisException("Cannot do this request: " + request + " . Error: " + str(error))
answer = " ".join([word.getValue() for word in answer_tuple])
self._voice.speak(answer)
return answer
def createWordsDataBase(self,builder):
"""
This method sets words database
Input:
builder - Word database builder
Returns:
Nothing
"""
self._word_db = builder.generateDataBase()
def createTrainingDataBase(self,builder):
"""
This method builds traning database
Input:
builder - Traning database builder
Returns:
Nothing
"""
self._traning_db = builder.generateDataBase()
def createInnerVoiceDatabase(self,builder):
"""
This method builds internal voice database
Input:
builder - Database builder
Returns:
Nothing
"""
self._inner_voices.innerVoices(builder.generateDataBase())
def createAbilitiesDataBase(self,builder):
"""
This method builds abilities database
Input:
builder - Abilities builder
Returns:
Nothing
"""
builder.jarvis(self)
self._body.abilitiesDataBase(builder.generateDataBase())
def train(self):
"""
Trains Jarvis brain
Input:
Nothing
Returns:
Nothing
"""
from trainer import Trainer
if self._word_db == None: raise JarvisException("Don't have dictionary.")
if self._traning_db == None: raise JarvisException("Don't have traning database.")
trainer = Trainer(self._word_db,self._traning_db)
trainer.train(self._brain)
def start(self):
"""
This method starts Jarvis internals
Input:
Nothing
Returns:
Nothing
"""
from neural import InnerVoiceException
try: self._inner_voices.start()
except InnerVoiceException as error: raise JarvisException(str(error))
self._stop_event.wait()
def stop(self):
"""
This method stops Jarvis internals
Input:
Nothing
Returns:
Nothing
"""
self._inner_voices.stop()
self._stop_event.set()
class Cell(object):
"""Represents one person/object on the floor.
Stores the following values:
m_field: store a back ref to the field that called us
m_id: the id of this cell (unique, but not enforced)
m_x, m_y: center of cell (coordinate tupple in m)
m_vx, m_vy: center of cell (coordinate tupple in m)
m_body_diam: diam of the person within the cell (m)
m_diam: diam of the cell surrounding the person (m)
m_visible: is this cell displayed currently? (boolean)
m_conx_dict: connectors attached to this cell (index by cid)
m_attr_dict: dict of attrs applied to this cell (indexed by type)
m_leglist: list of Leg objects
m_body: Body object
m_gid: GID of group this cell belongs to
m_fromcenter: dist cell is from geo center of everyone
m_fromnearest: dist cell is from another person
m_fromexit: dist cell is from exit
m_createtime: time that cell was created
m_updatetime: time that cell was last updated
m_frame: last frame in which we were updated
update: set center, readius, and attrs
geoupdate: set geo data for cell
set_attrs: add attrs to the attrs list
add_connector: add new connector to the list connected to this cell
del_connector: delete a connector from the list connected to this cell
"""
def __init__(self, field, cellid, x=None, y=None, vx=None, vy=None, major=None,
minor=None, gid=None, gsize=None, visible=None, frame=None):
# passed params
self.m_field = field
self.m_id = cellid
self.m_x = x
self.m_y = y
self.m_vx = vx
self.m_vy = vy
if major is None:
self.m_major = config.default_diam
self.m_body_diam = config.default_diam
self.m_diam = config.default_diam + config.diam_padding
else:
self.m_major = major
self.m_body_diam = major
self.m_diam = major + config.diam_padding
self.m_minor = minor
self.m_gid = gid
self.m_gsize = gsize
#TODO: Move this to graphics engine
self.m_diam = self.m_body_diam + config.diam_padding
if visible is None:
self.m_visible = True
#
# init vars
self.m_attr_dict = {}
self.m_conx_dict = {}
self.m_body = Body(field, cellid)
# create an array of leg instances
self.m_leglist = []
for i in range(config.max_legs):
self.m_leglist.append(Leg(field, cellid, i))
self.m_fromcenter = 0
self.m_fromnearest = 0
self.m_fromexit = 0
self.m_createtime = time()
self.m_updatetime = time()
self.m_frame = frame
self.m_history = []
def update(self, x=None, y=None, vx=None, vy=None, major=None,
minor=None, gid=None, gsize=None, visible=None, frame=None):
"""Store basic info and create a DataElement object"""
if x is not None:
self.m_x = x
if y is not None:
self.m_y = y
if vx is not None:
self.m_vx = vx
if vy is not None:
self.m_vy = vy
if major is not None:
self.m_major = major
self.m_body_diam = major
self.m_diam = major + config.diam_padding
if minor is not None:
self.m_minor = minor
if gid is not None:
self.m_gid = gid
if gsize is not None:
self.m_gsize = gsize
if visible is not None:
self.m_visible = visible
if frame is not None:
self.m_frame = frame
self.m_updatetime = time()
def geoupdate(self, fromcenter=None, fromnearest=None, fromexit=None):
"""Store geo data for cell."""
if fromcenter is not None:
self.m_fromcenter = fromcenter
if fromnearest is not None:
self.m_fromnearest = fromnearest
if fromexit is not None:
self.m_fromexit = fromexit
self.m_updatetime = time()
def update_body(self, x=None, y=None, ex=None, ey=None,
spd=None, espd=None, facing=None, efacing=None,
diam=None, sigmadiam=None, sep=None, sigmasep=None,
leftness=None, vis=None):
self.m_body.update(x, y, ex, ey, spd, espd, facing, efacing, diam, sigmadiam,
sep, sigmasep, leftness, vis)
def update_leg(self, leg, nlegs=None, x=None, y=None,
ex=None, ey=None, spd=None, espd=None,
heading=None, eheading=None, vis=None):
self.m_leglist[leg].update(nlegs, x, y, ex, ey, spd, espd, heading, eheading, vis)
def add_attr(self, atype, value):
self.m_attr_dict[atype] = Attr(atype, self.m_id, value)
def update_attr(self, atype, value, aboveTrigger=False):
if atype not in self.m_attr_dict:
assert aboveTrigger # Must be above trigger if we are creating it
self.m_attr_dict[atype] = Attr(atype, self.m_id, value)
else:
self.m_attr_dict[atype].update(value, aboveTrigger)
def del_attr(self, atype):
if atype in self.m_attr_dict:
del self.m_attr_dict[atype]
def add_connector(self, connector):
self.m_conx_dict[connector.m_id] = connector
def del_connector(self, connector):
if connector.m_id in self.m_conx_dict:
del self.m_conx_dict[connector.m_id]
def cell_disconnect(self):
"""Disconnects all the connectors and refs it can reach.
To actually delete it, remove it from the list of cells in the Field
class.
"""
logger.debug("cell_disconnect "+str(self.m_id))
# we make a copy because we can't iterate over the dict if we are
# deleting stuff from it!
new_conx_dict = self.m_conx_dict.copy()
# for each connector attached to this cell...
for connector in new_conx_dict.values():
# OPTION: for simplicity's sake, we do the work rather than passing to
# the object to do the work
# delete the connector from its two cells
if connector.m_id in connector.m_cell0.m_conx_dict:
del connector.m_cell0.m_conx_dict[connector.m_id]
if connector.m_id in connector.m_cell1.m_conx_dict:
del connector.m_cell1.m_conx_dict[connector.m_id]
# delete cells ref'd from this connector
connector.m_cell0 = None
connector.m_cell1 = None
# now delete from this cell's list
if connector.m_id in self.m_conx_dict:
del self.m_conx_dict[connector.m_id]
# OPTION: Let the objects do the work
#connector.conx_disconnect_thyself()
# we may not need this because the connector calls the same thing
# for it's two cells, including this one
#self.del_connector(connector)
def record_history(self, atype, uid, value, htime):
self.m_history.append(Journal(atype, self.m_id, uid, value, htime))
def get_history(self, uid1):
shared_history = []
for entry in self.m_history:
if entry.uid1 == uid1:
shared_history.append(entry)
return shared_history
def have_history(self, uid1):
for entry in self.m_history:
if entry.uid == uid1:
return True
return False
'type' : 'ldsampler',
'sampleCount' : 16
}
}
integrator_prop = {
'type' : 'path'
}
emitter_prop = {
'type' : 'directional',
'direction' : Vector(0, -1, 0),
'irradiance' : Spectrum(50)
}
body = Body(Point(0, 9, 30))
body.left_arm.set_slocal_rotate_angle(0, 0, 180)
body.right_arm.set_slocal_rotate_angle(0, 0, 180)
body.left_leg.set_hlocal_rotate_angle(0, 0, 180)
body.right_leg.set_hlocal_rotate_angle(0, 0, 180)
# create a queue for tracking render jobs
queue = RenderQueue()
# rendering again
for target in target_list:
# open json file
with open(target) as f:
json_data = json.load(f)
# Set angle parameters from json data (not json file!)
def __init__(self, x, y, shape_index):
Body.__init__(self, MOLD1)
self.shape_index = shape_index
self.set_position(x, y)
def _newtons_rock(self, speed):
body = Body((10.0, EARTH_R + self.sim.MOUNTAIN_HEIGHT, 10.0), (speed, 0.0, 0.0), 0.0, (0.5, 0.5, 0.5, 0.5))
body.orbit_end = 270
body.pos_viz_mode = Body.POSITION_VISUALISATIONS['dot']
body.orbit_viz_mode = Body.ORBIT_VISUALISATIONS['orbit']
return body
def render_one_movie(parameter_list):
# parameter_list = [num_images, movie_index, num_process]
# settings
lower_body_flag = False
first_person_vire_flag = True
lr_flip_flag = False
generate_json_flag = True
sensor_prop = {'type' : 'perspective'}
if first_person_vire_flag:
sensor_prop['fov'] = 120.0
sensor_prop['toWorld'] = Transform.lookAt(
Point(0, 15+9, 3.5), # Camera origin
Point(0, 9+9, 28.5), # Camera target
Vector(0, 1, 0) # 'up' vector
)
else:
sensor_prop['toWorld'] = Transform.lookAt(
Point(0, 0, 95), # Camera origin
Point(0, 0, 0), # Camera target
Vector(0, 1, 0) # 'up' vector
)
sensor_prop['film'] = {
'type' : 'ldrfilm',
'width' : 64,
'height' : 64,
'banner' : False
}
sensor_prop['sample'] = {
'type' : 'ldsampler',
'sampleCount' : 16
}
integrator_prop = {
'type' : 'path'
}
emitter_prop = {'type' : 'directional'}
emitter_prop['irradiance'] = Spectrum(50)
if first_person_vire_flag:
emitter_prop['direction'] = Vector(0, -1, 0)
else:
emitter_prop['direction'] = Vector(0, 0, -1)
scheduler = Scheduler.getInstance()
# Start up the scheduling system with one worker per local core
for i in range(0, multiprocessing.cpu_count() / parameter_list[2]):
scheduler.registerWorker(LocalWorker(i, 'wrk%i' % i))
scheduler.start()
# create a queue for tracking render jobs
queue = RenderQueue()
body = Body(Point(0, 9, 0), lower_body_flag)
shoulder_limits = {
'p': [-180, 25],
'y': [-90, 30],
'r': [-180 , 180]
}
elbow_limits = [0, 135]
hip_limits = {
'p': [-125, 15],
'y': [-90, 60],
'r': [-30, 70]
}
knee_limits = [0, 150]
left_shoulder_angles = {
'p': -85,
'y': -30,
'r': 0
}
right_shoulder_angles = {
'p': -85,
'y': -30,
'r': 0
}
left_elbow_angle = 70
right_elbow_angle = 70
prev_left_shoulder_angles = {}
prev_right_shoulder_angles = {}
prev_left_elbow_angle = 0
prev_right_elbow_angle = 0
body.left_arm.set_joint_angles(left_shoulder_angles['p'], left_shoulder_angles['y'], left_shoulder_angles['r'], left_elbow_angle)
body.right_arm.set_joint_angles(right_shoulder_angles['p'], right_shoulder_angles['y'], right_shoulder_angles['r'], right_elbow_angle)
if lower_body_flag:
left_hip_angles = {
'p': -55,
'y': -15,
'r': 20
}
right_hip_angles = {
'p': -55,
'y': -15,
'r': 20
}
left_knee_angle = 75
right_knee_angle = 75
prev_left_hip_angles = {}
prev_right_hip_angles = {}
prev_left_knee_angle = 0
prev_right_knee_angle = 0
body.left_leg.set_joint_angles(left_hip_angles['p'], left_hip_angles['y'], left_hip_angles['r'], left_knee_angle)
body.right_leg.set_joint_angles(right_hip_angles['p'], right_hip_angles['y'], right_hip_angles['r'], right_knee_angle)
index = 0
target_list = ['mit_body_v2_%03i_%05i' % (parameter_list[1], i+1) + '.png' for i in xrange(parameter_list[0])]
if not generate_json_flag:
json_list = ['mit_body_v2_%03i_%05i' % (parameter_list[1], i+1)+ '.json' for i in xrange(parameter_list[0])]
if generate_json_flag:
# Normal run (generating json & png images)
while (index < parameter_list[0]):
destination = 'mit_body_v2_%03i_%05i' % (parameter_list[1], index+1)
scene = Scene()
pmgr = PluginManager.getInstance()
# Create a sensor, film & sample generator
scene.addChild(pmgr.create(sensor_prop))
# Set the integrator
scene.addChild(pmgr.create(integrator_prop))
# Add a light source
scene.addChild(pmgr.create(emitter_prop))
prev_left_shoulder_angles = left_shoulder_angles
prev_right_shoulder_angles = right_shoulder_angles
prev_left_elbow_angle = left_elbow_angle
prev_right_elbow_angle = right_elbow_angle
if lower_body_flag:
prev_left_hip_angles = left_hip_angles
prev_right_hip_angles = right_hip_angles
prev_left_knee_angle = left_knee_angle
prev_right_knee_angle = right_knee_angle
temp1 = left_shoulder_angles['p'] + randint(-1, 2)
if ((temp1 < shoulder_limits['p'][0]) or (temp1 > shoulder_limits['p'][1])):
continue
temp2 = left_shoulder_angles['y'] + randint(-1, 2)
if ((temp2 < shoulder_limits['y'][0]) or (temp2 > shoulder_limits['y'][1])):
continue
temp3 = left_shoulder_angles['r'] + randint(-1, 2)
if ((temp3 < shoulder_limits['r'][0]) or (temp3 > shoulder_limits['r'][1])):
continue
temp4 = right_shoulder_angles['p'] + randint(-1, 2)
if ((temp4 < shoulder_limits['p'][0]) or (temp4 > shoulder_limits['p'][1])):
continue
temp5 = right_shoulder_angles['y'] + randint(-1, 2)
if ((temp5 < shoulder_limits['y'][0]) or (temp5 > shoulder_limits['y'][1])):
continue
temp6 = right_shoulder_angles['r'] + randint(-1, 2)
if ((temp6 < shoulder_limits['r'][0]) or (temp6 > shoulder_limits['r'][1])):
continue
temp7 = left_elbow_angle + randint(-1, 2)
if ((temp7 < elbow_limits[0]) or (temp7 > elbow_limits[1])):
continue
temp8 = right_elbow_angle + randint(-1, 2)
if ((temp8 < elbow_limits[0]) or (temp8 > elbow_limits[1])):
continue
if lower_body_flag:
temp9 = left_hip_angles['p'] + randint(-1, 2)
if ((temp9 < hip_limits['p'][0]) or (temp9 > hip_limits['p'][1])):
continue
temp10 = left_hip_angles['y'] + randint(-1, 2)
if ((temp10 < hip_limits['y'][0]) or (temp10 > hip_limits['y'][1])):
continue
temp11 = left_hip_angles['r'] + randint(-1, 2)
if ((temp11 < hip_limits['r'][0]) or (temp11 > hip_limits['r'][1])):
continue
temp12 = right_hip_angles['p'] + randint(-1, 2)
if ((temp12 < hip_limits['p'][0]) or (temp12 > hip_limits['p'][1])):
continue
temp13 = right_hip_angles['y'] + randint(-1, 2)
if ((temp13 < hip_limits['y'][0]) or (temp13 > hip_limits['y'][1])):
continue
temp14 = right_hip_angles['r'] + randint(-1, 2)
if ((temp14 < hip_limits['r'][0]) or (temp14 > hip_limits['r'][1])):
continue
temp15 = left_knee_angle + randint(-1, 2)
if ((temp15 < knee_limits[0]) or (temp15 > knee_limits[1])):
continue
temp16 = right_knee_angle + randint(-1, 2)
if ((temp16 < knee_limits[0]) or (temp16 > knee_limits[1])):
continue
left_shoulder_angles = dict(zip(['p', 'y', 'r'], [temp1, temp2, temp3]))
right_shoulder_angles = dict(zip(['p', 'y', 'r'], [temp4, temp5, temp6]))
left_elbow_angle = temp7
right_elbow_angle = temp8
if lower_body_flag:
left_hip_angles = dict(zip(['p', 'y', 'r'], [temp9, temp10, temp11]))
right_hip_angles = dict(zip(['p', 'y', 'r'], [temp12, temp13, temp14]))
left_knee_angle = temp15
right_knee_angle = temp16
body.left_arm.set_joint_angles(left_shoulder_angles['p'], left_shoulder_angles['y'], left_shoulder_angles['r'], left_elbow_angle)
body.right_arm.set_joint_angles(right_shoulder_angles['p'], right_shoulder_angles['y'], right_shoulder_angles['r'], right_elbow_angle)
if lower_body_flag:
body.left_leg.set_joint_angles(left_hip_angles['p'], left_hip_angles['y'], left_hip_angles['r'], left_knee_angle)
body.right_leg.set_joint_angles(right_hip_angles['p'], right_hip_angles['y'], right_hip_angles['r'], right_knee_angle)
cur_left_elbow = body.left_arm.calc_elbow_point()
cur_right_elbow = body.right_arm.calc_elbow_point()
cur_left_hand = body.left_arm.calc_hand_point()
cur_left_hand = body.right_arm.calc_hand_point()
departure_flag = (cur_left_elbow.z < 0) or (cur_right_elbow.z < 0) or (cur_left_hand.z < 0) or (cur_left_hand.z < 0)
if ((body.is_collision_body_parts() == False) and (departure_flag == False)):
print '\033[94mcollision detection passed!\033[0m'
# Add body parts
for prop in body.get_property_list():
scene.addChild(pmgr.create(prop))
json_data = body.constr_json_data()
with open('mit_body_v2_%05i.json' % (index + 1), 'w') as f:
json.dump(json_data, f, indent=2)
scene.configure()
scene.setDestinationFile(destination)
# Create a render job and insert it into the queue
job = RenderJob('myRenderJob' + str(index), scene, queue)
while True:
# Check current number of thread
num_thread = queue.getJobCount()
if num_thread > 1000:
time.sleep(1)
else:
break
job.start()
# Increment index
index += 1
else:
body.left_arm.set_joint_angles(prev_left_shoulder_angles['p'], prev_left_shoulder_angles['y'], prev_left_shoulder_angles['r'], prev_left_elbow_angle)
body.right_arm.set_joint_angles(prev_right_shoulder_angles['p'], prev_right_shoulder_angles['y'], prev_right_shoulder_angles['r'], prev_right_elbow_angle)
left_shoulder_angles['p'] = prev_left_shoulder_angles['p']
left_shoulder_angles['y'] = prev_left_shoulder_angles['y']
left_shoulder_angles['r'] = prev_left_shoulder_angles['r']
right_shoulder_angles['p'] = prev_right_shoulder_angles['p']
right_shoulder_angles['y'] = prev_right_shoulder_angles['y']
right_shoulder_angles['r'] = prev_right_shoulder_angles['r']
left_elbow_angle = prev_left_elbow_angle
right_elbow_angle = prev_right_elbow_angle
if lower_body_flag:
body.left_leg.set_joint_angles(prev_left_hip_angles['p'], prev_left_hip_angles['y'], prev_left_hip_angles['r'], prev_left_knee_angle)
body.right_leg.set_joint_angles(prev_right_hip_angles['p'], prev_right_hip_angles['y'], prev_right_hip_angles['r'], prev_right_knee_angle)
left_hip_angles['p'] = prev_left_hip_angles['p']
left_hip_angles['y'] = prev_left_hip_angles['y']
left_hip_angles['r'] = prev_left_hip_angles['r']
right_hip_angles['p'] = prev_right_hip_angles['p']
right_hip_angles['y'] = prev_right_hip_angles['y']
right_hip_angles['r'] = prev_right_hip_angles['r']
left_knee_angle = prev_left_knee_angle
right_knee_angle = prev_right_knee_angle
print '--------------------------------------'
# wait for all jobs to finish and release resource
queue.waitLeft(0)
queue.join()
# Print some statistics about the rendering process
print(Statistics.getInstance().getStats())
else:
# re-rendering run (generating only png images)
for index, target_json in enumerate(json_list):
# open json file
with open(target_json) as f:
json_data = json.load(f)
# Set angle parameters from json data (not json file!)
body.set_from_json_data(json_data)
destination = target_json.split('.')[0]
scene = Scene()
pmgr = PluginManager.getInstance()
# Create a sensor, film & sample generator
scene.addChild(pmgr.create(sensor_prop))
# Set the integrator
scene.addChild(pmgr.create(integrator_prop))
# Add a light source
scene.addChild(pmgr.create(emitter_prop))
# Add body parts
for prop in body.get_property_list():
scene.addChild(pmgr.create(prop))
scene.configure()
scene.setDestinationFile(destination)
# Create a render job and insert it into the queue
job = RenderJob('myRenderJob' + str(index), scene, queue)
job.start()
# wait for all jobs to finish and release resource
queue.waitLeft(0)
queue.join()
# Print some statistics about the rendering process
print(Statistics.getInstance().getStats())
while True:
print 'Now, Check rendering results and repeat rendering'
# check png file existence
flag_list = file_checker(target_list)
if flag_list.count(False) == 0:
break
# create a queue for tracking render jobs
queue = RenderQueue()
# rendering again
for i, flag in enumerate(flag_list):
if not flag:
# open json file
with open('mit_body_v2_%05i.json' % (i+1)) as f:
json_data = json.load(f)
# Set angle parameters from json data (not json file!)
body.set_from_json_data(json_data)
destination = 'mit_body_v2_%05i' % (i+1)
scene = Scene()
pmgr = PluginManager.getInstance()
# Create a sensor, film & sample generator
scene.addChild(pmgr.create(sensor_prop))
# Set the integrator
scene.addChild(pmgr.create(integrator_prop))
# Add a light source
scene.addChild(pmgr.create(emitter_prop))
# Add body parts
for prop in body.get_property_list():
scene.addChild(pmgr.create(prop))
scene.configure()
scene.setDestinationFile(destination)
# Create a render job and insert it into the queue
job = RenderJob('myRenderJob' + str(i), scene, queue)
job.start()
# wait for all jobs to finish and release resource
queue.waitLeft(0)
queue.join()
# Print some statistics about the rendering process
print(Statistics.getInstance().getStats())
# left right flip process (Third-persoon point of view vs. Mirror image)
if lr_flip_flag:
print 'Now, generating mirror images'
for target in target_list:
img = Image.open(target)
lr_flip_img = img.transpose(Image.FLIP_LEFT_RIGHT)
lr_flip_img.save(target.split('.')[0] + 'mirror.png')
def __init__(self):
Body.__init__(self, BODY1)
self.set_position(LEVEL_LEFT, \
LEVEL_TOP+LEVEL_HEIGHT/2-BODY_HEIGHT/2)
import math
from body import Body
from simulation import Simulation
from renderer import Renderer
##################
# Simulation setup
AU = (149.6e6 * 1000) # 149.6 million km, in meters.
timestep = 24*3600
sim = Simulation()
sun = Body('Sun')
sun.mass = 1.98892e30
sim.add_body(sun)
mercury = Body('Mercury')
mercury.mass = 3.3e23
mercury.x = 0.387 * AU
mercury.vy = 47362
sim.add_body(mercury)
venus = Body('Venus')
venus.mass = 4.8685e24
venus.x = 0.723 * AU
venus.vy = 35020
sim.add_body(venus)
earth = Body('Earth')
earth.mass = 5.9742e29
def __init__(self, master):
Body.__init__(self, master, [Chest, Head, Legs], 'Human')
self.make_animation(self.anim, 'Human', path)
