def __init__(self,
bg_params,
a_start=None,
a_end=None,
a_npoints=None,
x_array=None,
tau_init=0):
if x_array is None:
self.x_array = np.linspace(np.log(a_start), np.log(a_end), a_npoints)
else:
self.x_array = x_array
self.a_array = np.exp(self.x_array)
self.bg_params = bg_params
if tau_init != 0:
raise NotImplementedError('tau_init must currently be zero')
self.tau_init = tau_init
#Precompute info for splining
self.ne_array = compute_ne(self.x_array, self.bg_params)
self.tau_der_array = -self.ne_array * s_o_l * sigma_T * np.exp(self.x_array) / time_mod.get_H_p(self.x_array, self.bg_params)
#Reversing the array because we're starting at today and
#integrating backwards
self.tau_array = np.append(np.array([self.tau_init]), cumtrapz(self.tau_der_array[::-1], self.x_array[::-1]))[::-1]
#Typically, this won't matter, and it avoids log issues
self.tau_array[-1] = self.tau_array[-2]
self.g_array = - self.tau_der_array * np.exp(-self.tau_array)
#Set up splines
self.ne_spline = interpolation.cubic_spline(self.x_array, np.log(self.ne_array))
self.tau_spline = interpolation.cubic_spline(self.x_array, np.log(self.tau_array))
self.tau_der_spline = interpolation.cubic_spline(self.x_array, np.log(-self.tau_der_array))
self.g_spline = interpolation.cubic_spline(self.x_array, self.g_array)
#Spline the second derivative of the log of g
self.g2_spline = interpolation.cubic_spline(self.x_array, self.g_spline)
def get_eta(self, x):
""" Using input arrays, produces eta for a given value of x = ln a. """
if self.eta_spline is None:
if self.eta_array is None:
#Initialize the eta array based on the scale factor values.
#We need to append to an array with a single entry because
#cumtrapz returns an array with one less value than the input
#array
self.eta_array = np.append(np.array([self.eta_init]), s_o_l * cumtrapz(1 / (get_H_p(self.x_array, self.bg_params)), self.x_array))
self.eta_spline = interpolation.cubic_spline(self.x_array, self.eta_array)
# self.eta_splint = scipy.interpolate.interp1d(self.a_array, self.eta_array, kind='cubic')
if isinstance(x, np.ndarray):
x[x > self.x_array[-1]] = self.x_array[-1]
elif isinstance(x, float):
if x > self.x_array[-1]:
x = self.x_array[-1]
return interpolation.splint(self.x_array, self.eta_array, self.eta_spline, x)
def main():
# Select GPU
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
print("Device ID : {}".format(format(torch.cuda.current_device())))
print("torch.version : {}".format(torch.__version__))
print("cuda.version : {}".format(torch.version.cuda))
model_lstm = importlib.import_module('models.lstm')
data_manager = importlib.import_module("data_manager.tusimple_manager")
dataset = data_manager.Tusimple_Manager()
dataset.tusimple_load_from_json()
dataset.tusimple_split_instance()
two_train_data, two_test_data = dataset.get_instance(option=0)
for idx_, train_data in enumerate(two_train_data):
if idx_ == 20: break
# image clip directory
clip_dir = dataset.train_path + train_data['raw_file']
print("* clip dir : {}".format(clip_dir))
# load image
raw_image = cv2.imread(clip_dir)
# get lanes
lanes = dataset.get_lanes(train_data)
# visualize annotatied data
annot_image = raw_image.copy()
annot_image = vis_util.draw_points(annot_image, lanes)
# cubic spline interpolation
cubic_spline_image = raw_image.copy()
cubic_spline_sets = interpolation.cubic_spline(lanes)
cubic_spline_image = vis_util.draw_points(cubic_spline_image,
cubic_spline_sets)
# mono spline interpolation
mono_spline_image = raw_image.copy()
mono_spline_sets = interpolation.mono_spline(lanes)
mono_spline_image = vis_util.draw_points(mono_spline_image,
mono_spline_sets)
# linear interpolation
linear_intrp_image = raw_image.copy()
linear_intrp_sets = interpolation.linear_interpolate(lanes)
linear_intrp_image = vis_util.draw_points(linear_intrp_image,
linear_intrp_sets)
# quadratic interpolation
quadratic_intrp_image = raw_image.copy()
quadratic_intrp_sets = interpolation.quadratic_interpolate(lanes)
quadratic_intrp_image = vis_util.draw_points(quadratic_intrp_image,
quadratic_intrp_sets)
#----------------------------------------------------------------------------------------------------------------#
seq_len_ = 2
train_sets, test_sets = dataset.split_train_test(mono_spline_sets,
test_size=3,
seq_len=seq_len_)
# sequence train data
train_x_s = []
train_y_s = []
# sequence test data
test_x_s = []
test_y_s = []
for train_set in train_sets:
train_x, train_y = dataset.make_sequence_data(train_set,
seq_len=seq_len_)
train_x_s.append(Variable(torch.Tensor(train_x)))
train_y_s.append(Variable(torch.Tensor(train_y)))
for test_set in test_sets:
test_x, test_y = dataset.make_sequence_data(test_set,
seq_len=seq_len_)
test_x_s.append(Variable(torch.Tensor(test_x)))
test_y_s.append(Variable(torch.Tensor(test_y)))
# model
models = []
criterions = []
optimizers = []
for i in range(len(train_x_s)):
model = model_lstm.LSTM()
# criterion = torch.nn.SmoothL1Loss()
criterion = torch.nn.MSELoss()
#criterion = torch.nn.L1Loss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
models.append(model)
criterions.append(criterion)
optimizers.append(optimizer)
epochs = 500
train_loss_lane = []
test_loss_lane = []
for epoch in range(epochs):
# train_session
for idx, (train_x_tensor,
train_y_tensor) in enumerate(zip(train_x_s, train_y_s)):
models[idx].train()
optimizers[idx].zero_grad()
predict = models[idx].forward(
train_x_tensor.view(len(train_x_tensor), seq_len_, 1))
loss = criterions[idx](predict, train_y_tensor)
loss.backward()
if epoch == 0:
lane_loss = [loss.item()]
train_loss_lane.append(lane_loss)
else:
train_loss_lane[idx].append(loss.item())
optimizers[idx].step()
# test session
with torch.no_grad():
for idx, (test_x_tensor,
test_y_tensor) in enumerate(zip(test_x_s, test_y_s)):
models[idx].eval()
# forward
inference = models[idx].forward(
test_x_tensor.view(len(test_x_tensor), seq_len_, 1))
loss = criterions[idx](inference, test_y_tensor)
if epoch == 0:
lane_loss = [loss.item()]
test_loss_lane.append(lane_loss)
else:
test_loss_lane[idx].append(loss.item())
for idx, (train_loss,
test_loss) in enumerate(zip(train_loss_lane,
test_loss_lane)):
plt.plot(train_loss, label='train_loss_' + str(idx))
plt.plot(test_loss, label='test_loss_' + str(idx))
plt.legend()
#plt.show()
inference_set = np.arange(720, 0, -1)
test_set = dataset.make_test_sequence_data(inference_set,
seq_len_) / 720.0
test_sets = []
for i in range(len(train_x_s)):
test_sets.append(Variable(torch.Tensor(test_set)))
test_image = raw_image.copy()
vp_points = []
with torch.no_grad():
color_ = [(255, 100, 0), (100, 255, 0), (100, 120, 255),
(255, 100, 100), (0, 120, 80)]
for idx, (test_x_tensor,
test_y_tensor) in enumerate(zip(test_sets, test_y_s)):
#for idx, (test_x_tensor, test_y_tensor) in enumerate(zip(test_x_s, test_y_s)):
models[idx].eval()
# forward
inference = models[idx].forward(
test_x_tensor.view(len(test_x_tensor), seq_len_,
1)).data.numpy()
test_x_numpy = test_x_tensor.data.numpy()
test_y_numpy = test_y_tensor.data.numpy() * 1280
y_points = test_x_numpy[:, -1] * 720 - 10
inference = np.squeeze(inference, axis=1) * 1280
gt_pair = np.array(list(zip(test_y_numpy, y_points)))
predict_pair = np.array(list(zip(inference, y_points)))
print(predict_pair)
for pt in predict_pair:
cv2.circle(annot_image, (int(pt[0]), int(pt[1])),
radius=2,
color=color_[idx],
thickness=2)
vp_points.append(pt)
real_vp_1 = vanish_point(vp_points, annot_image)
# for pt in gt_pair:
# cv2.circle(test_image, (int(pt[0]), int(pt[1])), radius=2, color = color_[idx+1], thickness=2)
# cv2.imshow("raw_image", annot_image)
'''
cv2.imwrite("/home/sun/Desktop/Vanishing-Point-Detection/interpolation_image/annot_image.jpg", annot_image)
cv2.imwrite("/home/sun/Desktop/Vanishing-Point-Detection/interpolation_image/cubic_spline_image.jpg", cubic_spline_image)
cv2.imwrite("/home/sun/Desktop/Vanishing-Point-Detection/interpolation_image/mono_spline_image.jpg", mono_spline_image)
cv2.imwrite("/home/sun/Desktop/Vanishing-Point-Detection/interpolation_image/linear_intrp_image.jpg", linear_intrp_image)
cv2.imwrite("/home/sun/Desktop/Vanishing-Point-Detection/interpolation_image/quadratic_intrp_image.jpg", quadratic_intrp_image)
'''
cv2.imwrite(
"/home/sun/Desktop/Vanishing-Point-Detection/interpolation_image/vanishing_points_"
+ str(idx_) + "_" + str(seq_len_) + ".jpg", annot_image)
