def _function_graph_topics(*args):
Args = args_to_dictionary(args)
True
ctr_ = 0
for topic_ in sorted(D[topics].keys()):
if topic_ in P[TOPICS]:
vals_ = D[topics][topic_][vals][:]
ts_ = D[topics][topic_][ts][:]
if P[TOPICS][topic_][minval] == minval:
ymin_ = min(vals_)
else:
ymin_ = P[TOPICS][topic_][minval]
if P[TOPICS][topic_][maxval] == maxval:
ymax_ = max(vals_)
else:
ymax_ = P[TOPICS][topic_][maxval]
dyv = (ymax_ - ymin_)
ymin_ = ymax_ - dyv*(len(D[topics].keys())+1)
ymax_ += dyv*ctr_
ctr_ += 1
ymin_init_,ymax_init_, = ymin_,ymax_
I = {}
I[topic_] = Graph_Module.Graph_Image(
xsize,P[X_PIXEL_SIZE],
ysize,P[Y_PIXEL_SIZE],
xmin,D[start_time],
xmax,D[end_time],
ymin,ymin_,
ymax,ymax_,
Img,D[base_graph])
baseline_vals_ = 0*ts_ + P[TOPICS][topic_][baseline]
baseline_color_ = (64,64,64)
#####################################################################
#
I[topic_][ptsplot](x,ts_, y,vals_, color,P[TOPICS][topic_][color])
I[topic_][ptsplot](x,ts_, y,baseline_vals_, color,baseline_color_)
##################3
P[ICONS] = {}
h5py_runs_ = []
for dataset_path_ in P[DATASET_PATHS]:
h5py_runs_ += sggo(dataset_path_, 'h5py', '*')
icon_row_counter_ = 0
icon_column_counter_ = 0
for i_ in rlen(h5py_runs_):
O = h5r(opj(h5py_runs_[i_], 'original_timestamp_data.h5py'))
icon_img_ = O[left_image][vals][int(len(O[left_image][vals]) / 2)][:]
icon_img_ = cv2.resize(icon_img_, (0, 0), fx=0.5, fy=0.5)
name_ = fname(h5py_runs_[i_])
P[ICONS][name_] = Graph_Module.Icon(
y, int(10 + 1.1 * icon_column_counter_ * shape(icon_img_)[1]), x,
0.52 * P[Y_PIXEL_SIZE] + 1.1 * icon_row_counter_ * shape(icon_img_)[0],
img, icon_img_, Img, None, path, h5py_runs_[i_], name, name_)
icon_column_counter_ += 1
if icon_column_counter_ >= P[MAX_ICONS_PER_ROW]:
icon_column_counter_ = 0
icon_row_counter_ += 1
P[CURRENT_ICON_NAME] = name_
show_menu_ = True
first_time_ = True
while True:
run_name_ = P[ICONS][P[CURRENT_ICON_NAME]][name]
l_ = opj(P[ICONS][P[CURRENT_ICON_NAME]][path],
###############################
# for interactive terminal
import __main__ as main
if not hasattr(main, '__file__'):
from kzpy3.utils2 import *
pythonpaths(['kzpy3', 'kzpy3/Grapher_app', 'kzpy3/teg9'])
#
###############################
from Parameters_Module import *
from kzpy3.vis2 import *
import Graph_Module
from Car_Data_app.Names_Module import *
exec(identify_file_str)
_ = dictionary_access
for a in Args.keys():
_(P, a, equals, _(Args, a))
Img1 = Graph_Module.Image2(xmin, 0, xmax, 1000, ymin, -1, ymax, 100, xsize,
600, ysize, 600)
Img1[img][100:400, 100:400, :] = (255, 128, 64)
Img2 = Graph_Module.Image2(xmin, 0, xmax, 1000, ymin, -1, ymax, 100, xsize,
600, ysize, 600, Img, Img1)
mi(Img1[img], 1)
mi(Img2[img], 2)
else:
yminv = P[TOPICS][kv][minval]
if P[TOPICS][kv][maxval] == maxval:
ymaxv = max(valsv)
else:
ymaxv = P[TOPICS][kv][maxval]
P[START_TIME_INIT], P[
END_TIME_INIT], yminv_init, ymaxv_init, xpixelsv_init, ypixelsv_init = P[
START_TIME], P[END_TIME], yminv, ymaxv, xpixelsv, ypixelsv
screen_xv_init, screen_yv_init = screen_xv, screen_yv
show_menuv = True
first_timev = True
while True:
I = Graph_Module.Image2(xmin, P[START_TIME], xmax, P[END_TIME],
ymin, yminv, ymax, ymaxv, xsize, xpixelsv,
ysize, ypixelsv)
I[ptsplot](x, tsv, y, valsv, color, (0, 255, 0))
time_from_pixelv = I[pixel_to_float](
xint, int(P[VERTICAL_LINE_PROPORTION] * xpixelsv), yint, 0)[0]
ts_from_pixelv = find_nearest(tsv, time_from_pixelv)
assert (ts_from_pixelv in tsv) #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
cv2.putText(I[img], d2s(dp(ts_from_pixelv, 3)), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 1.0, (255, 0, 0), 4)
cv2.line(I[img], (int(P[VERTICAL_LINE_PROPORTION] * xpixelsv), 0),
(int(P[VERTICAL_LINE_PROPORTION] * xpixelsv), ypixelsv),
(0, 0, 255))
keyv = mci(I[img],
color_mode=cv2.COLOR_RGB2BGR,
delay=33,
title=kv)
def Display_Graph(*args):
Args = args_to_dictionary(args)
D = {}
D[topics] = Args[topics]
print D[topics].keys()
True
D[timestamp_to_left_image] = {}
ts_ = D[topics][left_image][ts][:]
for i_ in rlen(ts_):
D[timestamp_to_left_image][ts_[i_]] = i_
D[end_time] = max(ts_)
D[start_time] = min(ts_)
D[reference_time] = (D[start_time]+D[end_time])/2.0
D[start_time_init],D[end_time_init] = D[start_time],D[end_time]
D[base_graph] = Graph_Module.Graph_Image(
xmin,D[start_time],
xmax,D[end_time],
ymin,-1,
ymax,100,
xsize,P[X_PIXEL_SIZE],
ysize,P[Y_PIXEL_SIZE])
D[zero_baseline] = 0*ts_
D[baseline_with_tics] = D[zero_baseline].copy()
for i in rlen(D[baseline_with_tics]):
if np.mod(int(ts_[i]),10.0) == 0:
D[baseline_with_tics][i] = 1.0
def _function_vertical_line(*args):
Args = args_to_dictionary(args)
vertical_line_proportion_ = Args[vertical_line_proportion]
color_ = Args[color]
True
cv2.line(
D[base_graph][img],
(int(vertical_line_proportion_*P[X_PIXEL_SIZE]),0),
(int(vertical_line_proportion_*P[X_PIXEL_SIZE]),int(P[Y_PIXEL_SIZE]/2)),
color_)
D[vertical_line] = _function_vertical_line
def _function_insert_camera_image(*args):
Args = args_to_dictionary(args)
camera_ = Args[camera]
img_index_ = Args[img_index]
True
camera_img_ = camera_[img_index_][:] ###############################
cx_ = (P[Y_PIXEL_SIZE]-P[CAMERA_SCALE]*shape(camera_img_)[0])
cy_ = (P[X_PIXEL_SIZE]-P[CAMERA_SCALE]*shape(camera_img_)[1])
D[base_graph][img][cx_-10:-10,cy_-10:-10,:] = cv2.resize(camera_img_, (0,0), fx=4, fy=4)
D[insert_camera_image] = _function_insert_camera_image
D[cv2_key_commands] = {
'p':("P[START_TIME] -= P[REAL_TIME_DTV]; P[END_TIME] -= P[REAL_TIME_DTV]",
"Time step forward,real time"),
'm':("P[START_TIME] -= P[REAL_TIME_DTV]/2.0; P[END_TIME] -= P[REAL_TIME_DTV]/2.0",
"Time step forward,real time"),
'l':("P[START_TIME] -= dt_; P[END_TIME] -= dt_",
"Time step forward"),
'h':("P[START_TIME] += dt_; P[END_TIME] += dt_",
"Time step back"),
'u':("P[START_TIME] += P[REAL_TIME_DTV]; P[END_TIME] += P[REAL_TIME_DTV]",
"Time step back, real time"),
'v':("P[START_TIME] += P[REAL_TIME_DTV]/2.0; P[END_TIME] += P[REAL_TIME_DTV]/2.0",
"Time step back, real time"),
'j':("P[START_TIME] += 100.0*dt_; P[END_TIME] -= 100.0*dt_",
"Time scale out"),
'k':("P[START_TIME] -= 100.0*dt_; P[END_TIME] += 100.0*dt_",
"Time scale in"),
' ':("P[VERTICAL_LINE_PROPORTION]=0.5;" +
"P[START_TIME],P[END_TIME] = P[START_TIME_INIT],P[END_TIME_INIT];" +
"ymin_,ymax_ = ymin_init_,ymax_init_;"+
"show_menuv = True","Reset"),
'a':("show_menuv = True","Menu"),
'q':("sys.exit()","Quit"),
}
def _function_process_key_commands(*args):
Args = args_to_dictionary(args)
key_ = Args[key]
True
key_decoded_ = False
for mv in D[cv2_key_commands] :
if len(mv) > 0:
if key_ == ord(mv):
cmd_tuplev = D[cv2_key_commands] [mv]
#exec(cmd_tuplev[0])
key_decoded_ = True
if not key_decoded_:
if key_ != -1:
try:
print(d2s('key_ =',key_))
print(d2s(str(unichr(key_)), '=',key_))
except Exception as e:
print("********** Exception ***********************")
print(e.message, e.args)
D[process_key_commands] = _function_process_key_commands
def _function_graph_topics(*args):
Args = args_to_dictionary(args)
True
ctr_ = 0
for topic_ in sorted(D[topics].keys()):
if topic_ in P[TOPICS]:
vals_ = D[topics][topic_][vals][:]
ts_ = D[topics][topic_][ts][:]
if P[TOPICS][topic_][minval] == minval:
ymin_ = min(vals_)
else:
ymin_ = P[TOPICS][topic_][minval]
if P[TOPICS][topic_][maxval] == maxval:
ymax_ = max(vals_)
else:
ymax_ = P[TOPICS][topic_][maxval]
dyv = (ymax_ - ymin_)
ymin_ = ymax_ - dyv*(len(D[topics].keys())+1)
ymax_ += dyv*ctr_
ctr_ += 1
ymin_init_,ymax_init_, = ymin_,ymax_
I = {}
I[topic_] = Graph_Module.Graph_Image(
xsize,P[X_PIXEL_SIZE],
ysize,P[Y_PIXEL_SIZE],
xmin,D[start_time],
xmax,D[end_time],
ymin,ymin_,
ymax,ymax_,
Img,D[base_graph])
baseline_vals_ = 0*ts_ + P[TOPICS][topic_][baseline]
baseline_color_ = (64,64,64)
#####################################################################
#
I[topic_][ptsplot](x,ts_, y,vals_, color,P[TOPICS][topic_][color])
I[topic_][ptsplot](x,ts_, y,baseline_vals_, color,baseline_color_)
#
#####################################################################
D[graph_topics] = _function_graph_topics
def _function_show(*args):
Args = args_to_dictionary(args)
ref_time_ = Args[ref_time]
True
ref_time = find_nearest(D[topics][left_image][ts][:],ref_time_)
D[base_graph][img] *= 0
D[graph_topics]()
D[vertical_line_proportion] = D[end_time]-D[start_time]
tsv = L[ts]
tsv -= tsv[0]
Timestamp_to_left_image = {}
for iv in rlen(tsv):
Timestamp_to_left_image[tsv[iv]] = iv
P[END_TIME] = max(tsv)
P[START_TIME_INIT], P[END_TIME_INIT] = P[START_TIME], P[END_TIME]
show_menuv = True
first_timev = True
Background_image = Graph_Module.Image2(xmin, P[START_TIME], xmax, P[END_TIME],
ymin, 0, ymax, 100, xsize, xpixelsv,
ysize, ypixelsv)
Topic_images = {}
for kv in P[TOPICS].keys():
print(kv)
valsv = L[kv][:]
if P[TOPICS][kv][minval] == minval:
yminv = min(valsv)
else:
yminv = P[TOPICS][kv][minval]
if P[TOPICS][kv][maxval] == maxval:
ymaxv = max(valsv)
else:
else:
yminv = P[TOPICS][kv][minval]
if P[TOPICS][kv][maxval] == maxval:
ymaxv = max(valsv)
else:
ymaxv = P[TOPICS][kv][maxval]
P[START_TIME_INIT], P[END_TIME_INIT] = P[START_TIME], P[END_TIME]
yminv_init, ymaxv_init, xpixelsv_init, ypixelsv_init = yminv, ymaxv, xpixelsv, ypixelsv
screen_xv_init, screen_yv_init = screen_xv, screen_yv
show_menuv = True
first_timev = True
while True:
I = Graph_Module.Image2(xmin, P[START_TIME], xmax, P[END_TIME], ymin,
yminv, ymax, ymaxv, xsize, xpixelsv, ysize,
ypixelsv)
I[ptsplot](x, tsv, y, valsv, color, (0, 255, 0))
if np.abs(P[MOUSE_Y] - ypixelsv / 2) > 100:
ref_xv = int(P[VERTICAL_LINE_PROPORTION] * xpixelsv)
else:
ref_xv = P[MOUSE_X]
cv2.line(I[img], (P[MOUSE_X], 0), (P[MOUSE_X], ypixelsv),
(255, 0, 0))
time_from_pixelv = I[pixel_to_float](xint, ref_xv, yint, 0)[0]
ts_from_pixelv = find_nearest(tsv, time_from_pixelv)
cv2.putText(I[img], d2n(dp(ts_from_pixelv, 3), 's'), (10, 30),
cv2.FONT_HERSHEY_SIMPLEX, 0.75, (255, 0, 0), 1)
cv2.line(I[img], (int(P[VERTICAL_LINE_PROPORTION] * xpixelsv), 0),
(int(P[VERTICAL_LINE_PROPORTION] * xpixelsv), ypixelsv),
True
time_widthv = P[END_TIME] - P[START_TIME]
P[START_TIME] = center_timev - time_widthv / 2
P[END_TIME] = center_timev + time_widthv / 2
tsv = L[ts]
tsv -= tsv[0]
Timestamp_to_left_image = {}
for iv in rlen(tsv):
Timestamp_to_left_image[tsv[iv]] = iv
P[END_TIME] = max(tsv)
P[START_TIME_INIT], P[END_TIME_INIT] = P[START_TIME], P[END_TIME]
II = Graph_Module.Image2(xmin, P[START_TIME], xmax, P[END_TIME], ymin, -1,
ymax, 100, xsize, xpixelsv, ysize, ypixelsv)
I = {}
mouse_red_zone_warning_timerv = Timer(0)
show_menuv = True
first_timev = True
img_index_timerv = Timer(1)
img_index_listv = []
display_ratev = 0
while True:
II[img] *= 0
ctrv = 0
for kv in sorted(P[TOPICS].keys()):
#print(kv)
"""
Put in baseline
Put in second markers, both absolute and relative to verticle line
Put in multiple runs
-- write name on Graph_Module
-- allow selection with mouse
"""
_ = dictionary_access
for a in Args.keys():
_(P, a, equals, _(Args, a))
P[ICONS] = [
Graph_Module.Icon(x, 0, y, 0, width, 100, height, 100, name, 'Icon1', img,
None, number, 1)
]
P[X_PIXEL_SIZE_INIT], P[Y_PIXEL_SIZE_INIT] = P[X_PIXEL_SIZE], P[Y_PIXEL_SIZE]
while True:
run_namev, lv, ov = temp_get_files(P[TEMP_RUN_NUMBER])
L = h5r(lv)
O = h5r(ov)
tsv = L[ts][:]
tsv = tsv.copy()
tsv -= tsv[0]
Timestamp_to_left_image = {}
for iv in rlen(tsv):
Timestamp_to_left_image[tsv[iv]] = iv
P[END_TIME] = max(tsv)
P[X_PIXEL_SIZE_INIT],P[Y_PIXEL_SIZE_INIT] = P[X_PIXEL_SIZE],P[Y_PIXEL_SIZE]
##################3
P[ICONS] = {}
P[DATASET_PATH] = opjD('bdd_car_data_July2017_LCR')
P[H5PY_RUNS] = sggo(P[DATASET_PATH],'h5py','*')
for iv in rlen(P[H5PY_RUNS]):
O = h5r(opj(P[H5PY_RUNS][iv],'original_timestamp_data.h5py'))
icon_imgv = O[left_image][vals][int(len(O[left_image][vals])/2)][:]
icon_imgv = cv2.resize(icon_imgv, (0,0), fx=0.5, fy=0.5)
namev = fname(P[H5PY_RUNS][iv])
P[ICONS][namev] = Graph_Module.Icon(
y,int(10+1.1*iv*shape(icon_imgv)[1]),
x,0.52*P[Y_PIXEL_SIZE],
img,icon_imgv,
Img,None,
path,P[H5PY_RUNS][iv],
name,namev)
P[CURRENT_ICON_NAME] = namev
while True:
run_namev = P[ICONS][P[CURRENT_ICON_NAME]][name]
lv = opj(P[ICONS][P[CURRENT_ICON_NAME]][path],'left_timestamp_metadata.h5py')
ov = opj(P[ICONS][P[CURRENT_ICON_NAME]][path],'original_timestamp_data.h5py')
L = h5r(lv)
O = h5r(ov)
tsv = L[ts][:]