def __init__(self, per, cal, params): self.left = lane.Lane(params) self.right = lane.Lane(params) self.per = per self.cal = cal self.params = params self.binary = None
def __init__(self, vMax1, vMax2): vm = [vMax1, vMax2] ln = [settings.L1, settings.L2] self.lanes = [lane.Lane(ln[i], vm[i], 0.1, i+5) for i in range(2)] self.cell_size = settings.CELL_SIZE self.e_prob1 = 0.5 self.e_prob2 = 0.5
def __init__(self, C, coeff, image_size): """ Constructor :param C: Calibration matrix :param coeff: Distortion coefficients """ # Store calibration information self.C = C self.coeff = coeff # Save image information self.image_width = image_size[0] self.image_height = image_size[1] self.image_x_center = int(self.image_width / 2) # Perspective transform self.trapezium = np.float32([[560, 475], [205, self.image_height], [1105, self.image_height], [724, 475]]) self.rectangle = np.float32([[(self.image_width / 4), 0], [(self.image_width / 4), self.image_height], [(self.image_width * 3 / 4), self.image_height], [(self.image_width * 3 / 4), 0]]) # Image thresholding information after running from `adjust_parameters()` self.lower_HLS_threshold = np.array([0, 55, 74]) self.upper_HLS_threshold = np.array([85, 255, 255]) # Left lane information self.left_lane = lane.Lane(self.image_x_center) # Right lane information self.right_lane = lane.Lane(self.image_x_center) # Polynomial fit option # Number of sliding windows self.nwindows = 9 self.window_height = np.int(self.image_height / self.nwindows) # Set the width of the windows +/- margin self.margin = 100 # Set minimum number of pixels found to recenter window self.minpix = 50 # Debug counter self.false_counter = 0
def __init__(self, num_L, vMax): self.lanes = [] self.probRight = 0.8 # the probability to turn the right lane self.probLeft = 0.8 # the probability to turn the left lane self.num_L = num_L self.q = Queue.Queue() self.cell_size = settings.CELL_SIZE L = settings.L densities = [0.08, 0.08, 0.09, 0.09, 0.09] for i in range(num_L): if i == num_L - 1: vMax -= 1 self.lanes.append(lane.Lane(L, vMax, densities[i], i))
[bus_stop.BusStop(i) for i in range(40, ROAD_LENGTH, 200)], 70) line_2 = bus_line.BusLine( [bus_stop.BusStop(i) for i in range(140, ROAD_LENGTH, 200)], 120) line_3 = bus_line.BusLine( [bus_stop.BusStop(i) for i in range(80, ROAD_LENGTH, 200)], 110) line_4 = bus_line.BusLine( [bus_stop.BusStop(i) for i in range(180, ROAD_LENGTH, 200)], 230) config_lines = [line_1, line_2, line_3, line_4] while not condition: config_lanes = [ lane.Lane(), lane.Lane(), lane.Lane(), lane.Lane(True), ] line_1.last_time_appeared = 0 line_2.last_time_appeared = 0 line_3.last_time_appeared = 0 line_4.last_time_appeared = 0 sim = sim_module.Simulator(config_lanes, config_lines) if not histograms: histograms = {} for line in config_lines:
def sliding_window(image, n_windows=9, x_margin=100, minpix=50, previous_lane=None, show=False): ''' Parameters ---------- image : np.array binary and warped image containing the lane lines n_windows : int Number of sliding windows in which image is separated along y-axis x_margin : int width of the window to be addes at either side of the central point minpix : int minimum bumber of pixels found to recenter window ''' # Derived parameters Ny, Nx = image.shape if show: # Create an output image to draw on and visualize the result out_img = np.dstack((image, image, image)) * 255 # Identify the x and y positions of all nonzero pixels in the image nonzero = image.nonzero() nonzeroy = np.array(nonzero[0]) nonzerox = np.array(nonzero[1]) # Refind lanes if previous_lane is None: reset = True else: reset = False if not previous_lane.detected: reset = True if not previous_lane.sanity: reset = True if reset: left_lane_inds, right_lane_inds, out_img = _sliding_window(image, n_windows, x_margin, minpix, show=show) else: try: left_x_pred = previous_lane.left.current_poly(nonzeroy) right_x_pred = previous_lane.right.current_poly(nonzeroy) # Note to myself: & (bitwise and) and and (logical and) are not the same! # Only search +- margin around predicted lane center from previous line fit left_lane_inds = np.bitwise_and( nonzerox > (left_x_pred - x_margin), nonzerox < (left_x_pred + x_margin)) right_lane_inds = np.bitwise_and( nonzerox > (right_x_pred - x_margin), nonzerox < (right_x_pred + x_margin)) except: #raise ValueError print('Polynomes of previous lane are not defined.') left = l.Line(image, left_lane_inds) right = l.Line(image, right_lane_inds) lane = l.Lane(left, right) return lane
def pipeline(img, left_lane=None, right_lane=None ,mtx=None, dist=None, fname=None, testMode=False): """ Pipeline for finding lane lines on a given image. If camera calibration was not done in a previous step and the result are not given as mtx and dist to the function, it will calibrate the camera on itself. The pipeline consists of serveral steps: 1) Camera Calibration (done if necessary) 2) Distortion correction 3) Color & Gradient Threshold 4) Perspective Transform 5) Find lanes, calculate curvature and distance to center with peaks in histogram. Draw found lanes in transformed image 6) Retransform image and stack undistorted and rewarped image 7) Write text with calculations of step 5 on image Furthermore, it will save the images to output_images folder if it is run in test mode. """ ### Prepare lanes if function was called without if left_lane is None: left_lane = lane.Lane() if right_lane is None: right_lane = lane.Lane() ### Step 1 if mtx is None or dist is None: mtx, dist = camera_calibration.get_camera_calibration_values() ### Step 2 dst = cv2.undistort(img, mtx, dist, None, None) ### Step 3 combined = color_gradient_threshold.apply_thresholds(dst) ### Step 4 mask = perspective_transform.apply_standard_mask_to_image(combined) warped = perspective_transform.warp(mask) ### Step 5 left_lane, right_lane, center_distance, identified_lanes_image = find_lanes.find_lanes_with_histogram(warped, left_lane, right_lane) filled_image = find_lanes.fillPolySpace(identified_lanes_image, left_lane, right_lane) ### Step 6 rewarped = perspective_transform.warp(identified_lanes_image, toBirdView=False) result = perspective_transform.weighted_img(dst, rewarped, α=0.8, β=1, λ=0) ### Step 7 result = __put_texts_on_image(result, left_lane, right_lane, center_distance) ### Plot result of each step to the output_images folder if run in test mode if testMode: f, ((ax11, ax12, ax13, ax14),(ax21, ax22, ax23, ax24)) = plt.subplots(2, 4, figsize=(24, 9)) f.tight_layout() ax11.imshow(img) ax11.set_title('Original Image', fontsize=50) ax12.imshow(dst) ax12.set_title('Undistorted Image', fontsize=50) ax13.imshow(combined, cmap='gray') ax13.set_title('Combination', fontsize=50) ax14.imshow(mask, cmap='gray') ax14.set_title('Masked Image', fontsize=50) ax21.imshow(warped, cmap='gray') ax21.set_title('Warped Image', fontsize=50) ax22.imshow(identified_lanes_image) ax22.plot(left_lane.current_xfitted, left_lane.ploty, color='yellow') ax22.plot(right_lane.current_xfitted, right_lane.ploty, color='yellow') ax22.set_title('Identified Lanes', fontsize=50) ax23.imshow(rewarped) ax23.set_title('Rewarped Image', fontsize=50) ax24.imshow(result) ax24.set_title('Final Image', fontsize=50) plt.subplots_adjust(left=0., right=1, top=0.9, bottom=0.) plt.savefig('./output_images/'+fname.split('/')[-1], dpi=100) return result
""" Pipeline for finding lane lines. It needs a array of the images to proceed. The function calls pipeline() to proceed each image. """ ### Get calibration once global mtx, dist for fname in images: img = mpimg.imread(fname) ### Just for safety I work on a copy of the image copy_img = np.copy(img) pipeline(img, mtx=mtx, dist=dist, fname=fname, testMode=True) def video_pipeline(image): global mtx, dist, left_lane, right_lane return pipeline(image, left_lane, right_lane, mtx, dist, testMode=False) mtx, dist = camera_calibration.get_camera_calibration_values() camera_calibration.save_example_camera_calibration_images(mtx, dist) test_images = glob.glob('./test_images/test*.jpg') test_pipeline(test_images) straight_lines_images = glob.glob('./test_images/straight_lines*.jpg') test_pipeline(straight_lines_images) left_lane = lane.Lane() right_lane = lane.Lane() output = 'processed_project_video.mp4' clip = VideoFileClip('project_video.mp4') output_clip = clip.fl_image(video_pipeline) output_clip.write_videofile(output, audio=False)
import const import sprite import lane page = 1 # 1=menu, 2=game, 3= background = pg.display.set_mode((const.WIDTH, const.HEIGHT)) elementsgame = pg.sprite.Group() elementsmenu = pg.sprite.Group() Lhama1 = sprite.Player( pg.image.load('../../media/sprite/Skin0Test.png').convert_alpha()) Fundo1Game = sprite.Fundo( pg.image.load('../../media/img/FundoTest.png').convert_alpha()) Fundo1Menu = sprite.Fundo( pg.image.load('../../media/img/MenuTest.png').convert_alpha()) Enemy1 = sprite.Enemy(2) Enemy2 = sprite.Enemy(1) Enemy3 = sprite.Enemy(3) Guacamole1 = sprite.Point(3) Lane1 = lane.Lane(1, const.WIDTH / 2 - 150) Lane2 = lane.Lane(2, const.WIDTH / 2) Lane3 = lane.Lane(3, const.WIDTH / 2 + 150) lanes = [Lane1, Lane2, Lane3]
LANE_LEN = 100 def print_lanes(lanes): print("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n") for lane in lanes.values(): lane.printl() print("-" * LANE_LEN + "--") if __name__ == "__main__": arr = [1, 2, 3, 4, 5] print(arr[2:]) LANES = { 1: l.Lane(LANE_LEN, speed_limit=3), 2: l.Lane(LANE_LEN, speed_limit=4), 3: l.Lane(LANE_LEN, speed_limit=5), 4: l.Lane(LANE_LEN, speed_limit=6), 5: l.Lane(LANE_LEN, speed_limit=7) } LANES[1].add_vehicle(travelled=0) while True: print_lanes(LANES) for lane in LANES.values(): lane.update() time.sleep(0.15)
def __init__(self, vMax): ln = settings.L3 self.lanes = lane.Lane(ln, vMax, 0.1, 7) self.cell_size = settings.CELL_SIZE
import path as p pygame.init() win = pygame.display.set_mode(config.screen_size) pygame.display.set_caption("Artificial City") clock = pygame.time.Clock() visualisation = Visualisation(win, config.lane_width, config.cell_size, config.c_lanes_coordinates, config.z_lanes_coordinates, config.t_lanes_coordinates) TRAM_LANES = {1: l.TramLane(number=1), 2: l.TramLane(number=2)} CAR_LANES = { 1: l.Lane(number=1, length=25, spawn_probability=0), 2: l.Lane(number=2, length=35), 3: l.Lane(number=3, length=30), 4: l.Lane(number=4, length=30), 5: l.Lane(number=5, spawn_probability=0), 6: l.Lane(number=6), 7: l.Lane(number=7), 8: l.Lane(number=8), 9: l.Lane(number=9), 10: l.Lane(number=10), 11: l.Lane(number=11) } PEDESTRIAN_LANES = { 1: p.Path(number=1, length=20), 2: p.Path(number=2, length=20),
def addLane(self, edge, speed, length): return lane.Lane(edge, speed, length)