def main():
path = './inputvideos/'
video = 'project_video_1'
white_output = 'outputvideos/{}_done.mp4'.format(video)
clip1 = VideoFileClip('{}.mp4'.format(path+video))#.subclip(0,6)
white_clip = clip1.fl_image(process_image) # NOTE: this function expects color images!!
white_clip.write_videofile(white_output, audio=False)
def save_detected_lane_on_video(video_path):
"""Saves annotated video with lane detection"""
video = VideoFileClip(video_path)
video_annotated = video.fl_image(lane_detector.process_image)
name = os.path.basename(video_path)
video_annotated_file_name = '{}{}'.format(name.split('.')[0], ANNOTATED_VIDEO_SUFFIX)
video_annotated.write_videofile(video_annotated_file_name, audio=False)
def car_detection_on_video(in_path, out_path):
""" Performs car detection on each frame of the video """
car_detector = CarDetector()
clip = VideoFileClip(in_path)
video = clip.fl_image(car_detector.detect_cars)
video.write_videofile(out_path, audio=False)
def main():
# video = 'harder_challenge_video'
# video = 'challenge_video'
video = 'project_video'
white_output = '{}_done_2.mp4'.format(video)
clip1 = VideoFileClip('{}.mp4'.format(video)).subclip(30, 51)
white_clip = clip1.fl_image(process_image) # NOTE: this function expects color images!!
white_clip.write_videofile(white_output, audio=False)
def main():
#clip1 = VideoFileClip(args["input"])
#project_clip = clip1.fl_image(find_lane)
clip1 = VideoFileClip(VIDEOS[SELECTED_VIDEO])
project_clip = clip1.fl_image(find_lane)
project_output = VIDEOS[SELECTED_VIDEO][:-4] + '_ann.mp4'
project_clip.write_videofile(project_output, audio=False)
def video(input_video):
"""
Build video with vehicle detection boxes, number of vehicles detected
"""
original_video = '{}.mp4'.format(input_video)
video = VideoFileClip(original_video)
output_video = video.fl_image(process)
output_video.write_videofile('{}_output.mp4'.format(input_video),
audio=False)
def annotate_video(video_path, save=False):
"""Returns or saves annotated video"""
video = VideoFileClip(video_path)
video_annotated = video.fl_image(lane_detector.process_image)
if save:
video_annotated_file_name = '{}{}'.format(video_path.split('.')[0], ANNOTATED_VIDEO_SUFFIX)
video_annotated.write_videofile(video_annotated_file_name, audio=False)
else:
return video_annotated
def test_using_video():
video_output = '..\\project_video_out.mp4'
clip1 = VideoFileClip('..\\project_video.mp4')
ctr[0] = 0
video_clip = clip1.fl_image(
process_image) #NOTE: this function expects color images!!
video_clip.write_videofile(video_output, audio=False)
def main_video():
camera = prepare()
warper = Warper()
s = lane.LaneSearch(window_count=15)
clip = VideoFileClip('project_video.mp4')
#clip = clip.subclip(t_start=38, t_end=43)
#clip = clip.subclip(t_start=35, t_end=44)
result = clip.fl_image(process(camera, warper, s))
result.write_videofile('out.mp4', audio=False)
def main(video_name='other_video'):
if video_name.endswith('.mp4'):
video_name = video_name.rsplit('.', 1)[0]
white_output = '{}_done.mp4'.format(video_name)
# Uncomment the end of the line to analyze a subclip of the video.
clip1 = VideoFileClip('{}.mp4'.format(video_name)) #.subclip(0, 5)
white_clip = clip1.fl_image(
process_image) # NOTE: this function expects color images!!
white_clip.write_videofile(white_output, audio=False)
def process_video(video_file_name, input_video_dir, output_video_dir):
if not os.path.exists(output_directory + '/' + output_video_dir):
os.makedirs(output_directory + '/' + output_video_dir)
clip = VideoFileClip(input_video_dir + '/' + video_file_name)
output_clip = clip.fl_image(process_image)
video_file_output = output_directory + '/' + output_video_dir + '/' + video_file_name
output_clip.write_videofile(video_file_output, audio = False)
display(
HTML("""<video width="960" height="540" controls><source src="{0}"></video>""".format(video_file_output))
)
def detect_on_video(self, video_in_path=Constants.VIDEOS_IN_PATH):
dataset_utils = DatasetUtils(
detections_path=Constants.VIDEO_DETECTIONS_PATH)
video = VideoFileClip(video_in_path)
output_video = video.fl_image(self.detect)
extension = video_in_path.split(".")[-1]
filename = video_in_path.split('/')[-1].split('.')[0]
filename = filename + "_result." + extension
video_out_path = Constants.VIDEOS_OUT_PATH + filename
output_video.write_videofile(video_out_path, audio=False)
dataset_utils.save_detections(in_paths=[video_in_path],
out_paths=[video_out_path])
def process_video(name):
if os.path.exists(name) == False:
print("Can't find file:", name)
return
basename = os.path.basename(name)
head, ext = os.path.splitext(basename)
output_video = head + '_output' + ext
svc, scaler, dcspace, spatial_size, hist_bins, orient, pix_per_cell, cell_per_block, hog_channel, spatial_feat, hist_feat, hog_feat = load_classifier()
clip1 = VideoFileClip(name)
output_clip = clip1.fl_image(lambda frame: process_frame(frame, svc, scaler, dcspace, spatial_size,
hist_bins, orient, pix_per_cell, cell_per_block, hog_channel, spatial_feat, hist_feat, hog_feat))
output_clip.write_videofile(output_video, audio=False)
def main():
#input file name without extension type
video = 'project_video'
path = './inputvideos/'
video_in = path + video
time_name = time.strftime("%Y%m%d-%H%M%S")
white_output = 'output_videos/{}_{}.webm'.format(video, time_name)
#change the subclip size
clip1 = VideoFileClip('{}.mp4'.format(video_in)).subclip(1, 6)
white_clip = clip1.fl_image(
process_image) # NOTE: this function expects color images!!
white_clip.write_videofile(white_output, audio=False, codec='libvpx')
def process_video(self,
video_file,
file_out,
t_start=None,
t_end=None,
process_pool=None):
input_clip = VideoFileClip(video_file)
if t_start is not None:
input_clip = input_clip.subclip(t_start=t_start, t_end=t_end)
if self.debug:
self.processed_frames = []
stage_idx = 0
output_clip = input_clip.fl_image(
lambda frame: self.process_frame_stage(frame, stage_idx,
process_pool))
output_clip.write_videofile(file_out, audio=False)
if len(self.processed_frames) > 0:
out_file_path = os.path.split(file_out)
out_file_name = out_file_path[1].split('.')
for _ in range(len(self.processed_frames[0]) - 1):
self.frame_count = 0
stage_idx += 1
stage_file = '{}.{}'.format(
os.path.join(out_file_path[0], out_file_name[0]) +
'_' + str(stage_idx), out_file_name[1])
output_clip.write_videofile(stage_file, audio=False)
else:
output_clip = input_clip.fl_image(
lambda frame: self.process_frame(frame, process_pool))
output_clip.write_videofile(file_out, audio=False)
def process_video():
pipeline = get_pipeline()
clip = VideoFileClip(filename="./project_video.mp4")
class Processor:
def __init__(self):
self.heatmap = None
def bounding_box(self, image):
thresholded = np.multiply(np.copy(self.heatmap.thresholded), 255).round().astype('uint8')
thresholded = cv2.cvtColor(thresholded, cv2.COLOR_RGB2GRAY)
ret, thresh = cv2.threshold(thresholded, 0, 255, cv2.THRESH_BINARY)
im2, contours, hierarchy = cv2.findContours(thresh, 1, 2)
for contour in contours:
M = cv2.moments(contour)
x, y, w, h = cv2.boundingRect(contour)
image = cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
return image
def process(self, image):
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
if self.heatmap is None:
self.heatmap = Heatmap(
image=image,
cooldown_rate=0.05,
warmup_rate=0.1,
threshold=0.8
)
pipeline.process(image, self.heatmap)
image = self.bounding_box(image)
image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
return image
clip = clip.fl_image(Processor().process)
clip.write_videofile(filename="./project_video_output.mp4", audio=False)
pipeline.feature_extractor_cache.save()
def main(_):
model = DCSCN.SuperResolution(FLAGS, model_name=FLAGS.model_name)
model.build_graph()
model.build_optimizer()
model.build_summary_saver()
model.init_all_variables()
model.load_model()
video=FLAGS.file
lrclip=VideoFileClip(video).subclip(0,20)
audioclip=lrclip.audio
audioclip.write_audiofile('audio'+video[:-4]+'.mp3')
hrclip=lrclip.fl_image(model.doframe)
# hrclip.ipython_display()
# lrclip.ipython_display()
'''
Uncomment the line if you run the code in jupyter notebook
'''
hroutput='hr'+video
hrclip.write_videofile(hroutput, audio='audio'+video[:-4]+'.mp3', threads=8, progress_bar=False)
def main():
# Load parameters
parser = argparse.ArgumentParser(
description=
'Locates cars in video and places bounding boxes around them.',
usage='%(prog)s [ -vi & -vo | -img ]? [extra_options]')
parser.add_argument('-vi',
'--video_in',
type=str,
default='./data/test_videos/test_video.mp4',
help='Video to find cars in.')
parser.add_argument('-vo',
'--video_out',
type=str,
help='Where to save video to.')
parser.add_argument(
'-img',
'--images_in',
type=str,
help=
'Search path (glob style) to test images. Cars will be found in images rather than video.'
)
parser.add_argument(
'-clf',
'--clf_savefile',
type=str,
default='./data/trained_classifier.pkl',
help="File path to pickled trained classifier made by 'train.py'")
parser.add_argument(
'-sc',
'--scaler_savefile',
type=str,
default='./data/Xy_scaler.pkl',
help="File path to pickled StandardScalar made by 'train.py'")
parser.add_argument(
'-viz',
'--visualization',
type=str,
default='cars',
help=
"'cars' to draw bounding box around cars or 'windows' to show all the detected windows."
)
parser.add_argument('-st',
'--start',
type=int,
default=0,
help="Timestamp (seconds) to start video.")
parser.add_argument('-nd',
'--end',
type=int,
default=None,
help="Timestamp (seconds) to end video.")
args = parser.parse_args()
name, ext = args.video_in.split('/')[-1].rsplit('.', 1)
args.video_out = './output/{}_{}.{}'.format(name, args.visualization, ext)
# Set up car finder
print("Loading classifier from '{}'.".format(args.clf_savefile))
clf = joblib.load(args.clf_savefile)
print("Loading scaler from '{}'.".format(args.scaler_savefile))
scaler = joblib.load(args.scaler_savefile)
fvb = CarFeatureVectorBuilder(feature_scaler=scaler)
car_finder = CarFinder(clf, fvb, args.visualization)
# Find cars in...
if args.images_in is not None: # run on images
print('\nSearching for cars in images...')
imgs = []
files = sorted(glob(args.images_in))
for imgf in files:
# Find cars
image = plt.imread(imgf)
display_img = car_finder.find_cars(image, single=True)
imgs.append(display_img)
n_col = 3
fig, axes = plt.subplots(len(files) // n_col + 1, n_col)
for ax, f, img in zip(axes.flatten(), files, imgs):
ax.imshow(img)
ax.set_title(f)
ax.axis('off')
plt.show()
else: # run on video
print("\nFinding cars in '{}',\nthen saving to '{}'...".format(
args.video_in, args.video_out))
input_video = VideoFileClip(args.video_in)
output_video = input_video.fl_image(car_finder.find_cars).subclip(
args.start, args.end)
output_video.write_videofile(args.video_out, audio=False)
#
# undist = undistort(image, calib_params)
#
# # Warp
# warped, M = bird_view(undist)
#
# # Threshold
# binary_image = threshold_image(warped)
# Plot the result
# result = binary_image
# f, (ax1, ax2) = plt.subplots(1, 2, figsize=(24, 9))
# f.tight_layout()
#
# ax1.imshow(image)
# ax1.set_title('Original Image', fontsize=40)
#
# ax2.imshow(result, cmap='gray')
# ax2.set_title('Pipeline Result', fontsize=40)
# plt.subplots_adjust(left=0., right=1, top=0.9, bottom=0.)
# plt.savefig('result.jpg')
# plt.show()
# Process video
Left = Line("left")
Right = Line("right")
video_output = 'result.mp4'
clip1 = VideoFileClip("project_video.mp4") #.subclip(40, 43)
white_clip = clip1.fl_image(process)
white_clip.write_videofile(video_output, audio=False)
def process_and_save_video(input, output, pipeline):
clip = VideoFileClip(input)
white_clip = clip.fl_image(pipeline)
white_clip.write_videofile(output, audio=False)
def process_image(base_img):
global BASE_IMG, CANNY_IMG
BASE_IMG = base_img
ysize = base_img.shape[0]
xsize = base_img.shape[1]
image = to_hsv(base_img)
image = gaussian_blur(image, 3)
image = filter_color(image)
image = canny(image, 30, 130)
CANNY_IMG = image
image = region_of_interest(
image,
np.array([[(40, ysize), (xsize / 2, ysize / 2 + 40),
(xsize / 2, ysize / 2 + 40), (xsize - 40, ysize)]],
dtype=np.int32))
image = hough_lines(image, 1, np.pi / 90, 10, 15, 10)
# return image
return weighted_img(image, base_img, β=250.)
# src_img = (matplotlib.image.imread('../vlcsnap-error105.png') * 255).astype('uint8')
# src_img = process_image(src_img)
# plt.imshow(src_img, cmap='hsv_r')
# plt.show()
white_output = 'challengeDone.mp4'
clip1 = VideoFileClip('challenge.mp4') # .subclip(14, 16)
white_clip = clip1.fl_image(
process_image) # NOTE: this function expects color images!!
white_clip.write_videofile(white_output, audio=False)
def pipe(img):
draw_img = np.copy(img)
box_list = []
out_img, _list = find_cars(img, draw_img, 1, classifier.svc, classifier.X_scaler, classifier.orient,
classifier.pix_per_cell, classifier.cell_per_block, classifier.spatial,
classifier.histbin)
box_list = box_list + _list
out_img, _list = find_cars(img, draw_img, 1.5, classifier.svc, classifier.X_scaler, classifier.orient,
classifier.pix_per_cell, classifier.cell_per_block, classifier.spatial,
classifier.histbin)
box_list = box_list + _list
out_img, _list = find_cars(img, draw_img, 2, classifier.svc, classifier.X_scaler, classifier.orient,
classifier.pix_per_cell, classifier.cell_per_block, classifier.spatial,
classifier.histbin)
box_list = box_list + _list
draw_img, heatmap = heat_map(img, box_list)
return draw_img
if __name__ == '__main__':
# clip = VideoFileClip("test_video.mp4")
# processed_clip = clip.fl_image(pipe) # NOTE: this function expects color images!!
# processed_clip.write_videofile("test_video_out.mp4", audio=False)
clip = VideoFileClip("project_video.mp4")
processed_clip = clip.fl_image(pipe) # NOTE: this function expects color images!!
processed_clip.write_videofile("project_video_out.mp4", audio=False)
FRAME_SHAPE = (1280, 720)
HIST_STEPS = 10
OFFSET = 250
FRAME_MEMORY = 7
SRC = np.float32([(132, 703), (540, 466), (740, 466), (1147, 703)])
DST = np.float32([(SRC[0][0] + OFFSET, 720), (SRC[0][0] + OFFSET, 0),
(SRC[-1][0] - OFFSET, 0), (SRC[-1][0] - OFFSET, 720)])
VIDEOS = [
"../videos/project_video.mp4", "../videos/challenge_video.mp4",
"../videos/harder_challenge_video.mp4"
]
SELECTED_VIDEO = 0
if __name__ == '__main__':
cam_calibration = get_camera_calibration()
cam_calibrator = CameraCalibrator(FRAME_SHAPE, cam_calibration)
ld = LaneDetector(SRC,
DST,
n_frames=FRAME_MEMORY,
cam_calibration=cam_calibrator,
transform_offset=OFFSET)
clip1 = VideoFileClip(VIDEOS[SELECTED_VIDEO])
project_clip = clip1.fl_image(ld.process_frame)
project_output = VIDEOS[SELECTED_VIDEO][:-4] + '_ann.mp4'
project_clip.write_videofile(project_output, audio=False)
undist = cv2.undistort(img, mtx, dist, None, mtx)
# Get color and
thresh_img = get_thresh(img)
top_down, Minv = perspective_transform(thresh_img)
yvals, left_fitx, right_fitx, left_curve, right_curve = collect_points(
top_down)
result = display_rewarp(yvals, left_fitx, right_fitx, img, top_down, Minv,
undist, left_curve, right_curve)
return result
# 4 instances of Line class, two for current lanes (left and right), and two for storing information about all
# detected lines
left_line = Line()
right_line = Line()
left_curr = Line()
right_curr = Line()
video_output = 'video_out_0129_2.mp4'
clip1 = VideoFileClip("project_video.mp4")
# Load calibration matricies
with open("camera_cal/camera_dist_pickle.p", mode='rb') as f:
pfile = pickle.load(f)
mtx = pfile["mtx"]
dist = pfile["dist"]
# Perform image processing on each frame and save new video
video_clip = clip1.fl_image(process_frame)
video_clip.write_videofile(video_output, audio=False)
offset = img_size[0] * 0.25 destination_points = np.float32( [ [offset, 0], [img_size[0] - offset, 0], [offset, img_size[1]], [img_size[0] - offset, img_size[1]], ] ) # Calculating the perspective transform M and its inverse based on the source points and the destination points. M = cv2.getPerspectiveTransform(source_points, destination_points) M_inverse = cv2.getPerspectiveTransform(destination_points, source_points) video_clip1 = clip1.fl_image(process_image) video_clip1.write_videofile(output_video1, audio=False) # output_video1 = 'test_videos_output/challenge_video_tracked.mp4' # input_video1 = 'test_videos/challenge_video.mp4' # clip1 = VideoFileClip(input_video1) # video_clip1 = clip1.fl_image(process_image) # video_clip1.write_videofile(output_video1, audio=False) # # output_video1 = 'test_videos_output/harder_challenge_video_tracked.mp4' # input_video1 = 'test_videos/harder_challenge_video.mp4' # clip1 = VideoFileClip(input_video1) # video_clip1 = clip1.fl_image(process_image) # video_clip1.write_videofile(output_video1, audio=False)
lane.get_curvature(), lane.get_position())
cv2.putText(undistorted,
radius_label, (0, 24),
cv2.FONT_HERSHEY_SIMPLEX,
1, (255, 0, 0),
thickness=2)
unwarped_lane_projection = unwarp(lane.get_projection(image))
return cv2.addWeighted(undistorted, 1, unwarped_lane_projection, 0.3, 0)
if __name__ == '__main__':
test_images = glob.glob('../test_images/*.jpg')
output_images = []
for test_image in test_images:
image = cv2.imread(test_image)
result = process_image(image,
smooth=False,
threshold=0.0,
use_mask=False)
output_images.append(image)
output_images.append(result)
collage = util.collage(output_images, len(test_images), 2)
cv2.imwrite('../output_images/pipeline.png', collage)
input_clip = VideoFileClip('../project_video.mp4')
output_clip = input_clip.fl_image(process_image)
output_clip.write_videofile('../output.mp4', audio=False)
hough_img = list(map(linedetect, canny_img))
def weightSum(input_set):
img = list(input_set)
return cv2.addWeighted(img[0], 1, img[1], 0.8, 0)
result_img = list(map(weightSum, zip(hough_img, imageList)))
# display_images(result_img)
def processImage(image):
interest = roi(image)
filterimg = color_filter(interest)
canny = cv2.Canny(grayscale(filterimg), 50, 120)
myline = hough_lines(canny, 1, np.pi / 180, 10, 20, 5)
weighted_img = cv2.addWeighted(myline, 1, image, 0.8, 0)
return weighted_img
# we can use camera instead of video clip(port 1 open for usb camera so we can make use of that)
output1 = 'test_videos_output/challenge.mp4'
clip1 = VideoFileClip("test_videos/challenge.mp4")
pclip1 = clip1.fl_image(
processImage) # NOTE: this function expects color images!!
pclip1.write_videofile(output1, audio=False)
def processVideo(input_path, output_path, detection_method, audio=False):
video = VideoFileClip(input_path)
output_video = video.fl_image(detection_method)
output_video.write_videofile(output_path, audio=False)
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')
ytop_draw + win_draw + ystart)))
return boxes
def pipeline_keras(image):
scale = 1.5
boxes = find_cars(image, 400, 670, 0, 1280, scale, model, X_scaler, orient,
pix_per_cell, cell_per_block, spatial_size, hist_bins)
scale = 2
boxes.extend(
find_cars(image, 400, 670, 0, 1280, scale, model, X_scaler, orient,
pix_per_cell, cell_per_block, spatial_size, hist_bins))
print boxes
image = draw_boxes(image, boxes, (0, 255, 0), 1)
return image
white_output = 'output_keras_v1.mp4'
clip1 = VideoFileClip("project_video.mp4")
# white_clip = clip1.subclip(2,7).fl_image(process_imagev2) #NOTE: this function expects color images!!
white_clip = clip1.fl_image(
pipeline_keras) #NOTE: this function expects color images!!
white_clip.write_videofile(white_output, audio=False)
file_name = 'test_images/test17.jpg'
def pipeline(file_name):
image = mpimg.imread(file_name)
return pipeline_keras(image)
