Draw reinvent base map

canvasexample.py

from tkinter import Tk, Canvas, Frame, BOTH
import numpy as np
import math

import time
import os


def _create_circle(self, x, y, r, **kwargs):
    return self.create_oval(x - r, y - r, x + r, y + r, **kwargs)


Canvas.create_circle = _create_circle


# Type of worker
SIMULATION_WORKER = "SIMULATION_WORKER"
SAGEMAKER_TRAINING_WORKER = "SAGEMAKER_TRAINING_WORKER"

node_type = os.environ.get("NODE_TYPE", SIMULATION_WORKER)


TRAINING_IMAGE_SIZE = (160, 120)
FINISH_LINE = 100
multiplier = 200

# REWARD ENUM
CRASHED = 0
NO_PROGRESS = -1
FINISHED = 10000000.0
MAX_STEPS = 1000000

# SLEEP INTERVALS
SLEEP_AFTER_RESET_TIME_IN_SECOND = 0.5
SLEEP_BETWEEN_ACTION_AND_REWARD_CALCULATION_TIME_IN_SECOND = 0.1
SLEEP_WAITING_FOR_IMAGE_TIME_IN_SECOND = 0.01


class Example(Frame):
    def __init__(self):
        super().__init__()

        self.on_track = 0
        self.progress = 0
        self.yaw = 0
        self.x = 0
        self.y = 0
        self.z = 0
        self.distance_from_center = 0
        self.distance_from_border_1 = 0
        self.distance_from_border_2 = 0
        self.steps = 0
        self.progress_at_beginning_of_race = 0
        self.reward_in_episode = 0
        self.prev_progress = 0
        self.steps = 0

        self.car_x = 1.75 * multiplier
        self.car_y = 0.6 * multiplier
        self.car_heading = 0.0
        self.car_throttle = 0.0
        self.car_max_speed = 8.0
        self.car_max_left_angle = -30.0
        self.car_max_right_angle = 30.0
        self.throttle_actions = 3
        self.steering_actions = 7

        Canvas.create_circle = _create_circle

        self.initUI()

    def initUI(self):

        self.master.title("Lines")
        self.pack(fill=BOTH, expand=1)

        canvas = Canvas(self)
        # canvas.create_line(15, 25, 200, 25)
        # canvas.create_line(300, 35, 300, 200, dash=(4, 2))
        # canvas.create_line(55, 85, 155, 85, 105, 180, 55, 85)
        self.waypoints = vertices = np.zeros((31, 2))
        self.road_width = 0.44
        vertices[0][0] = 1.5
        vertices[0][1] = 0.58
        vertices[1][0] = 5.5
        vertices[1][1] = 0.58
        vertices[2][0] = 5.6
        vertices[2][1] = 0.6
        vertices[3][0] = 5.7
        vertices[3][1] = 0.65
        vertices[4][0] = 5.8
        vertices[4][1] = 0.7
        vertices[5][0] = 5.9
        vertices[5][1] = 0.8
        vertices[6][0] = 6.0
        vertices[6][1] = 0.9
        vertices[7][0] = 6.08
        vertices[7][1] = 1.1
        vertices[8][0] = 6.1
        vertices[8][1] = 1.2
        vertices[9][0] = 6.1
        vertices[9][1] = 1.3
        vertices[10][0] = 6.1
        vertices[10][1] = 1.4
        vertices[11][0] = 6.07
        vertices[11][1] = 1.5
        vertices[12][0] = 6.05
        vertices[12][1] = 1.6
        vertices[13][0] = 6
        vertices[13][1] = 1.7
        vertices[14][0] = 5.9
        vertices[14][1] = 1.8
        vertices[15][0] = 5.75
        vertices[15][1] = 1.9
        vertices[16][0] = 5.6
        vertices[16][1] = 2.0
        vertices[17][0] = 4.2
        vertices[17][1] = 2.02
        vertices[18][0] = 4
        vertices[18][1] = 2.1
        vertices[19][0] = 2.6
        vertices[19][1] = 3.92
        vertices[20][0] = 2.4
        vertices[20][1] = 4
        vertices[21][0] = 1.2
        vertices[21][1] = 3.95
        vertices[22][0] = 1.1
        vertices[22][1] = 3.92
        vertices[23][0] = 1
        vertices[23][1] = 3.88
        vertices[24][0] = 0.8
        vertices[24][1] = 3.72
        vertices[25][0] = 0.6
        vertices[25][1] = 3.4
        vertices[26][0] = 0.58
        vertices[26][1] = 3.3
        vertices[27][0] = 0.57
        vertices[27][1] = 3.2
        vertices[28][0] = 1
        vertices[28][1] = 1
        vertices[29][0] = 1.25
        vertices[29][1] = 0.7
        vertices[30][0] = 1.5
        vertices[30][1] = 0.58

        road_width = 0.48 * multiplier
        radius = math.sqrt((road_width * road_width) / 2)
        for i in range(0, 31, 1):
            vertices[i][0] = vertices[i][0] * multiplier
            vertices[i][1] = vertices[i][1] * multiplier
            canvas.create_circle(
                vertices[i][0], vertices[i][1], 10, fill="blue", outline="#DDD", width=4
            )

        for i in range(0, 30, 1):

            if i == 31:
                roadside_vertices = getLeftRightVectors(
                    vertices[i], vertices[0], radius, vertices[i - 1]
                )
                canvas.create_line(
                    roadside_vertices[0][0],
                    roadside_vertices[0][1],
                    roadside_vertices[1][0],
                    roadside_vertices[1][1],
                )
                canvas.create_line(
                    roadside_vertices[2][0],
                    roadside_vertices[2][1],
                    roadside_vertices[3][0],
                    roadside_vertices[3][1],
                )
                break
            canvas.create_line(
                vertices[i][0], vertices[i][1], vertices[i + 1][0], vertices[i + 1][1]
            )

            roadside_vertices = getLeftRightVectors(
                vertices[i], vertices[i + 1], radius, vertices[i - 1]
            )

            canvas.create_line(
                roadside_vertices[0][0],
                roadside_vertices[0][1],
                roadside_vertices[1][0],
                roadside_vertices[1][1],
            )
            canvas.create_line(
                roadside_vertices[2][0],
                roadside_vertices[2][1],
                roadside_vertices[3][0],
                roadside_vertices[3][1],
            )

        canvas.pack(fill=BOTH, expand=1)


def getLeftRightVectors(firstVertex, secondVertex, radius, lastVertex):
    left_vertex = getRadialVector(firstVertex, secondVertex, radius, math.pi / 2.0)
    right_vertex = getRadialVector(firstVertex, secondVertex, radius, math.pi / -2.0)

    backleft_vertex = getRadialVector(lastVertex, firstVertex, radius, math.pi / 2.0)
    backright_vertex = getRadialVector(lastVertex, firstVertex, radius, math.pi / -2.0)
    result = np.zeros((4, 2))
    result[0][0] = backleft_vertex[0]
    result[0][1] = backleft_vertex[1]
    result[1][0] = left_vertex[0]
    result[1][1] = left_vertex[1]

    result[2][0] = backright_vertex[0]
    result[2][1] = backright_vertex[1]
    result[3][0] = right_vertex[0]
    result[3][1] = right_vertex[1]

    return result


def getRadialVector(firstVertex, lastVertex, radius, angleOffset):
    delta_x = firstVertex[0] - lastVertex[0]
    delta_y = firstVertex[1] - lastVertex[1]
    theta_radians = math.atan2(delta_y, delta_x)

    offset_radians = theta_radians + angleOffset
    if offset_radians > math.pi * 2.0:
        offset_radians = offset_radians - math.pi * 2.0
    if offset_radians < math.pi * -2.0:
        offset_radians = offset_radians + math.pi * 2.0

    result = np.zeros((2))
    result[0] = radius * math.cos(offset_radians) + firstVertex[0]
    result[1] = radius * math.sin(offset_radians) + firstVertex[1]
    return result


def getFuturePoint(x, y, radius, heading_radians):
    import math

    result = [0, 0]
    result[0] = radius * math.cos(heading_radians) + x
    result[1] = radius * math.sin(heading_radians) + y
    return result


def distance(x, y, waypoint):
    import math

    result = math.sqrt(
        (x - waypoint[0]) * (x - waypoint[0]) + (y - waypoint[1]) * (y - waypoint[1])
    )
    return result


def anglenext(x, y, next_point):
    import math

    return math.degrees(math.atan2(next_point[1] - y, next_point[0] - x))


def offtarget(prev_point, next_point, heading):
    # Calculate the direction in radius, arctan2(dy, dx), the result is (-pi, pi) in radians
    track_direction = anglenext(prev_point[0], prev_point[1], next_point)
    # Calculate the difference between the track direction and the heading direction of the car
    return anglediff(track_direction, heading)


def anglediff(ang1, ang2):
    diff = abs(ang1 - ang2)
    if diff > 180:
        diff = diff - 180
    return diff


def main():
    root = Tk()
    ex = Example()
    root.geometry("400x250+300+300")
    root.mainloop()


if __name__ == "__main__":
    main()