from moviepy.editor import VideoFileClip from lane_finder import LaneFinder from object_detect_yolo import YoloDetector if __name__ == "__main__": def remove_mp4_extension(file_name): return file_name.replace(".mp4", "") yolo = YoloDetector() lane_finder = LaneFinder(save_original_images=True, object_detection_func=yolo.process_image_array) video_file = 'project_video.mp4' # video_file = 'challenge_video.mp4' # video_file = 'back_home.mov' # video_file = 'file01_2017322191247.mp4' clip = VideoFileClip(video_file, audio=False) t_start = 0 t_end = 0 if t_end > 0.0: clip = clip.subclip(t_start=t_start, t_end=t_end) else: clip = clip.subclip(t_start=t_start) clip = clip.fl_image(lane_finder.process_image) clip.write_videofile("{}_output.mp4".format( remove_mp4_extension(video_file)), audio=False) yolo.shutdown()
from moviepy.video.io.VideoFileClip import VideoFileClip from lane_finder import LaneFinder easy = "./videos/project_video.mp4" medium = "./videos/challenge_video.mp4" hard = "./videos/harder_challenge_video.mp4" input_video = hard debug = False # output a debugging version of the video if __name__ == '__main__': """ Process each frame of a video to detect lanes and render output video """ lane_finder = LaneFinder() video_clip = VideoFileClip(input_video) if debug: processed_clip = video_clip.fl_image(lane_finder.debug_frame) else: processed_clip = video_clip.fl_image(lane_finder.process_frame) # save video processed_clip.write_videofile(input_video[:-4] + '_processed.mp4', audio=False) print('Done')
video_files = ['test_video.mp4', 'project_video.mp4'] output_path = "output_videos" def process_image(img, car_finder, lane_finder, cam_matrix, dist_coeffs, reset=False): img = cv2.undistort(img, cam_matrix, dist_coeffs) car_finder.find_cars(img, reset=reset) lane_finder.find_lane(img, distorted=False, reset=reset) return lane_finder.draw_lane_weighted(car_finder.draw_cars(img)) lf = LaneFinder(ORIGINAL_SIZE, UNWARPED_SIZE, cam_matrix, dist_coeffs, perspective_transform, pixels_per_meter, "warning.png") cf = CarFinder(64, hist_bins=128, small_size=20, orientations=12, pix_per_cell=8, cell_per_block=1, classifier=cls, scaler=scaler, window_sizes=window_size, window_rois=window_roi, transform_matrix=perspective_transform, warped_size=UNWARPED_SIZE, pix_per_meter=pixels_per_meter) for img_path in os.listdir(test_images_dir):
mtx, dist = cal_cam() print("matrix: {} ; distortion: {}".format(mtx, dist)) # Read test image and convert to RGB as pipeline expects! img = cv2.imread(r'C:\Code\AdvLaneFind\test_images\straight_lines1.jpg') img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # Use calculated Matrix to undistort. undist_img = undist_image(img, mtx, dist) # Use the Sobel operator to calculate gradients and use a color threshold and combine # NOTE: for speed, get rid of colored binary output that shows which part of binary image is produced by what. binary, color_binary = color_threshold(undist_img) # Transform to Bird's eye perspective. # top_down, perspective_M = corners_unwarp(img, nx, ny, mtx, dist) birdseye, M, Minv = warp_to_birdseye(binary, calibrate=True) from lane_finder import LaneFinder lf = LaneFinder() # Feed lanefinder previously found fit values # lf.left_fit = np.array([0, 0, 1.60436725e+02]) # lf.right_fit = np.array([0, 0, 1.13855949e+03]) lane_fit_img = lf.find_lane(birdseye, visualization=True) birdseye_with_rad, left_curverad, right_curverad = lf.measure_lane_geometry( birdseye) print('Curvature in m: {}'.format((left_curverad, right_curverad))) # Plot Undistorted Test Image test_image = cv2.imread('camera_cal/calibration1.jpg') undist_test_image = undist_image(test_image, mtx, dist) f, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 9)) f.tight_layout() ax1.imshow(test_image)
from moviepy.editor import VideoFileClip import numpy as np import cv2 from camera_calibration import cal_cam, undist_image, color_threshold, warp_to_birdseye, warp from lane_finder import LaneFinder # Calibrate the camera mtx, dist = cal_cam() # Create Lanefinder instance lf = LaneFinder() def lane_find_on_image(image): """ A function that takes a colored RGB image and detects and plots lanes on it """ img = np.copy(image) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) undist_img = undist_image(img, mtx, dist) binary, color_binary = color_threshold(undist_img) birdseye, M, Minv = warp_to_birdseye(binary) lines = lf.find_lane(birdseye) lines = warp(lines, Minv) lines, left_rad, right_rad = lf.measure_lane_geometry(lines) output_image = cv2.addWeighted(image, 1.0, lines, 0.3, 0.0) return output_image if __name__ == "__main__": write_output = 'output_images/challenge_video.mp4' clip1 = VideoFileClip("challenge_video.mp4")
from moviepy.editor import VideoFileClip import pickle from lane_finder import LaneFinder from line import Line import numpy as np gray_shape, objpoints, imgpoints = pickle.load(open('camera.p', 'rb')) lane_finder = LaneFinder(gray_shape, objpoints, imgpoints) left_line = Line(gray_shape[1]) right_line = Line(gray_shape[1]) is_previous_lane_detected = False global n_skipped_frames n_skipped_frames = 0 def sanity_check(lane_finder): curs = lane_finder.window_searcher.measure_curvature_real() if abs(curs[0] - curs[1]) > 4000: print(curs) return False errors = (lane_finder.window_searcher.right_fitx - lane_finder.window_searcher.left_fitx).mean() if errors > 1000 or errors < 200: print(errors) return False return True def process_image(image): global n_skipped_frames if n_skipped_frames <= 5:
import cv2 from lane_finder import LaneFinder if __name__ == "__main__": lane_finder = LaneFinder() filename = "/home/operador/Documentos/_row_image_0.jpeg" print filename image = cv2.imread(filename) lane_finder.process_image(image) lane_finder.find_simil_points_lanes() hull = lane_finder.hull_set for point in lane_finder.points_pair_set: cv2.line(image, (point[0], point[1]), (point[2], point[3]), (0, 175, 0), 2) for i in range(len(hull)): color_contours = (0, 255, 0) # green - color for contours color = (0, 0, 255) # blue - color for convex hull # draw ith contour #cv2.drawContours(drawing, contours, i, color_contours, 1, 8, hierarchy) # draw ith convex hull object cv2.drawContours(image, hull, i, color, 1, 8) cv2.imshow('original', image) cv2.waitKey(0) cv2.destroyAllWindows()
def main(args): client = carla.Client(args.host, args.port) client.set_timeout(10.0) rng = np.random.default_rng(args.seed) vehicle = None lanefinder = None try: world = client.get_world() spectator = world.get_spectator() print('got world') # Setup world settings = world.get_settings() # world.set_weather(carla.WeatherParameters()) settings.synchronous_mode = True settings.fixed_delta_seconds = 0.05 world.apply_settings(settings) world.tick() # check if necessary print('set world settings') # Select and spawn vehicle. vehicle_blueprint = rng.choice(world.get_blueprint_library().filter( args.filter)) world_map = world.get_map() spawn_point = world_map.get_spawn_points()[12] vehicle = world.try_spawn_actor(vehicle_blueprint, spawn_point) print('created vehicle') # Move spectator to newly created vehicle. world.tick() world.tick() spectator.set_transform(vehicle.get_transform()) print("Initial vehicle position: ", vehicle.get_transform().location) all_waypoints = world_map.generate_waypoints( 10) # meters between pickup/dropoff positions passenger_gen = PassengerGenerator(PASSENGER_ARRIVAL_RATE, rng) endpoint_selector = EndpointSelector() endpoint_selector.add_passenger_point( passenger_gen.generate_new_passenger(all_waypoints)) current_endpoint = endpoint_selector.next_endpoint() assert (current_endpoint is not None) print(current_endpoint.transform.location) planner = Planner(world_map, MAP_SAMPLING_RESOLUTION, WAYPOINT_ERROR_THRESHOLD) planner.set_endpoint(vehicle, current_endpoint) turn_controller = PurePursuitController(vehicle, target_speed=10) lane_keeping_controller = LaneKeepingController(vehicle, target_speed=10) print('Created controller') lanefinder = LaneFinder(world, vehicle) print('Created Lane Finder') world.tick() i = 0 while True: world.tick() world_snapshot = world.get_snapshot() time = world_snapshot.timestamp.elapsed_seconds if passenger_gen.new_passenger_arrived(time): endpoint_selector.add_passenger_point( passenger_gen.generate_new_passenger(all_waypoints)) target_waypoint = planner.get_target_waypoint(vehicle) while target_waypoint is None: current_endpoint = endpoint_selector.next_endpoint() if current_endpoint is None: target_waypoint = world_map.get_waypoint( vehicle.get_transform().location) break planner.set_endpoint(vehicle, current_endpoint) target_waypoint = planner.get_target_waypoint(vehicle) if i % 1 == 0: lanefinder.run_step() else: lanefinder.image_queue.get() road_option = planner.get_target_road_option(vehicle) if road_option == RoadOption.LANEFOLLOW or road_option == RoadOption.STRAIGHT: control = lane_keeping_controller.run_step( vehicle, target_waypoint, lanefinder.get_left_lane_x(), lanefinder.get_right_lane_x()) else: control = turn_controller.run_step(vehicle, target_waypoint) vehicle.apply_control(control) i += 1 finally: # Destroy vehicle. print("Destroy Vehicle") # client.apply_batch([carla.command.DestroyActor(vehicle), # carla.command.DestroyActor(lanefinder.sensor)]) if vehicle is not None: vehicle.destroy() if lanefinder is not None and lanefinder.sensor is not None: lanefinder.sensor.destroy()
curve_disp_3 = 'Right Radius = ' + str(np.round(right_curve_rad, 2)) + 'm' off_disp_txt = 'Car off track by ' + str(np.round(car_off, 2)) + 'm' cv2.putText(final_result, curve_disp_1, (30, 50), font, 1.5, (255, 255, 255), 2) cv2.putText(final_result, curve_disp_2, (30, 100), font, 1.5, (255, 255, 255), 2) cv2.putText(final_result, curve_disp_3, (30, 150), font, 1.5, (255, 255, 255), 2) cv2.putText(final_result, off_disp_txt, (30, 200), font, 1.5, (255, 255, 255), 2) return image final_result = display_on_frame(final_result, left_curve_rad=left_curve_rad, right_curve_rad=right_curve_rad, car_off=car_off) plt.imshow(final_result) plt.show() plt.imsave('output_images/final_result.png', final_result) from moviepy.editor import VideoFileClip frame_line_finder = LaneFinder() vid_output = 'project_solved.mp4' clip_source = VideoFileClip("project_video.mp4") vid_clip = clip_source.fl_image(frame_line_finder.Lane_find) vid_clip.write_videofile(vid_output, audio=False)