def _build_display(self, gold_cell, trap_cells): screen_width = (self.num_cols + 2) * CELL_SIZE screen_height = (self.num_rows + 2) * CELL_SIZE self.viewer = rendering.Viewer(screen_width, screen_height) all_objects = [] # List of border points' coordinates bp_list = [(CELL_SIZE - MARGIN, CELL_SIZE - MARGIN), (screen_width - CELL_SIZE + MARGIN, CELL_SIZE - MARGIN), (screen_width - CELL_SIZE + MARGIN, screen_height - CELL_SIZE + MARGIN), (CELL_SIZE - MARGIN, screen_height - CELL_SIZE + MARGIN)] border = rendering.PolyLine(bp_list, True) border.set_linewidth(5) all_objects.append(border) # Vertical lines for col in range(self.num_cols + 1): x1, y1 = (col + 1) * CELL_SIZE, CELL_SIZE x2, y2 = (col + 1) * CELL_SIZE, \ (self.num_rows + 1) * CELL_SIZE line = rendering.PolyLine([(x1, y1), (x2, y2)], False) all_objects.append(line) # Horizontal lines for row in range(self.num_rows + 1): x1, y1 = CELL_SIZE, (row + 1) * CELL_SIZE x2, y2 = (self.num_cols + 1) * CELL_SIZE, \ (row + 1) * CELL_SIZE line = rendering.PolyLine([(x1, y1), (x2, y2)], False) all_objects.append(line) # Traps: --> circles for cell in trap_cells: trap_coords = get_coords(*cell, loc='center') all_objects.append(draw_object([trap_coords])) # Gold: --> triangle gold_coords = get_coords(*gold_cell, loc='interior_triangle') all_objects.append(draw_object(gold_coords)) # Agent --> square or robot if (os.path.exists('robot-coordinates.pkl') and CELL_SIZE == 100): agent_coords = pickle.load(open('robot-coordinates.pkl', 'rb')) starting_coords = get_coords(0, 0, loc='center') agent_coords += np.array(starting_coords) else: agent_coords = get_coords(0, 0, loc='interior_corners') agent = draw_object(agent_coords) self.agent_trans = rendering.Transform() agent.add_attr(self.agent_trans) all_objects.append(agent) for obj in all_objects: self.viewer.add_geom(obj)
def _render_mvas(self): """ Renders the outlines of the minimum vectoring altitudes onto the screen. :return: None """ def transform_world_to_screen(coords): return [ ((coord[0] - self._world_x_min) * self._scale + self._padding, (coord[1] - self._world_y_min) * self._scale + self._padding) for coord in coords ] for mva in self._mvas: coordinates = transform_world_to_screen(mva.area.exterior.coords) fill = rendering.FilledPolygon(coordinates) fill.set_color(*ColorScheme.background_active) self.viewer.add_geom(fill) for mva in self._mvas: coordinates = transform_world_to_screen(mva.area.exterior.coords) outline = rendering.PolyLine(coordinates, True) outline.set_linewidth(1) outline.set_color(*ColorScheme.mva) self.viewer.add_geom(outline)
def init_rendering(self, viewer): self.steering_wheel = SteeringWheel() self.add_part(self.steering_wheel, 0.065, 0.0, 0.0) self.breadcrumb = rendering.PolyLine([], close=False) self.breadcrumb._color.vec4 = Color.set_alpha(self.color, 0.5) viewer.add_geom(self.breadcrumb)
def _render_faf(self): """ Renders the final approach fix symbol onto the screen Currently only supports a single runway and a single approach corridor :return: None """ faf_screen_render_size = 6 faf_x = self._runway.corridor.faf[0][0] faf_y = self._runway.corridor.faf[1][0] faf_vector = self._screen_vector(faf_x, faf_y) corner_vector = np.array([[0], [faf_screen_render_size]]) corner_top = faf_vector + corner_vector corner_right = np.dot(model.rot_matrix(121), corner_vector) + faf_vector corner_left = np.dot(model.rot_matrix(242), corner_vector) + faf_vector poly_line = rendering.PolyLine([corner_top, corner_right, corner_left], True) poly_line.set_color(*ColorScheme.lines_info) poly_line.set_linewidth(2) self.viewer.add_geom(poly_line)
def _render(self, mode='human', close=False): screen_width = 1200 screen_height = 400 # Shift the coordinates so that we can see above the top lane, below the bottom lane, # left of the start position of the cars. shift_y = 0.005 shift_x = 0.02 # The scaling is defined in terms of the height, apply the same scaling so that the # rendering doesn't look weird. # TODO: make sure we can see all obstacles (and maybe all cars). scale_y = float(screen_height) / float(self._top_lane - self._bottom_lane + 2 * shift_y) scale_x = scale_y if self.viewer is None: self.viewer = rendering.Viewer(screen_width, screen_height) # Draw the obstacles: for obs in self._obstacles: circle = geometry_utils.make_circle(obs.pos_x, obs.pos_y, obs.radius) circle = geometry_utils.shift_then_scale_points( circle, shift_x, shift_y, scale_x, scale_y) self.viewer.add_onetime(rendering.FilledPolygon(circle)) # Draw the car for c in self._cars: circle = geometry_utils.make_circle(c.pos_x, c.pos_y, self._car_radius) circle = geometry_utils.shift_then_scale_points( circle, shift_x, shift_y, scale_x, scale_y) self.viewer.add_onetime(rendering.PolyLine(circle, True)) # Draw the lanes bottom_lane = [(-shift_x, self._bottom_lane), (self._road_length + shift_x, self._bottom_lane)] bottom_lane = geometry_utils.shift_then_scale_points( bottom_lane, shift_x, shift_y, scale_x, scale_y) self.viewer.add_onetime(rendering.PolyLine(bottom_lane, True)) top_lane = [(-shift_x, self._top_lane), (self._road_length + shift_x, self._top_lane)] top_lane = geometry_utils.shift_then_scale_points( top_lane, shift_x, shift_y, scale_x, scale_y) self.viewer.add_onetime(rendering.PolyLine(top_lane, True)) return self.viewer.render(return_rgb_array=(mode == "rgb_array"))
def make_ellipse(major=10, minor=5, res=30, filled=True): points = [] for i in range(res): ang = 2*np.pi*i / res points.append((np.cos(ang)*major, np.sin(ang)*minor)) if filled: return rendering.FilledPolygon(points) else: return rendering.PolyLine(points, True)
def make_disk_at(x, y, radius, res=30, filled=True): points = [] for i in range(res): ang = 2 * np.pi * i / res points.append((np.cos(ang) * radius + x, np.sin(ang) * radius + y)) if filled: return rendering.FilledPolygon(points) else: return rendering.PolyLine(points, True)
def make_circleCv4(radius=10, angle=2*np.pi, res=30, filled=True): points = [(0, 0)] for i in range(res + 1): ang = (np.pi - (angle) / 2) + (angle * (i / res)) points.append((np.cos(ang) * radius, np.sin(ang) * radius)) if filled: return FilledPolygonCv4(points) else: return rendering.PolyLine(points,True)
def make_oval(width=10, height=10, res=30, filled=True): points = [] for i in range(res): ang = 2 * math.pi * i / res points.append((math.cos(ang) * width / 2, math.sin(ang) * height / 2)) if filled: return rendering.FilledPolygon(points) else: return rendering.PolyLine(points, True)
def make_half_circle(radius=10, res=20, filled=True): """ helper function for pyglet renderer""" points = [] for i in range(res+1): ang = math.pi-math.pi*i / res points.append((math.cos(ang)*radius, math.sin(ang)*radius)) if filled: return rendering.FilledPolygon(points) else: return rendering.PolyLine(points, True)
def create_rectangle(x, y, width, height, color, hollow=False): ps = [(x, y), ((x + width), y), ((x + width), (y + height)), (x, (y + height))] if hollow: rect = rendering.PolyLine(ps, True) else: rect = rendering.FilledPolygon(ps) rect.set_color(color[0], color[1], color[2]) rect.add_attr(rendering.Transform()) return rect
def _render_runway(self): runway_length = 1.7 * self._scale runway_to_threshold_vector = \ np.dot(model.rot_matrix(self._runway.phi_from_runway), np.array([[0], [runway_length / 2]])) runway_vector = self._screen_vector(self._runway.x, self._runway.y) runway_line = rendering.PolyLine([ runway_vector - runway_to_threshold_vector, runway_vector + runway_to_threshold_vector ], False) runway_line.set_linewidth(5) runway_line.set_color(*ColorScheme.runway) self.viewer.add_geom(runway_line)
def render(self, mode='human'): screen_width = 600 screen_height = 400 world_height = self.slider_range scale_y = screen_height / world_height scale_x = 1.0 * (screen_width / 2) egg_x = screen_width / 2 egg_width = 20.0 egg_height = 30.0 reference_width = 2.0 reference_x_resolution = int(20 * self.episode_length_s) reference_points = np.zeros((reference_x_resolution, 2)) reference_scale = np.linspace(0, self.episode_length_s, reference_x_resolution) reference_points[:, 0] = (scale_x * reference_scale) + (screen_width / 2) reference_points[:, 1] = scale_y * self.reference_trajectory_fn( reference_scale) if self.viewer is None: from gym.envs.classic_control import rendering self.viewer = rendering.Viewer(screen_width, screen_height) l, r, t, b = -egg_width / 2, egg_width / 2, egg_height / 2, -egg_height / 2 egg = rendering.FilledPolygon([(l, 0), (0, t), (r, 0), (0, b)]) self.egg_transform = rendering.Transform() egg.add_attr(self.egg_transform) self.viewer.add_geom(egg) reference = rendering.PolyLine(reference_points, False) self.reference_transform = rendering.Transform() reference.add_attr(self.reference_transform) self.viewer.add_geom(reference) if self.state is None: return None x, x_dot, r, r_dot, \ force_net, force_net_dot, \ force_interaction, force_interaction_dot = self.state egg_y = (x * scale_y) + (screen_height / 2) self.egg_transform.set_translation(egg_x, egg_y) self.reference_transform.set_translation(-self.t * scale_x, screen_height / 2) return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def _render_approach(self): iaf_x = self._runway.corridor.iaf[0][0] iaf_y = self._runway.corridor.iaf[1][0] dashes = 48 runway_vector = self._screen_vector(self._runway.x, self._runway.y) runway_iaf = self._screen_vector(iaf_x - self._runway.x, iaf_y - self._runway.y) for i in range(int(dashes / 2 + 1)): start = runway_vector + runway_iaf / dashes * 2 * i end = runway_vector + runway_iaf / dashes * (2 * i + 1) dash = rendering.PolyLine([start, end], False) dash.set_color(*ColorScheme.lines_info) self.viewer.add_geom(dash)
def render(self, mode='human'): screen_width = 350 screen_height = 400 scale = screen_width / 7 class Tank(): def __init__(self, x, y, dx, dy, viewer): x, y, dx, dy = [z * scale for z in (x, y, dx, dy)] self.x, self.y = x, y tank = rendering.PolyLine([(x, y), (x + dx, y), (x + dx, y + dy), (x, y + dy)], True) viewer.add_geom(tank) level = rendering.FilledPolygon([(0, 0), (dx, 0), (dx, dy), (0, dy)]) self.trans = rendering.Transform() level.add_attr(self.trans) level.set_color(.5, .5, 1.) viewer.add_geom(level) def setLevel(self, perc): self.trans.set_scale(1, perc) self.trans.set_translation(self.x, 1 + self.y) if self.viewer is None: self.viewer = rendering.Viewer(screen_width, screen_height) self.tanks = [ Tank(*dim, self.viewer) for dim in ((1, 2, 2, 2), (1, 5, 2, 2), (4, 2, 2, 2), (4, 5, 2, 2), (0, 0.5, 7, 1.0)) ] for poly in (((.5, 1.5), (.5, 7.33), (5, 7.33), (5, 7)), ((6.5, 1.5), (6.5, 7.66), (2, 7.66), (2, 7)), ((.5, 4.5), (1.5, 4.5), (1.5, 4)), ((6.5, 4.5), (5.5, 4.5), (5.5, 4)), ((2, 2), (2, 1.5)), ((2, 5), (2, 4.5)), ((5, 2), (5, 1.5)), ((5, 5), (5, 4.5))): poly = [[x * scale for x in point] for point in poly] self.viewer.add_geom(rendering.PolyLine(poly, False)) if self.state is None: return None for tank, h in zip(self.tanks, self.state): tank.setLevel(h / self.h_max) self.tanks[4].setLevel(1 - sum(self.state) / (4 * self.h_max)) return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def get_geometry(self): d = 0.0075 sensor = rendering.FilledPolygon([(-d, -d), (-d, +d), (+d, +d), (+d, -d)]) sensor.set_color(1, 0, 0) range_max, range_min, arc, precision = self.specs ry = range_max * sin(arc) rx = range_max * cos(arc) cone = rendering.PolyLine([(rx, ry), (0., 0.), (rx, -ry)], close=False) cone.set_linewidth(1) cone._color.vec4 = (1, 0, 0, 0.3) return [sensor, cone]
def _render_airplane(self, airplane: model.Airplane): """ Renders the airplane symbol and adjacent information onto the screen Already supports multiple airplanes in the environment. :param airplane: Airplane to render :return: None """ render_size = 4 vector = self._screen_vector(airplane.x, airplane.y) corner_vector = np.array([[0], [render_size]]) corner_top_right = np.dot(model.rot_matrix(45), corner_vector) + vector corner_bottom_right = np.dot(model.rot_matrix(135), corner_vector) + vector corner_bottom_left = np.dot(model.rot_matrix(225), corner_vector) + vector corner_top_left = np.dot(model.rot_matrix(315), corner_vector) + vector symbol = rendering.PolyLine([ corner_top_right, corner_bottom_right, corner_bottom_left, corner_top_left ], True) symbol.set_color(*ColorScheme.airplane) symbol.set_linewidth(2) self.viewer.add_onetime(symbol) label_pos = np.dot(model.rot_matrix(135), 2 * corner_vector) + vector render_altitude = round(airplane.h / 100) render_speed = round(airplane.v / 10) render_text = "%d %d" % (render_altitude, render_speed) label_name = Label(airplane.name, x=label_pos[0][0], y=label_pos[1][0]) label_details = Label(render_text, x=label_pos[0][0], y=label_pos[1][0] - 15) self.viewer.add_onetime(label_name) self.viewer.add_onetime(label_details) n = len(airplane.position_history) for i in range(n - 5, max(0, n - 25), -1): if i % 5 == 0: circle = rendering.make_circle(radius=2, res=12) screen_vector = self._screen_vector( airplane.position_history[i][0], airplane.position_history[i][1]) transform = rendering.Transform( translation=(screen_vector[0][0], screen_vector[1][0])) circle.add_attr(transform) circle.set_color(*ColorScheme.airplane) self.viewer.add_onetime(circle)
def __init__(self, x, y, dx, dy, viewer): x, y, dx, dy = [z * scale for z in (x, y, dx, dy)] self.x, self.y = x, y tank = rendering.PolyLine([(x, y), (x + dx, y), (x + dx, y + dy), (x, y + dy)], True) viewer.add_geom(tank) level = rendering.FilledPolygon([(0, 0), (dx, 0), (dx, dy), (0, dy)]) self.trans = rendering.Transform() level.add_attr(self.trans) level.set_color(.5, .5, 1.) viewer.add_geom(level)
def get_geometry(self): l = -self.length / 2.0 r = self.length / 2.0 t = self.width / 2.0 b = -self.width / 2.0 body = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)]) body.set_color(1, 1, 1) bumpers = rendering.PolyLine([(l, b), (l, t), (r, t), (r, b)], close=True) bumpers.set_linewidth(3) bumpers._color.vec4 = self.color return [body, bumpers]
def _render_mvas(self): def transform_world_to_screen(coords): return [((coord[0] + self._world_x0) * self._scale + self._padding, (coord[1] + self._world_y0) * self._scale + self._padding) for coord in coords] for mva in self._mvas: coordinates = transform_world_to_screen(mva.area.exterior.coords) fill = rendering.FilledPolygon(coordinates) fill.set_color(*ColorScheme.background_active) self.viewer.add_geom(fill) outline = rendering.PolyLine(coordinates, True) outline.set_linewidth(1) outline.set_color(*ColorScheme.mva) self.viewer.add_geom(outline)
def _render_faf(self): faf_screen_render_size = 6 faf_x = self._runway.corridor.faf[0][0] faf_y = self._runway.corridor.faf[1][0] faf_vector = self._screen_vector(faf_x, faf_y) corner_vector = np.array([[0], [faf_screen_render_size]]) corner_top = faf_vector + corner_vector corner_right = np.dot(model.rot_matrix(121), corner_vector) + faf_vector corner_left = np.dot(model.rot_matrix(242), corner_vector) + faf_vector poly_line = rendering.PolyLine([corner_top, corner_right, corner_left], True) poly_line.set_color(*ColorScheme.lines_info) poly_line.set_linewidth(2) self.viewer.add_geom(poly_line)
def _render_runway(self): """ Renders the runway symbol onto the screen Currently only supports a single runway and a single approach corridor :return: None """ runway_length = 1.7 * self._scale runway_to_threshold_vector = \ np.dot(model.rot_matrix(self._runway.phi_from_runway), np.array([[0], [runway_length / 2]])) runway_vector = self._screen_vector(self._runway.x, self._runway.y) runway_line = rendering.PolyLine([ runway_vector - runway_to_threshold_vector, runway_vector + runway_to_threshold_vector ], False) runway_line.set_linewidth(5) runway_line.set_color(*ColorScheme.runway) self.viewer.add_geom(runway_line)
def render(self, mode='human'): screen_width = 800 screen_height = 600 cell_width = 50 cell_height = 50 if self.viewer is None: from gym.envs.classic_control import rendering self.viewer = rendering.Viewer(screen_width, screen_height) leftmargin = (screen_width-(cell_width*self.columns))/2 topmargin = screen_height - (screen_height-(cell_height*self.rows))/2 l, r, t, b = leftmargin, leftmargin+cell_width, topmargin, topmargin-cell_height for row in range(self.rows): for col in range(self.columns): self.cells[(row, col)] = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)]) red, green, blue = self.getcolors(0) self.cells[(row, col)].set_color(red, green, blue) self.viewer.add_geom(self.cells[(row, col)]) border = rendering.PolyLine([(l, b), (l, t), (r, t), (r, b), (l, b)], True) self.viewer.add_geom(border) l, r = l + cell_width, r + cell_width t, b = t - cell_height, b - cell_height l, r = leftmargin, leftmargin+cell_width if self.prevpos is not None: red, green, blue = self.getcolors(1) self.cells[tuple(self.prevpos)].set_color(red, green, blue) for i in self.possiblemoves: red, green, blue = self.getcolors(0) self.cells[tuple(i)].set_color(red, green, blue) red, green, blue = self.getcolors(2) self.cells[tuple(self.pos)].set_color(red, green, blue) red, green, blue = self.getcolors(3) self.possiblemoves = self.getmoves()[self.getmask()] for move in self.possiblemoves: self.cells[(move[0], move[1])].set_color(red, green, blue) return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def _render_approach(self): """ Render the approach path on the screen Currently only supports a single runway and a single approach corridor :return: None """ iaf_x = self._runway.corridor.iaf[0][0] iaf_y = self._runway.corridor.iaf[1][0] dashes = 48 runway_vector = self._screen_vector(self._runway.x, self._runway.y) runway_iaf = np.array([[iaf_x - self._runway.x], [iaf_y - self._runway.y]]) * self._scale for i in range(int(dashes / 2 + 1)): start = runway_vector + runway_iaf / dashes * 2 * i end = runway_vector + runway_iaf / dashes * (2 * i + 1) dash = rendering.PolyLine([start, end], False) dash.set_color(*ColorScheme.lines_info) self.viewer.add_geom(dash)
def draw_tasks(self, type_='box', fname=None): drawn_tasks, shift = [], 0 for task in self.components['tasks']: #if not task.completed: drawn_tasks.append(rendering.Transform()) if type_ == 'box': shift = 0.1 box = rendering.PolyLine( [(0.1 * self.draw_scale, 0.4 * self.draw_scale), (0.5 * self.draw_scale, 0.4 * self.draw_scale), (0.5 * self.draw_scale, 0.1 * self.draw_scale), (0.1 * self.draw_scale, 0.1 * self.draw_scale), (0.1 * self.draw_scale, 0.4 * self.draw_scale), (0.35 * self.draw_scale, 0.65 * self.draw_scale), (0.75 * self.draw_scale, 0.65 * self.draw_scale), (0.75 * self.draw_scale, 0.35 * self.draw_scale), (0.5 * self.draw_scale, 0.1 * self.draw_scale), (0.5 * self.draw_scale, 0.4 * self.draw_scale), (0.75 * self.draw_scale, 0.65 * self.draw_scale)], close=False) box.set_linewidth(2) box.add_attr(drawn_tasks[-1]) self.viewer.add_geom(box) elif type_ == 'figure': shift = 0.5 try: with open(fname): figure = rendering.Image(fname, \ width=0.9 * self.draw_scale, height=0.9 * self.draw_scale) figure.add_attr(drawn_tasks[-1]) self.viewer.add_geom(figure) except FileNotFoundError as e: raise e else: raise NotImplementedError #else: # drawn_tasks.append(None) return drawn_tasks, shift
def render(self, mode='human'): screen_width = 600 screen_height = 400 if self.viewer is None: self.viewer = rendering.Viewer(screen_width, screen_height) self.track = rendering.Line((0, screen_height / 2), (screen_width, screen_height / 2)) self.track.set_color(0, 0, 1) self.viewer.add_geom(self.track) self.traj = rendering.PolyLine([], False) self.traj.set_color(1, 0, 0) self.traj.set_linewidth(3) self.viewer.add_geom(self.traj) if len(self.traj.v) != len(self._path): self.traj.v = [] for p in self._path: self.traj.v.append( (p[0] * 100, screen_height / 2 + p[1] * 100)) return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def make_ant(length=1): l = length/4 leg1 = rendering.PolyLine([(l/2,0),(l/2,l),(-l*.5,3*l),(l/2,l)],True) leg2 = rendering.PolyLine([(l/2,0),(l/2,-l),(-l*1.5,-3*l),(l/2,-l)],True) leg3 = rendering.PolyLine([(l*1.5,0),(l*1.5,l/2),(l,2.5*l),(l*1.5,l/2)],True) leg4 = rendering.PolyLine([(l*1.5,0),(l*1.5,-l/2),(l*2,-2.5*l),(l*1.5,-l/2)],True) leg5 = rendering.PolyLine([(l*2.5,0),(l*2.5,l/2),(l*2.5,2*l),(l*2.5,l/2)],True) leg6 = rendering.PolyLine([(l*2.5,0),(l*2.5,-l/2),(l*3.5,-2*l),(l*2.5,-l/2)],True) circ0 = make_ellipse(2*l, l/1.5) circ1 = make_ellipse(l, l/2) circ1.add_attr(rendering.Transform(translation=(l+l/2, 0))) circ2 = make_ellipse(l, l) circ2.add_attr(rendering.Transform(translation=(2*l+l/2, 0))) geom = rendering.Compound([leg1, leg2, leg3, leg4, leg5, leg6, circ0, circ1, circ2]) geom.add_attr(rendering.Transform(translation=(-3*l, 0))) geom.add_attr(Flip(flipx=True)) return geom
def render(self, state, mode): from gym.envs.classic_control import rendering if self.viewer is None: self.viewer = rendering.Viewer(self.screen_width, self.screen_height) #wall l, r, t, b = self.get_lrtb(0, state.dimentions[0], 0, state.dimentions[1]) wall = rendering.PolyLine([(l, b), (l, t), (r, t), (r, b)], True) wall.set_color(0., 0., 0.) self.viewer.add_geom(wall) #robot robot = rendering.make_circle(self.robot["radius"] * self.scale) self.robot_trans = rendering.Transform() robot.add_attr(self.robot_trans) robot.set_color(0.0, 0.0, 1.0) self.viewer.add_geom(robot) robot_orientation = rendering.make_capsule( self.robot["radius"] * self.scale, 1.0) self.orientation_trans = rendering.Transform() robot_orientation.set_color(0.0, 1.0, 0.0) robot_orientation.add_attr(self.orientation_trans) self.viewer.add_geom(robot_orientation) #target target = rendering.make_circle(self.robot["radius"] * 0.3 * self.scale) self.target_trans = rendering.Transform() target.add_attr(self.target_trans) target.set_color(1.0, 0.0, 0.0) self.viewer.add_geom(target) #obstract for obj in state.layout["static_objects"]: l, r, t, b = self.get_lrtb(obj["l"], obj["r"], obj["t"], obj["b"]) ob = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)]) ob.set_color(0, 0, 0) self.viewer.add_geom(ob) robot_x = (self.margin + state.pose[0]) * self.scale robot_y = (self.margin + state.pose[1]) * self.scale robot_orientation = state.pose[2] self.robot_trans.set_translation(robot_x, robot_y) self.orientation_trans.set_translation(robot_x, robot_y) self.orientation_trans.set_rotation(robot_orientation) self.target_trans.set_translation( (state.target[0] + self.margin) * self.scale, (state.target[1] + self.margin) * self.scale) if state.obs is not None: for i in range(int(len(state.obs))): if i % self.SKIP_RENDER == 0: lidar = rendering.make_capsule(self.scale * state.obs[i], 1.0) lidar_trans = rendering.Transform() lidar_trans.set_translation(robot_x, robot_y) lidar_trans.set_rotation( state.pose[2] + i * self.robot["lidar"]["angle_increment"] - self.robot["lidar"]["max_angle"]) lidar.set_color(1.0, 0.0, 0.0) lidar.add_attr(lidar_trans) self.viewer.add_onetime(lidar) return self.viewer.render(return_rgb_array=mode == 'rgb_array')
def _render(self, mode='human', close=False): if close: if self.viewer is not None: self.viewer.close() self.viewer = None return CELL_SIZE = 30 PAD = 2 screen_width = CELL_SIZE * SnakeEnv.W + 2 screen_height = CELL_SIZE * SnakeEnv.H + 2 if self.viewer is None: self.viewer = rendering.Viewer(screen_width, screen_height) # lines self.viewer.geoms = [] snake = np.append([self.head_new], self.body_new, 0) body_unravel = np.unravel_index(snake, (SnakeEnv.H, SnakeEnv.W)) body_unravel = np.transpose(body_unravel) body_unravel = np.multiply(body_unravel, screen_height / SnakeEnv.H + 0) body_unravel = np.add(body_unravel, CELL_SIZE / 2) body_unravel[:, 0] = screen_height - body_unravel[:, 0] body_unravel = np.flip(body_unravel, 1) body_unravel[:, 0] = body_unravel[:, 0] line = rendering.PolyLine(body_unravel, False) self.viewer.add_geom(line) food_idx = np.unravel_index(self.food_new, (SnakeEnv.H, SnakeEnv.W)) l, r, t, b = food_idx[1] * CELL_SIZE, (food_idx[1] + 1) * CELL_SIZE, ( SnakeEnv.H - food_idx[0]) * CELL_SIZE, (SnakeEnv.H - food_idx[0] - 1) * CELL_SIZE l, r, t, b = l + PAD, r - PAD, t - PAD, b + PAD food = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)]) food.set_color(0, 1, 0) self.viewer.add_geom(food) # field = self.state2field(self.head_new, self.body_new, self.food_new) # # food_idx = np.unravel_index(self.food_new, (SnakeEnv.H, SnakeEnv.W)) # # l, r, t, b = food_idx[1] * CELL_SIZE, (food_idx[1] + 1) * CELL_SIZE, (SnakeEnv.H - food_idx[0]) * CELL_SIZE, (SnakeEnv.H - food_idx[0] - 1) * CELL_SIZE # # l, r, t, b = l + PAD, r - PAD, t - PAD, b + PAD # # food = rendering.FilledPolygon([(l,b), (l,t), (r,t), (r,b)]) # # food.set_color(0, 1, 0) # # self.viewer.add_geom(food) # snake_idxs = np.argwhere(field>0) # snake_lifes = [field[tuple(idx)] for idx in snake_idxs] # snake_idxs = [(idx, field[tuple(idx)]) for idx in snake_idxs] # snake_idxs.sort(key=lambda x: x[1]) # idx0 = snake_idxs[0][0] # l0, r0, t0, b0 = idx0[1] * CELL_SIZE, (idx0[1] + 1) * CELL_SIZE, (SnakeEnv.H - idx0[0]) * CELL_SIZE, (SnakeEnv.H - idx0[0] - 1) * CELL_SIZE # l0, r0, t0, b0 = l0 + PAD, r0 - PAD, t0 - PAD, b0 + PAD # for idx in snake_idxs[1:]: # idx = idx[0] # l, r, t, b = idx[1] * CELL_SIZE, (idx[1] + 1) * CELL_SIZE, (SnakeEnv.H - idx[0]) * CELL_SIZE, (SnakeEnv.H - idx[0] - 1) * CELL_SIZE # l, r, t, b = l + PAD, r - PAD, t - PAD, b + PAD # c = [idx[1] * CELL_SIZE + CELL_SIZE / 2, (SnakeEnv.H - idx[0]) * CELL_SIZE + CELL_SIZE / 2] # step = idx-idx0 # if np.array_equal(step, [1,0]): # cell = rendering.FilledPolygon([(l0,t0), (r0,t0), (r0,b), (l,b)]) # elif np.array_equal(step, [0,-1]): # cell = rendering.FilledPolygon([(l,t0), (r0,t0), (r0,b0), (l,b0)]) # elif np.array_equal(step, [-1,0]): # cell = rendering.FilledPolygon([(l,t), (r,t), (r,b0), (l,b0)]) # elif np.array_equal(step, [0,1]): # cell = rendering.FilledPolygon([(l0,t0), (r,t), (r,b), (l0,b0)]) # else: # print('oops') # cell.set_color(0.5, 0.5, 0.5) # self.viewer.add_geom(cell) # idx0 = idx # l0, r0, t0, b0 = l, r, t, b # # for i in range(11): # # print(self.field[i,:]) return self.viewer.render()
def render(self, mode='human', close=False): if close: if self.viewer is not None: self.viewer.close() self.viewer = None return screen_width = 640 screen_height = 480 scale = np.max(self.h_added) / 440 bdata = [ ] # (screen_width - 20, 20)] # first point in lower right corner y = list(reversed(self.h_base)) for j, i in enumerate(y): bdata.append((screen_width - 20 - j, 20 + int(i / scale))) # bdata.append((screen_width - 20 - len(y), 20)) adata = [] # (screen_width - 20, 20)] y = list(reversed(self.h_added)) for j, i in enumerate(y): adata.append((screen_width - 20 - j, 20 + int(i / scale))) # adata.append((screen_width - 20 - len(y), 20)) adata = adata[:self.tstep] if self.viewer is None: self.viewer = rendering.Viewer(screen_width, screen_height) # l, r, t, b = -cartwidth / 2, cartwidth / 2, cartheight / 2, -cartheight / 2 # axleoffset = cartheight / 4.0 # cart = rendering.FilledPolygon([(l, b), (l, t), (r, t), (r, b)]) # self.carttrans = rendering.Transform() # cart.add_attr(self.carttrans) # self.viewer.add_geom(cart) # self.poletrans = rendering.Transform(translation=(0, axleoffset)) # pole.add_attr(self.poletrans) # pole.add_attr(self.carttrans) # self.axle = rendering.make_circle(polewidth / 2) # self.axle.add_attr(self.poletrans) # self.axle.add_attr(self.carttrans) self.xaxis = rendering.Line((20, 20), (screen_width - 20, 20)) self.xaxis.set_color(0, 0, 0) self.yaxis = rendering.Line((20, 20), (20, screen_height - 20)) self.yaxis.set_color(0, 0, 0) self.viewer.add_geom(self.xaxis) self.viewer.add_geom(self.yaxis) adde = rendering.PolyLine(adata, False) adde.set_color(.1, .6, .8) self.viewer.add_onetime(adde) base = rendering.PolyLine(bdata, False) base.set_color(.8, .6, .4) self.viewer.add_onetime(base) max_line = self.max_link_rate / scale ml = rendering.Line((20, max_line + 20), (screen_width - 20, max_line + 20)) ml.set_color(0.1, 0.9, .1) self.viewer.add_onetime(ml) # if self.state is None: # return None # x = self.state # cartx = x[0] * scale + screen_width / 2.0 # MIDDLE OF CART # self.carttrans.set_translation(cartx, carty) # self.poletrans.set_rotation(-x[2]) return self.viewer.render(return_rgb_array=mode == 'rgb_array')