def main(in_path: str, ref_channel: str, out_dir: str, n_workers: int, tile_size: int, overlap: int, ):
if not osp.exists(out_dir):
os.makedirs(out_dir)
if n_workers == 1:
dask.config.set({'scheduler': 'synchronous'})
else:
dask.config.set({'num_workers': n_workers, 'scheduler': 'processes'})
st = datetime.now()
with tif.TiffFile(in_path, is_ome=True) as stack:
ome = stack.ome_metadata
cycle_size, ncycles, first_ref_position = get_cycle_composition(ome, ref_channel)
block_width = tile_size
block_height = tile_size
overlap = overlap
warper = Warper()
warper.block_w = block_width
warper.block_h = block_height
warper.overlap = overlap
# perform registration of full stack
register(in_path, out_dir, cycle_size, ncycles, first_ref_position, ome, warper, block_width, block_height, overlap)
fin = datetime.now()
print('time elapsed', fin - st)
def __init__(self, gray_shape, objpoints, imgpoints):
self.camera_undistort = CameraUndistort(gray_shape, objpoints,
imgpoints)
self.gradient_filter = GradientFilter()
self.warper = Warper(gray_shape)
self.window_searcher = WindowSearcher()
self.cnt = 0
def __init__(self, opts):
super(Loss, self).__init__()
self.ssim_wt = opts.ssim_wt
self.l1_wt = opts.l1_wt
self.smooth_wt = opts.smooth_wt
self.ssim = SSIM(opts)
self.warper = Warper(opts)
# for debugging only
self.recon_im = []
def process_level(self, level, u0, v0):
I0_ = self.I0pyr[level]
I1_ = self.I1pyr[level]
#print I1_.shape, u0.shape, self.I0pyr[level].shape
wrpr = Warper(I0_.shape, u0, v0, I0_, I1_,
train_function=self.class_train_function(u0, v0, **self.train_function_args), display=0)
for i in range(self.warps):
wrpr.warp()
self.u, self.v = wrpr.u, wrpr.v
class Loss():
def __init__(self, opts):
super(Loss, self).__init__()
self.ssim_wt = opts.ssim_wt
self.l1_wt = opts.l1_wt
self.smooth_wt = opts.smooth_wt
self.ssim = SSIM(opts)
self.warper = Warper(opts)
# for debugging only
self.recon_im = []
def __call__(self, in_data, disp):
left_im = in_data['left_im']
right_im = in_data['right_im']
right_recon = self.warper.warp(left_im, disp)
self.recon_im = right_recon
photo_loss = self.ssim_wt * self.ssim(right_im, right_recon).mean() + \
self.l1_wt * (right_recon - right_im).abs().mean()
smooth_loss = self.compute_smooth_loss(disp, left_im)
net_loss = (1.0 - self.smooth_wt) * photo_loss + self.smooth_wt * smooth_loss
return {'photo_loss': photo_loss,
'smooth_loss': smooth_loss}, net_loss
def compute_smooth_loss(self, depth, frame):
depth = depth.unsqueeze(1)
mean_depth = depth.mean(2, True).mean(3, True)
n_depth = depth / (mean_depth + 1e-7)
grad_depth_x = torch.abs(n_depth[:, :, :, :-1] - n_depth[:, :, :, 1:])
grad_depth_y = torch.abs(n_depth[:, :, :-1, :] - n_depth[:, :, 1:, :])
grad_fr_x = torch.mean(torch.abs(frame[:, :, :, :-1] - frame[:, :, :, 1:]), 1, keepdim=True)
grad_fr_y = torch.mean(torch.abs(frame[:, :, :-1, :] - frame[:, :, 1:, :]), 1, keepdim=True)
wt_grad_depth_x = grad_depth_x * torch.exp(-grad_fr_x)
wt_grad_depth_y = grad_depth_y * torch.exp(-grad_fr_y)
return torch.mean(wt_grad_depth_x) + torch.mean(wt_grad_depth_y)
def main():
flag = False
cap = cv2.VideoCapture("canny2.avi")
while True:
# 이미지를 캡쳐
ret, img = cap.read()
# 캡쳐되지 않은 경우 처리
if not ret:
break
if cv2.waitKey(0) & 0xFF == 27:
break
# Warper 객체 생성 (초기 1번만)
if not flag:
flag = True
global warper
warper = Warper(img)
# warper, slidewindow 실행
slideImage, x_location = process_image(img)
cv2.imshow("originImage", img)
# cv2.imshow("warper", warper.warp(img))
cv2.imshow("slidewindow", slideImage)
def process_level(self, level, u0, v0):
I0_ = self.I0pyr[level]
I1_ = self.I1pyr[level]
#print I1_.shape, u0.shape, self.I0pyr[level].shape
wrpr = Warper(I0_.shape,
u0,
v0,
I0_,
I1_,
train_function=self.class_train_function(
u0, v0, **self.train_function_args),
display=0)
for i in range(self.warps):
wrpr.warp()
self.u, self.v = wrpr.u, wrpr.v
def main(in_path: str, ref_channel: str, out_dir: str, n_workers: int, tile_size: int, overlap: int, method: str):
if not osp.exists(out_dir):
os.makedirs(out_dir)
if n_workers == 1:
dask.config.set({'scheduler': 'synchronous'})
else:
dask.config.set({'num_workers': n_workers, 'scheduler': 'processes'})
avail_methods = ('farneback', 'denselk', 'deepflow', 'rlof', 'pcaflow')
if method not in avail_methods:
raise ValueError('Provided opt flow method is not recognised. ' +
'\nAvailable methods: ' + str(avail_methods))
print('Using method', method)
st = datetime.now()
with tif.TiffFile(in_path, is_ome=True) as stack:
ome = stack.ome_metadata
cycle_size, ncycles, first_ref_position = get_cycle_composition(ome, ref_channel)
block_width = tile_size
block_height = tile_size
overlap = overlap
warper = Warper()
warper.block_w = block_width
warper.block_h = block_height
warper.overlap = overlap
# perform registration of full stack
register(in_path, out_dir,
cycle_size, ncycles,
first_ref_position, ome, warper,
block_width, block_height, overlap, method)
fin = datetime.now()
print('time elapsed', fin - st)
def main():
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
#cudnn.benchmark = True
pidcal = PidCal()
opt = opts.parse()
warper = Warper()
slidewindow = SlideWindow()
print(("device id: {}".format(torch.cuda.current_device())))
print("torch.version", torch.__version__)
print("cuda_version", torch.version.cuda)
models = importlib.import_module('models.init')
# print(models)
criterions = importlib.import_module('criterions.init')
checkpoints = importlib.import_module('checkpoints')
Trainer = importlib.import_module('models.' + opt.netType + '-train')
# Data loading
print('=> Setting up data loader')
# Load previous checkpoint, if it exists
print('=> Checking checkpoints')
checkpoint = checkpoints.load(opt)
# Create model
model, optimState = models.setup(opt, checkpoint)
model.cuda()
criterion = criterions.setup(opt, checkpoint, model)
##################################################################################
model.eval()
cap = cv2.VideoCapture("input_video/test.avi")
if cap.isOpened():
print("width : {}, height : {}".format(cap.get(3), cap.get(4)))
video_width = int(cap.get(3))
video_height = int(cap.get(4))
fourcc = cv2.VideoWriter_fourcc('M', 'J', 'P', 'G')
# out = cv2.VideoWriter('output_video/TEST_1.avi', fourcc, 20.0, (1280,480),0)
prev_time = 0
fps_list = []
# fourcc =cv2.VideoWriter_fourcc(*'MJPG')
out = cv2.VideoWriter('input_video/processed_video.avi', fourcc, 40.0,
(480, 320), 0)
steer_list = list()
lpf_list = list()
while True:
ret, frame = cap.read()
if ret:
cur_time = time.time()
frame_new = cv2.resize(frame, (320, 180))
input_img = frame_new / 255.
input_img = preprocess_img(input_img)
# array to tensor
input_img = torch.from_numpy(input_img).float()
with torch.no_grad():
inputData_var = Variable(input_img).unsqueeze(0).cuda()
# inference
output = model.forward(inputData_var)
output = torch.sigmoid(output)
#output = F.softmax(output, dim=1)
# gpu -> cpu, tensor -> numpy
output = output.detach().cpu().numpy()
output = output[0]
output = postprocess_img(output)
output = np.clip(output, 0, 1)
output *= 255
output = np.uint8(output)
output = cv2.resize(output, (640, 360))
output[output > 80] = 255
output[output <= 80] = 0
warper_img, point_img = warper.warp(output)
ret, left_start_x, right_start_x, cf_img = slidewindow.w_slidewindow(
warper_img)
if ret:
left_x_current, right_x_current, sliding_img, steer_theta = slidewindow.h_slidewindow(
warper_img, left_start_x, right_start_x)
cv2.imshow('sliding_img', sliding_img)
steer_list.append(steer_theta)
lpf_result = lpf(steer_theta, 0.5)
lpf_list.append(lpf_result)
print("steer theta:", steer_theta)
if steer_theta < -28 or steer_theta > 28:
continue
else:
pid = round(pidcal.pid_control(int(50 * steer_theta)),
6)
print("pid :", pid)
'''
auto_drive(pid)
'''
else:
pidcal.error_sum = 0
end_time = time.time()
sec = end_time - cur_time
fps = 1 / sec
fps_list.append(fps)
print("Estimated fps {0} ".format(fps))
# out.write(add_img)
cv2.imshow("frame", frame)
out.write(warper_img)
# cv2.imshow("src", warper_img)
# cv2.imshow("out_img", output)
cv2.imshow("cf_img", cf_img)
key = cv2.waitKey(1) & 0xFF
if key == 27: break
elif key == ord('p'):
cv2.waitKey(-1)
plt.figure(1)
plt.plot(steer_list)
plt.figure(2)
plt.plot(lpf_list)
plt.show()
def depth_callback(self, data):
try:
global depth
depth = self.bridge.imgmsg_to_cv2(data, "32FC1")
# cv_image.astype('uint8')
except CvBridgeError as e:
print(e)
# out.write(cv_image)
# print depth.shape
# cv2.imshow('Depth', depth)
# cv2.waitKey(1)
if __name__ == '__main__':
rospy.init_node('image_display', anonymous=True)
threshold_object = Thresholder()
warp_object = Warper()
fitt_object = Polyfitter()
draw_object = Polydrawer()
# fourcc = cv2.VideoWriter_fourcc('M', 'J', 'P', 'G')
fourcc = cv2.VideoWriter_fourcc(*'XVID')
out = cv2.VideoWriter('test.avi', fourcc, 30.0, (1080, 720))
image_object = Image_process()
try:
rospy.spin()
except KeyboardInterrupt:
rospy.is_shutdown()
print 'Shutting Down'
out.release()
cv2.destroyAllWindows()
def main():
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
#cudnn.benchmark = True
opt = opts.parse()
warper = Warper()
#slidewindow = SlideWindow()
# slidewindow = LineDetector()
pidcal = PidCal()
print(("device id: {}".format(torch.cuda.current_device())))
print("torch.version", torch.__version__)
print("cuda_version", torch.version.cuda)
models = importlib.import_module('models.init')
# print(models)
criterions = importlib.import_module('criterions.init')
checkpoints = importlib.import_module('checkpoints')
Trainer = importlib.import_module('models.' + opt.netType + '-train')
# Data loading
print('=> Setting up data loader')
#trainLoader, valLoader = DataLoader.create(opt)
#print('opt',opt)
# Load previous checkpoint, if it exists
print('=> Checking checkpoints')
checkpoint = checkpoints.load(opt)
# Create model
model, optimState = models.setup(opt, checkpoint)
model.cuda()
criterion = criterions.setup(opt, checkpoint, model)
##################################################################################
model.eval()
cap = cv2.VideoCapture(
"/home/foscar/ISCC_2019/src/race/src/my_lane_detection/input_video/0.avi"
)
ret, frame = cap.read()
slidewindow = LineDetector(frame)
if cap.isOpened():
print("width : {}, height : {}".format(cap.get(3), cap.get(4)))
video_width = int(cap.get(3))
video_height = int(cap.get(4))
fourcc = cv2.VideoWriter_fourcc(*'DIVX')
video_name = time.time()
out = cv2.VideoWriter('output_video/{}.avi'.format(video_name), fourcc,
25.0, (video_width, video_height), 0)
prev_time = 0
count = 0
while True:
ret, frame = cap.read()
count += 1
if ret:
cur_time = time.time()
frame = cv2.resize(frame, (480, 360))
input_img = frame / 255.
input_img = preprocess_img(input_img)
# array to tensor
input_img = torch.from_numpy(input_img).float()
with torch.no_grad():
inputData_var = Variable(input_img).unsqueeze(0).cuda()
# inference
output = model.forward(inputData_var)
print("output.shape : ", output.shape)
# gpu -> cpu, tensor -> numpy
output = output.detach().cpu().numpy()
output = output[0]
output = postprocess_img(output)
# cv2.imshow("203",output)
output *= 255
output = np.clip(output, 0, 255)
output = np.uint8(output)
# resize
output = cv2.resize(output, (640, 480))
# cv2.imshow('resize',output)
# threshold
ret, thr_img = cv2.threshold(output, 20, 255, 0)
# cv2.imshow('threshold',thr_img)
# warp
warp_img = warper.warp(thr_img)
# cv2.imshow('warped',warp_img)
# cv2.imshow("new output", canny_like_output)
#canny = cv2.Canny(warp_img, 40, 255)
kernel1 = np.array([[-1, -1, -1], [-1, 9, -1], [-1, -1, -1]])
kernel2 = np.ones((
5,
5,
), np.uint8)
#dilate = cv2.dilate(warp_img, kernel1, iterations=2)
#closed = cv2.morphologyEx(dilate, cv2.MORPH_OPEN, kernel2)
# x_start_L, x_start_R=slidewindow.find_sliding_point(warp_img)
# img, x_location = slidewindow.slide_window(x_start_L,x_start_R,warp_img)
slided_img, x_location, point_list_left, point_list_right = slidewindow.main(
warp_img)
if x_location != None:
# cv2.circle(img,(int(x_location),300),5,(0,0,255),3)
pid = round(pidcal.pid_control(int(x_location)), 6)
#print("pid rate : ", pid)
auto_drive(pid, x_location)
else:
pid = pidcal.pid_control(slidewindow_middle)
print("pid rate : ", pid)
auto_drive(pid)
end_time = time.time()
sec = end_time - cur_time
fps = 1 / sec
fps_list.append(fps)
print("Estimated fps {0} ".format(fps))
out.write(output)
cv2.imshow("src", frame)
pid_draw.append(pid)
# cv2.imshow("th_img", thr_img)
# cv2.imshow("output", output)
# img = cv2.imread('/home/foscar/Downloads/wapped_screenshot_12.08.2020.png',cv2.IMREAD_GRAYSCALE)
# img = cv2.resize(img, (640, 480))
# ret, thr_img = cv2.threshold(img,20,255,cv2.THRESH_BINARY)
# img ,xloc, point_list_left, point_list_right = slidewindow.main(thr_img)
# plt.xlim(0,640)
# plt.ylim(0,480)
# plt.plot(point_list_left[0], point_list_left[1])
# plt.plot(point_list_right[0], point_list_right[1])
# plt.show()
# cv2.imshow('aa',img)
# key = cv2.waitKey(1) & 0xFFx
# if key == 27: break
# elif key == ord('p'):
# cv2.waitKey(-1)
cv2.imshow("ws", slided_img)
print("x_loc :", x_location)
key = cv2.waitKey(1) & 0xFF
if key == 27: break
elif key == ord('p'):
cv2.waitKey(-1)
def main():
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
#cudnn.benchmark = True
opt = opts.parse()
warper = Warper()
slidewindow = SlideWindow()
pidcal = PidCal()
print(("device id: {}".format(torch.cuda.current_device())))
print("torch.version",torch.__version__)
print("cuda_version",torch.version.cuda)
models = importlib.import_module('models.init')
# print(models)
criterions = importlib.import_module('criterions.init')
checkpoints = importlib.import_module('checkpoints')
Trainer = importlib.import_module('models.' + opt.netType + '-train')
# Data loading
print('=> Setting up data loader')
#trainLoader, valLoader = DataLoader.create(opt)
#print('opt',opt)
# Load previous checkpoint, if it exists
print('=> Checking checkpoints')
checkpoint = checkpoints.load(opt)
# Create model
model, optimState = models.setup(opt, checkpoint)
model.cuda()
criterion = criterions.setup(opt, checkpoint, model)
##################################################################################
model.eval()
cap = cv2.VideoCapture(0)
if cap.isOpened():
print("width : {}, height : {}".format(cap.get(3), cap.get(4)))
video_width = int(cap.get(3))
video_height = int(cap.get(4))
fourcc = cv2.VideoWriter_fourcc(*'DIVX')
video_name = time.time()
out = cv2.VideoWriter('output_video/{}.avi'.format(video_name), fourcc, 25.0, (video_width,video_height),0)
prev_time = 0
fps_list = []
while True:
ret, frame = cap.read()
if ret:
cur_time = time.time()
frame = cv2.resize(frame, (480,360))
input_img = frame / 255.
input_img = preprocess_img(input_img)
# array to tensor
input_img = torch.from_numpy(input_img).float()
with torch.no_grad():
inputData_var = Variable(input_img).unsqueeze(0).cuda()
# inference
output = model.forward(inputData_var)
print("output.shape : ", output.shape)
# gpu -> cpu, tensor -> numpy
output = output.detach().cpu().numpy()
output = output[0]
output = postprocess_img(output)
output *= 255
output = np.clip(output, 0, 255)
output = np.uint8(output)
# resize
output = cv2.resize(output, (640, 480))
# threshold
ret, thr_img = cv2.threshold(output, 180, 255, 0)
# warp
output, warp_img = warper.warp(output, thr_img)
img, x_location = slidewindow.slidewindow(warp_img)
if x_location != None:
pid = round(pidcal.pid_control(int(x_location)), 6)
print("pid rate : ", pid)
auto_drive(pid, x_location)
else:
pid = pidcal.pid_control(320)
print("pid rate : ", pid)
auto_drive(pid)
end_time = time.time()
sec = end_time - cur_time
fps = 1/sec
fps_list.append(fps)
print("Estimated fps {0} " . format(fps))
out.write(output)
cv2.imshow("src", frame)
cv2.imshow("output", output)
cv2.imshow("thre", img)
key = cv2.waitKey(1) & 0xFF
if key == 27: break
elif key == ord('p'):
cv2.waitKey(-1)
def main():
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
#cudnn.benchmark = True
pidcal = PidCal()
opt = opts.parse()
warper = Warper()
slidewindow = SlideWindow()
stopline = StopLine()
print(("device id: {}".format(torch.cuda.current_device())))
print("torch.version",torch.__version__)
print("cuda_version",torch.version.cuda)
models = importlib.import_module('models.init')
# print(models)
criterions = importlib.import_module('criterions.init')
checkpoints = importlib.import_module('checkpoints')
Trainer = importlib.import_module('models.' + opt.netType + '-train')
# Data loading
print('=> Setting up data loader')
# Load previous checkpoint, if it exists
print('=> Checking checkpoints')
checkpoint = checkpoints.load(opt)
# Create model
model, optimState = models.setup(opt, checkpoint)
model.cuda()
criterion = criterions.setup(opt, checkpoint, model)
##################################################################################
model.eval()
cap = None
if opt.video_idx is 0:
cap = cv2.VideoCapture("input_video/720p.mp4")
elif opt.video_idx is 1:
cap = cv2.VideoCapture("input_video/straight.avi")
elif opt.video_idx is 2:
cap = cv2.VideoCapture("input_video/test.avi")
elif opt.video_idx is 3:
cap = cv2.VideoCapture("input_video/track.avi")
elif opt.video_idx is 4:
cap =cv2.VideoCapture("output_video/field.avi")
elif opt.video_idx is 5:
cap = cv2.VideoCapture("output_video/2020-08-23 19:20:01.166517.avi")
else:
cap = cv2.VideoCapture(0)
# video test
cap.set(3,1280)
cap.set(4,720)
if cap.isOpened():
print("width : {}, height : {}".format(cap.get(3), cap.get(4)))
video_width = int(cap.get(3))
video_height = int(cap.get(4))
#fourcc = cv2.VideoWriter_fourcc('M','J','P','G')
# out = cv2.VideoWriter('output_video/TEST_1.avi', fourcc, 20.0, (1280,480),0)
prev_time = 0
fps_list = []
now = datetime.datetime.now()
fourcc = None
out = None
if opt.video_idx > 2:
fourcc =cv2.VideoWriter_fourcc(*'MJPG')
out = cv2.VideoWriter('output_video/' + str(now) + '.avi',fourcc,30.0,(1280,720))
pid_list=list()
steer_list = list()
lpf_list = list()
pid_old = None
steer_theta = 0
i=0
x_location = 240
frame_cnt = 0
while True:
ret, frame = cap.read()
if frame is None:
break
frame_height, frame_width, frame_channels = frame.shape
print("Frame Info : (Height, Width, Channels) : ({}, {}, {})".format(frame_height, frame_width, frame_channels))
record_frame = cv2.resize(frame, (1280,720))
if ret:
cur_time = time.time()
frame_new = cv2.resize(frame, (320,180))
input_img = frame_new / 255.
input_img = preprocess_img(input_img)
# array to tensor
input_img = torch.from_numpy(input_img).float()
with torch.no_grad():
inputData_var = Variable(input_img).unsqueeze(0).cuda()
# inference
output = model.forward(inputData_var)
output = torch.sigmoid(output)
#output = F.softmax(output, dim=1)
# gpu -> cpu, tensor -> numpy
output = output.detach().cpu().numpy()
output = output[0]
output = postprocess_img(output)
output = np.clip(output, 0, 1)
output *= 255
output = np.uint8(output)
output = cv2.resize(output, (640, 360))
output[output>80] = 255
output[output<=80] = 0
# cv2.circle(output, (output.shape[1]/2, output.shape[0]), 9, (255,255,0), -1)
cv2.imshow("output_img", output)
print("shape_info", output.shape)
# cv2.circle(output, (output.shape[0]/2, output.shape[1]/2), 9, (0,255,0), -1)
#warper_img = warper.warp(output)
warper_img = warper.warp_test(output)
cv2.imshow("warp_img", warper_img)
# warper_img_test = warper.warp_test(output)
# cv2.imshow("warp_img_test",warper_img_test)
ret, left_start_x, right_start_x, cf_img = slidewindow.w_slidewindow(warper_img, 180)
if ret:
i+=1
left_x_current,right_x_current, sliding_img,steer_theta,center, length = slidewindow.h_slidewindow(warper_img, left_start_x, right_start_x)
#stop_test Lee youn joo
# if center != None:
# locate_x, locate_y = center
# if (warper_img[int(locate_y)][int(locate_x)] != 0):
# stopFlag, id_L, id_R = stopline.findline(warper_img,locate_x,locate_y,length,left_x_current,right_x_current)
# if stopFlag != None:
# if frame_cnt == 0:
# print('STOP!')
# cv2.line(warper_img,id_L,id_R,(0,0,255),2)
# cv2.waitKey(-1)
# frame += 1
# if (frame_cnt > 0):
# frame_cnt = 0
# print(stopFlag,frame_cnt)
# SD.stop(warper_img)
SD.stoping_tmp(warper_img)
cv2.imshow('sliding_img', sliding_img)
steer_list.append(steer_theta)
x_location = (left_x_current+right_x_current)/2
# low pass filter
steer_theta = lpf(steer_theta, 0.3)
lpf_list.append(steer_theta)
# steer theta : Degree
print("steer theta:" ,steer_theta)
#
# if steer_theta<-28.0 or steer_theta >28.0:
# # auto_drive(pid_old)
# auto_drive(steer_theta)
# else:
# degree angle
pid = round(pidcal.pid_control(steer_theta),6)
pid_list.append(pid)
print("pid :",pid)
pid_old = pid
auto_drive(steer_theta)
# auto_drive(pid)
else:
auto_drive(steer_theta)
# auto_drive(pid)
pidcal.error_sum = 0
pidcal.error_old = 0
end_time = time.time()
sec = end_time - cur_time
fps = 1/sec
fps_list.append(fps)
print("Estimated fps {0} " . format(fps))
# out.write(add_img)
cv2.imshow("frame",frame)
if opt.video_idx == -1:
print("frame.shape : {}".format(frame.shape))
out.write(frame)
# cv2.imshow("src", warper_img)
# cv2.imshow("out_img", output)
cv2.imshow("cf_img", cf_img)
key = cv2.waitKey(1) & 0xFF
if key == 27: break
elif key == ord('p'):
cv2.waitKey(-1)
cap.release()
cv2.destroyAllWindows()
plt.plot(range(i),steer_list,label='steer')
plt.legend()
plt.plot(range(i),pid_list,label='pid')
plt.legend()
plt.plot(range(i),lpf_list,label='lpf')
plt.legend()
pid_info=pidcal.info_p()
plt.savefig('output_video/video_idx:'+ str(opt.video_idx)+' '+str(pid_info) +'.png', dpi=300)
class LaneFinder:
def __init__(self, gray_shape, objpoints, imgpoints):
self.camera_undistort = CameraUndistort(gray_shape, objpoints,
imgpoints)
self.gradient_filter = GradientFilter()
self.warper = Warper(gray_shape)
self.window_searcher = WindowSearcher()
self.cnt = 0
def run_pipeline(self, img, left_fit=None, right_fit=None):
self.cnt += 1
dst = self.camera_undistort.undistort(img)
#cv2.imwrite('../output_images/undistort_images/undistort_' + file_name, dst)
self.binary = self.gradient_filter.process(dst)
# cv2.imwrite('../output_images/gradient_filter/filter_' + file_name, binary.astype('uint8') * 255)
# cv2.imwrite('../output_images/debug/binary_%d.png' % self.cnt, self.binary.astype('uint8') * 255)
#cv2.polylines(img, [np.int32(warper.src.reshape(-1,1,2))], True,(0,0,255), 3)
#cv2.imwrite('../output_images/warped/src_' + file_name, img)
# warped = warper.warp(img)
# cv2.polylines(warped, [np.int32(warper.dst.reshape(-1,1,2))], True, (0,0,255), 3)
# cv2.imwrite('../output_images/warped/dst_' + file_name, warped)
self.warped = self.warper.warp(self.binary)
# cv2.imwrite('../output_images/debug/warped_%d.png' % self.cnt, self.warped.astype('uint8') * 255)
# cv2.imwrite('../output_images/warped/dst_binary_' + file_name, warped.astype('uint8') * 255)
out_img = self.window_searcher.fit_polynomial(self.warped, left_fit,
right_fit)
# cv2.imwrite('../output_images/debug/out_%d.png' % self.cnt, out_img)
# cv2.imwrite('../output_images/window_search/' + file_name, out_img)
# unwarped = warper.unwarp(out_img)
# cv2.imwrite('../output_images/unwarped/' + file_name, unwarped)
# print(window_searcher.measure_curvature_real())
# print(window_searcher.measure_center())
def add_detect_lanes(self, img, left_line, right_line):
ploty = left_line.ally
left_fitx = left_line.allx
right_fitx = right_line.allx
dst = self.camera_undistort.undistort(img)
warp_zero = np.zeros_like(self.warped).astype(np.uint8)
color_warp = np.dstack((warp_zero, warp_zero, warp_zero))
# Recast the x and y points into usable format for cv2.fillPoly()
pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])
pts_right = np.array(
[np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])
pts = np.hstack((pts_left, pts_right))
# Draw the lane onto the warped blank image
cv2.fillPoly(color_warp, np.int_([pts]), (0, 255, 0))
# Warp the blank back to original image space using inverse perspective matrix (Minv)
newwarp = self.warper.unwarp(color_warp)
# Combine the result with the original image
result = cv2.addWeighted(dst, 1, newwarp, 0.3, 0)
# cv2.imwrite('../output_images/final/' + file_name, result)
font = cv2.FONT_HERSHEY_SIMPLEX
result = cv2.putText(
result, 'radius of curvature = %d m' %
((left_line.radius_of_curvature + right_line.radius_of_curvature) /
2.0), (50, 50), font, 1, (255, 255, 255), 2, cv2.LINE_AA)
result = cv2.putText(
result,
'distance from the center = %.2f m' % left_line.line_base_pos,
(50, 100), font, 1, (255, 255, 255), 2, cv2.LINE_AA)
return result
from std_msgs.msg import String from sensor_msgs.msg import Image from obstacle_detector.msg import Obstacles from cv_bridge import CvBridge, CvBridgeError from ackermann_msgs.msg import AckermannDriveStamped from datetime import datetime # for record from Stop_Counter import Stop_Counter from CurveDetector import CurveDetector from ObstacleDetector import ObstacleDetector, Position x_location_old = None warper = Warper() slidewindow = SlideWindow() pidcal = PidCal() q1 = que.Queue() bridge = CvBridge() now = datetime.now() # for record cv_image = None obstacles = None ack_publisher = None car_run_speed = 0.5 OBSTACLE_NUM = 3
import cv2
import numpy as np
from thresholder import Thresholder
from warper import Warper
from polyfitter import Polyfitter
from polydrawer import Polydrawer
if __name__ == '__main__':
cap = cv2.VideoCapture(0)
threshold_object = Thresholder()
warp_object = Warper()
fitt_object = Polyfitter()
draw_object = Polydrawer()
while (cap.isOpened()):
ret, color = cap.read()
print color.shape
th = threshold_object.threshold(color)
# cv2.imshow('Combined', threshold_object.threshold(color))
# cv2.imshow('Warped', warp_object.warp(th))
img = warp_object.warp(th)
left_fit, right_fit = fitt_object.polyfit(img)
print left_fit, right_fit
img = draw_object.draw(color, left_fit, right_fit, warp_object.Minv)
cv2.imshow('Lane Detection', img)
if cv2.waitKey(1) & 0xFF == 27:
break
cv2.destroyAllWindows()
nonzero = self.check_many_lines(warp_img)
if nonzero > 1350 and self.check_time():
self.on_detected_crosswallk()
self.previous_time = time.time()
return True
return False
if __name__ == '__main__':
stop_counter = StopDetector()
warper = None
cap = cv2.VideoCapture('../capture/origin18654.avi')
while cap.isOpened():
ret, frame = cap.read()
if not ret:
break
if warper == None:
warper = Warper(frame)
# stop_counter.check_yellow_line(frame)
warp_img = warper.warp(frame)
stop_counter.check_crocss_walk(frame, warp_img)
# cv2.imshow('frame', detect_img)
if cv2.waitKey(0) == 27:
break