def __call__(self, img):
undistorted = camera.undistort(img, self.mtx, self.dist)
thresh_img = processImage(undistorted)
warped, Minv = perspective.warp(thresh_img)
leftx_poly, rightx_poly = self.lanefinder.findLanes(warped)
polygon = vis.drawLaneWithPolygon(warped, leftx_poly, rightx_poly,
self.ploty)
polygon = perspective.unwarp(polygon, Minv)
combined = cv2.addWeighted(undistorted, 1.0, polygon, 0.3, 0)
curvature = self.lanefinder.getCurvature()
car_offset = self.lanefinder.getCarOffset()
cv2.putText(combined,
"Curvature Radius:" + "{:5.2f}km".format(curvature),
(20, 40), cv2.FONT_HERSHEY_SIMPLEX, 1.0, [255, 255, 255],
2, cv2.LINE_AA)
cv2.putText(
combined,
"Distance from Center:" + '{:5.2f}cm'.format(car_offset * 100),
(20, 80), cv2.FONT_HERSHEY_SIMPLEX, 1.0, [255, 255, 255], 2,
cv2.LINE_AA)
return combined
def find_lane(img, prev_lane: Lane, standard_lane_params=STANDARD_LANE_PARAMS):
mtx, dst = cam.load_calibration_results()
undistort = cam.undistort(img, mtx, dst, True)
process = pr.prepare_for_thresholding(undistort)
binary = pr.threshold(process)
src, dst = pr.load_perspective_points()
M, Minv, binary_warped = pr.perspective_transform(binary, src, dst)
if prev_lane is None or not prev_lane.detected:
leftx, lefty, rightx, righty = det.sliding_window(binary_warped)
else:
leftx, lefty, rightx, righty = det.search_around_poly(
binary_warped, prev_lane.left.current_fit,
prev_lane.right.current_fit)
left_fit, right_fit = det.fit_poly(leftx, lefty, rightx, righty)
left_line = Line(left_fit, leftx, lefty)
right_line = Line(right_fit, rightx, righty)
prev_left = None if prev_lane is None else prev_lane.left
prev_right = None if prev_lane is None else prev_lane.right
lane = Lane(undistort, binary_warped, M, Minv, left_line, right_line,
prev_left, prev_right, standard_lane_params)
return lane
def process_image(image):
"""
Image pre-processing pipeline.
"""
image = np.copy(image)
image = undistort(image)
image = thresholds.default(image)
image = perspective.transform(image)
return image
def process_image(image):
orgImage = image.copy()
# 1. Camera calibration and 2. Distortion correction
image = camera.undistort(image)
# 3. Color/gradient threshold, combination binary image
image = threshold.pipeline(image)
# 4.Perspective transform warp image
warpedImage = transform.warp(image)
# 5. Detect lane lines
# 6. Determine the lane curvature
line.laneDetect(warpedImage)
# 7. OutPut the result Image
image = line.reslutImage(orgImage,warpedImage)
return image
def get_perspective_transform_matrices():
if not hasattr(get_perspective_transform_matrices, 'M'):
if not os.path.exists('test_images/straight_lines1_undistorted.jpg'):
image = undistort(mpimg.imread('test_images/straight_lines1.jpg'))
mpimg.imsave('test_images/straight_lines1_undistorted.jpg', image)
else:
image = mpimg.imread('test_images/straight_lines1_undistorted.jpg')
nx, ny = image.shape[:2][::-1]
src = np.float32([(0,ny-93-1), (572-1-9,ny-275-1),
(nx-562-1, ny-275-1), (nx-1, ny-93-1)])
dst = np.float32([src[0], (src[0][0], 0),
(src[3][0], 0), src[3]])
get_perspective_transform_matrices.M = cv2.getPerspectiveTransform(src, dst)
get_perspective_transform_matrices.Minv = cv2.getPerspectiveTransform(dst, src)
return get_perspective_transform_matrices.M, get_perspective_transform_matrices.Minv
import cv2
import camera
cap = cv2.VideoCapture("nvcamerasrc ! video/x-raw(memory:NVMM), width=(int)320, height=(int)160,format=(string)I420, framerate=(fraction)30/1 ! nvvidconv flip-method=0 ! video/x-raw, format=(string)BGRx ! videoconvert ! video/x-raw, format=(string)BGR ! appsink")
i = 0
mtx, dist = camera.load_calibration()
while cap.isOpened():
ret, frame = cap.read()
frame = camera.undistort(frame, mtx, dist)
frame = cv2.resize(frame, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)
cv2.imshow('frame', frame)
key = cv2.waitKey(10) & 0xFF
if key == ord('q'):
break
elif key == ord('s'):
cv2.imwrite(str(i) + '.jpg', frame)
i += 1
cv2.destroyAllWindows()
cap.release()