def updateWindow(self, map, combo):
self.viewer.geoms = []
for x in range(len(map)): # max_x == 5
for y in range(len(map[x])): # max_y == 6
Img = rendering.Image(self.paths[map[x][y]], self.STONE_WIDTH,
self.STONE_HEIGHT)
Img.add_attr(
rendering.Transform(translation=(25 + x * self.STONE_WIDTH,
75 +
y * self.STONE_HEIGHT)))
Img.set_color(1., 1., 1.)
self.viewer.add_geom(Img)
if combo < 0 or not type(combo) == int:
self.viewer.render()
return
nums = []
end = False
while not end:
if combo < 10: #個位數是最後一次
end = True
num = combo % 10
print("num為{0}".format(num))
combo = int(combo / 10)
nums.insert(0, num)
print('最後結果為:{0}'.format(nums))
for i in range(len(nums)):
Img = rendering.Image(self.n_paths[nums[i]], self.NUM_WIDTH,
self.NUM_HEIGHT)
print('位於 {0}'.format((25 + i * 35, 25)))
Img.add_attr(rendering.Transform(translation=(25 + i * 35, 25)))
Img.set_color(1., 1., 1.)
self.viewer.add_geom(Img)
self.viewer.render()
def render(self, mode='human'):
red = Color('red')
colors = list(red.range_to(Color('green'), self.num_agents))
if self.viewer is None:
self.viewer = rendering.Viewer(map_width * 5, map_height * 5)
self.viewer.set_bounds(0, map_width, 0, map_height)
for id, aircraft in self.aircraft_dict.ac_dict.items():
aircraft_img = rendering.Image(os.getcwd() + '/images/plane1.png',
5, 5)
heading_img = rendering.Transform(rotation=aircraft.heading -
math.pi / 2,
translation=aircraft.position)
aircraft_img.add_attr(heading_img)
r, g, b = colors[int(aircraft.id) % self.num_agents].get_rgb()
aircraft_img.set_color(r, g, b)
self.viewer.onetime_geoms.append(aircraft_img)
goal_img = rendering.Image(os.getcwd() + '/images/runway.png',
goal_radius, goal_radius)
heading_img = rendering.Transform(rotation=math.radians(rwy_degree) -
math.pi / 2,
translation=self.airport.position)
goal_img.add_attr(heading_img)
r, g, b = Color('white').get_rgb()
goal_img.set_color(r, g, b)
self.viewer.onetime_geoms.append(goal_img)
return self.viewer.render(return_rgb_array=False)
def render(self, mode="human"):
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(1000, 1000)
self.viewer.set_bounds(-2.5, 2.5, -2.5, 2.5)
fname = path.dirname(__file__) + "/classic/assets/lds_arrow.png"
self.img = rendering.Image(fname, 0.35, 0.35)
self.img.set_color(1.0, 1.0, 1.0)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
fnamewind = path.dirname(__file__) + "/classic/assets/lds_grid.png"
self.imgwind = rendering.Image(fnamewind, 5.0, 5.0)
self.imgwind.set_color(0.5, 0.5, 0.5)
self.imgtranswind = rendering.Transform()
self.imgwind.add_attr(self.imgtranswind)
self.viewer.add_onetime(self.imgwind)
self.viewer.add_onetime(self.img)
cur_x, cur_y = self.imgtrans.translation
# new_x, new_y = self.state[0], self.state[1]
new_x, new_y = jnp.dot(self.state.squeeze(),
self.proj_vector1), jnp.dot(
self.state.squeeze(), self.proj_vector2)
diff_x = new_x - cur_x
diff_y = new_y - cur_y
new_rotation = jnp.arctan2(diff_y, diff_x)
self.imgtrans.set_translation(new_x, new_y)
self.imgtrans.set_rotation(new_rotation)
return self.viewer.render(return_rgb_array=mode == "rgb_array")
def render(self, mode='human'):
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.Viewer(self.window_width,
self.window_height)
self.viewer.set_bounds(0, self.window_width, 0, self.window_height)
# if self.drone is None:
# return None
import os
__location__ = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__)))
# draw red aircraft
pos, _, att, pos_hist = self._redAC.get_sta()
red_ac_img = rendering.Image(
os.path.join(__location__, 'images/f16_red.png'), 36, 36)
jtransform = rendering.Transform(rotation=-att[2],
translation=np.array([pos[1],
pos[0]]))
red_ac_img.add_attr(jtransform)
self.viewer.onetime_geoms.append(red_ac_img)
self.viewer.draw_polyline(pos_hist[::5, [-2, -3]], ).set_color(1, 0, 0)
transform2 = rendering.Transform(translation=(self.goal_pos[1],
self.goal_pos[0]))
self.viewer.draw_circle(5).add_attr(transform2)
transform2 = rendering.Transform(translation=(self.goal_pos[1],
self.goal_pos[0]))
self.viewer.draw_circle(50, filled=False).add_attr(transform2)
transform3 = rendering.Transform(translation=(pos[1], pos[0]))
self.viewer.draw_circle(250, filled=False).add_attr(transform3)
l, r, t, b = 0, 10, -pos[2] / self.window_z * self.window_height, 0
cart = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
cart.set_color(1, 0, 0)
self.viewer.add_onetime(cart)
# draw blue aircraft
pos, _, att, pos_hist = self._blueAC.get_sta()
blue_ac_img = rendering.Image(
os.path.join(__location__, 'images/f16_blue.png'), 36, 36)
jtransform = rendering.Transform(rotation=-att[2],
translation=np.array([pos[1],
pos[0]]))
blue_ac_img.add_attr(jtransform)
self.viewer.onetime_geoms.append(blue_ac_img)
self.viewer.draw_polyline(pos_hist[::5, [-2, -3]]).set_color(0, 0, 1)
l, r, t, b = 10, 20, -pos[2] / self.window_z * self.window_height, 0
cart = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)])
cart.set_color(0, 0, 1)
self.viewer.add_onetime(cart)
return self.viewer.render(return_rgb_array=mode == "rgb_array")
def __init__(self, env):
self.env = env
self.sim = env.sim
self.pathTrace = 30
self.pathTraceSpace = 2
self.pathTraceSpaceCounter = 0
self.path = np.zeros([self.pathTrace, 2])
self.pathPtr = 0
# Set the display window size and range
self.viewer = rendering.Viewer(500, 500)
self.viewer.set_bounds(-self.sim.FIELD_SIZE, self.sim.FIELD_SIZE,
-self.sim.FIELD_SIZE,
self.sim.FIELD_SIZE) # Scale (X,X,Y,Y)
# Create the robot
fname = path.join(path.dirname(__file__), "assets/robot.png")
self.robotobj = rendering.Image(fname, .25, .25)
self.robot_t = rendering.Transform()
self.robotobj.add_attr(self.robot_t)
# Create the target goal
fname = path.join(path.dirname(__file__), "assets/target.png")
self.targetobj = rendering.Image(fname, .3, .3)
self.targetobj.set_color(255, 0, 0)
self.target_t = rendering.Transform()
self.targetobj.add_attr(self.target_t)
# Create the goal location
#self.goalobj = rendering.make_circle(.1)
#self.goalobj.set_color(255, 0, 0)
#self.goal_t = rendering.Transform()
#self.goalobj.add_attr(self.goal_t)
#self.viewer.add_geom(self.goalobj)
#self.goal_t.set_translation(*self.env.goal_pos)
# Create trace path
self.traceobj = []
self.traceobj_t = []
for i in range(self.pathTrace):
self.traceobj.append(
rendering.make_circle(.02 + .03 * i / self.pathTrace))
# print(.5 * i / self.pathTrace, 1. - .5 * i / self.pathTrace, i / self.pathTrace)
self.traceobj[i].set_color(
.5 - .5 * i / self.pathTrace, 1. - .5 * i / self.pathTrace,
i / self.pathTrace) # Setting the color gradiant for path
self.traceobj_t.append(rendering.Transform())
self.traceobj[i].add_attr(self.traceobj_t[i])
self.traceobj_t[i].set_translation(-2 + i * 0.05, 0)
self.viewer.add_geom(self.traceobj[i])
self.goalPathobj = []
self.goalPathobj_t = []
for i in range(1, len(self.env.path)):
self.goalPathobj.append(
rendering.Line(self.env.path[i - 1], self.env.path[i]))
self.goalPathobj[i - 1].set_color(1., 0, 0)
self.viewer.add_geom(self.goalPathobj[i - 1])
def render(self, mode='human'):
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.Viewer(self.window_width,
self.window_height)
self.viewer.set_bounds(0, self.window_width, 0, self.window_height)
# if self.drone is None:
# return None
import os
__location__ = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__)))
# draw red aircraft
pos, _, att, pos_hist = self._redAC.get_sta()
red_ac_img = rendering.Image(
os.path.join(__location__, 'images/f16_red.png'), 48, 48)
jtransform = rendering.Transform(rotation=-att[2],
translation=np.array([pos[1],
pos[0]]))
red_ac_img.add_attr(jtransform)
self.viewer.onetime_geoms.append(red_ac_img)
self.viewer.draw_polyline(pos_hist[::5, [-2, -3]], )
transform2 = rendering.Transform(
translation=(self.goal_pos[1],
self.goal_pos[0])) # Relative offset
self.viewer.draw_circle(5).add_attr(transform2)
transform2 = rendering.Transform(
translation=(self.goal_pos[1],
self.goal_pos[0])) # Relative offset
self.viewer.draw_circle(50, filled=False).add_attr(transform2)
transform3 = rendering.Transform(
translation=(pos[1], pos[0])) # red dangerous circle
self.viewer.draw_circle(250, filled=False).add_attr(transform3)
# draw blue aircraft
pos, _, att, pos_hist = self._blueAC.get_sta()
blue_ac_img = rendering.Image(
os.path.join(__location__, 'images/f16_blue.png'), 48, 48)
jtransform = rendering.Transform(rotation=-att[2],
translation=np.array([pos[1],
pos[0]]))
blue_ac_img.add_attr(jtransform)
self.viewer.onetime_geoms.append(blue_ac_img)
self.viewer.draw_polyline(pos_hist[::5, [-2, -3]])
return self.viewer.render(return_rgb_array=False)
def render(self, mode='human'):
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.Viewer(self.window_width, self.window_height)
self.viewer.set_bounds(0, self.window_width, 0, self.window_height)
if self.drone is None:
return None
import os
__location__ = os.path.realpath(os.path.join(os.getcwd(), os.path.dirname(__file__)))
# draw ownship
ownship_img = rendering.Image(os.path.join(__location__, 'images/aircraft.png'), 32, 32)
jtransform = rendering.Transform(rotation=self.drone.heading - math.pi / 2, translation=self.drone.position)
ownship_img.add_attr(jtransform)
ownship_img.set_color(255, 241, 4) # set it to yellow
self.viewer.onetime_geoms.append(ownship_img)
self.own_hist.append( self.drone.position.copy() )
# draw goal
goal_img = rendering.Image(os.path.join(__location__, 'images/goal.png'), 32, 32)
jtransform = rendering.Transform(rotation=0, translation=self.goal.position)
goal_img.add_attr(jtransform)
goal_img.set_color(15, 210, 81) # green
self.viewer.onetime_geoms.append(goal_img)
# draw intruders
for i, aircraft in enumerate(self.intruder_list):
intruder_img = rendering.Image(os.path.join(__location__, 'images/intruder.png'), 32, 32)
jtransform = rendering.Transform(rotation=aircraft.heading - math.pi / 2, translation=aircraft.position)
intruder_img.add_attr(jtransform)
intruder_img.set_color(237, 26, 32) # red color
self.viewer.onetime_geoms.append(intruder_img)
self.int_hist[ i ].append( aircraft.position.copy() )
#print( np.array( self.own_hist ) )
#print( np.array( self.int_hist ) )
hist_pt = Points( self.own_hist )
self.viewer.onetime_geoms.append(hist_pt)
for i, aircraft in enumerate(self.intruder_list):
hist_pt = Points( self.int_hist[i] )
self.viewer.onetime_geoms.append(hist_pt)
return self.viewer.render(return_rgb_array=False)
def render(self, mode='human'):
from gym.envs.classic_control import rendering
from colour import Color
red = Color('red')
colors = list(red.range_to(Color('green'), self.num_aircraft))
if self.viewer is None:
self.viewer = rendering.Viewer(self.window_width,
self.window_height)
self.viewer.set_bounds(0, self.window_width, 0, self.window_height)
import os
__location__ = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__)))
# plot the annulus
# inner_circle_img = rendering.make_circle(radius=10000 / Config.scale, res=50, filled=False)
# outer_circle_img = rendering.make_circle(radius=15000 / Config.scale, res=50, filled=False)
# jtransform = rendering.Transform(rotation=0, translation=(400, 400))
# inner_circle_img.add_attr(jtransform)
# outer_circle_img.add_attr(jtransform)
# self.viewer.onetime_geoms.append(inner_circle_img)
# self.viewer.onetime_geoms.append(outer_circle_img)
# draw all the aircraft
for id, aircraft in self.aircraft_dict.ac_dict.items():
aircraft_img = rendering.Image(
os.path.join(__location__, 'images/aircraft.png'), 32, 32)
jtransform = rendering.Transform(rotation=aircraft.heading -
math.pi / 2,
translation=aircraft.position)
aircraft_img.add_attr(jtransform)
r, g, b = colors[aircraft.id % self.num_aircraft].get_rgb()
# r, g, b = black.get_rgb()
aircraft_img.set_color(r, g, b)
self.viewer.onetime_geoms.append(aircraft_img)
goal_img = rendering.Image(
os.path.join(__location__, 'images/goal.png'), 20, 20)
jtransform = rendering.Transform(
rotation=0, translation=aircraft.goal.position)
goal_img.add_attr(jtransform)
goal_img.set_color(r, g, b)
self.viewer.onetime_geoms.append(goal_img)
# plot the line connecting aircraft and its goal
# line = rendering.DashedLine(start=aircraft.position, end=aircraft.goal.position)
# self.viewer.onetime_geoms.append(line)
return self.viewer.render(return_rgb_array=False)
def draw_rocks(self, type_='box', fname='imgs/rocksample/rock.jpeg'):
drawn_rocks, shift, recs = [], 0, []
shift = 0.5
for rock in self.components['rocks']:
drawn_rocks.append(rendering.Transform())
try:
with open(fname):
figure = rendering.Image(fname, \
width=0.5 * self.draw_scale, height=0.5 * self.draw_scale)
figure.add_attr(drawn_rocks[-1])
x = 0.45 * self.draw_scale
rectangle = FilledPolygonCv4([(x, x), (-x, x), (-x, -x),
(x, -x)])
rectangle.add_attr(drawn_rocks[-1])
col = "red" if rock.type == "bad" else "green"
rectangle.set_color(self.colors[col][0],
self.colors[col][1],
self.colors[col][2], 1)
self.viewer.add_geom(rectangle)
self.viewer.add_geom(figure)
recs.append(rectangle)
except FileNotFoundError as e:
raise e
return drawn_rocks, shift, recs
def render(self, mode='human'):
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(500, 500)
self.viewer.set_bounds(-2.2, 2.2, -2.2, 2.2)
rod = rendering.make_capsule(1, .2)
rod.set_color(.8, .3, .3)
self.pole_transform = rendering.Transform()
rod.add_attr(self.pole_transform)
self.viewer.add_geom(rod)
axle = rendering.make_circle(.05)
axle.set_color(0, 0, 0)
self.viewer.add_geom(axle)
# YOU MUST GIVE THE PATH OF THE IMAGE FILE TO THE ARROW IN THE OPEN AI GYM INSTALATION
# fname='/home/paulo/.conda/envs/PythonControl/lib/python3.6/site-packages/gym/envs/classic_control/assets/clockwise.png'
fname = './clockwise.png'
# fname = path.join(path.dirname(__file__), "assets/clockwise.png")
self.img = rendering.Image(fname, 1., 1.)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
self.viewer.add_onetime(self.img)
self.pole_transform.set_rotation(self.state[0] + np.pi / 2)
if self.last_u:
self.imgtrans.scale = (-self.last_u / 2, np.abs(self.last_u) / 2)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def __call__(self, trajectory):
mode = 'human'
for timeStep in range(len(trajectory)):
state = trajectory[timeStep][0]
action = trajectory[timeStep][1]
action = np.clip(action, -self.max_torque, self.max_torque)[0]
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(500, 500)
self.viewer.set_bounds(-2.2, 2.2, -2.2, 2.2)
rod = rendering.make_capsule(1, .2)
rod.set_color(.8, .3, .3)
self.pole_transform = rendering.Transform()
rod.add_attr(self.pole_transform)
self.viewer.add_geom(rod)
axle = rendering.make_circle(.05)
axle.set_color(0, 0, 0)
self.viewer.add_geom(axle)
fname = path.join(path.dirname(__file__), "assets/clockwise.png")
self.img = rendering.Image(fname, 1., 1.)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
self.viewer.add_onetime(self.img)
self.pole_transform.set_rotation(state[0] + np.pi / 2)
self.imgtrans.scale = (-action/ 2, np.abs(action) / 2)
self.viewer.render(return_rgb_array=mode == 'rgb_array')
if self.viewer:
self.viewer.close()
self.viewer = None
return
def draw_point(self, point):
# for debug
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.Viewer(self.window_width,
self.window_height)
self.viewer.set_bounds(0, self.window_width, 0, self.window_height)
img = self.viewer.draw_polygon(Config.point)
jtransform = rendering.Transform(rotation=0, translation=point)
img.add_attr(jtransform)
self.viewer.onetime_geoms.append(img)
import os
__location__ = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__)))
for veriport in self.vertiport_list:
vertiport_img = rendering.Image(
os.path.join(__location__, 'images/verti.png'), 32, 32)
jtransform = rendering.Transform(rotation=0,
translation=veriport.position)
vertiport_img.add_attr(jtransform)
self.viewer.onetime_geoms.append(vertiport_img)
return self.viewer.render(return_rgb_array=False)
def _append_elements_to_viewer(self,
viewer,
screen_width,
screen_height,
obstacles,
destination=None,
destination_tolerance_range=None):
viewer.set_bounds(left=0,
right=screen_width,
bottom=0,
top=screen_height)
image = rendering.Image(self.image_path, screen_width, screen_height)
def renderSpoof1(self):
sprite = pyglet.sprite.Sprite(self.img)
sprite.draw()
image.render1 = MethodType(renderSpoof1, image)
viewer.add_geom(image)
if not (destination is None):
tr = rendering.Transform(translation=(destination[0],
destination[1]))
polygon = rendering.make_circle(radius=destination_tolerance_range,
res=30,
filled=True)
polygon.add_attr(tr)
polygon.set_color(1.0, 0., 0.)
viewer.add_geom(polygon)
def render(self, mode="human"):
"""Render pendulum."""
if self.viewer is None:
self.viewer = rendering.Viewer(500, 500)
self.viewer.set_bounds(-2.2, 2.2, -2.2, 2.2)
rod = rendering.make_capsule(1, 0.2)
rod.set_color(0.8, 0.3, 0.3)
self.pole_transform = rendering.Transform()
rod.add_attr(self.pole_transform)
self.viewer.add_geom(rod)
axle = rendering.make_circle(0.05)
axle.set_color(0, 0, 0)
self.viewer.add_geom(axle)
fname = os.path.dirname(
rendering.__file__) + "/assets/clockwise.png"
self.img = rendering.Image(fname, 1.0, 1.0)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
self.viewer.add_onetime(self.img)
self.pole_transform.set_rotation(self.state[0] + np.pi / 2)
if self.last_action:
self.imgtrans.scale = (-self.last_action / 2,
np.abs(self.last_action) / 2)
return self.viewer.render(return_rgb_array=mode == "rgb_array")
def __init__(self, time_limit=10, throttle_limit=1.0, gamma=0.98, \
show_true_median_pos=False, trail_length=2.4):
self.time_limit = time_limit
self.throttle_limit = throttle_limit
self.show_true_median_pos = show_true_median_pos
self.trail_length = trail_length
# corresponds to the maximum discounted reward over a median lap
max_reward = throttle_limit * v_max * dt / (1 - gamma)
self.out_reward = -max_reward
self.viewer = None
high = np.array([ 1.0, 1.0, 1.0, 1.0, 1.0 ])
low = np.array([ -1.0, -1.0, -1.0, -1.0, 0.0 ])
self.action_space = spaces.Discrete(len(steer_actions))
# for a continuous action space:
# self.action_space = spaces.Box(self.min_action, self.max_action, shape = (1,))
self.observation_space = spaces.Box(low, high)
fname = path.join(path.dirname(__file__), "track.png")
self.track = rendering.Image(fname, 2., 2.)
self._seed()
self.time = -1.0
self.reset()
def render(self, mode='human', title=None):
data = np.array(self.hist)
x = np.arange(data.shape[0])
plt.plot(x, data[:, 0], label="Current")
plt.plot(x, data[:, 1], label="Desired")
plt.title(title)
plt.legend()
plt.show()
return
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(500, 500)
self.viewer.set_bounds(-2.2, 2.2, -2.2, 2.2)
rod = rendering.make_capsule(1, .2)
rod.set_color(.8, .3, .3)
self.pole_transform = rendering.Transform()
rod.add_attr(self.pole_transform)
self.viewer.add_geom(rod)
axle = rendering.make_circle(.05)
axle.set_color(0, 0, 0)
self.viewer.add_geom(axle)
fname = path.join(path.dirname(__file__), "assets/clockwise.png")
self.img = rendering.Image(fname, 1., 1.)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
self.viewer.add_onetime(self.img)
self.pole_transform.set_rotation(self.state[0] + np.pi / 2)
if self.last_u:
self.imgtrans.scale = (-self.last_u / 2, np.abs(self.last_u) / 2)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(env, mode='human', side=28):
if env.env.viewer is None:
from gym.envs.classic_control import rendering
env.env.viewer = rendering.Viewer(side, side)
env.env.viewer.set_bounds(-1.2, 1.2, -1.2, 1.2)
rod = rendering.make_capsule(1, .3)
rod.set_color(.8, .3, .3)
env.env.pole_transform = rendering.Transform()
rod.add_attr(env.env.pole_transform)
env.env.viewer.add_geom(rod)
axle = rendering.make_circle(.05)
axle.set_color(0, 0, 0)
env.env.viewer.add_geom(axle)
fname = path.join(
path.dirname(
'/home/christine/projects/hamiltonian/lagrangian-nn/'),
"assets/clockwise.png")
env.env.img = rendering.Image(fname, 1., 1.)
env.env.imgtrans = rendering.Transform()
env.env.img.add_attr(env.env.imgtrans)
env.env.viewer.add_onetime(env.env.img)
env.env.pole_transform.set_rotation(env.env.state[0] + np.pi / 2)
if env.env.last_u:
env.env.imgtrans.scale = (-env.env.last_u / 2,
np.abs(env.env.last_u) / 2)
return env.env.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(500, 500)
self.viewer.set_bounds(-2.2, 2.2, -2.2, 2.2)
rod = rendering.make_capsule(1, .2)
rod.set_color(.8, .3, .3)
self.pole_transform = rendering.Transform()
rod.add_attr(self.pole_transform)
self.viewer.add_geom(rod)
axle = rendering.make_circle(.05)
axle.set_color(0, 0, 0)
self.viewer.add_geom(axle)
fname = path.join(path.dirname(__file__), "assets/clockwise.png")
self.img = rendering.Image(fname, 1., 1.)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
self.viewer.add_onetime(self.img)
self.pole_transform.set_rotation(self.state[0] + np.pi / 2)
if self.last_u:
self.imgtrans.scale = (-self.last_u / 2, np.abs(self.last_u) / 2)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
if self.viewer is None:
self.viewer = rendering.Viewer(500, 500)
self.viewer.set_bounds(-2.2, 2.2, -2.2, 2.2)
rod = rendering.make_capsule(self.LINK_LENGTH,
0.2 * self.LINK_LENGTH)
rod.set_color(0.8, 0.3, 0.3)
self.pole_transform = rendering.Transform()
rod.add_attr(self.pole_transform)
self.viewer.add_geom(rod)
axle = rendering.make_circle(0.05 * self.LINK_LENGTH)
axle.set_color(0, 0, 0)
self.viewer.add_geom(axle)
fname = path.join(path.dirname(__file__), "assets/clockwise.png")
self.img = rendering.Image(fname, 1.0, 1.0)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
self.viewer.add_onetime(self.img)
self.pole_transform.set_rotation(self.state[0] + 0.5 * np.pi)
if self.last_u:
self.imgtrans.scale = (-self.last_u / self.MAX_TORQUE,
np.abs(self.last_u) / self.MAX_TORQUE)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def get_viewer(self):
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(500, 500)
self.viewer.set_bounds(-2.2, 2.2, -2.2, 2.2)
rod = rendering.make_capsule(1, .2)
# rod.set_color(.8, .3, .3)
if self.color == 'red':
rod.set_color(.8, .3, .3)
elif self.color == 'blue':
rod.set_color(.288, .466, 1.)
else:
print('pendulum color err!!!!')
input()
return
self.pole_transform = rendering.Transform()
rod.add_attr(self.pole_transform)
self.viewer.add_geom(rod)
axle = rendering.make_circle(.05)
axle.set_color(0, 0, 0)
self.viewer.add_geom(axle)
fname = "/home/wmingd/anaconda3/envs/GAIL/lib/python3.5/site-packages/gym/envs/classic_control/assets/clockwise.png"
# fname = path.join(path.dirname(__file__), "assets/clockwise.png")
self.img = rendering.Image(fname, 1., 1.)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
return self.viewer
def _make_uav(self,
color: str) -> Tuple[rendering.Image, rendering.Transform]:
fname = str(Path(__file__).parent / f"aircraft_{color}.png")
uav = rendering.Image(fname, 0.05, 0.1)
xform = rendering.Transform()
uav.add_attr(xform)
return uav, xform
def render_goal_2(self, goal1, goal2, end_goal, mode='human'):
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(500, 500)
self.viewer.set_bounds(-2.2, 2.2, -2.2, 2.2)
rod = rendering.make_capsule(1, .2)
rod.set_color(.8, .3, .3)
self.pole_transform = rendering.Transform()
rod.add_attr(self.pole_transform)
self.viewer.add_geom(rod)
################ goal 1 ################
rod1 = rendering.make_goal_circ(1, .1)
rod1.set_color(.8, .8, .3)
self.pole_transform1 = rendering.Transform()
rod1.add_attr(self.pole_transform1)
self.viewer.add_geom(rod1)
########################################
################ goal 2 ################
rod2 = rendering.make_goal_circ(1, .1)
rod2.set_color(.3, .8, .3)
self.pole_transform2 = rendering.Transform()
rod2.add_attr(self.pole_transform2)
self.viewer.add_geom(rod2)
########################################
############### End Goal ###############
rod3 = rendering.make_goal_circ(1, .1)
rod3.set_color(.3, .3, .8)
self.pole_transform3 = rendering.Transform()
rod3.add_attr(self.pole_transform3)
self.viewer.add_geom(rod3)
########################################
axle = rendering.make_circle(.05)
axle.set_color(0, 0, 0)
self.viewer.add_geom(axle)
fname = path.join(path.dirname(__file__), "assets/clockwise.png")
self.img = rendering.Image(fname, 1., 1.)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
# self.viewer.add_onetime(self.img)
self.pole_transform.set_rotation(self.state[0] + np.pi / 2)
self.pole_transform1.set_rotation(goal1[0] + np.pi / 2)
self.pole_transform2.set_rotation(goal2[0] + np.pi / 2)
self.pole_transform3.set_rotation(end_goal[0] + np.pi / 2)
if self.last_u:
self.imgtrans.scale = (-self.last_u / 2, np.abs(self.last_u) / 2)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def render(self, mode='human'):
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(500, 500)
self.viewer.set_bounds(-2.2, 2.2, -2.2, 2.2)
surface = rendering.Line(start=(-1.2, -0.05), end=(1.2, -0.05))
self.viewer.add_geom(surface)
bob = rendering.make_circle(0.15, filled=True)
bob.set_color(.8, .3, .2)
attributes = rendering.Transform(translation=(0.0, 1.0))
bob.add_attr(attributes)
rod = rendering.FilledPolygon([(-0.025, 0), (-0.025, 1.0 - 0.15),
(0.025, 1.0 - 0.15), (0.025, 0)])
rod.set_color(0.2, 0.2, 0.7)
pendulum = rendering.Compound([bob, rod])
pendulum.set_color(0.4, 0.5, 1)
translate = rendering.Transform(translation=(0.0, -0.05))
pendulum.add_attr(translate)
self.pole_transform = rendering.Transform()
pendulum.add_attr(self.pole_transform)
self.viewer.add_geom(pendulum)
axle_fill = rendering.make_circle(radius=.1, res=30, filled=True)
axle_fill.set_color(1, 1, 1)
axle = rendering.make_circle(radius=0.1, res=30, filled=False)
semi = rendering.Transform(translation=(0.0, -0.05))
axle_fill.add_attr(semi)
axle.add_attr(semi)
axle.set_color(0, 0, 0)
self.viewer.add_geom(axle_fill)
self.viewer.add_geom(axle)
pivot = rendering.make_circle(0.02, filled=True)
self.viewer.add_geom(pivot)
hide = rendering.FilledPolygon([(-2.2, -0.07), (-2.2, -2.2),
(2.2, -2.2), (2.2, -0.07)])
hide.set_color(1, 1, 1)
self.viewer.add_geom(hide)
fname = path.join(path.dirname(__file__), "clockwise.png")
self.img = rendering.Image(fname, 0.5, 0.5)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
self.viewer.add_onetime(self.img)
self.pole_transform.set_rotation(self.state[0])
if self.action != 0:
self.imgtrans.scale = (-self.action / 8, np.abs(self.action) / 8)
return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def make_ant2():
# Ant using a single bitmap
path = os.path.dirname(os.path.abspath(__file__))
#filename = os.path.join(path, 'ant.png')
filename = os.path.join(path, 'antspritesheet.png')
ant = rendering.Image(filename, 30, 30)
ant.set_color(1, 1, 1)
return ant
def make_texture(self):
"""
Create the render image to render on the board
"""
img = rendering.Image(self.picture, SQUARE_WIDTH, SQUARE_HEIGHT)
img.set_color(1., 1., 1.)
img.add_attr(self.trans)
return img
def render(self, mode='human'):
from gym.envs.classic_control import rendering
from colour import Color
red = Color('red')
colors = list(red.range_to(Color('green'), self.num_aircraft))
if self.viewer is None:
self.viewer = rendering.Viewer(self.window_width,
self.window_height)
self.viewer.set_bounds(0, self.window_width, 0, self.window_height)
import os
__location__ = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__)))
# draw all the aircraft
for id, aircraft in self.aircraft_dict.ac_dict.items():
aircraft_img = rendering.Image(
os.path.join(__location__, 'images/aircraft.png'), 32, 32)
jtransform = rendering.Transform(rotation=aircraft.heading -
math.pi / 2,
translation=aircraft.position)
aircraft_img.add_attr(jtransform)
r, g, b = colors[aircraft.id % self.num_aircraft].get_rgb()
aircraft_img.set_color(r, g, b)
self.viewer.onetime_geoms.append(aircraft_img)
goal_img = rendering.Image(
os.path.join(__location__, 'images/goal.png'), 32, 32)
jtransform = rendering.Transform(
rotation=0, translation=aircraft.goal.position)
goal_img.add_attr(jtransform)
goal_img.set_color(r, g, b)
self.viewer.onetime_geoms.append(goal_img)
# draw all the vertiports
for veriport in self.vertiport_list:
vertiport_img = rendering.Image(
os.path.join(__location__, 'images/verti.png'), 32, 32)
jtransform = rendering.Transform(rotation=0,
translation=veriport.position)
vertiport_img.add_attr(jtransform)
self.viewer.onetime_geoms.append(vertiport_img)
return self.viewer.render(return_rgb_array=False)
def render(self, mode='human'):
screen_width = 800
screen_height = 800
if self.__viewer is None:
self.__viewer = rendering.Viewer(screen_width, screen_height)
self.draw_maze(screen_width, screen_height)
fname = path.join(path.dirname(__file__), "assets/car.png")
self.img = rendering.Image(fname, 40., 20.)
self.imgtrans = rendering.Transform()
self.img.add_attr(self.imgtrans)
fnamegold = path.join(path.dirname(__file__), "assets/gold.png")
self.imgGold = rendering.Image(fnamegold, 40., 20.)
self.imgGoldtrans = rendering.Transform()
self.imgGold.add_attr(self.imgGoldtrans)
self.draw_car_position()
self.draw_gold_position()
return self.__viewer.render(return_rgb_array=mode == 'rgb_array')
def draw_point(self, point):
# for debug
from gym.envs.classic_control import rendering
if self.viewer is None:
self.viewer = rendering.Viewer(self.window_width,
self.window_height)
self.viewer.set_bounds(0, self.window_width, 0, self.window_height)
img = self.viewer.draw_polygon(Config.point)
jtransform = rendering.Transform(rotation=0, translation=point)
img.add_attr(jtransform)
self.viewer.onetime_geoms.append(img)
import os
__location__ = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__)))
for veriport in self.vertiport_list:
vertiport_img = rendering.Image(
os.path.join(__location__, 'images/verti.png'), 32, 32)
jtransform = rendering.Transform(rotation=0,
translation=veriport.position)
vertiport_img.add_attr(jtransform)
self.viewer.onetime_geoms.append(vertiport_img)
for sector in self.sectors:
if sector.id == 0:
for i, exit in enumerate(sector.exits):
exit_img = self.viewer.draw_polygon(Config.vertices)
jtransform = rendering.Transform(
rotation=math.radians(60 * i - 90),
translation=exit[0])
exit_img.add_attr(jtransform)
exit_img.set_color(255 / 255.0, 165 / 255.0, 0)
self.viewer.onetime_geoms.append(exit_img)
else:
for i, exit in enumerate(sector.exits):
exit_img = self.viewer.draw_polygon(Config.vertices)
angle = 60 * (sector.id + i) + 30
jtransform = rendering.Transform(
rotation=math.radians(angle), translation=exit[0])
exit_img.add_attr(jtransform)
exit_img.set_color(255 / 255.0, 165 / 255.0, 0)
self.viewer.onetime_geoms.append(exit_img)
self.viewer.draw_polyline(
Config.vertiport_loc[[1, 2, 3, 4, 5, 6, 1], :])
for sector in self.sectors:
self.viewer.draw_polyline(
sector.vertices[[0, 1, 2, 3, 4, 5, 0], :])
return self.viewer.render(return_rgb_array=False)
def render(self, mode='human', close=False):
screen_width = self.Y_MAX
screen_height = self.X_MAX
cell_width = 20
cell_height = 20
if self.viewer is None:
from gym.envs.classic_control import rendering
self.viewer = rendering.Viewer(screen_width, screen_height)
dirname = os.path.dirname(__file__)
filename = os.path.join(dirname, 'godiland500by500.png')
background = rendering.Image(filename, 499, 499)
self.viewer.add_geom(background)
drone = rendering.FilledPolygon([(1, 1), (1, 10), (10, 5)])
self.dronetrans = rendering.Transform()
drone.add_attr(self.dronetrans)
self.viewer.add_geom(drone)
self.dronetrans.set_translation(self.drone.x, self.drone.y)
drone.set_color(.8, .6, .3)
hiker = rendering.FilledPolygon([(1, 1), (1, 10), (10, 10),
(10, 1)])
self.hiker_trans = rendering.Transform()
hiker.add_attr(self.hiker_trans)
self.viewer.add_geom(hiker)
self.hiker_trans.set_translation(self.hiker.x, self.hiker.y)
hiker.set_color(0.8, 0.3, 0.5)
#if self.viewer_ego is None:
#from gym.envs.classic_control import rendering
#self.viewer_ego = rendering.Viewer(self.OBS_SIZE_Y * cell_width,
#self.OBS_SIZE_X * cell_height)
#self.cells = [[rendering.FilledPolygon(
#[(y_cell * cell_width, x_cell * cell_height),
#((y_cell + 1) * cell_width, x_cell * cell_height),
#((y_cell + 1) * cell_width, (x_cell + 1) * cell_height),
#(y_cell * cell_width, (x_cell + 1) * cell_width)])
#for x_cell in range(self.OBS_SIZE_X)]
#for y_cell in range(self.OBS_SIZE_Y)]
#[[self.viewer_ego.add_geom(self.cells[y_cell][x_cell])
#for x_cell in range(self.OBS_SIZE_X)]
#for y_cell in range(self.OBS_SIZE_Y)]
#[[self.cells[y_cell][x_cell].set_color(rd.random(), rd.random(),
#rd.random())
#for x_cell in range(self.OBS_SIZE_X)]
#for y_cell in range(self.OBS_SIZE_Y)]
from gym.envs.classic_control import rendering
self.dronetrans.set_translation(self.drone.x, self.drone.y)
self.hiker_trans.set_translation(self.hiker.x, self.hiker.y)
#self._set_cells_color()
point = rendering.Point()
t = rendering.Transform()
point.add_attr(t)
self.viewer.add_geom(point)
t.set_translation(self.drone.x, self.drone.y)
point.set_color(.4, .1, .3)
return self.viewer.render(return_rgb_array=mode == 'rgb_array') #, \
def draw_fire(self,position):
try:
with open('imgs/smartfirebrigade/fire.png'):
fire = rendering.Image('imgs/smartfirebrigade/fire.png', \
width=25, height=25)
except FileNotFoundError as e:
raise e
fire.add_attr(rendering.Transform(
translation=(int(self.scale*position[0]),
int(self.scale*position[1]))))
return fire
