def get_density_image_old(im_shape,x,y):
"""
im_shape: [ # pixels left-to-right, # pixels top-to-bottom ]
"""
#
# setup variables
#
# im_shape = im_shape[::-1]
#print(im_shape)
thresh = 0.85
sigma = 250.
z_thresh = 10e-3
my_dpi = 100
my_figsize = (im_shape[1] / my_dpi, im_shape[0] / my_dpi)
centers = np.c_[x,y]
def nice_cov(*args):
return .5 * 10e-3 * np.array([1,3])
cmap = plt.cm.Purples
cmap.set_bad(color="white")
#
# create dummy data (testing only)
#
# nsamples = 100
# centers = np.ones( (nsamples,2) )
# centers[:,0] *= 300 + 10 * npr.normal(size=nsamples)
# centers[:,1] *= 1500 + 10 * npr.normal(size=nsamples)
# centers.astype(np.int)
#
# create the kde
#
#centers += 0.01 * np.random.normal(size=centers.shape)
centers = index_img_to_plt(centers,im_shape[0])
kde = stats.gaussian_kde(centers.T)
kde.set_bandwidth(nice_cov)
gap_size = 2
xx,yy = np.mgrid[0:im_shape[1]:gap_size,0:im_shape[0]:gap_size]
z = kde(np.c_[xx.flat,yy.flat].T).reshape(xx.shape)
z = np_log(z)
z = np.ma.masked_where(z > -10e-4, z)
#
# create figure
#
fig = plt.figure(frameon=False,facecolor='white',figsize=my_figsize)
ax = plt.Axes(fig,[0.,0.,1.,1.])
fig.add_axes(ax)
ax.set_axis_off()
ax.set_xlim([0,im_shape[1]])
ax.set_ylim([0,im_shape[0]])
#
# plot and ndarray
#
ax.contourf(xx,yy,z,25,cmap=cmap)
img = matplotlib_to_numpy(fig,im_shape[::-1],dpi=my_dpi)
img = invert_np_image(img)
# img = np.rot90(img,k=2)
# img = np.fliplr(img)
#print("shape := [ # rows x # cols ]",img.shape)
#cv2.imwrite("./tmp.png",img)
plt.close(fig)
return img
def driftmap_color(clusters_depths,
spikes_times,
spikes_amps,
spikes_depths,
spikes_clusters,
ax=None,
axesoff=False,
return_lims=False):
'''
Plots the driftmap of a session or a trial
The plot shows the spike times vs spike depths.
Each dot is a spike, whose color indicates the cluster
and opacity indicates the spike amplitude.
Parameters
-------------
clusters_depths: ndarray
depths of all clusters
spikes_times: ndarray
spike times of all clusters
spikes_amps: ndarray
amplitude of each spike
spikes_depths: ndarray
depth of each spike
spikes_clusters: ndarray
cluster idx of each spike
ax: matplotlib.axes.Axes object (optional)
The axis object to plot the driftmap on
(if `None`, a new figure and axis is created)
Return
---
ax: matplotlib.axes.Axes object
The axis object with driftmap plotted
x_lim: list of two elements
range of x axis
y_lim: list of two elements
range of y axis
'''
color_bins = sns.color_palette("hls", 500)
new_color_bins = np.vstack(
np.transpose(np.reshape(color_bins, [5, 100, 3]), [1, 0, 2]))
# get the sorted idx of each depth, and create colors based on the idx
sorted_idx = np.argsort(np.argsort(clusters_depths))
colors = np.vstack([
np.repeat(new_color_bins[np.mod(idx, 500), :][np.newaxis, ...],
n_spikes,
axis=0)
for (
idx,
n_spikes) in zip(sorted_idx,
np.unique(spikes_clusters, return_counts=True)[1])
])
max_amp = np.percentile(spikes_amps, 90)
min_amp = np.percentile(spikes_amps, 10)
opacity = np.divide(spikes_amps - min_amp, max_amp - min_amp)
opacity[opacity > 1] = 1
opacity[opacity < 0] = 0
colorvec = np.zeros([len(opacity), 4], dtype='float16')
colorvec[:, 3] = opacity.astype('float16')
colorvec[:, 0:3] = colors.astype('float16')
x = spikes_times.astype('float32')
y = spikes_depths.astype('float32')
args = dict(color=colorvec, edgecolors='none')
if ax is None:
fig = plt.Figure(dpi=200, frameon=False, figsize=[10, 10])
ax = plt.Axes(fig, [0.1, 0.1, 0.9, 0.9])
ax.set_xlabel('Time (sec)')
ax.set_ylabel('Distance from the probe tip (um)')
savefig = True
args.update(s=0.1)
ax.scatter(x, y, **args)
x_edge = (max(x) - min(x)) * 0.05
x_lim = [min(x) - x_edge, max(x) + x_edge]
y_lim = [min(y) - 50, max(y) + 100]
ax.set_xlim(x_lim[0], x_lim[1])
ax.set_ylim(y_lim[0], y_lim[1])
if axesoff:
ax.axis('off')
if savefig:
fig.add_axes(ax)
fig.savefig('driftmap.png')
if return_lims:
return ax, x_lim, y_lim
else:
return ax
def get_zoom_iamges(image_path, save_dir, is_initial=False, is_last=False, use_first_zoom_factor=True):
legend_loc = 50
t = 1
cmap = {1: [1.0, 0.0, 0.0, t], 2: [0.75, 0.75, 0.75, t], 3: [0.0, 1.0, 0.0, t]}
labels = {1: "Initial", 2: "GT", 3: "Refined"}
patches = [mpatches.Patch(color=cmap[i], label=labels[i]) for i in range(1, 4)]
if use_first_zoom_factor:
init_info_path = image_path.replace(
os.path.basename(image_path)[os.path.basename(image_path).find("iter") :], "iter_00_info.txt"
)
_, _, zoom_factor = read_info(init_info_path)
info_path = image_path.replace(".png", "_info.txt")
title, legend, _ = read_info(info_path)
else:
info_path = image_path.replace(".png", "_info.txt")
title, legend, zoom_factor = read_info(info_path)
zoom_factor = zoom_factor[None, :]
# print(zoom_factor)
image_real = cv2.imread(image_path, cv2.IMREAD_COLOR).transpose([2, 0, 1])[None, :, :, :]
image_rendered = image_real.copy()
exe1 = zoom_op.simple_bind(
ctx=ctx, zoom_factor=zoom_factor.shape, image_real=image_real.shape, image_rendered=image_rendered.shape
)
def simple_forward(exe1, zoom_factor, image_real, image_rendered, ctx=ctx, is_train=False):
print("zoom factor: ", zoom_factor)
exe1.arg_dict["zoom_factor"][:] = mx.nd.array(zoom_factor, ctx=ctx)
exe1.arg_dict["image_real"][:] = mx.nd.array(image_real, ctx=ctx)
exe1.arg_dict["image_rendered"][:] = mx.nd.array(image_rendered, ctx=ctx)
exe1.forward(is_train=is_train)
if is_initial:
# original
fig = plt.figure(frameon=False, figsize=(8, 6), dpi=100)
ax = plt.Axes(fig, [0.0, 0.0, 1.0, 1.0])
ax.set_axis_off()
fig.add_axes(ax)
# print(image_real[0].shape)
ax.imshow(image_real[0].transpose((1, 2, 0))[:, :, [2, 1, 0]])
fig.gca().text(10, 25, title, color="green", bbox=dict(facecolor="white", alpha=0.8))
fig.gca().text(10, legend_loc, legend, color="red", bbox=dict(facecolor="white", alpha=0.8))
plt.legend(handles=patches, loc=4, borderaxespad=0.0)
# plt.show()
save_d = os.path.join(save_dir, os.path.dirname(image_path).split("/")[-1])
mkdir_if_missing(save_d)
save_path = os.path.join(save_d, os.path.basename(image_path).replace(".png", "_0.png"))
plt.savefig(save_path, aspect="normal")
plt.close()
# ################### (1/3)
wx, wy, tx, ty = zoom_factor[0]
delta = (1 - wx) / 3
zoom_factor_1 = np.zeros((1, 4))
zoom_factor_1[0, 0] = 1 - delta
zoom_factor_1[0, 1] = 1 - delta
zoom_factor_1[0, 2] = tx / 3
zoom_factor_1[0, 3] = ty / 3
simple_forward(exe1, zoom_factor_1, image_real, image_rendered, ctx=ctx, is_train=True)
zoom_image_real = exe1.outputs[0].asnumpy()[0].transpose((1, 2, 0)) + pixel_means
zoom_image_real[zoom_image_real < 0] = 0
zoom_image_real[zoom_image_real > 255] = 255
zoom_image_real = zoom_image_real.astype("uint8")
fig = plt.figure(frameon=False, figsize=(8, 6), dpi=100)
ax = plt.Axes(fig, [0.0, 0.0, 1.0, 1.0])
ax.set_axis_off()
fig.add_axes(ax)
ax.imshow(zoom_image_real[:, :, [2, 1, 0]])
fig.gca().text(10, 25, title, color="green", bbox=dict(facecolor="white", alpha=0.8))
fig.gca().text(10, legend_loc, legend, color="red", bbox=dict(facecolor="white", alpha=0.8))
plt.legend(handles=patches, loc=4, borderaxespad=0.0)
save_d = os.path.join(save_dir, os.path.dirname(image_path).split("/")[-1])
mkdir_if_missing(save_d)
save_path = os.path.join(save_d, os.path.basename(image_path).replace(".png", "_1.png"))
plt.savefig(save_path, aspect="normal")
# plt.show()
plt.close()
# #################### (2/3)
zoom_factor_2 = np.zeros((1, 4))
zoom_factor_2[0, 0] = 1 - 2 * delta
zoom_factor_2[0, 1] = 1 - 2 * delta
zoom_factor_2[0, 2] = tx / 3 * 2
zoom_factor_2[0, 3] = ty / 3 * 2
simple_forward(exe1, zoom_factor_2, image_real, image_rendered, ctx=ctx, is_train=True)
zoom_image_real = exe1.outputs[0].asnumpy()[0].transpose((1, 2, 0)) + pixel_means
zoom_image_real[zoom_image_real < 0] = 0
zoom_image_real[zoom_image_real > 255] = 255
zoom_image_real = zoom_image_real.astype("uint8")
fig = plt.figure(frameon=False, figsize=(8, 6), dpi=100)
ax = plt.Axes(fig, [0.0, 0.0, 1.0, 1.0])
ax.set_axis_off()
fig.add_axes(ax)
ax.imshow(zoom_image_real[:, :, [2, 1, 0]])
fig.gca().text(10, 25, title, color="green", bbox=dict(facecolor="white", alpha=0.8))
fig.gca().text(10, legend_loc, legend, color="red", bbox=dict(facecolor="white", alpha=0.8))
plt.legend(handles=patches, loc=4, borderaxespad=0.0)
save_d = os.path.join(save_dir, os.path.dirname(image_path).split("/")[-1])
mkdir_if_missing(save_d)
save_path = os.path.join(save_d, os.path.basename(image_path).replace(".png", "_2.png"))
plt.savefig(save_path, aspect="normal")
# plt.show()
plt.close()
# ###################### (3/3)
simple_forward(exe1, zoom_factor, image_real, image_rendered, ctx=ctx, is_train=True)
zoom_image_real = exe1.outputs[0].asnumpy()[0].transpose((1, 2, 0)) + pixel_means
zoom_image_real[zoom_image_real < 0] = 0
zoom_image_real[zoom_image_real > 255] = 255
zoom_image_real = zoom_image_real.astype("uint8")
fig = plt.figure(frameon=False, figsize=(8, 6), dpi=100)
ax = plt.Axes(fig, [0.0, 0.0, 1.0, 1.0])
ax.set_axis_off()
fig.add_axes(ax)
ax.imshow(zoom_image_real[:, :, [2, 1, 0]])
fig.gca().text(10, 25, title, color="green", bbox=dict(facecolor="white", alpha=0.8))
fig.gca().text(10, legend_loc, legend, color="red", bbox=dict(facecolor="white", alpha=0.8))
plt.legend(handles=patches, loc=4, borderaxespad=0.0)
save_d = os.path.join(save_dir, os.path.dirname(image_path).split("/")[-1])
mkdir_if_missing(save_d)
if is_initial:
save_path = os.path.join(save_d, os.path.basename(image_path).replace(".png", "_3.png"))
# plt.show()
plt.savefig(save_path, aspect="normal")
plt.close()
elif is_last:
save_path_0 = os.path.join(save_d, os.path.basename(image_path).replace(".png", "_0.png"))
save_path_1 = os.path.join(save_d, os.path.basename(image_path).replace(".png", "_1.png"))
save_path_2 = os.path.join(save_d, os.path.basename(image_path).replace(".png", "_2.png"))
plt.savefig(save_path_0, aspect="normal")
plt.savefig(save_path_1, aspect="normal")
plt.savefig(save_path_2, aspect="normal")
# plt.show()
plt.close()
else:
save_path = os.path.join(save_d, os.path.basename(image_path))
plt.savefig(save_path, aspect="normal")
# plt.show()
plt.close()
def _plot_pseudo_labels(batch_dict, ib):
# pseudo labels
pl_xy = batch_dict["pseudo_label_loc_xy"][ib]
pl_boxes = batch_dict["pseudo_label_boxes"][ib]
if len(pl_xy) == 0:
return
# groundtruth
anns_rphi = np.array(batch_dict["dets_wp"][ib],
dtype=np.float32)[batch_dict["anns_valid_mask"][ib]]
# match pseudo labels with groundtruth
if len(anns_rphi) > 0:
gts_x, gts_y = u.rphi_to_xy(anns_rphi[:, 0], anns_rphi[:, 1])
x_diff = pl_xy[:, 0].reshape(-1, 1) - gts_x.reshape(1, -1)
y_diff = pl_xy[:, 1].reshape(-1, 1) - gts_y.reshape(1, -1)
d_diff = np.sqrt(x_diff * x_diff + y_diff * y_diff)
match_found = d_diff < 0.3 # (pl, gt)
match_found = match_found.max(axis=1)
else:
match_found = np.zeros(len(pl_xy), dtype=np.bool)
# overlay image with laser
im = batch_dict["im_data"][ib]["stitched_image0"]
scan_r = batch_dict["scans"][ib][-1]
scan_phi = batch_dict["scan_phi"][ib]
scan_x, scan_y = u.rphi_to_xy(scan_r, scan_phi)
scan_z = batch_dict["laser_z"][ib]
scan_xyz_laser = np.stack((scan_x, -scan_y, scan_z),
axis=0) # in JRDB laser frame
p_xy, ib_mask = jt.transform_pts_laser_to_stitched_im(scan_xyz_laser)
p_xy = p_xy[:, ib_mask]
c_bgr = _distance_to_bgr_color(scan_r[ib_mask])
# plot
frame_id = f"{batch_dict['frame_id'][ib]:06d}"
sequence = batch_dict["sequence"][ib]
for count, (xy, box, is_pos) in enumerate(zip(pl_xy, pl_boxes,
match_found)):
# image
x0, y0, x1, y1 = box
x0 = int(x0)
x1 = int(x1)
y0 = int(y0)
y1 = int(y1)
im_box = im[y0:y1 + 1, x0:x1 + 1]
height = y1 - y0
width = x1 - x0
fig_w_inch = 0.314961 * 2.0
fig_h_inch = 0.708661 * 2.0
fig_im = plt.figure()
fig_im.set_size_inches(fig_w_inch, fig_h_inch, forward=False)
ax_im = plt.Axes(fig_im, [0.0, 0.0, 1.0, 1.0])
ax_im.imshow(im_box)
ax_im.set_axis_off()
ax_im.axis(([0, width, height, 0]))
ax_im.set_aspect((fig_h_inch / fig_w_inch) / (height / width))
fig_im.add_axes(ax_im)
in_box_mask = np.logical_and(
np.logical_and(p_xy[0] >= x0, p_xy[0] <= x1),
np.logical_and(p_xy[1] >= y0, p_xy[1] <= y1),
)
plt.scatter(
p_xy[0, in_box_mask] - x0,
p_xy[1, in_box_mask] - y0,
s=3,
c=c_bgr[in_box_mask],
)
pos_neg_dir = "true" if is_pos else "false"
fig_file = os.path.join(
_SAVE_DIR,
f"samples/{sequence}/{pos_neg_dir}/{frame_id}_{count}_im.pdf")
os.makedirs(os.path.dirname(fig_file), exist_ok=True)
plt.savefig(fig_file, dpi=height / fig_h_inch)
plt.close(fig_im)
# lidar
plot_range = 0.5
close_mask = np.hypot(scan_x - xy[0], scan_y - xy[1]) < plot_range
fig = plt.figure(figsize=(5, 5))
ax = fig.add_subplot()
ax.set_aspect("equal")
ax.axis("off")
# ax.set_xlim(-plot_range, plot_range)
# ax.set_ylim(-plot_range, plot_range)
# ax.set_xlabel("x [m]")
# ax.set_ylabel("y [m]")
# ax.set_aspect("equal")
# ax.set_title(f"Frame {batch_dict['idx'][ib]}")
# plot points in local frame (so it looks aligned with image)
ang = np.mean(scan_phi[close_mask]) - 0.5 * np.pi
ca, sa = np.cos(ang), np.sin(ang)
xy_plotting = np.array([[ca, sa], [-sa, ca]]) @ np.stack(
(scan_x[close_mask] - xy[0], scan_y[close_mask] - xy[1]), axis=0)
ax.scatter(-xy_plotting[0],
xy_plotting[1],
s=80,
color=(191 / 255, 83 / 255, 79 / 255))
ax.scatter(0,
0,
s=500,
color=(18 / 255, 105 / 255, 176 / 255),
marker="+",
linewidth=5)
fig_file = os.path.join(
_SAVE_DIR,
f"samples/{sequence}/{pos_neg_dir}/{frame_id}_{count}_pt.pdf")
fig.savefig(fig_file)
plt.close(fig)
def demo(opt):
model.eval()
#########################################################################################
# eval begins here
#########################################################################################
data_iter_val = iter(dataloader_val)
loss_temp = 0
start = time.time()
num_show = 0
predictions = []
count = 0
for step in range(1000):
data = data_iter_val.next()
img, iseq, gts_seq, num, proposals, bboxs, box_mask, img_id = data
# if img_id[0] != 134688:
# continue
# # for i in range(proposals.size(1)): print(opt.itoc[proposals[0][i][4]], i)
# # list1 = [6, 10]
# list1 = [0, 1, 10, 2, 3, 4, 5, 6, 7, 8, 9]
# proposals = proposals[:,list1]
# num[0,1] = len(list1)
proposals = proposals[:,:max(int(max(num[:,1])),1),:]
input_imgs.data.resize_(img.size()).copy_(img)
input_seqs.data.resize_(iseq.size()).copy_(iseq)
gt_seqs.data.resize_(gts_seq.size()).copy_(gts_seq)
input_num.data.resize_(num.size()).copy_(num)
input_ppls.data.resize_(proposals.size()).copy_(proposals)
gt_bboxs.data.resize_(bboxs.size()).copy_(bboxs)
mask_bboxs.data.resize_(box_mask.size()).copy_(box_mask)
input_imgs.data.resize_(img.size()).copy_(img)
eval_opt = {'sample_max':1, 'beam_size': opt.beam_size, 'inference_mode' : True, 'tag_size' : opt.cbs_tag_size}
seq, bn_seq, fg_seq, _, _, _ = model._sample(input_imgs, input_ppls, input_num, eval_opt)
sents, det_idx, det_word = utils.decode_sequence_det(dataset_val.itow, dataset_val.itod, dataset_val.ltow, dataset_val.itoc, dataset_val.wtod, \
seq, bn_seq, fg_seq, opt.vocab_size, opt)
if opt.dataset == 'flickr30k':
im2show = Image.open(os.path.join(opt.image_path, '%d.jpg' % img_id[0])).convert('RGB')
else:
if os.path.isfile(os.path.join(opt.image_path, 'val2014/COCO_val2014_%012d.jpg' % img_id[0])):
im2show = Image.open(os.path.join(opt.image_path, 'val2014/COCO_val2014_%012d.jpg' % img_id[0])).convert('RGB')
else:
im2show = Image.open(os.path.join(opt.image_path, 'train2014/COCO_train2014_%012d.jpg' % img_id[0])).convert('RGB')
w, h = im2show.size
rest_idx = []
for i in range(proposals[0].shape[0]):
if i not in det_idx:
rest_idx.append(i)
if len(det_idx) > 0:
# for visulization
proposals = proposals[0].numpy()
proposals[:,0] = proposals[:,0] * w / float(opt.image_crop_size)
proposals[:,2] = proposals[:,2] * w / float(opt.image_crop_size)
proposals[:,1] = proposals[:,1] * h / float(opt.image_crop_size)
proposals[:,3] = proposals[:,3] * h / float(opt.image_crop_size)
cls_dets = proposals[det_idx]
rest_dets = proposals[rest_idx]
# fig = plt.figure()
# fig = plt.figure(frameon=False)
# ax = plt.Axes(fig, [0., 0., 1., 1.])
fig = plt.figure(frameon=False)
# fig.set_size_inches(5,5*h/w)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
a=fig.gca()
a.set_frame_on(False)
a.set_xticks([]); a.set_yticks([])
plt.axis('off')
plt.xlim(0,w); plt.ylim(h,0)
# fig, ax = plt.subplots(1)
# show other box in grey.
plt.imshow(im2show)
if len(rest_idx) > 0:
for i in range(len(rest_dets)):
ax = utils.vis_detections(ax, dataset_val.itoc[int(rest_dets[i,4])], rest_dets[i,:5], i, 1)
if len(det_idx) > 0:
for i in range(len(cls_dets)):
ax = utils.vis_detections(ax, dataset_val.itoc[int(cls_dets[i,4])], cls_dets[i,:5], i, 0)
# plt.axis('off')
# plt.axis('tight')
# plt.tight_layout()
fig.savefig('visu/%d.jpg' %(img_id[0]), bbox_inches='tight', pad_inches=0, dpi=150)
print(str(img_id[0]) + ': ' + sents[0])
entry = {'image_id': img_id[0], 'caption': sents[0]}
predictions.append(entry)
return predictions
def main():
# Initialize and parse command-line arguments.
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--verbose', action = 'store_true',
help = 'Provide verbose output.')
descwl.output.Reader.add_args(parser)
parser.add_argument('--no-display', action = 'store_true',
help = 'Do not display the image on screen.')
parser.add_argument('-o','--output-name',type = str, default = None, metavar = 'FILE',
help = 'Name of the output file to write.')
select_group = parser.add_argument_group('Object selection options')
select_group.add_argument('--galaxy', type = int, action = 'append',
default = [ ], metavar = 'ID',
help = 'Select the galaxy with this database ID (can be repeated).')
select_group.add_argument('--group', type = int, action = 'append',
default = [ ], metavar = 'ID',
help = 'Select galaxies belonging to the group with this group ID (can be repeated).')
select_group.add_argument('--select', type = str, action = 'append',
default = [ ], metavar = 'CUT',
help = 'Select objects passing the specified cut (can be repeated).')
select_group.add_argument('--select-region', type = str,
default = None, metavar = '[XMIN,XMAX,YMIN,YMAX]',
help = 'Select objects within this region relative to the image center (arcsecs).')
select_group.add_argument('--save-selected', type = str, default = None,
help = 'Name of FITS file for saving table of selected objects')
match_group = parser.add_argument_group('Detection catalog matching options')
match_group.add_argument('--match-catalog', type = str,
default = None, metavar = 'FILE',
help = 'Name of SExtractor-compatible detection catalog to read.')
match_group.add_argument('--match-color', type = str,
default = 'black', metavar = 'COL',
help = 'Matplotlib color name to use for displaying detection catalog matches.')
match_group.add_argument('--match-info', type = str,
default = None, metavar = 'FMT',
help = 'String interpolation format to generate matched object annotations.')
view_group = parser.add_argument_group('Viewing options')
view_group.add_argument('--magnification', type = float,
default = 1, metavar = 'MAG',
help = 'Magnification factor to use for display.')
view_group.add_argument('--crop', action = 'store_true',
help = 'Crop the displayed pixels around the selected objects.')
view_group.add_argument('--view-region', type = str,
default = None, metavar = '[XMIN,XMAX,YMIN,YMAX]',
help = 'Viewing region in arcsecs relative to the image center (overrides crop if set).')
view_group.add_argument('--draw-moments', action = 'store_true',
help = 'Draw ellipses to represent the 50%% iosophote second moments of selected objects.')
view_group.add_argument('--info', type = str,
default = None, metavar = 'FMT',
help = 'String interpolation format to generate annotation labels.')
view_group.add_argument('--no-crosshair', action = 'store_true',
help = 'Do not draw a crosshair at the centroid of each selected object.')
view_group.add_argument('--clip-lo-noise-fraction', type = float,
default = 0.05, metavar = 'FRAC',
help = 'Clip pixels with values below this fraction of the mean sky noise.')
view_group.add_argument('--clip-hi-percentile', type = float,
default = 90.0, metavar = 'PCT',
help = 'Clip pixels with non-zero values above this percentile for the selected image.')
view_group.add_argument('--hide-background', action = 'store_true',
help = 'Do not display background pixels.')
view_group.add_argument('--hide-selected', action = 'store_true',
help = 'Do not overlay any selected pixels.')
view_group.add_argument('--add-noise',type = int,default = None,metavar = 'SEED',
help = 'Add Poisson noise using the seed provided (no noise is added unless this is set).')
view_group.add_argument('--clip-noise',type = float,default = -1.,metavar = 'SIGMAS',
help = 'Clip background images at this many sigmas when noise is added.')
view_group.add_argument('--zscale-all', action='store_true',
help = 'Set zscale using all displayed objects instead of only selected ones')
format_group = parser.add_argument_group('Formatting options')
format_group.add_argument('--info-size', type = str,
default = 'large', metavar = 'SIZE',
help = 'Matplotlib font size specification in points or relative (small,large,...)')
format_group.add_argument('--dpi', type = float, default = 64.,
help = 'Number of pixels per inch to use for display.')
format_group.add_argument('--max-view-size', type = int,
default = 2048, metavar = 'SIZE',
help = 'Maximum allowed pixel dimensions of displayed image.')
format_group.add_argument('--colormap', type = str,
default = 'viridis', metavar = 'CMAP',
help = 'Matplotlib colormap name to use for background pixel values.')
format_group.add_argument('--highlight', type = str,
default = 'red', metavar = 'COL',
help = 'Matplotlib color name to use for highlighted pixel values.')
format_group.add_argument('--crosshair-color', type = str,
default = 'greenyellow', metavar = 'COL',
help = 'Matplotlib color name to use for crosshairs.')
format_group.add_argument('--ellipse-color', type = str,
default = 'greenyellow', metavar = 'COL',
help = 'Matplotlib color name to use for second-moment ellipses.')
format_group.add_argument('--info-color', type = str,
default = 'green', metavar = 'COL',
help = 'Matplotlib color name to use for info text.')
format_group.add_argument('--outline-color', type = str,
default = None, metavar = 'COL',
help = 'Matplotlib color name to use for outlining text.')
args = parser.parse_args()
if args.no_display and not args.output_name:
print('No display our output requested.')
return 0
if args.hide_background and args.hide_selected:
print('No pixels visible with --hide-background and --hide-selected.')
return 0
# Load the analysis results file we will display from.
try:
reader = descwl.output.Reader.from_args(defer_stamp_loading = True,args = args)
results = reader.results
if args.verbose:
print(results.survey.description())
except RuntimeError as e:
print(str(e))
return -1
# Add noise, if requested.
if args.add_noise is not None:
results.add_noise(args.add_noise)
# Match detected objects to simulated objects, if requested.
if args.match_catalog:
detected,matched,matched_indices,matched_distance = (
results.match_sextractor(args.match_catalog))
if args.verbose:
print('Matched %d of %d detected objects (median sep. = %.2f arcsecs).' % (
np.count_nonzero(matched),len(matched),np.median(matched_distance)))
# Create region selectors.
if args.select_region:
try:
assert args.select_region[0] == '[' and args.select_region[-1] == ']'
xmin,xmax,ymin,ymax = [ float(token) for token in args.select_region[1:-1].split(',') ]
assert xmin < xmax and ymin < ymax
except (ValueError,AssertionError):
print('Invalid select-region xmin,xmax,ymin,ymax = %s.' % args.select_region)
return -1
args.select.extend(['dx>=%f'%xmin,'dx<%f'%xmax,'dy>=%f'%ymin,'dy<%f'%ymax])
# Perform object selection.
if args.select:
# Combine select clauses with logical AND.
selection = results.select(*args.select,mode='and',format='mask')
else:
# Nothing is selected by default.
selection = results.select('NONE',format='mask')
# Add any specified groups to the selection with logical OR.
for identifier in args.group:
selected = results.select('grp_id==%d' % identifier,format='mask')
if not np.any(selected):
print('WARNING: no group found with ID %d.' % identifier)
selection = np.logical_or(selection,selected)
# Add any specified galaxies to the selection with logical OR.
for identifier in args.galaxy:
selected = results.select('db_id==%d' % identifier,format='mask')
if not np.any(selected):
print('WARNING: no galaxy found with ID %d.' % identifier)
selection = np.logical_or(selection,selected)
selected_indices = np.arange(results.num_objects)[selection]
if args.verbose:
print('Selected IDs:\n%s' % np.array(results.table['db_id'][selected_indices]))
groups = np.unique(results.table[selected_indices]['grp_id'])
print('Selected group IDs:\n%s' % np.array(groups))
# Do we have individual objects available for selection in the output file?
if np.any(selection) and not results.stamps:
print('Cannot display selected objects without any stamps available.')
return -1
# Save table of selected objects if requested.
if args.save_selected:
if args.verbose:
print('Saving selected objects to %s.' % args.save_selected)
results.table[selected_indices].write(args.save_selected, overwrite=True)
# Build the image of selected objects (might be None).
selected_image = results.get_subimage(selected_indices)
# Calculate our viewing bounds as (xmin,xmax,ymin,ymax) in floating-point pixels
# relative to the image bottom-left corner. Also calculate view_bounds with
# integer values that determine how to extract sub-images to display.
scale = results.survey.pixel_scale
if args.view_region is not None:
try:
assert args.view_region[0] == '[' and args.view_region[-1] == ']'
xmin,xmax,ymin,ymax = [ float(token) for token in args.view_region[1:-1].split(',') ]
assert xmin < xmax and ymin < ymax
except (ValueError,AssertionError):
print('Invalid view-window xmin,xmax,ymin,ymax = %s.' % args.view_region)
return -1
# Convert to pixels relative to bottom-left corner.
xmin = xmin/scale + 0.5*results.survey.image_width
xmax = xmax/scale + 0.5*results.survey.image_width
ymin = ymin/scale + 0.5*results.survey.image_height
ymax = ymax/scale + 0.5*results.survey.image_height
# Calculate integer pixel bounds that cover the view window.
view_bounds = galsim.BoundsI(
int(math.floor(xmin)),int(math.ceil(xmax))-1,
int(math.floor(ymin)),int(math.ceil(ymax))-1)
elif args.crop and selected_image is not None:
view_bounds = selected_image.bounds
xmin,xmax,ymin,ymax = (
view_bounds.xmin,view_bounds.xmax+1,view_bounds.ymin,view_bounds.ymax+1)
else:
view_bounds = results.survey.image.bounds
xmin,xmax,ymin,ymax = 0,results.survey.image_width,0,results.survey.image_height
if args.verbose:
vxmin = (xmin - 0.5*results.survey.image_width)*scale
vxmax = (xmax - 0.5*results.survey.image_width)*scale
vymin = (ymin - 0.5*results.survey.image_height)*scale
vymax = (ymax - 0.5*results.survey.image_height)*scale
print('View window is [xmin,xmax,ymin,ymax] = [%.2f,%.2f,%.2f,%.2f] arcsecs' % (
vxmin,vxmax,vymin,vymax))
print('View pixels in %r' % view_bounds)
# Initialize a matplotlib figure to display our view bounds.
view_width = float(xmax - xmin)
view_height = float(ymax - ymin)
if (view_width*args.magnification > args.max_view_size or
view_height*args.magnification > args.max_view_size):
print('Requested view dimensions %d x %d too big. Increase --max-view-size if necessary.' % (
view_width*args.magnification,view_height*args.magnification))
return -1
fig_height = args.magnification*(view_height/args.dpi)
fig_width = args.magnification*(view_width/args.dpi)
figure = plt.figure(figsize = (fig_width,fig_height),frameon = False,dpi = args.dpi)
axes = plt.Axes(figure, [0., 0., 1., 1.])
axes.axis(xmin = xmin,xmax = xmax,ymin = ymin,ymax = ymax)
axes.set_axis_off()
figure.add_axes(axes)
# Get the background and highlighted images to display, sized to our view.
background = galsim.Image(bounds = view_bounds,dtype = np.float32,scale = scale)
highlighted = background.copy()
if not args.hide_background:
overlap = results.survey.image.bounds & view_bounds
if overlap.area() > 0:
background[overlap] = results.survey.image[overlap]
if not args.hide_selected and selected_image is not None:
overlap = selected_image.bounds & view_bounds
if overlap.area() > 0:
highlighted[overlap] = selected_image[overlap]
if np.count_nonzero(highlighted.array) == 0:
if args.hide_background or np.count_nonzero(background.array) == 0:
print('There are no non-zero pixel values in the view window.')
return -1
# Prepare the z scaling.
zscale_pixels = results.survey.image.array
if selected_image and not args.zscale_all:
if selected_image.bounds.area() < 16:
print('WARNING: using full image for z-scaling since only %d pixel(s) selected.' % (
selected_image.bounds.area()))
else:
zscale_pixels = selected_image.array
# Clip large fluxes to a fixed percentile of the non-zero selected pixel values.
non_zero_pixels = (zscale_pixels != 0)
vmax = np.percentile(zscale_pixels[non_zero_pixels],q = (args.clip_hi_percentile))
# Clip small fluxes to a fixed fraction of the mean sky noise.
vmin = args.clip_lo_noise_fraction*np.sqrt(results.survey.mean_sky_level)
if args.verbose:
print('Clipping pixel values to [%.1f,%.1f] detected electrons.' % (vmin,vmax))
# Define the z scaling function. See http://ds9.si.edu/ref/how.html#Scales
def zscale(pixels):
return np.sqrt(pixels)
# Calculate the clipped and scaled pixel values to display.
highlighted_z = zscale((np.clip(highlighted.array,vmin,vmax) - vmin)/(vmax-vmin))
if args.add_noise:
vmin = args.clip_noise*np.sqrt(results.survey.mean_sky_level)
if args.verbose:
print('Background pixels with noise clipped to [%.1f,%.1f].' % (vmin,vmax))
background_z = zscale((np.clip(background.array,vmin,vmax) - vmin)/(vmax-vmin))
# Convert the background image to RGB using the requested colormap.
# Drop the alpha channel [3], which is all ones anyway.
cmap = matplotlib.cm.get_cmap(args.colormap)
background_rgb = cmap(background_z)[:,:,:3]
# Overlay the highlighted image using alpha blending.
# http://en.wikipedia.org/wiki/Alpha_compositing#Alpha_blending
if args.highlight and args.highlight != 'none':
alpha = highlighted_z[:,:,np.newaxis]
color = np.array(matplotlib.colors.colorConverter.to_rgb(args.highlight))
final_rgb = alpha*color + background_rgb*(1.-alpha)
else:
final_rgb = background_rgb
# Draw the composite image.
extent = (view_bounds.xmin,view_bounds.xmax+1,view_bounds.ymin,view_bounds.ymax+1)
axes.imshow(final_rgb,extent = extent,aspect = 'equal',origin = 'lower',
interpolation = 'nearest')
# The argparse module escapes any \n or \t in string args, but we need these
# to be unescaped in the annotation format string.
if args.info:
args.info = binary_type(args.info, 'utf-8').decode('unicode-escape')
if args.match_info:
args.match_info = binary_type(args.match_info, 'utf-8').decode('string-escape')
num_selected = len(selected_indices)
ellipse_centers = np.empty((num_selected,2))
ellipse_widths = np.empty(num_selected)
ellipse_heights = np.empty(num_selected)
ellipse_angles = np.empty(num_selected)
match_ellipse_centers = np.empty((num_selected,2))
match_ellipse_widths = np.empty(num_selected)
match_ellipse_heights = np.empty(num_selected)
match_ellipse_angles = np.empty(num_selected)
num_match_ellipses = 0
for index,selected in enumerate(selected_indices):
info = results.table[selected]
# Do we have a detected object matched to this simulated source?
match_info = None
if args.match_catalog and info['match'] >= 0:
match_info = detected[info['match']]
# Calculate the selected object's centroid position in user display coordinates.
x_center = (0.5*results.survey.image_width + info['dx']/scale)
y_center = (0.5*results.survey.image_height + info['dy']/scale)
if match_info is not None:
x_match_center = match_info['X_IMAGE']-0.5
y_match_center = match_info['Y_IMAGE']-0.5
# Draw a crosshair at the centroid of selected objects.
if not args.no_crosshair:
axes.plot(x_center,y_center,'+',color = args.crosshair_color,
markeredgewidth = 2,markersize = 24)
if match_info:
axes.plot(x_match_center,y_match_center,'x',color = args.match_color,
markeredgewidth = 2,markersize = 24)
# Add annotation text if requested.
if args.info:
path_effects = None if args.outline_color is None else [
matplotlib.patheffects.withStroke(linewidth = 2,
foreground = args.outline_color)]
try:
annotation = args.info % info
except IndexError:
print('Invalid annotate-format %r' % args.info)
return -1
axes.annotate(annotation,xy = (x_center,y_center),xytext = (4,4),
textcoords = 'offset points',color = args.info_color,
fontsize = args.info_size,path_effects = path_effects)
if match_info and args.match_info:
path_effects = None if args.outline_color is None else [
matplotlib.patheffects.withStroke(linewidth = 2,
foreground = args.outline_color)]
try:
annotation = args.match_info % match_info
except IndexError:
print('Invalid match-format %r' % args.match_info)
return -1
axes.annotate(annotation,xy = (x_match_center,y_match_center),
xytext = (4,4),textcoords = 'offset points',
color = args.info_color,fontsize = args.info_size,
path_effects = path_effects)
# Add a second-moments ellipse if requested.
if args.draw_moments:
ellipse_centers[index] = (x_center,y_center)
ellipse_widths[index] = info['a']/scale
ellipse_heights[index] = info['b']/scale
ellipse_angles[index] = np.degrees(info['beta'])
if match_info:
# This will only work if we have the necessary additional fields in the match catalog.
try:
match_ellipse_centers[num_match_ellipses] = (x_match_center,y_match_center)
match_ellipse_widths[num_match_ellipses] = match_info['A_IMAGE']
match_ellipse_heights[num_match_ellipses] = match_info['B_IMAGE']
match_ellipse_angles[num_match_ellipses] = match_info['THETA_IMAGE']
num_match_ellipses += 1
except IndexError:
pass
# Draw any ellipses.
if args.draw_moments:
ellipses = matplotlib.collections.EllipseCollection(units = 'x',
widths = ellipse_widths,heights = ellipse_heights,angles = ellipse_angles,
offsets = ellipse_centers, transOffset = axes.transData)
ellipses.set_facecolor('none')
ellipses.set_edgecolor(args.ellipse_color)
axes.add_collection(ellipses,autolim = True)
if num_match_ellipses > 0:
ellipses = matplotlib.collections.EllipseCollection(units = 'x',
widths = match_ellipse_widths,heights = match_ellipse_heights,
angles = match_ellipse_angles,offsets = match_ellipse_centers,
transOffset = axes.transData)
ellipses.set_facecolor('none')
ellipses.set_edgecolor(args.match_color)
#ellipses.set_linestyle('dashed')
axes.add_collection(ellipses,autolim = True)
if args.output_name:
figure.savefig(args.output_name,dpi = args.dpi)
if not args.no_display:
plt.show()
def run_mdnet(img_list, init_bbox, gt=None, savefig_dir='', display=False):
# Init bbox
target_bbox = np.array(init_bbox)
result = np.zeros((len(img_list), 4))
result_bb = np.zeros((len(img_list), 4))
result[0] = target_bbox
result_bb[0] = target_bbox
# Init model
model = MDNet(opts['model_path'])
if opts['use_gpu']:
model = model
model.set_learnable_params(opts['ft_layers'])
# Init criterion and optimizer
criterion = BinaryLoss()
init_optimizer = set_optimizer(model, opts['lr_init'])
update_optimizer = set_optimizer(model, opts['lr_update'])
tic = time.time()
# Load first image
image = Image.open(img_list[0]).convert('RGB')
# Train bbox regressor
bbreg_examples = gen_samples(
SampleGenerator('uniform', image.size, 0.3, 1.5, 1.1), target_bbox,
opts['n_bbreg'], opts['overlap_bbreg'], opts['scale_bbreg'])
bbreg_feats = forward_samples(model, image, bbreg_examples)
bbreg = BBRegressor(image.size)
bbreg.train(bbreg_feats, bbreg_examples, target_bbox)
# Draw pos/neg samples
pos_examples = gen_samples(
SampleGenerator('gaussian', image.size, 0.1, 1.2), target_bbox,
opts['n_pos_init'], opts['overlap_pos_init'])
neg_examples = np.concatenate([
gen_samples(SampleGenerator('uniform', image.size, 1, 2,
1.1), target_bbox, opts['n_neg_init'] // 2,
opts['overlap_neg_init']),
gen_samples(SampleGenerator('whole', image.size, 0, 1.2,
1.1), target_bbox, opts['n_neg_init'] // 2,
opts['overlap_neg_init'])
])
neg_examples = np.random.permutation(neg_examples)
# Extract pos/neg features
pos_feats = forward_samples(model, image, pos_examples)
neg_feats = forward_samples(model, image, neg_examples)
feat_dim = pos_feats.size(-1)
# Initial training
train(model, criterion, init_optimizer, pos_feats, neg_feats,
opts['maxiter_init'])
# Init sample generators
sample_generator = SampleGenerator('gaussian',
image.size,
opts['trans_f'],
opts['scale_f'],
valid=True)
pos_generator = SampleGenerator('gaussian', image.size, 0.1, 1.2)
neg_generator = SampleGenerator('uniform', image.size, 1.5, 1.2)
# Init pos/neg features for update
pos_feats_all = [pos_feats[:opts['n_pos_update']]]
neg_feats_all = [neg_feats[:opts['n_neg_update']]]
spf_total = time.time() - tic
# Display
savefig = savefig_dir != ''
if display or savefig:
dpi = 80.0
figsize = (image.size[0] / dpi, image.size[1] / dpi)
fig = plt.figure(frameon=False, figsize=figsize, dpi=dpi)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
im = ax.imshow(image, aspect='normal')
if gt is not None:
gt_rect = plt.Rectangle(tuple(gt[0, :2]),
gt[0, 2],
gt[0, 3],
linewidth=3,
edgecolor="#00ff00",
zorder=1,
fill=False)
ax.add_patch(gt_rect)
rect = plt.Rectangle(tuple(result_bb[0, :2]),
result_bb[0, 2],
result_bb[0, 3],
linewidth=3,
edgecolor="#ff0000",
zorder=1,
fill=False)
ax.add_patch(rect)
if display:
plt.pause(.01)
plt.draw()
if savefig:
fig.savefig(os.path.join(savefig_dir, '0000.jpg'), dpi=dpi)
# Main loop
for i in range(1, len(img_list)):
tic = time.time()
# Load image
image = Image.open(img_list[i]).convert('RGB')
# Estimate target bbox
samples = gen_samples(sample_generator, target_bbox, opts['n_samples'])
sample_scores = forward_samples(model, image, samples, out_layer='fc6')
top_scores, top_idx = sample_scores[:, 1].topk(5)
top_idx = top_idx.cpu().numpy()
target_score = top_scores.mean()
target_bbox = samples[top_idx].mean(axis=0)
success = target_score > opts['success_thr']
# Expand search area at failure
if success:
sample_generator.set_trans_f(opts['trans_f'])
else:
sample_generator.set_trans_f(opts['trans_f_expand'])
# Bbox regression
if success:
bbreg_samples = samples[top_idx]
bbreg_feats = forward_samples(model, image, bbreg_samples)
bbreg_samples = bbreg.predict(bbreg_feats, bbreg_samples)
bbreg_bbox = bbreg_samples.mean(axis=0)
else:
bbreg_bbox = target_bbox
# Copy previous result at failure
if not success:
target_bbox = result[i - 1]
bbreg_bbox = result_bb[i - 1]
# Save result
result[i] = target_bbox
result_bb[i] = bbreg_bbox
# Data collect
if success:
# Draw pos/neg samples
pos_examples = gen_samples(pos_generator, target_bbox,
opts['n_pos_update'],
opts['overlap_pos_update'])
neg_examples = gen_samples(neg_generator, target_bbox,
opts['n_neg_update'],
opts['overlap_neg_update'])
# Extract pos/neg features
pos_feats = forward_samples(model, image, pos_examples)
neg_feats = forward_samples(model, image, neg_examples)
pos_feats_all.append(pos_feats)
neg_feats_all.append(neg_feats)
if len(pos_feats_all) > opts['n_frames_long']:
del pos_feats_all[0]
if len(neg_feats_all) > opts['n_frames_short']:
del neg_feats_all[0]
# Short term update
if not success:
nframes = min(opts['n_frames_short'], len(pos_feats_all))
pos_data = torch.stack(pos_feats_all[-nframes:],
0).view(-1, feat_dim)
neg_data = torch.stack(neg_feats_all, 0).view(-1, feat_dim)
train(model, criterion, update_optimizer, pos_data, neg_data,
opts['maxiter_update'])
# Long term update
elif i % opts['long_interval'] == 0:
pos_data = torch.stack(pos_feats_all, 0).view(-1, feat_dim)
neg_data = torch.stack(neg_feats_all, 0).view(-1, feat_dim)
train(model, criterion, update_optimizer, pos_data, neg_data,
opts['maxiter_update'])
spf = time.time() - tic
spf_total += spf
# Display
if display or savefig:
im.set_data(image)
if gt is not None:
gt_rect.set_xy(gt[i, :2])
gt_rect.set_width(gt[i, 2])
gt_rect.set_height(gt[i, 3])
rect.set_xy(result_bb[i, :2])
rect.set_width(result_bb[i, 2])
rect.set_height(result_bb[i, 3])
if display:
plt.pause(.01)
plt.draw()
if savefig:
fig.savefig(os.path.join(savefig_dir, '%04d.jpg' % (i)),
dpi=dpi)
if gt is None:
print("Frame %d/%d, Score %.3f, Time %.3f" % \
(i, len(img_list), target_score, spf))
else:
print("Frame %d/%d, Overlap %.3f, Score %.3f, Time %.3f" % \
(i, len(img_list), overlap_ratio(gt[i],result_bb[i])[0], target_score, spf))
fps = len(img_list) / spf_total
return result, result_bb, fps
def vis_one_image(im,
im_name,
output_dir,
boxes,
segms=None,
keypoints=None,
thresh=0.9,
kp_thresh=2,
dpi=200,
box_alpha=0.0,
dataset=None,
show_class=False,
ext='pdf'):
"""Visual debugging of detections."""
if output_dir is not None:
if not os.path.exists(output_dir):
os.makedirs(output_dir)
if isinstance(boxes, list):
boxes, segms, keypoints, classes = convert_from_cls_format(
boxes, segms, keypoints)
if boxes is None or boxes.shape[0] == 0 or max(boxes[:, 4]) < thresh:
return
if segms is not None:
masks = mask_util.decode(segms)
color_list = colormap(rgb=True) / 255
dataset_keypoints, _ = keypoint_utils.get_keypoints()
kp_lines = kp_connections(dataset_keypoints)
cmap = plt.get_cmap('rainbow')
colors = [cmap(i) for i in np.linspace(0, 1, len(kp_lines) + 2)]
fig = plt.figure(frameon=False)
if output_dir is not None:
fig.set_size_inches(im.shape[1] / dpi, im.shape[0] / dpi)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.axis('off')
fig.add_axes(ax)
ax.imshow(im)
# preprocess the boxes
if thresh < 0:
# When VIS_TH less than zero, it means take the highest -thresh score boxes
sorted_inds = np.argsort(-boxes[:, -1])
boxes = boxes[sorted_inds[:-int(thresh)]]
classes = [classes[_] for _ in sorted_inds[:-int(thresh)]]
# Display in largest to smallest order to reduce occlusion
areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
sorted_inds = np.argsort(-areas)
_boxes = []
texts = []
for i in sorted_inds:
bbox = boxes[i, :4]
score = boxes[i, -1]
if score < thresh:
continue
if len(_boxes) > 0 and (bbox == _boxes[-1][:4]).all():
# Same box, merge prediction
texts[-1] += '/' + get_class_string(classes[i], score, dataset)
else:
_boxes.append(boxes[i])
texts.append(get_class_string(classes[i], score, dataset))
boxes = np.stack(_boxes)
mask_color_id = 0
for i in range(len(boxes)):
bbox = boxes[i, :4]
score = boxes[i, -1]
if score < thresh:
continue
# print(dataset.classes[classes[i]], score)
print(texts[i])
# show box (off by default, box_alpha=0.0)
ax.add_patch(
plt.Rectangle(
(bbox[0], bbox[1]),
bbox[2] - bbox[0],
bbox[3] - bbox[1],
fill=False,
edgecolor='r', #'##66FF66' if '@'in texts[i] else '#0099FF' ,
linewidth=5,
alpha=box_alpha))
if show_class:
ax.text(
bbox[0],
bbox[1] + 6,
texts[i].split(' ')
[0], #get_class_string(classes[i], score, dataset),
fontsize=3,
family='serif',
bbox=dict(
facecolor='#66FF66' if '@' in texts[i] else '#0099FF',
alpha=0.4,
pad=0,
edgecolor='none'),
color='white')
# show mask
if segms is not None and len(segms) > i:
img = np.ones(im.shape)
color_mask = color_list[mask_color_id % len(color_list), 0:3]
mask_color_id += 1
w_ratio = .4
for c in range(3):
color_mask[c] = color_mask[c] * (1 - w_ratio) + w_ratio
for c in range(3):
img[:, :, c] = color_mask[c]
e = masks[:, :, i]
_, contour, hier = cv2.findContours(e.copy(), cv2.RETR_CCOMP,
cv2.CHAIN_APPROX_NONE)
for c in contour:
polygon = Polygon(c.reshape((-1, 2)),
fill=True,
facecolor=color_mask,
edgecolor='w',
linewidth=1.2,
alpha=0.5)
ax.add_patch(polygon)
# show keypoints
if keypoints is not None and len(keypoints) > i:
kps = keypoints[i]
plt.autoscale(False)
for l in range(len(kp_lines)):
i1 = kp_lines[l][0]
i2 = kp_lines[l][1]
if kps[2, i1] > kp_thresh and kps[2, i2] > kp_thresh:
x = [kps[0, i1], kps[0, i2]]
y = [kps[1, i1], kps[1, i2]]
line = ax.plot(x, y)
plt.setp(line, color=colors[l], linewidth=1.0, alpha=0.7)
if kps[2, i1] > kp_thresh:
ax.plot(kps[0, i1],
kps[1, i1],
'.',
color=colors[l],
markersize=3.0,
alpha=0.7)
if kps[2, i2] > kp_thresh:
ax.plot(kps[0, i2],
kps[1, i2],
'.',
color=colors[l],
markersize=3.0,
alpha=0.7)
# add mid shoulder / mid hip for better visualization
mid_shoulder = (
kps[:2, dataset_keypoints.index('right_shoulder')] +
kps[:2, dataset_keypoints.index('left_shoulder')]) / 2.0
sc_mid_shoulder = np.minimum(
kps[2, dataset_keypoints.index('right_shoulder')],
kps[2, dataset_keypoints.index('left_shoulder')])
mid_hip = (kps[:2, dataset_keypoints.index('right_hip')] +
kps[:2, dataset_keypoints.index('left_hip')]) / 2.0
sc_mid_hip = np.minimum(
kps[2, dataset_keypoints.index('right_hip')],
kps[2, dataset_keypoints.index('left_hip')])
if (sc_mid_shoulder > kp_thresh
and kps[2, dataset_keypoints.index('nose')] > kp_thresh):
x = [mid_shoulder[0], kps[0, dataset_keypoints.index('nose')]]
y = [mid_shoulder[1], kps[1, dataset_keypoints.index('nose')]]
line = ax.plot(x, y)
plt.setp(line,
color=colors[len(kp_lines)],
linewidth=1.0,
alpha=0.7)
if sc_mid_shoulder > kp_thresh and sc_mid_hip > kp_thresh:
x = [mid_shoulder[0], mid_hip[0]]
y = [mid_shoulder[1], mid_hip[1]]
line = ax.plot(x, y)
plt.setp(line,
color=colors[len(kp_lines) + 1],
linewidth=1.0,
alpha=0.7)
if output_dir is not None:
output_name = os.path.basename(im_name) + '.' + ext
fig.savefig(os.path.join(output_dir, '{}'.format(output_name)),
dpi=dpi)
plt.close('all')
else:
plt.plot()
def demo(sess,
net,
im_file,
vis_file,
fits_fn,
conf_thresh=0.8,
eval_class=True,
extra_vis_png=False):
"""
Detect object classes in an image using pre-computed object proposals.
im_file: The "fused" image file path
vis_file: The background image file on which detections are laid.
Normallly, this is just the IR image file path
fits_fn: The FITS file path
eval_class: True - use traditional per class-based evaluation style
False - use per RoI-based evaluation
"""
show_img_size = cfg.TEST.SCALES[0]
if (not os.path.exists(im_file)):
print('%s cannot be found' % (im_file))
return -1
im = cv2.imread(im_file)
# Detect all object classes and regress object bounds
timer = Timer()
timer.tic()
image_name = osp.basename(im_file)
scores, boxes = im_detect(sess,
net,
im,
save_vis_dir=None,
img_name=os.path.splitext(image_name)[0])
boxes *= float(show_img_size) / float(im.shape[0])
timer.toc()
sys.stdout.write('Done in {:.3f} secs'.format(timer.total_time))
sys.stdout.flush()
print(scores)
im = cv2.imread(vis_file)
my_dpi = 100
fig = plt.figure()
fig.set_size_inches(show_img_size / my_dpi, show_img_size / my_dpi)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
ax.set_xlim([0, show_img_size])
ax.set_ylim([show_img_size, 0])
#ax.set_aspect('equal')
im = cv2.resize(im, (show_img_size, show_img_size))
im = im[:, :, (2, 1, 0)]
ax.imshow(im, aspect='equal')
if ((fits_fn is not None) and (not extra_vis_png)):
patch_contour = fuse(fits_fn,
im,
None,
sigma_level=4,
mask_ir=False,
get_path_patch_only=True)
ax.add_patch(patch_contour)
NMS_THRESH = cfg.TEST.NMS #cfg.TEST.RPN_NMS_THRESH # 0.3
tt_vis = 0
bbox_img = []
bscore_img = []
num_sources = 0
#if (eval_class):
for cls_ind, cls in enumerate(CLASSES[1:]):
cls_ind += 1 # because we skipped background
cls_boxes = boxes[:, 4 * cls_ind:4 * (cls_ind + 1)]
cls_scores = scores[:, cls_ind]
dets = np.hstack(
(cls_boxes, cls_scores[:, np.newaxis])) #.astype(np.float32)
keep = nms(dets, NMS_THRESH)
dets = dets[keep, :]
num_sources += vis_detections(im, cls, dets, ax, thresh=conf_thresh)
#dets = np.hstack((dets, np.ones([dets.shape[0], 1]) * cls_ind))
# if (dets.shape[0] > 0):
# bbox_img.append(dets)
# bscore_img.append(np.reshape(dets[:, -2], [-1, 1]))
# else:
# for eoi_ind, eoi in enumerate(boxes):
# eoi_scores = scores[eoi_ind, 1:] # skip background
# cls_ind = np.argmax(eoi_scores) + 1 # add the background index back
# cls_boxes = boxes[eoi_ind, 4 * cls_ind : 4 * (cls_ind + 1)]
# cls_scores = scores[eoi_ind, cls_ind]
# dets = np.hstack((np.reshape(cls_boxes, [1, -1]),
# np.reshape(cls_scores, [-1, 1])))#.astype(np.float32)
# dets = np.hstack((dets, np.ones([dets.shape[0], 1]) * cls_ind))
# bbox_img.append(dets)
# bscore_img.append(np.reshape(dets[:, -2], [-1, 1]))
#
# boxes_im = np.vstack(bbox_img)
# scores_im = np.vstack(bscore_img)
#
# #if (not eval_class):
# # a numpy float is a C double, so need to use float32
# keep = nms(boxes_im[:, :-1].astype(np.float32), NMS_THRESH)
# boxes_im = boxes_im[keep, :]
# scores_im = scores_im[keep, :]
#
# keep_indices = range(boxes_im.shape[0])
#num_sources = vis_detections(im, None, boxes_im[keep_indices, :], ax, thresh=conf_thresh)
print(', found %d sources' % num_sources)
return 0
def plot_all(plain_path, pre_HA_path, pre_PV_path, post_HA_path, post_PV_path,
pre_HA_label_path, pre_PV_label_path, post_HA_label_path,
post_PV_label_path, output_dir):
reader = sitk.ImageFileReader()
reader.SetFileName(plain_path)
plain = reader.Execute()
reader.SetFileName(pre_HA_path)
pre_HA = reader.Execute()
reader.SetFileName(pre_PV_path)
pre_PV = reader.Execute()
reader.SetFileName(post_HA_path)
post_HA = reader.Execute()
reader.SetFileName(post_PV_path)
post_PV = reader.Execute()
reader.SetFileName(pre_HA_label_path)
pre_HA_label = reader.Execute()
reader.SetFileName(pre_PV_label_path)
pre_PV_label = reader.Execute()
reader.SetFileName(post_HA_label_path)
post_HA_label = reader.Execute()
reader.SetFileName(post_PV_label_path)
post_PV_label = reader.Execute()
intensityWindowingFilter = sitk.IntensityWindowingImageFilter()
intensityWindowingFilter.SetOutputMaximum(255)
intensityWindowingFilter.SetOutputMinimum(0)
intensityWindowingFilter.SetWindowMaximum(300)
intensityWindowingFilter.SetWindowMinimum(0)
plain = intensityWindowingFilter.Execute(plain)
pre_HA = intensityWindowingFilter.Execute(pre_HA)
pre_PV = intensityWindowingFilter.Execute(pre_PV)
post_HA = intensityWindowingFilter.Execute(post_HA)
post_PV = intensityWindowingFilter.Execute(post_PV)
plain_np = sitk.GetArrayFromImage(plain)
pre_HA_np = sitk.GetArrayFromImage(pre_HA)
pre_PV_np = sitk.GetArrayFromImage(pre_PV)
post_HA_np = sitk.GetArrayFromImage(post_HA)
post_PV_np = sitk.GetArrayFromImage(post_PV)
pre_HA_label_np = sitk.GetArrayFromImage(pre_HA_label)
pre_PV_label_np = sitk.GetArrayFromImage(pre_PV_label)
post_HA_label_np = sitk.GetArrayFromImage(post_HA_label)
post_PV_label_np = sitk.GetArrayFromImage(post_PV_label)
for z in tqdm(range(plain_np.shape[0])):
# if not (z == 32):
# continue
plain_slice = plain_np[z, :, :]
pre_HA_slice = pre_HA_np[z, :, :]
pre_PV_slice = pre_PV_np[z, :, :]
post_HA_slice = post_HA_np[z, :, :]
post_PV_slice = post_PV_np[z, :, :]
pre_HA_label_slice = pre_HA_label_np[z, :, :]
pre_PV_label_slice = pre_PV_label_np[z, :, :]
post_HA_label_slice = post_HA_label_np[z, :, :]
post_PV_label_slice = post_PV_label_np[z, :, :]
dpi = 100
shape = np.shape(plain_slice)[0:2][::-1]
size = [float(i) / dpi for i in shape]
size[0] = size[0] * 5
fig = plt.figure()
fig.set_size_inches(size)
ax = plt.Axes(fig, [0, 0, 0.2, 1])
ax.set_axis_off()
fig.add_axes(ax)
ax.imshow(plain_slice, cmap="gray", origin='lower')
CS_pre_HA = ax.contour(pre_HA_label_slice, [0, 1],
colors='r',
origin='lower',
linewidths=1)
CS_pre_PV = ax.contour(pre_PV_label_slice, [0, 1],
colors='lawngreen',
origin='lower',
linewidths=1)
CS_post_HA = ax.contour(post_HA_label_slice, [0, 1],
colors='dodgerblue',
origin='lower',
linewidths=1)
CS_post_PV = ax.contour(post_PV_label_slice, [0, 1],
colors='yellow',
origin='lower',
linewidths=1)
CS_pre_HA.collections[0].set_label("Pre HA")
CS_pre_PV.collections[0].set_label("Pre PV")
CS_post_HA.collections[0].set_label("Post HA")
CS_post_PV.collections[0].set_label("Post PV")
leg = ax.legend(loc='upper right', frameon=False)
for text in leg.get_texts():
plt.setp(text, color='w')
ax = plt.Axes(fig, [0.2, 0, 0.2, 1])
ax.set_axis_off()
fig.add_axes(ax)
ax.imshow(pre_HA_slice, cmap="gray", origin='lower')
CS_pre_HA = ax.contour(pre_HA_label_slice, [0, 1],
colors='r',
origin='lower',
linewidths=1)
ax = plt.Axes(fig, [0.4, 0, 0.2, 1])
ax.set_axis_off()
fig.add_axes(ax)
ax.imshow(pre_PV_slice, cmap="gray", origin='lower')
CS_pre_PV = ax.contour(pre_PV_label_slice, [0, 1],
colors='lawngreen',
origin='lower',
linewidths=1)
ax = plt.Axes(fig, [0.6, 0, 0.2, 1])
ax.set_axis_off()
fig.add_axes(ax)
ax.imshow(post_HA_slice, cmap="gray", origin='lower')
CS_post_HA = ax.contour(post_HA_label_slice, [0, 1],
colors='dodgerblue',
origin='lower',
linewidths=1)
ax = plt.Axes(fig, [0.8, 0, 0.2, 1])
ax.set_axis_off()
fig.add_axes(ax)
ax.imshow(post_PV_slice, cmap="gray", origin='lower')
CS_post_PV = ax.contour(post_PV_label_slice, [0, 1],
colors='yellow',
origin='lower',
linewidths=1)
if z < 9:
fig.savefig(os.path.join(output_dir, "0" + str(z + 1) + ".jpg"),
dpi=dpi)
else:
fig.savefig(os.path.join(output_dir, str(z + 1) + ".jpg"), dpi=dpi)
plt.close(fig)
def display_instances(image,
boxes,
masks,
class_ids,
class_names,
scores=None,
title="",
figsize=(16, 16),
ax=None,
dstPath=None,
filename=None,
truemask=None):
"""
boxes: [num_instance, (y1, x1, y2, x2, class_id)] in image coordinates.
masks: [height, width, num_instances]
class_ids: [num_instances]
class_names: list of class names of the dataset
scores: (optional) confidence scores for each box
figsize: (optional) the size of the image.
"""
#scores_ = np.asarray(scores)
# Number of instances
scores = np.asarray(scores)
maxvalue = np.amax(scores)
indece = []
for i, score in enumerate(scores):
if (score == maxvalue):
indece.append(i)
indece = np.asarray(indece)
indece_tmp = []
index = -1
tmp = 1024
if (len(indece) == 1):
index = indece[0]
else:
for i in indece:
y1, x1, y2, x2, _ = bboxes[i]
if (x1 < 512 and y1 < tmp):
tmp = y1
indece_tmp.append(i)
tmp = 1024
if (len(indece_tmp) == 1):
index = indece_tmp[0]
else:
for i in indece_tmp:
y1, x1, y2, x2, _ = bboxes[i]
if (x1 < tmp):
tmp = x1
index = i
print("index", index)
#assert index < N and index >= 0
# if not N:
# print("\n*** No instances to display *** \n")
# else:
# assert boxes.shape[0] == masks.shape[-1] == class_ids.shape[0]
fig = plt.figure()
if not ax:
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
# Generate random colors
colors = random_colors(2)
# Show area outside image boundaries.
height, width = image.shape[:2]
ax.set_ylim(height + 10, -10)
ax.set_xlim(-10, width + 10)
ax.axis('off')
ax.set_title(title)
masked_image = image.astype(np.uint32).copy()
#for index in range(N):
color = colors[0]
#if not np.any(boxes[index]):
# Skip this instance. Has no bbox. Likely lost in image cropping.
#continue
y1, x1, y2, x2 = boxes[index]
p = patches.Rectangle((x1, y1),
x2 - x1,
y2 - y1,
linewidth=0.5,
alpha=0.7,
linestyle="dashed",
edgecolor=color,
facecolor='none')
ax.add_patch(p)
# Label
class_id = class_ids[index]
score = scores[i] if scores is not None else None
label = class_names[class_id]
x = random.randint(x1, (x1 + x2) // 2)
#caption = "{} {:.3f}".format(label, score) if score else label
#ax.text(x1, y1 + 8, caption,
# color='w', size=11, backgroundcolor="none")
# Mask
mask = masks[:, :, index]
masked_image = apply_mask(masked_image, mask, color)
#truemask = np.asarray(truemask)
#color = colors[1]
#masked_image = apply_mask(masked_image, truemask, color)
# Mask Polygon
# Pad to ensure proper polygons for masks that touch image edges.
padded_mask = np.zeros((mask.shape[0] + 2, mask.shape[1] + 2),
dtype=np.uint8)
padded_mask[1:-1, 1:-1] = mask
contours = find_contours(padded_mask, 0.5)
for verts in contours:
# Subtract the padding and flip (y, x) to (x, y)
verts = np.fliplr(verts) - 1
p = Polygon(verts, facecolor="none", edgecolor=color)
ax.add_patch(p)
padded_mask = np.zeros((truemask.shape[0] + 2, truemask.shape[1] + 2),
dtype=np.uint8)
padded_mask[1:-1, 1:-1] = truemask
contours = find_contours(padded_mask, 0.5)
for verts in contours:
# Subtract the padding and flip (y, x) to (x, y)
verts = np.fliplr(verts) - 1
p = Polygon(verts, facecolor="none", edgecolor=colors[1])
ax.add_patch(p)
ax.imshow(masked_image.astype(np.uint8))
#ax.imshow(truemask, cmap='Blues', alpha = 0.5, interpolation = 'nearest')
plt.show()
fig.savefig(dstPath + "/" + filename[:-4] + "_fig.png", dpi=1024)
def plot_chunk(chunk,
mode='spectrogram',
output_folder=None,
base_path=None,
size=227,
nfft=None,
file_type='png',
labelling=False,
**kwargs):
"""
Plot spectrograms for a chunk of a wav-file using the described parameters.
:param chunk: audio chunk to be plotted.
:param mode: type of audio plot to create.
:param nfft: number of samples for the fast fourier transformation \
(Default: 256)
:param size: size of the spectrogram plot in pixels. Height and width are \
always identical (Default: 227)
:param output_folder: if given, the plot is saved to this path in .png \
format (Default: None)
:param kwargs: keyword args for plotting functions
:return: blob of the spectrogram plot
"""
matplotlib.use('Agg')
import matplotlib.pyplot as plt
filename, sr, ts, audio = chunk
write_index = ts is not None
if not nfft:
nfft = _next_power_of_two(int(sr * 0.025))
log.debug(f'Using nfft={nfft} for the FFT.')
fig = plt.figure(frameon=False, tight_layout=False)
if labelling:
pass
else:
fig.set_size_inches(1, 1)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
with warnings.catch_warnings():
warnings.simplefilter('ignore')
spectrogram_axes = PLOTTING_FUNCTIONS[mode](audio, sr, nfft, **kwargs)
if labelling:
original_xlim = spectrogram_axes.get_xlim()
if mode != 'chroma':
kHz_ticks = np.apply_along_axis(lambda x: x / 1000, 0,
spectrogram_axes.get_yticks())
spectrogram_axes.set_yticklabels(kHz_ticks)
spectrogram_axes.set_ylabel('Frequency [kHz]',
fontdict=label_font)
else:
spectrogram_axes.set_ylabel('Pitch Classes',
fontdict=label_font)
if labelling:
spectrogram_axes.set_xticks(spectrogram_axes.get_xticks()[::2])
spectrogram_axes.set_xlabel('Time [s]', fontdict=label_font)
spectrogram_axes.set_xlim(original_xlim)
del audio
fig.add_axes(spectrogram_axes, id='spectrogram')
if labelling:
plt.colorbar(format='%+2.1f dB')
plt.tight_layout()
if output_folder:
relative_file_name = f'{splitext(get_relative_path(filename, base_path))[0]}_{ts:g}.{file_type}' if write_index else f'{splitext(get_relative_path(filename, base_path))[0]}.{file_type}'
if base_path is None:
outfile = join(output_folder, basename(relative_file_name))
else:
outfile = join(output_folder, relative_file_name)
log.debug(f'Saving spectrogram plot to {outfile}.')
makedirs(dirname(outfile), exist_ok=True)
fig.savefig(outfile, format=file_type, dpi=size)
buf = io.BytesIO()
fig.savefig(buf, format='png', dpi=size)
buf.seek(0)
fig.clf()
plt.close(fig)
img_blob = buf.read()
buf.close()
try:
img = imread_from_blob(img_blob, 'png')
img = img[:, :, :-1]
log.debug(f'Read spectrogram plot with shape {img.shape}.')
except IOError:
log.error('Error while reading the spectrogram blob.')
return None
return PlotTuple(name=get_relative_path(filename, base_path),
timestamp=ts,
plot=img)
def vis_one_image(im,
im_name,
output_dir,
boxes,
segms=None,
keypoints=None,
thresh=0.9,
kp_thresh=2,
dpi=200,
box_alpha=0.8,
dataset=None,
show_class=False,
ext='pdf',
labels=None):
"""Visual debugging of detections."""
# if not os.path.exists ( output_dir ) :
# os.makedirs ( output_dir )
print("Processing image: {}".format(im_name))
if isinstance(boxes, list):
boxes, segms, keypoints, classes = convert_from_cls_format(
boxes, segms, keypoints)
if boxes is None or boxes.shape[0] == 0 or max(boxes[:, 4]) < thresh:
return
# 这里的mask是一个三维数组,1,2维分别代表原图的横纵坐标，3维一共有当前预测出的instanecs个数的大小。
if segms is not None:
masks = mask_util.decode(segms)
color_list = colormap(rgb=True) / 255
# print ( np.unique ( classes ) )
dataset_keypoints, _ = keypoint_utils.get_keypoints()
kp_lines = kp_connections(dataset_keypoints)
cmap = plt.get_cmap('rainbow')
colors = [cmap(i) for i in np.linspace(0, 1, len(kp_lines) + 2)]
fig = plt.figure(frameon=False)
fig.set_size_inches(im.shape[1] / dpi, im.shape[0] / dpi)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.axis('off')
fig.add_axes(ax)
ax.imshow(im)
# Display in largest to smallest order to reduce occlusion
areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
# 默认从大到小排序，先画大的，小的会在后面把大的覆盖，这样大的和小的都能看到。
sorted_inds = np.argsort(-areas)
instance_cnt = defaultdict(int)
labels_graph = np.zeros((im.shape[0], im.shape[1]))
for item in enumerate(["instances_text", "instances", "labels"]):
if not os.path.exists(os.path.join(output_dir, item[1])):
os.makedirs(os.path.join(output_dir, item[1]), 0o777)
mask_file = open("{}/instances_text/{}.txt".format(output_dir, im_name),
"w")
# output labels prediction
for i in sorted_inds:
bbox = boxes[i, :4]
score = boxes[i, -1]
# 如果置信度大于0.5，执行
if score > 0.5:
single_mask = masks[:, :, i]
instances_graph = np.zeros((im.shape[0], im.shape[1]))
label_id = classes[i]
instance_cnt[dataset.classes[label_id]] += 1
instance_id = instance_cnt[dataset.classes[label_id]]
labels_graph[single_mask == 1] = label_id
instances_graph[single_mask == 1] = 255
scipy.misc.imsave(
'{}/instances/{}_{}.png'.format(output_dir, im_name,
label_id * 256 + instance_id),
instances_graph)
# 写入格式为mask_file_point class_name score
mask_file.write("{}/instances/{}_{}.png {} {}\n".format(
output_dir, im_name, label_id * 256 + instance_id, classes[i],
score))
# # current_graph存的是比较raw的值
# scipy.misc.imsave ( '/nfs/project/libo_i/mask-rcnn.pytorch/map_evaluation_format/raw/{}.jpg'.format ( im_name ) ,
# labels_graph )
# print ( np.unique ( labels_graph ) )
# colored_graph里存的是经过config中的cmap赋值之后的值。
# colored_graph = apply_color_map ( labels_graph , labels )
# gray_graph = rgb2gray ( colored_graph )
scipy.misc.imsave('{}/labels/{}.png'.format(output_dir, im_name),
labels_graph)
mask_file.close()
def make_map(e, n, t, d, dat_port, dat_star, data_R, pix_m, res, cs2cs_args,
sonpath, p, mode, nn, numstdevs, c, dx,
use_uncorrected): #dogrid, influence,dowrite,
thres = 5
trans = pyproj.Proj(init=cs2cs_args)
merge = np.vstack((dat_port, dat_star))
del dat_port, dat_star
merge[np.isnan(merge)] = 0
merge = merge[:, :len(n)]
## actual along-track resolution is this: dx times dy = Af
tmp = data_R * dx * (c * 0.007 / 2
) #dx = np.arcsin(c/(1000*meta['t']*meta['f']))
res_grid = np.sqrt(np.vstack((tmp, tmp)))
del tmp
res_grid = res_grid[:np.shape(merge)[0], :np.shape(merge)[1]]
#if use_uncorrected != 1:
# merge = merge - 10*np.log10(res_grid)
res_grid = res_grid.astype('float32')
merge[np.isnan(merge)] = 0
merge[merge < 0] = 0
merge = merge.astype('float32')
R = np.vstack((np.flipud(data_R), data_R))
del data_R
R = R[:np.shape(merge)[0], :np.shape(merge)[1]]
# get number pixels in scan line
extent = int(np.shape(merge)[0] / 2)
yvec = np.squeeze(
np.linspace(np.squeeze(pix_m), extent * np.squeeze(pix_m), extent))
X, Y, D, h, t = getXY(e, n, yvec, np.squeeze(d), t, extent)
X = X.astype('float32')
Y = Y.astype('float32')
D = D.astype('float32')
h = h.astype('float32')
t = t.astype('float32')
X = X.astype('float32')
D[np.isnan(D)] = 0
h[np.isnan(h)] = 0
t[np.isnan(t)] = 0
X = X[np.where(np.logical_not(np.isnan(Y)))]
merge = merge.flatten()[np.where(np.logical_not(np.isnan(Y)))]
res_grid = res_grid.flatten()[np.where(np.logical_not(np.isnan(Y)))]
Y = Y[np.where(np.logical_not(np.isnan(Y)))]
D = D[np.where(np.logical_not(np.isnan(Y)))]
R = R.flatten()[np.where(np.logical_not(np.isnan(Y)))]
h = h[np.where(np.logical_not(np.isnan(Y)))]
t = t[np.where(np.logical_not(np.isnan(Y)))]
Y = Y[np.where(np.logical_not(np.isnan(X)))]
merge = merge.flatten()[np.where(np.logical_not(np.isnan(X)))]
res_grid = res_grid.flatten()[np.where(np.logical_not(np.isnan(X)))]
X = X[np.where(np.logical_not(np.isnan(X)))]
D = D[np.where(np.logical_not(np.isnan(X)))]
R = R.flatten()[np.where(np.logical_not(np.isnan(X)))]
h = h[np.where(np.logical_not(np.isnan(X)))]
t = t[np.where(np.logical_not(np.isnan(X)))]
X = X[np.where(np.logical_not(np.isnan(merge)))]
Y = Y[np.where(np.logical_not(np.isnan(merge)))]
merge = merge[np.where(np.logical_not(np.isnan(merge)))]
res_grid = res_grid.flatten()[np.where(np.logical_not(np.isnan(merge)))]
D = D[np.where(np.logical_not(np.isnan(merge)))]
R = R[np.where(np.logical_not(np.isnan(merge)))]
h = h[np.where(np.logical_not(np.isnan(merge)))]
t = t[np.where(np.logical_not(np.isnan(merge)))]
X = X[np.where(np.logical_not(np.isinf(merge)))]
Y = Y[np.where(np.logical_not(np.isinf(merge)))]
merge = merge[np.where(np.logical_not(np.isinf(merge)))]
res_grid = res_grid.flatten()[np.where(np.logical_not(np.isinf(merge)))]
D = D[np.where(np.logical_not(np.isinf(merge)))]
R = R[np.where(np.logical_not(np.isinf(merge)))]
h = h[np.where(np.logical_not(np.isinf(merge)))]
t = t[np.where(np.logical_not(np.isinf(merge)))]
print "writing point cloud"
#if dowrite==1:
## write raw bs to file
outfile = os.path.normpath(
os.path.join(sonpath, 'x_y_ss_raw' + str(p) + '.asc'))
##write.txtwrite( outfile, np.hstack((humutils.ascol(X.flatten()),humutils.ascol(Y.flatten()), humutils.ascol(merge.flatten()), humutils.ascol(D.flatten()), humutils.ascol(R.flatten()), humutils.ascol(h.flatten()), humutils.ascol(t.flatten()) )) )
np.savetxt(outfile,
np.hstack(
(humutils.ascol(X.flatten()), humutils.ascol(Y.flatten()),
humutils.ascol(merge.flatten()),
humutils.ascol(D.flatten()), humutils.ascol(R.flatten()),
humutils.ascol(h.flatten()), humutils.ascol(t.flatten()))),
fmt="%8.6f %8.6f %8.6f %8.6f %8.6f %8.6f %8.6f")
del D, R, h, t
sigmas = 0.1 #m
eps = 2
#if dogrid==1:
if 2 > 1:
if res == 99:
resg = np.min(res_grid[res_grid > 0]) / 2
else:
resg = res
tree = KDTree(np.c_[X.flatten(), Y.flatten()])
complete = 0
while complete == 0:
try:
grid_x, grid_y, res = getmesh(np.min(X), np.max(X), np.min(Y),
np.max(Y), resg)
longrid, latgrid = trans(grid_x, grid_y, inverse=True)
longrid = longrid.astype('float32')
latgrid = latgrid.astype('float32')
shape = np.shape(grid_x)
## create mask for where the data is not
if pykdtree == 1:
dist, _ = tree.query(np.c_[grid_x.ravel(),
grid_y.ravel()],
k=1)
else:
try:
dist, _ = tree.query(np.c_[grid_x.ravel(),
grid_y.ravel()],
k=1,
n_jobs=cpu_count())
except:
#print ".... update your scipy installation to use faster kd-tree queries"
dist, _ = tree.query(np.c_[grid_x.ravel(),
grid_y.ravel()],
k=1)
dist = dist.reshape(grid_x.shape)
targ_def = pyresample.geometry.SwathDefinition(
lons=longrid.flatten(), lats=latgrid.flatten())
del longrid, latgrid
humlon, humlat = trans(X, Y, inverse=True)
orig_def = pyresample.geometry.SwathDefinition(
lons=humlon.flatten(), lats=humlat.flatten())
del humlon, humlat
if 'orig_def' in locals():
complete = 1
except:
print "memory error: trying grid resolution of %s" % (str(
resg * 2))
resg = resg * 2
if mode == 1:
complete = 0
while complete == 0:
try:
try:
dat = pyresample.kd_tree.resample_nearest(
orig_def,
merge.flatten(),
targ_def,
radius_of_influence=res * 20,
fill_value=None,
nprocs=cpu_count())
except:
dat = pyresample.kd_tree.resample_nearest(
orig_def,
merge.flatten(),
targ_def,
radius_of_influence=res * 20,
fill_value=None,
nprocs=1)
try:
r_dat = pyresample.kd_tree.resample_nearest(
orig_def,
res_grid.flatten(),
targ_def,
radius_of_influence=res * 20,
fill_value=None,
nprocs=cpu_count())
except:
r_dat = pyresample.kd_tree.resample_nearest(
orig_def,
res_grid.flatten(),
targ_def,
radius_of_influence=res * 20,
fill_value=None,
nprocs=1)
stdev = None
counts = None
if 'dat' in locals():
complete = 1
except:
del grid_x, grid_y, targ_def, orig_def
wf = None
humlon, humlat = trans(X, Y, inverse=True)
dat, stdev, counts, resg, complete, shape = getgrid_lm(
humlon, humlat, merge, res * 20, min(X), max(X),
min(Y), max(Y), resg * 2, mode, trans, nn, wf, sigmas,
eps)
r_dat, stdev, counts, resg, complete, shape = getgrid_lm(
humlon, humlat, res_grid, res * 20, min(X), max(X),
min(Y), max(Y), resg * 2, mode, trans, nn, wf, sigmas,
eps)
del humlon, humlat
elif mode == 2:
# custom inverse distance
wf = lambda r: 1 / r**2
complete = 0
while complete == 0:
try:
try:
dat, stdev, counts = pyresample.kd_tree.resample_custom(
orig_def,
merge.flatten(),
targ_def,
radius_of_influence=res * 20,
neighbours=nn,
weight_funcs=wf,
fill_value=None,
with_uncert=True,
nprocs=cpu_count())
except:
dat, stdev, counts = pyresample.kd_tree.resample_custom(
orig_def,
merge.flatten(),
targ_def,
radius_of_influence=res * 20,
neighbours=nn,
weight_funcs=wf,
fill_value=None,
with_uncert=True,
nprocs=1)
try:
r_dat = pyresample.kd_tree.resample_custom(
orig_def,
res_grid.flatten(),
targ_def,
radius_of_influence=res * 20,
neighbours=nn,
weight_funcs=wf,
fill_value=None,
with_uncert=False,
nprocs=cpu_count())
except:
r_dat = pyresample.kd_tree.resample_custom(
orig_def,
res_grid.flatten(),
targ_def,
radius_of_influence=res * 20,
neighbours=nn,
weight_funcs=wf,
fill_value=None,
with_uncert=False,
nprocs=1)
if 'dat' in locals():
complete = 1
except:
del grid_x, grid_y, targ_def, orig_def
humlon, humlat = trans(X, Y, inverse=True)
dat, stdev, counts, resg, complete, shape = getgrid_lm(
humlon, humlat, merge, res * 2, min(X), max(X), min(Y),
max(Y), resg * 2, mode, trans, nn, wf, sigmas, eps)
r_dat, stdev, counts, resg, complete, shape = getgrid_lm(
humlon, humlat, res_grid, res * 2, min(X), max(X),
min(Y), max(Y), resg * 2, mode, trans, nn, wf, sigmas,
eps)
del humlat, humlon
del stdev_null, counts_null
elif mode == 3:
wf = None
complete = 0
while complete == 0:
try:
try:
dat, stdev, counts = pyresample.kd_tree.resample_gauss(
orig_def,
merge.flatten(),
targ_def,
radius_of_influence=res * 20,
neighbours=nn,
sigmas=sigmas,
fill_value=None,
with_uncert=True,
nprocs=cpu_count(),
epsilon=eps)
except:
dat, stdev, counts = pyresample.kd_tree.resample_gauss(
orig_def,
merge.flatten(),
targ_def,
radius_of_influence=res * 20,
neighbours=nn,
sigmas=sigmas,
fill_value=None,
with_uncert=True,
nprocs=1,
epsilon=eps)
try:
r_dat = pyresample.kd_tree.resample_gauss(
orig_def,
res_grid.flatten(),
targ_def,
radius_of_influence=res * 20,
neighbours=nn,
sigmas=sigmas,
fill_value=None,
with_uncert=False,
nprocs=cpu_count(),
epsilon=eps)
except:
r_dat = pyresample.kd_tree.resample_gauss(
orig_def,
res_grid.flatten(),
targ_def,
radius_of_influence=res * 20,
neighbours=nn,
sigmas=sigmas,
fill_value=None,
with_uncert=False,
nprocs=1,
epsilon=eps)
if 'dat' in locals():
complete = 1
except:
del grid_x, grid_y, targ_def, orig_def
humlon, humlat = trans(X, Y, inverse=True)
dat, stdev, counts, resg, complete, shape = getgrid_lm(
humlon, humlat, merge, res * 20, min(X), max(X),
min(Y), max(Y), resg * 2, mode, trans, nn, wf, sigmas,
eps)
r_dat, stdev_null, counts_null, resg, complete, shape = getgrid_lm(
humlon, humlat, res_grid, res * 20, min(X), max(X),
min(Y), max(Y), resg * 2, mode, trans, nn, wf, sigmas,
eps)
del humlat, humlon
del stdev_null, counts_null
humlon, humlat = trans(X, Y, inverse=True)
del X, Y, res_grid, merge
dat = dat.reshape(shape)
dat[dist > res * 10] = np.nan
del dist
r_dat = r_dat.reshape(shape)
r_dat[r_dat < 1] = 1
r_dat[r_dat > 2 * np.pi] = 1
r_dat[np.isnan(dat)] = np.nan
dat = dat + r_dat #np.sqrt(np.cos(np.deg2rad(r_dat))) #dat*np.sqrt(r_dat) + dat
del r_dat
if mode > 1:
stdev = stdev.reshape(shape)
counts = counts.reshape(shape)
mask = dat.mask.copy()
dat[mask == 1] = np.nan
#dat[mask==1] = 0
if mode > 1:
dat[(stdev > numstdevs) & (mask != 0)] = np.nan
dat[(counts < nn) & (counts > 0)] = np.nan
#if dogrid==1:
dat[dat == 0] = np.nan
dat[np.isinf(dat)] = np.nan
dat[dat < thres] = np.nan
datm = np.ma.masked_invalid(dat)
glon, glat = trans(grid_x, grid_y, inverse=True)
del grid_x, grid_y
try:
# =========================================================
print "creating kmz file ..."
## new way to create kml file
pixels = 1024 * 10
fig, ax = humutils.gearth_fig(llcrnrlon=glon.min(),
llcrnrlat=glat.min(),
urcrnrlon=glon.max(),
urcrnrlat=glat.max(),
pixels=pixels)
cs = ax.pcolormesh(glon, glat, datm, cmap='gray')
ax.set_axis_off()
fig.savefig(os.path.normpath(
os.path.join(sonpath, 'map' + str(p) + '.png')),
transparent=True,
format='png')
del fig, ax
# =========================================================
fig = plt.figure(figsize=(1.0, 4.0), facecolor=None, frameon=False)
ax = fig.add_axes([0.0, 0.05, 0.2, 0.9])
cb = fig.colorbar(cs, cax=ax)
cb.set_label('Intensity [dB W]', rotation=-90, color='k', labelpad=20)
fig.savefig(os.path.normpath(
os.path.join(sonpath, 'legend' + str(p) + '.png')),
transparent=False,
format='png')
del fig, ax, cs, cb
# =========================================================
humutils.make_kml(
llcrnrlon=glon.min(),
llcrnrlat=glat.min(),
urcrnrlon=glon.max(),
urcrnrlat=glat.max(),
figs=[
os.path.normpath(os.path.join(sonpath,
'map' + str(p) + '.png'))
],
colorbar=os.path.normpath(
os.path.join(sonpath, 'legend' + str(p) + '.png')),
kmzfile=os.path.normpath(
os.path.join(sonpath, 'GroundOverlay' + str(p) + '.kmz')),
name='Sidescan Intensity')
except:
print "error: map could not be created..."
#y1 = np.min(glat)-0.001
#x1 = np.min(glon)-0.001
#y2 = np.max(glat)+0.001
#x2 = np.max(glon)+0.001
print "drawing and printing map ..."
fig = plt.figure(frameon=False)
map = Basemap(
projection='merc',
epsg=cs2cs_args.split(':')[1],
resolution='i', #h #f
llcrnrlon=np.min(humlon) - 0.001,
llcrnrlat=np.min(glat) - 0.001,
urcrnrlon=np.max(humlon) + 0.001,
urcrnrlat=np.max(glat) + 0.001)
try:
map.arcgisimage(server='http://server.arcgisonline.com/ArcGIS',
service='World_Imagery',
xpixels=1000,
ypixels=None,
dpi=300)
except:
map.arcgisimage(server='http://server.arcgisonline.com/ArcGIS',
service='ESRI_Imagery_World_2D',
xpixels=1000,
ypixels=None,
dpi=300)
#finally:
# print "error: map could not be created..."
#if dogrid==1:
gx, gy = map.projtran(glon, glat)
ax = plt.Axes(
fig,
[0., 0., 1., 1.],
)
ax.set_axis_off()
fig.add_axes(ax)
#if dogrid==1:
if 2 > 1:
if datm.size > 25000000:
print "matrix size > 25,000,000 - decimating by factor of 5 for display"
map.pcolormesh(gx[::5, ::5],
gy[::5, ::5],
datm[::5, ::5],
cmap='gray',
vmin=np.nanmin(datm),
vmax=np.nanmax(datm))
else:
map.pcolormesh(gx,
gy,
datm,
cmap='gray',
vmin=np.nanmin(datm),
vmax=np.nanmax(datm))
del datm, dat
else:
## draw point cloud
x, y = map.projtran(humlon, humlat)
map.scatter(x.flatten(),
y.flatten(),
0.5,
merge.flatten(),
cmap='gray',
linewidth='0')
#map.drawmapscale(x1+0.001, y1+0.001, x1, y1, 200., units='m', barstyle='fancy', labelstyle='simple', fontcolor='k') #'#F8F8FF')
#map.drawparallels(np.arange(y1-0.001, y2+0.001, 0.005),labels=[1,0,0,1], linewidth=0.0, rotation=30, fontsize=8)
#map.drawmeridians(np.arange(x1, x2, 0.002),labels=[1,0,0,1], linewidth=0.0, rotation=30, fontsize=8)
custom_save2(sonpath, 'map_imagery' + str(p))
del fig
del humlat, humlon
return res #return the new resolution
def vis_one_image(im,
im_name,
boxes,
segms=None,
keypoints=None,
thresh=0.9,
kp_thresh=2,
dpi=200,
box_alpha=0.0,
dataset=None,
show_class=False,
ext=None):
if isinstance(boxes, list):
boxes, segms, keypoints, classes = convert_from_cls_format(
boxes, segms, keypoints)
if boxes is None or boxes.shape[0] == 0 or max(boxes[:, 4]) < thresh:
return
dataset_keypoints, _ = keypoint_utils.get_keypoints()
if segms is not None and len(segms) > 0:
masks = mask_util.decode(segms)
color_list = colormap(rgb=True) / 255
kp_lines = kp_connections(dataset_keypoints)
cmap = plt.get_cmap('rainbow')
colors = [cmap(i) for i in np.linspace(0, 1, len(kp_lines) + 2)]
fig = plt.figure(frameon=False)
fig.set_size_inches(im.shape[1] / dpi, im.shape[0] / dpi)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.axis('off')
fig.add_axes(ax)
ax.imshow(im)
areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
sorted_inds = np.argsort(-areas)
mask_color_id = 0
C = []
for i in sorted_inds:
bbox = boxes[i, :4]
score = boxes[i, -1]
if score < thresh:
continue
ax.add_patch(
plt.Rectangle((bbox[0], bbox[1]),
bbox[2] - bbox[0],
bbox[3] - bbox[1],
fill=False,
edgecolor='g',
linewidth=0.5,
alpha=box_alpha))
if show_class:
ax.text(bbox[0],
bbox[1] - 2,
get_class_string(classes[i], score, dataset),
fontsize=3,
family='serif',
bbox=dict(facecolor='g',
alpha=0.4,
pad=0,
edgecolor='none'),
color='white')
if segms is not None and len(segms) > i:
#print ("duoshaogeIIIIIIIIIIIIIIIIIIIIIIIIIII")
#print (i)
#print ("len(segms)*********")
#print (len(segms))
img = np.ones(im.shape)
color_mask = color_list[mask_color_id % len(color_list), 0:3]
mask_color_id += 1
w_ratio = .4
for c in range(3):
color_mask[c] = color_mask[c] * (1 - w_ratio) + w_ratio
for c in range(3):
img[:, :, c] = color_mask[c]
e = masks[:, :, i]
_, contour, hier = cv2.findContours(e.copy(), cv2.RETR_CCOMP,
cv2.CHAIN_APPROX_NONE)
for c in contour:
polygon = Polygon(c.reshape((-1, 2)),
fill=True,
facecolor=color_mask,
edgecolor='w',
linewidth=0.2,
alpha=0.5)
ddd = list(c)
woca = c.reshape((-1, 2))
arr = np.array(woca)
key = np.unique(woca)
result = {}
k_qu = []
arr_end = []
arr_end2 = []
arr_endlast = []
A = []
B = []
Bplus = []
jjj = []
Bwanmei = []
Bcao = []
Bao = []
for k in key:
mask = (arr == k)
arr_new = arr[mask]
v = arr_new.size
result[k] = v
x = np.argwhere(arr == k)
if v > 1:
x = np.argwhere(arr == k)
x = np.array(x)
x0 = arr[:, 0]
y0 = arr[:, 1]
y0lie = []
for i in range(0, len(x0)):
if x0[i] != k:
pass
if x0[i] == k:
y0lie.append(y0[i])
y0lienew = []
arr_new = []
arr_new_2 = []
if y0lie == []:
pass
else:
miny0 = np.min(y0lie)
maxy0 = np.max(y0lie)
for i in range(miny0, maxy0 + 1):
y0lienew.append(i)
y0liezuizhong = []
if y0lienew == []:
pass
else:
miny0lienew = np.min(y0lienew)
maxy0lienew = np.max(y0lienew)
for i in range(miny0lienew, maxy0lienew + 1):
y0liezuizhong.append(i)
for i in range(0, len(y0liezuizhong)):
arr_temp = [k, y0liezuizhong[i]]
arr_new.append(arr_temp)
arr_end.append(arr_new)
x0lie = []
for i in range(0, len(y0)):
if y0[i] != k:
pass
if y0[i] == k:
x0lie.append(x0[i])
x0lienew = []
arr_new2 = []
if x0lie == []:
pass
else:
minx0 = np.min(x0lie)
maxx0 = np.max(x0lie)
for i in range(minx0, maxx0 + 1):
x0lienew.append(i)
x0liezuizhong = []
if x0lienew == []:
pass
else:
minx0lienew = np.min(x0lienew)
maxx0lienew = np.max(x0lienew)
for i in range(minx0lienew, maxx0lienew + 1):
x0liezuizhong.append(i)
for i in range(0, len(x0liezuizhong)):
arr_temp = [x0liezuizhong[i], k]
arr_new2.append(arr_temp)
arr_end2.append(arr_new2)
arr_endlast = arr_end + arr_end2 + ddd
A = list(chain(*arr_endlast))
B = np.array(list(set([tuple(t) for t in A])))
if len(B) > 10:
Bplus = random.sample(B, 5)
if len(B) < 10:
jjj = arr_endlast
Bwanmei = Bplus + jjj
Bcaotmp = list(chain(*Bwanmei))
Bcao = np.array(Bcaotmp)
Bao = Bcao.reshape(-1, 2)
C.append(Bao)
if keypoints is not None and len(keypoints) > i:
kps = keypoints[i]
plt.autoscale(False)
for l in range(len(kp_lines)):
i1 = kp_lines[l][0]
i2 = kp_lines[l][1]
if kps[2, i1] > kp_thresh and kps[2, i2] > kp_thresh:
x = [kps[0, i1], kps[0, i2]]
y = [kps[1, i1], kps[1, i2]]
line = plt.plot(x, y)
plt.setp(line, color=colors[l], linewidth=1.0, alpha=0.7)
if kps[2, i1] > kp_thresh:
plt.plot(kps[0, i1],
kps[1, i1],
'.',
color=colors[l],
markersize=3.0,
alpha=0.7)
if kps[2, i2] > kp_thresh:
plt.plot(kps[0, i2],
kps[1, i2],
'.',
color=colors[l],
markersize=3.0,
alpha=0.7)
mid_shoulder = (
kps[:2, dataset_keypoints.index('right_shoulder')] +
kps[:2, dataset_keypoints.index('left_shoulder')]) / 2.0
sc_mid_shoulder = np.minimum(
kps[2, dataset_keypoints.index('right_shoulder')],
kps[2, dataset_keypoints.index('left_shoulder')])
mid_hip = (kps[:2, dataset_keypoints.index('right_hip')] +
kps[:2, dataset_keypoints.index('left_hip')]) / 2.0
sc_mid_hip = np.minimum(
kps[2, dataset_keypoints.index('right_hip')],
kps[2, dataset_keypoints.index('left_hip')])
if (sc_mid_shoulder > kp_thresh
and kps[2, dataset_keypoints.index('nose')] > kp_thresh):
x = [mid_shoulder[0], kps[0, dataset_keypoints.index('nose')]]
y = [mid_shoulder[1], kps[1, dataset_keypoints.index('nose')]]
line = plt.plot(x, y)
plt.setp(line,
color=colors[len(kp_lines)],
linewidth=1.0,
alpha=0.7)
if sc_mid_shoulder > kp_thresh and sc_mid_hip > kp_thresh:
x = [mid_shoulder[0], mid_hip[0]]
y = [mid_shoulder[1], mid_hip[1]]
line = plt.plot(x, y)
plt.setp(line,
color=colors[len(kp_lines) + 1],
linewidth=1.0,
alpha=0.7)
plt.close('all')
C = np.array(C)
return C
def plot_rms(rms,
output='rms.png',
mode='both',
scale=1.0,
cmap='RdBu',
cbar_size=0.8,
cbar_sens=1.0,
vmin=None,
vmax=None,
cbar_pad=0.01,
pct_ticks=False,
**kwargs):
orig_cmap = plt.get_cmap(cmap)
rms_cmap = colors.LinearSegmentedColormap.from_list(
name='rms_cmap',
N=255,
colors=[orig_cmap(0), (1, 1, 1),
orig_cmap(255)]
) #this adds a white color in the midpoint of the chosen colormap (remove if not divergent cmap)
dpi = 100.0 #approx value. not used unless we wanted to plot this directly.
fig = plt.figure(figsize=(rms.shape[1] / dpi, rms.shape[0] / dpi),
frameon=False)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
ax2 = plt.Axes(fig, [1.0, 0.5 * (1 - cbar_size), 0.05, cbar_size])
fig.add_axes(ax2)
if (vmin is None) and (vmax is None):
_min, _max = rms.min(), rms.max()
if (sign(_min) != sign(_max)):
absmax = max(-_min, _max)
vmin, vmax = -absmax, absmax
elif (sign(_min) == +1):
vmin, vmax = 0.0, _max
else:
vmin, vmax = _min, 0.0
sns.heatmap(scale * rms,
norm=MidpointNormalize(midpoint=0.,
vmin=vmin,
vmax=vmax,
sensitivity=cbar_sens),
vmin=vmin,
vmax=vmax,
cbar=True,
cmap=rms_cmap,
cbar_ax=ax2,
annot=False,
xticklabels=False,
yticklabels=False,
ax=ax,
cbar_kws={'format': ticker.FuncFormatter(pct_fmt)}
if pct_ticks else {})
if (mode == 'both'):
fig.savefig(output, dpi=dpi, bbox_inches='tight')
elif (mode == 'error_only'):
ax2.remove()
fig.savefig(output, dpi=dpi)
elif (mode == 'cbar_only'):
ax.remove()
fig.savefig(output, bbox_inches='tight')
def gen_land_bitmap(bmap, resolution_meters):
#Get land polygons and bbox of polygons
polys = []
xmin = np.finfo(np.float64).max
xmax = -np.finfo(np.float64).max
ymin = xmin
ymax = xmax
logging.debug('Rasterizing Basemap, number of land polys: ' + str(len(bmap.landpolygons)))
# If no polys: return a zero map
if (len(bmap.landpolygons) == 0):
raise Exception('Basemap contains no land polys to rasterize')
for polygon in bmap.landpolygons:
coords = polygon.get_coords()
xmin = min(xmin, np.min(coords[:,0]))
xmax = max(xmax, np.max(coords[:,0]))
ymin = min(ymin, np.min(coords[:,1]))
ymax = max(ymax, np.max(coords[:,1]))
polys.append(coords)
xmin = np.floor(xmin/resolution_meters)*resolution_meters
xmax = np.ceil(xmax/resolution_meters)*resolution_meters
ymin = np.floor(ymin/resolution_meters)*resolution_meters
ymax = np.ceil(ymax/resolution_meters)*resolution_meters
# For debugging
logging.debug('Rasterizing Basemap, bounding box: ' + str([xmin, xmax, ymin, ymax]))
# Switch backend to prevent creating an empty figure in notebook
orig_backend = plt.get_backend()
plt.switch_backend('agg')
# Create figure to help rasterize
fig = plt.figure(frameon=False)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
ax.set_xlim(xmin, xmax)
ax.set_ylim(ymin, ymax)
# Set aspect and resolution
# Aspect gives 1 in high plot
aspect = (xmax-xmin)/(ymax-ymin)
resolution_dpi = (ymax-ymin) / resolution_meters
while resolution_dpi > 10000:
logging.debug('Too large dpi %s, reducing by factor of 2'
% resolution_dpi)
resolution_meters = resolution_meters*2
resolution_dpi = (ymax-ymin) / resolution_meters
fig.set_dpi(resolution_dpi)
fig.set_size_inches(aspect, 1)
# Add polygons
lc = PolyCollection(polys, facecolor='k', lw=0)
ax.add_collection(lc)
# Create canvas and rasterize
canvas = FigureCanvasAgg(fig)
try:
canvas.draw()
width, height = canvas.get_width_height()
rgb_data = np.frombuffer(canvas.tostring_rgb(), dtype='uint8').reshape(height, width, 3)
data = rgb_data[:,:,1]
plt.close(fig) #comment this for debugging purposes and replace with plt.show()
logging.debug('Rasterized size: ' + str([width, height]))
except MemoryError:
gc.collect()
raise Exception('Basemap rasterized size too large: '
+ str(aspect*resolution_dpi) + '*' + str(resolution_dpi)
+ ' cells')
finally:
# Reset backend
plt.switch_backend(orig_backend)
return RasterizedBasemap(xmin, xmax, ymin, ymax, resolution_meters, data)
def create_raster_plot_combined(trials,
align_event,
sorting_var='trial_id',
x_lim=[-1, 1],
show_plot=False,
fig_dir=None,
store_type=None):
sorting_query, mark, label = get_sort_and_marker(align_event, sorting_var)
fig = plt.figure(dpi=150, frameon=False, figsize=[10, 5])
ax = plt.Axes(fig, [0., 0., 1., 1.])
if len(trials):
if sorting_var == 'trial_id':
spk_times, trial_ids = (trials
& 'event="{}"'.format(align_event)).fetch(
'trial_spike_times',
'trial_id',
order_by='trial_id')
spk_trial_ids = np.hstack(
[[trial_id] * len(spk_time)
for trial_id, spk_time in enumerate(spk_times)])
ax.plot(np.hstack(spk_times),
spk_trial_ids,
'k.',
alpha=0.5,
markeredgewidth=0)
elif sorting_var == 'contrast':
spk_times, trial_contrasts = (
trials & 'event="{}"'.format(align_event)).fetch(
'trial_spike_times',
'trial_signed_contrast',
order_by='trial_signed_contrast, trial_id')
spk_trial_ids = np.hstack(
[[trial_id] * len(spk_time)
for trial_id, spk_time in enumerate(spk_times)])
ax.plot(np.hstack(spk_times),
spk_trial_ids,
'k.',
alpha=0.5,
markeredgewidth=0)
# plot different contrasts as background
contrasts, u_inds = np.unique(trial_contrasts, return_index=True)
u_inds = list(u_inds) + [len(trial_contrasts)]
tick_positions = np.add(u_inds[1:], u_inds[:-1]) / 2
puor = cl.scales[str(len(contrasts))]['div']['PuOr']
puor = np.divide(cl.to_numeric(puor), 255)
for i, ind in enumerate(u_inds[:-1]):
ax.fill_between([-1, 1],
u_inds[i],
u_inds[i + 1] - 1,
color=puor[i],
alpha=0.8)
fig.add_axes(ax)
elif sorting_var == 'feedback type':
spk_times, trial_fb_types = (
trials & 'event="{}"'.format(align_event)).fetch(
'trial_spike_times',
'trial_feedback_type',
order_by='trial_feedback_type, trial_id')
spk_trial_ids = np.hstack(
[[trial_id] * len(spk_time)
for trial_id, spk_time in enumerate(spk_times)])
ax.plot(np.hstack(spk_times),
spk_trial_ids,
'k.',
alpha=0.5,
markeredgewidth=0)
# plot different feedback types as background
fb_types, u_inds = np.unique(trial_fb_types, return_index=True)
u_inds = list(u_inds) + [len(trial_fb_types)]
colors = sns.diverging_palette(10, 240, n=len(fb_types))
for i, ind in enumerate(u_inds[:-1]):
ax.fill_between([-1, 1],
u_inds[i],
u_inds[i + 1] - 1,
color=colors[i],
alpha=0.5)
fig.add_axes(ax)
else:
spk_times_left, marking_points_left, \
spk_times_right, marking_points_right, \
spk_times_incorrect, marking_points_incorrect = \
get_spike_times_trials(
trials, sorting_var, align_event, sorting_query, mark)
id_gap = len(trials) * 0
if len(spk_times_incorrect):
spk_times_all_incorrect = np.hstack(spk_times_incorrect)
id_incorrect = [
[i] * len(spike_time)
for i, spike_time in enumerate(spk_times_incorrect)
]
id_incorrect = np.hstack(id_incorrect)
ax.plot(spk_times_all_incorrect,
id_incorrect,
'r.',
alpha=0.5,
markeredgewidth=0,
label='incorrect trials')
ax.plot(marking_points_incorrect,
range(len(spk_times_incorrect)),
'r',
label=label)
else:
id_incorrect = [0]
if not len(id_incorrect):
id_incorrect = [0]
if len(spk_times_left):
spk_times_all_left = np.hstack(spk_times_left)
id_left = [[i + max(id_incorrect) + id_gap] * len(spike_time)
for i, spike_time in enumerate(spk_times_left)]
id_left = np.hstack(id_left)
ax.plot(spk_times_all_left,
id_left,
'g.',
alpha=0.5,
markeredgewidth=0,
label='left trials')
ax.plot(
marking_points_left,
np.add(range(len(spk_times_left)),
max(id_incorrect) + id_gap), 'g')
else:
id_left = [max(id_incorrect)]
if not len(id_left):
id_left = [max(id_incorrect)]
if len(spk_times_right):
spk_times_all_right = np.hstack(spk_times_right)
id_right = [[i + max(id_left) + id_gap] * len(spike_time)
for i, spike_time in enumerate(spk_times_right)]
id_right = np.hstack(id_right)
ax.plot(spk_times_all_right,
id_right,
'b.',
alpha=0.5,
markeredgewidth=0,
label='right trials')
ax.plot(
marking_points_right,
np.add(range(len(spk_times_right)),
max(id_left) + id_gap), 'b')
else:
id_right = [max(id_left)]
if not len(id_right):
id_right = [max(id_left)]
ax.set_axis_off()
fig.add_axes(ax)
# hide the axis
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
# set the limits
ax.set_xlim(x_lim[0], x_lim[1])
if sorting_var in ('trial_id', 'contrast', 'feedback type'):
if len(spk_trial_ids):
y_lim = max(spk_trial_ids) * 1.02
else:
y_lim = 2
else:
y_lim = max(id_right) * 1.02
ax.set_ylim(-2, y_lim)
if not show_plot:
plt.close(fig)
# save the figure with `pad_inches=0` to remove
# any padding in the image
if fig_dir:
store_fig_external(fig, store_type, fig_dir)
fig.clear()
gc.collect()
if sorting_var == 'contrast':
return [0, y_lim], label, contrasts, tick_positions
else:
return [0, y_lim], label
else:
encoded_string = convert_fig_to_encoded_string(fig)
if sorting_var == 'contrast':
return encoded_string, [0, y_lim], label, contrasts, tick_positions
else:
return encoded_string, [0, y_lim], label
def plot(self,
figure=None,
overlays=None,
draw_limb=True,
gamma=None,
draw_grid=False,
colorbar=True,
basic_plot=False,
**matplot_args):
"""Plots the map object using matplotlib
Parameters
----------
overlays : list
List of overlays to include in the plot
draw_limb : bool
Whether the solar limb should be plotted.
draw_grid : bool
Whether solar meridians and parallels
grid_spacing : float
Set the spacing between meridians and parallels for the grid
gamma : float
Gamma value to use for the color map
colorbar : bool
Whether to display a colorbar next to the plot
basic_plot : bool
If true, the data is plotted by itself at it's natural scale; no
title, labels, or axes are shown.
**matplot_args : dict
Matplotlib Any additional imshow arguments that should be used
when plotting the image.
"""
if overlays is None:
overlays = []
if draw_limb:
overlays = overlays + [self._draw_limb]
# TODO: need to be able to pass the grid spacing to _draw_grid from the
# plot command.
if draw_grid:
overlays = overlays + [self._draw_grid]
# Create a figure and add title and axes
if figure is None:
figure = plt.figure(frameon=not basic_plot)
# Basic plot
if basic_plot:
axes = plt.Axes(figure, [0., 0., 1., 1.])
axes.set_axis_off()
figure.add_axes(axes)
# Normal plot
else:
axes = figure.add_subplot(111)
axes.set_title("%s %s" % (self.name, self.date))
# x-axis label
if self.coordinate_system['x'] == 'HG':
xlabel = 'Longitude [%s]' % self.units['x']
else:
xlabel = 'X-position [%s]' % self.units['x']
# y-axis label
if self.coordinate_system['y'] == 'HG':
ylabel = 'Latitude [%s]' % self.units['y']
else:
ylabel = 'Y-position [%s]' % self.units['y']
axes.set_xlabel(xlabel)
axes.set_ylabel(ylabel)
# Determine extent
extent = self.xrange + self.yrange
# Matplotlib arguments
params = {"cmap": self.cmap, "norm": self.norm()}
params.update(matplot_args)
if gamma is not None:
params['cmap'] = copy(params['cmap'])
params['cmap'].set_gamma(gamma)
im = axes.imshow(self, origin='lower', extent=extent, **params)
if colorbar and not basic_plot:
figure.colorbar(im)
for overlay in overlays:
figure, axes = overlay(figure, axes)
return figure
def driftmap(clusters_depths,
spikes_times,
spikes_amps,
spikes_depths,
spikes_clusters,
ax=None,
axesoff=False,
return_lims=False):
'''
Plots the driftmap of a session or a trial.
The plot shows the spike times vs spike depths.
Each dot is a spike, whose color indicates the cluster
and opacity indicates the spike amplitude.
Parameters
-------------
clusters_depths: ndarray
depths of all clusters
spikes_times: ndarray
spike times of all clusters
spikes_amps: ndarray
amplitude of each spike
spikes_depths: ndarray
depth of each spike
spikes_clusters: ndarray
cluster idx of each spike
ax: axessubplot (optional)
The axis handle to plot the driftmap on
(if `None`, a new figure and axis is created)
Return
---
ax: axessubplot
x_lim: list of two elements
y_lim: list of two elements
'''
# get the sorted idx of each depth, and create colors based on the idx
sorted_idx = np.argsort(np.argsort(clusters_depths))
colors = np.vstack([
np.repeat(new_color_bins[np.mod(idx, 500), :][np.newaxis, ...],
n_spikes,
axis=0)
for (
idx,
n_spikes) in zip(sorted_idx,
np.unique(spikes_clusters, return_counts=True)[1])
])
max_amp = np.percentile(spikes_amps, 90)
min_amp = np.percentile(spikes_amps, 10)
opacity = np.divide(spikes_amps - min_amp, max_amp - min_amp)
opacity[opacity > 1] = 1
opacity[opacity < 0] = 0
colorvec = np.zeros([len(opacity), 4], dtype='float16')
colorvec[:, 3] = opacity.astype('float16')
colorvec[:, 0:3] = colors.astype('float16')
x = spikes_times.astype('float32')
y = spikes_depths.astype('float32')
if ax is None:
fig = plt.Figure(dpi=50, frameon=False, figsize=[90, 90])
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.scatter(x, y, color=colorvec, edgecolors='none')
x_edge = (np.nanmax(x) - np.nanmin(x)) * 0.05
x_lim = [np.nanmin(x) - x_edge, np.nanmax(x) + x_edge]
y_lim = [np.nanmin(y) - 50, np.nanmax(y) + 100]
ax.set_xlim(x_lim[0], x_lim[1])
ax.set_ylim(y_lim[0], y_lim[1])
if axesoff:
ax.axis('off')
if return_lims:
return ax, x_lim, y_lim
else:
return ax
def draw_display(dispsize, imagefile=None):
"""Returns a matplotlib.pyplot Figure and its axes, with a size of
dispsize, a black background colour, and optionally with an image drawn
onto it
arguments
dispsize - tuple or list indicating the size of the display,
e.g. (1024,768)
keyword arguments
imagefile - full path to an image file over which the heatmap
is to be laid, or None for no image; NOTE: the image
may be smaller than the display size, the function
assumes that the image was presented at the centre of
the display (default = None)
returns
fig, ax - matplotlib.pyplot Figure and its axes: field of zeros
with a size of dispsize, and an image drawn onto it
if an imagefile was passed
"""
# construct screen (black background)
screen = numpy.zeros((dispsize[1], dispsize[0], 3), dtype='uint8')
# if an image location has been passed, draw the image
if imagefile != None:
# check if the path to the image exists
if not os.path.isfile(imagefile):
raise Exception(
"ERROR in draw_display: imagefile not found at '%s'" %
imagefile)
# load image
img = image.imread(imagefile)
# flip image over the horizontal axis
# (do not do so on Windows, as the image appears to be loaded with
# the correct side up there; what's up with that? :/)
if not os.name == 'nt':
img = numpy.flipud(img)
# width and height of the image
w, h = len(img[0]), len(img)
# x and y position of the image on the display
x = dispsize[0] / 2 - w / 2
y = dispsize[1] / 2 - h / 2
# draw the image on the screen
screen[y:y + h, x:x + w, :] += img
# dots per inch
dpi = 100.0
# determine the figure size in inches
figsize = (dispsize[0] / dpi, dispsize[1] / dpi)
# create a figure
fig = pyplot.figure(figsize=figsize, dpi=dpi, frameon=False)
ax = pyplot.Axes(fig, [0, 0, 1, 1])
ax.set_axis_off()
fig.add_axes(ax)
# plot display
ax.axis([0, dispsize[0], 0, dispsize[1]])
ax.imshow(screen) #, origin='upper')
return fig, ax
def plot_array(imgdata, pixelsize=1., pixelunit="", scale_bar=True,
show_fig=True, width=15, dpi=None,
sb_settings={"location": 'lower right',
"color": 'k',
"length_fraction": 0.15,
"font_properties": {"size": 12}},
imshow_kwargs={"cmap": "Greys_r"}):
'''
Plot a 2D numpy array as an image.
A scale-bar can be included.
Parameters
----------
imgdata : array-like, 2D
the image frame
pixelsize : float, optional
the scale size of one pixel
pixelunit : str, optional
the unit in which pixelsize is expressed
scale_bar : bool, optional
whether to add a scale bar to the image. Defaults to True.
show_fig : bool, optional
whether to show the figure. Defaults to True.
width : float, optional
width (in cm) of the plot. Default is 15 cm
dpi : int, optional
alternative to width. dots-per-inch can give an indication of size
if the image is printed. Overrides width.
sb_settings : dict, optional
key word args passed to the scale bar function. Defaults are:
{"location":'lower right', "color" : 'k', "length_fraction" : 0.15,
"font_properties": {"size": 40}}
See: <https://pypi.org/project/matplotlib-scalebar/>
imshow_kwargs : dict, optional
optional formating arguments passed to the pyplot.imshow function.
Defaults are: {"cmap": "Greys_r"}
Returns
-------
ax : matplotlib Axis object
im : the image plot object
'''
# initialize the figure and axes objects
if not show_fig:
plt.ioff()
if dpi is not None:
fig = plt.figure(frameon=False,
figsize=(imgdata.shape[1]/dpi, imgdata.shape[0]/dpi))
else:
# change cm units into inches
width = width*0.3937008
height = width/imgdata.shape[1]*imgdata.shape[0]
fig = plt.figure(frameon=False,
figsize=(width, height))
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
# plot the figure on the axes
im = ax.imshow(imgdata, **imshow_kwargs)
if scale_bar:
# get scale bar info from metadata
px = pixelsize
unit = pixelunit
# check the units and adjust sb accordingly
scalebar = get_scalebar(px, unit, sb_settings)
plt.gca().add_artist(scalebar)
# if show_fig:
# plt.show()
# else:
# plt.close()
return ax, im
def detect_objects(model,
IMAGE_PATH,
CATEGORY_INDEX,
ANCHOR_POINTS,
MINIMUM_CONFIDENCE,
SAVE_DIR=None):
'''
Adapted from tensorflow slim.
Performs object detection inference on given image (.jpg in IMAGE_PATH)
with a tflite Mobilenet-V1 model which has already been allocated tensors
Args:
model : (tf.lite.Interpreter) applied to MODEL_PATH
Should have run model.allocate_tensors() previously.
See initiate_tflite_model
IMAGE_PATH : (String) Path to image (.jpg) on which to perform inference
CATEGORY_INDEX : (Dictionary) Dictionary of dictionaries, key: position in labels.json
Each sub-dictionary has "name" field which will be displayed
beside the bounding box
ANCHOR_POINTS : array(N, 4) Shaped numpy array representing each of the
anchor points provided for Mobilenet-v1 SSD in anchors.json
MINIMUM_CONFIDENCE : (Float) Minimum score permissible for box to be considered for
display. Mobilenet-V1 SSD tends to provide quite low probabilities.
SAVE_DIR : (String) (Optional) Directory to save output inference images to.
If None, will print the plot to CLI with Matplotlib
'''
image = Image.open(IMAGE_PATH)
start = t.time()
classes, boxes, scores = call_tflite_model(model, image)
print("Inference time: {}".format(t.time() - start))
image_np = load_image_into_numpy_array(image)
image_np_reg = load_image_into_numpy_array(image, reg=True)
image_np_expanded = np.expand_dims(image_np, axis=0)
# Convert the quantised boxes to normalised
ty = boxes[:, 0] / float(10)
tx = boxes[:, 1] / float(10)
th = boxes[:, 2] / float(5)
tw = boxes[:, 3] / float(5)
yACtr = ANCHOR_POINTS[:, 0]
xACtr = ANCHOR_POINTS[:, 1]
ha = ANCHOR_POINTS[:, 2]
wa = ANCHOR_POINTS[:, 3]
w = np.exp(tw) * wa
h = np.exp(th) * ha
yCtr = ty * ha + yACtr
xCtr = tx * wa + xACtr
yMin = yCtr - h / float(2)
xMin = xCtr - w / float(2)
yMax = yCtr + h / float(2)
xMax = xCtr + w / float(2)
boxes_normalised = [yMin, xMin, yMax, xMax]
print("-" * 10)
print("Inference Summary:")
print("Highest Score: {}".format(np.max(scores)))
print("Highest Scoring Box: {}".format(
np.transpose(np.squeeze(boxes_normalised))[np.argmax(scores)]))
print("-" * 10)
print("Image shape: {}".format(np.squeeze(image_np).shape))
print("Boxes shape: {}".format(
np.transpose(np.squeeze(boxes_normalised)).shape))
print("Classes shape: {}".format(
np.round(np.squeeze(classes)).astype(np.int32).shape))
print("Scores shape: {}".format(np.squeeze(scores).shape))
fig = plt.figure()
out_image = vis_util.visualize_boxes_and_labels_on_image_array(
np.squeeze(image_np),
np.transpose(np.squeeze(boxes_normalised)),
np.round(np.squeeze(classes)).astype(np.int32),
np.squeeze(scores),
CATEGORY_INDEX,
min_score_thresh=MINIMUM_CONFIDENCE,
use_normalized_coordinates=True,
line_thickness=1,
ret=True)
fig.set_size_inches(16, 9)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
plt.imshow(out_image / 255)
if SAVE_DIR:
output_dir = SAVE_DIR + '/' + 'location_1' #image name
mkdir_p(Path(output_dir).parent)
plt.savefig(
output_dir, dpi=62
) #save the image with the detected frame in the output directory
plt.close(fig)
print("Image Saved")
print("=" * 10)
CURRENT_PATH = os.getcwd()
STATUS_PATH = os.path.join(CURRENT_PATH, 'model/output/status_1.txt')
if np.max(
scores
) > 0.60: # Write to status_ID.txt file to indicate whether a fire is detected
f = open(STATUS_PATH, "w")
f.write("1")
f.close()
else:
f = open(STATUS_PATH, "w")
f.write("0")
f.close
def export_html(exp,
sample_field=None,
feature_field=False,
title=None,
xticklabel_len=50,
cmap=None,
clim=None,
transform=log_n,
output_file='out',
html_template=None,
**kwargs):
'''Export an interactive html heatmap for the experiment.
Creates a standalone html file with interactive d3.js heatmap of the experiment and interface to dbBact.
Parameters
----------
sample_field : str or None (optional)
The field to display on the x-axis (sample):
None (default) to not show x labels.
str to display field values for this field
feature_field : str or None or False(optional)
Name of the field to display on the y-axis (features) or None not to display names
Flase (default) to use the experiment subclass default field
title : None or str (optional)
None (default) to show experiment description field as title. str to set title to str.
xticklabel_len : int (optional) or None
The maximal length for the x label strings (will be cut to
this length if longer). Used to prevent long labels from
taking too much space. None indicates no cutting
cmap : None or str (optional)
None (default) to use mpl default color map. str to use colormap named str.
clim : tuple of (float, float) or None (optional)
the min and max values for the heatmap or None to use all range. It uses the min
and max values in the ``data`` array by default.
transform : function (optional)
The transform function to apply to the data before plotting. default is log_n
output_file : str (optional)
Name of the output html file (no .html ending - it will be appended).
html_template : str or None (optional)
Name of the html template to use. None to use the default export_html_template.html template
'''
import matplotlib.pyplot as plt
if html_template is None:
html_template = resource_filename(__package__,
'export_html_template.html')
logger.debug('using default template file %s' % html_template)
logger.debug('export_html heatmap')
# get the default feature field if not specified (i.e. False)
if feature_field is False:
feature_field = exp.heatmap_feature_field
numrows, numcols = exp.shape
# step 1. transform data
if transform is None:
data = exp.get_data(sparse=False)
else:
logger.debug('transform exp with %r with param %r' %
(transform, kwargs))
data = transform(exp, inplace=False, **kwargs).data
# step 2. plot heatmap.
# init the default colormap
if cmap is None:
cmap = plt.rcParams['image.cmap']
# plot the heatmap with 1 pixel per feature/sample, no axes/lines
fig = plt.figure(frameon=False, dpi=300)
fig.set_size_inches(exp.shape[0] / 300, exp.shape[1] / 300)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
ax.imshow(data.transpose(), interpolation='nearest')
if title is None:
title = exp.description
# add parameters to html template
with open(html_template) as fl:
html_page = fl.read()
html_page = html_page.replace(
'// yticklabels go here', 'var yticklabels = %s;' %
_list_to_string(exp.feature_metadata[feature_field].values))
html_page = html_page.replace(
'// ids go here',
'var ids = %s;' % _list_to_string(exp.feature_metadata.index.values))
html_page = html_page.replace(
'// samples go here', 'var samples = %s;' %
_list_to_string(exp.sample_metadata.index.values))
if sample_field is not None:
html_page = html_page.replace('// field_name goes here',
'var field_name = "%s";' % sample_field)
html_page = html_page.replace('// title_text goes here',
'var title_text = "%s";' % title)
# add vertical lines between sample groups and add x tick labels
if sample_field is not None:
try:
xticks = _transition_index(exp.sample_metadata[sample_field])
except KeyError:
raise ValueError('Sample field %r not in sample metadata.' %
sample_field)
x_pos, x_val = zip(*xticks)
x_pos = np.array([0.] + list(x_pos))
html_page = html_page.replace(
'// vlines go here',
'var vlines = %s;' % _list_to_string(x_pos[1:-1]))
xtick_pos = x_pos[:-1] + (x_pos[1:] - x_pos[:-1]) / 2
html_page = html_page.replace(
'// xtick_pos go here',
'var xtick_pos = %s;' % _list_to_string(xtick_pos))
xticklabels = [str(i) for i in x_val]
# shorten x tick labels that are too long:
if xticklabel_len is not None:
mid = int(xticklabel_len / 2)
xticklabels = [
'%s..%s' %
(i[:mid], i[-mid:]) if len(i) > xticklabel_len else i
for i in xticklabels
]
html_page = html_page.replace(
'// xtick_labels go here',
'var xtick_labels = %s;' % _list_to_string(xticklabels))
# embed the figure png into the html page
with BytesIO() as figfile:
fig.savefig(figfile, format='png', dpi=300)
figfile.seek(0) # rewind to beginning of file
import base64
figdata_png = base64.b64encode(figfile.getvalue())
figdata_png = urllib.parse.quote(figdata_png)
html_page = html_page.replace('**image_goes_here**', figdata_png)
if output_file[-5:] != '.html':
output_file = output_file + '.html'
# save the output html export
with open(output_file, 'w') as fl:
fl.write(html_page)
logger.info('exported experiment to html file %s' % output_file)
return
def vis_one_image(im,
im_name,
output_dir,
boxes,
segms=None,
keypoints=None,
thresh=0.9,
kp_thresh=2,
dpi=200,
box_alpha=0.0,
dataset=None,
show_class=False,
ext='pdf',
out_when_no_box=False):
"""Visual debugging of detections."""
if not os.path.exists(output_dir):
os.makedirs(output_dir)
if isinstance(boxes, list):
boxes, segms, keypoints, classes = convert_from_cls_format(
boxes, segms, keypoints)
if (boxes is None or boxes.shape[0] == 0
or max(boxes[:, 4]) < thresh) and not out_when_no_box:
return
dataset_keypoints, _ = keypoint_utils.get_keypoints()
if segms is not None and len(segms) > 0:
masks = mask_util.decode(segms)
color_list = colormap(rgb=True) / 255
kp_lines = kp_connections(dataset_keypoints)
cmap = plt.get_cmap('rainbow')
colors = [cmap(i) for i in np.linspace(0, 1, len(kp_lines) + 2)]
fig = plt.figure(frameon=False)
fig.set_size_inches(im.shape[1] / dpi, im.shape[0] / dpi)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.axis('off')
fig.add_axes(ax)
ax.imshow(im)
if boxes is None:
sorted_inds = [] # avoid crash when 'boxes' is None
else:
# Display in largest to smallest order to reduce occlusion
areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
sorted_inds = np.argsort(-areas)
mask_color_id = 0
for i in sorted_inds:
bbox = boxes[i, :4]
score = boxes[i, -1]
if score < thresh:
continue
# show box (off by default)
ax.add_patch(
plt.Rectangle((bbox[0], bbox[1]),
bbox[2] - bbox[0],
bbox[3] - bbox[1],
fill=False,
edgecolor='g',
linewidth=0.5,
alpha=box_alpha))
if show_class:
ax.text(bbox[0],
bbox[1] - 2,
get_class_string(classes[i], score, dataset),
fontsize=3,
family='serif',
bbox=dict(facecolor='g',
alpha=0.4,
pad=0,
edgecolor='none'),
color='white')
# show mask
if segms is not None and len(segms) > i:
img = np.ones(im.shape)
color_mask = color_list[mask_color_id % len(color_list), 0:3]
mask_color_id += 1
w_ratio = .4
for c in range(3):
color_mask[c] = color_mask[c] * (1 - w_ratio) + w_ratio
for c in range(3):
img[:, :, c] = color_mask[c]
e = masks[:, :, i]
contour = cv2.findContours(e.copy(), cv2.RETR_CCOMP,
cv2.CHAIN_APPROX_NONE)[-2]
for c in contour:
polygon = Polygon(c.reshape((-1, 2)),
fill=True,
facecolor=color_mask,
edgecolor='w',
linewidth=1.2,
alpha=0.5)
ax.add_patch(polygon)
# show keypoints
if keypoints is not None and len(keypoints) > i:
kps = keypoints[i]
plt.autoscale(False)
for l in range(len(kp_lines)):
i1 = kp_lines[l][0]
i2 = kp_lines[l][1]
if kps[2, i1] > kp_thresh and kps[2, i2] > kp_thresh:
x = [kps[0, i1], kps[0, i2]]
y = [kps[1, i1], kps[1, i2]]
line = plt.plot(x, y)
plt.setp(line, color=colors[l], linewidth=1.0, alpha=0.7)
if kps[2, i1] > kp_thresh:
plt.plot(kps[0, i1],
kps[1, i1],
'.',
color=colors[l],
markersize=3.0,
alpha=0.7)
if kps[2, i2] > kp_thresh:
plt.plot(kps[0, i2],
kps[1, i2],
'.',
color=colors[l],
markersize=3.0,
alpha=0.7)
# add mid shoulder / mid hip for better visualization
mid_shoulder = (
kps[:2, dataset_keypoints.index('right_shoulder')] +
kps[:2, dataset_keypoints.index('left_shoulder')]) / 2.0
sc_mid_shoulder = np.minimum(
kps[2, dataset_keypoints.index('right_shoulder')],
kps[2, dataset_keypoints.index('left_shoulder')])
mid_hip = (kps[:2, dataset_keypoints.index('right_hip')] +
kps[:2, dataset_keypoints.index('left_hip')]) / 2.0
sc_mid_hip = np.minimum(
kps[2, dataset_keypoints.index('right_hip')],
kps[2, dataset_keypoints.index('left_hip')])
if (sc_mid_shoulder > kp_thresh
and kps[2, dataset_keypoints.index('nose')] > kp_thresh):
x = [mid_shoulder[0], kps[0, dataset_keypoints.index('nose')]]
y = [mid_shoulder[1], kps[1, dataset_keypoints.index('nose')]]
line = plt.plot(x, y)
plt.setp(line,
color=colors[len(kp_lines)],
linewidth=1.0,
alpha=0.7)
if sc_mid_shoulder > kp_thresh and sc_mid_hip > kp_thresh:
x = [mid_shoulder[0], mid_hip[0]]
y = [mid_shoulder[1], mid_hip[1]]
line = plt.plot(x, y)
plt.setp(line,
color=colors[len(kp_lines) + 1],
linewidth=1.0,
alpha=0.7)
output_name = os.path.basename(im_name) + '.' + ext
fig.savefig(os.path.join(output_dir, '{}'.format(output_name)), dpi=dpi)
plt.close('all')
def main(argv):
ntrans = 1
save_to_mat = 'off'
flip_profile = 'no'
which_gps = 'all'
flip_updown = 'yes'
incidence_file = 'incidence_file'
display_InSAR = 'on'
display_Average = 'on'
display_Standard_deviation = 'on'
try:
opts, args = getopt.getopt(
argv, "f:s:e:n:d:g:l:h:r:L:F:p:u:G:S:i:I:A:U:E:D:W:x:X:")
except getopt.GetoptError:
usage()
sys.exit(1)
for opt, arg in opts:
if opt == '-f':
velocityFile = arg
elif opt == '-s':
pnt1 = arg.split(',')
y0 = int(pnt1[0])
x0 = int(pnt1[1])
elif opt == '-e':
pnt2 = arg.split(',')
y1 = int(pnt2[0])
x1 = int(pnt2[1])
elif opt == '-n':
ntrans = int(arg)
elif opt == '-d':
dp = float(arg)
elif opt == '-g':
gpsFile = arg
elif opt == '-r':
refStation = arg
elif opt == '-i':
incidence_file = arg
elif opt == '-L':
stationsList = arg.split(',')
elif opt == '-F':
Fault_coord_file = arg
elif opt == '-p':
flip_profile = arg
elif opt == '-u':
flip_updown = arg
print(flip_updown)
elif opt == '-G':
which_gps = arg
elif opt == '-S':
gps_source = arg
elif opt == '-l':
lbound = float(arg)
elif opt == '-I':
display_InSAR = arg
elif opt == '-A':
display_Average = arg
elif opt == '-U':
display_Standard_deviation = arg
elif opt == '-E':
save_to_mat = arg
elif opt == '-h':
hbound = float(arg)
elif opt == '-D':
Dp = float(arg)
elif opt == '-W':
profile_Length = float(arg)
elif opt == '-x':
x_lbound = float(arg)
elif opt == '-X':
x_hbound = float(arg)
try:
h5file = h5py.File(velocityFile, 'r')
except:
usage()
sys.exit(1)
k = list(h5file.keys())
dset = h5file[k[0]].get(k[0])
z = dset[0:dset.shape[0], 0:dset.shape[1]]
dx = float(h5file[k[0]].attrs['X_STEP']) * 6375000.0 * np.pi / 180.0
dy = float(h5file[k[0]].attrs['Y_STEP']) * 6375000.0 * np.pi / 180.0
#############################################################################
try:
lat, lon, lat_step, lon_step, lat_all, lon_all = get_lat_lon(h5file)
except:
print('radar coordinate')
Fault_lon, Fault_lat = read_fault_coords(Fault_coord_file, Dp)
# Fault_lon=[66.40968453947265,66.36000186563085,66.31103920134248]
# Fault_lat=[30.59405079532564,30.51565960186412,30.43928430936202]
Num_profiles = len(Fault_lon) - 1
print('*********************************************')
print('*********************************************')
print('Number of profiles to be generated: ' + str(Num_profiles))
print('*********************************************')
print('*********************************************')
for Np in range(Num_profiles):
FaultCoords = [
Fault_lat[Np], Fault_lon[Np], Fault_lat[Np + 1], Fault_lon[Np + 1]
]
print('%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%')
print('%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%')
print('')
print('Profile ' + str(Np) + ' [of total ' + str(Num_profiles) + ']')
print('')
try:
# Lat0 = dms2d(FaultCoords[0]); Lon0 = dms2d(FaultCoords[1])
# Lat1 = dms2d(FaultCoords[2]); Lon1 = dms2d(FaultCoords[3])
Lat0 = FaultCoords[0]
Lon0 = FaultCoords[1]
Lat1 = FaultCoords[2]
Lon1 = FaultCoords[3]
Length, Width = np.shape(z)
Yf0, Xf0 = find_row_column(Lon0, Lat0, lon, lat, lon_step,
lat_step)
Yf1, Xf1 = find_row_column(Lon1, Lat1, lon, lat, lon_step,
lat_step)
print('*********************************************')
print(' Fault Coordinates:')
print(' -------------------------- ')
print(' Lat Lon')
print(str(Lat0) + ' , ' + str(Lon0))
print(str(Lat1) + ' , ' + str(Lon1))
print(' -------------------------- ')
print(' row column')
print(str(Yf0) + ' , ' + str(Xf0))
print(str(Yf1) + ' , ' + str(Xf1))
print('*********************************************')
#mf=float(Yf1-Yf0)/float((Xf1-Xf0)) # slope of the fault line
#cf=float(Yf0-mf*Xf0) # intercept of the fault line
#df0=dist_point_from_line(mf,cf,x0,y0,1,1) #distance of the profile start point from the Fault line
#df1=dist_point_from_line(mf,cf,x1,y1,1,1) #distance of the profile end point from the Fault line
#mp=-1./mf # slope of profile which is perpendicualr to the fault line
# correcting the end point of the profile to be on a line perpendicular to the Fault
#x1=int((df0+df1)/np.sqrt(1+mp**2)+x0)
#y1=int(mp*(x1-x0)+y0)
except:
print('*********************************************')
print('No information about the Fault coordinates!')
print('*********************************************')
#############################################################################
y0, x0, y1, x1 = get_start_end_point(Xf0, Yf0, Xf1, Yf1,
profile_Length, dx, dy)
try:
x0
y0
x1
y1
except:
fig = plt.figure()
ax = fig.add_subplot(111)
ax.imshow(z)
try:
ax.plot([Xf0, Xf1], [Yf0, Yf1], 'k-')
except:
print('Fault line is not specified')
xc = []
yc = []
print('please click on start and end point of the desired profile')
def onclick(event):
if event.button == 1:
print('click')
xc.append(int(event.xdata))
yc.append(int(event.ydata))
cid = fig.canvas.mpl_connect('button_press_event', onclick)
plt.show()
x0 = xc[0]
x1 = xc[1]
y0 = yc[0]
y1 = yc[1]
##############################################################################
print('******************************************************')
print('First profile coordinates:')
print('Start point: y = ' + str(y0) + ',x = ' + str(x0))
print('End point: y = ' + str(y1) + ' , x = ' + str(x1))
print('')
print(str(y0) + ',' + str(x0))
print(str(y1) + ',' + str(x1))
print('******************************************************')
length = int(np.hypot(x1 - x0, y1 - y0))
x, y = np.linspace(x0, x1, length), np.linspace(y0, y1, length)
zi = z[y.astype(np.int), x.astype(np.int)]
try:
lat_transect = lat_all[y.astype(np.int), x.astype(np.int)]
lon_transect = lon_all[y.astype(np.int), x.astype(np.int)]
except:
lat_transect = 'Nan'
lon_transect = 'Nan'
# zi=get_transect(z,x0,y0,x1,y1)
try:
dx = float(
h5file[k[0]].attrs['X_STEP']) * 6375000.0 * np.pi / 180.0
dy = float(
h5file[k[0]].attrs['Y_STEP']) * 6375000.0 * np.pi / 180.0
DX = (x - x0) * dx
DY = (y - y0) * dy
D = np.hypot(DX, DY)
print('geo coordinate:')
print('profile length = ' + str(D[-1] / 1000.0) + ' km')
#df0_km=dist_point_from_line(mf,cf,x0,y0,dx,dy)
except:
dx = float(h5file[k[0]].attrs['RANGE_PIXEL_SIZE'])
dy = float(h5file[k[0]].attrs['AZIMUTH_PIXEL_SIZE'])
DX = (x - x0) * dx
DY = (y - y0) * dy
D = np.hypot(DX, DY)
print('radar coordinate:')
print('profile length = ' + str(D[-1] / 1000.0) + ' km')
#df0_km=dist_point_from_line(mf,cf,x0,y0,dx,dy)
try:
mf, cf = line(Xf0, Yf0, Xf1, Yf1)
df0_km = dist_point_from_line(mf, cf, x0, y0, dx, dy)
except:
print('Fault line is not specified')
transect = np.zeros([len(D), ntrans])
transect[:, 0] = zi
XX0 = []
XX1 = []
YY0 = []
YY1 = []
XX0.append(x0)
XX1.append(x1)
YY0.append(y0)
YY1.append(y1)
if ntrans > 1:
m = float(y1 - y0) / float((x1 - x0))
c = float(y0 - m * x0)
m1 = -1.0 / m
try:
dp
except:
dp = 1.0
if lat_transect == 'Nan':
for i in range(1, ntrans):
X0 = i * dp / np.sqrt(1 + m1**2) + x0
Y0 = m1 * (X0 - x0) + y0
X1 = i * dp / np.sqrt(1 + m1**2) + x1
Y1 = m1 * (X1 - x1) + y1
zi = get_transect(z, X0, Y0, X1, Y1)
transect[:, i] = zi
XX0.append(X0)
XX1.append(X1)
YY0.append(Y0)
YY1.append(Y1)
else:
transect_lat = np.zeros([len(D), ntrans])
transect_lat[:, 0] = lat_transect
transect_lon = np.zeros([len(D), ntrans])
transect_lon[:, 0] = lon_transect
for i in range(1, ntrans):
X0 = i * dp / np.sqrt(1 + m1**2) + x0
Y0 = m1 * (X0 - x0) + y0
X1 = i * dp / np.sqrt(1 + m1**2) + x1
Y1 = m1 * (X1 - x1) + y1
zi = get_transect(z, X0, Y0, X1, Y1)
lat_transect = get_transect(lat_all, X0, Y0, X1, Y1)
lon_transect = get_transect(lon_all, X0, Y0, X1, Y1)
transect[:, i] = zi
transect_lat[:, i] = lat_transect
transect_lon[:, i] = lon_transect
XX0.append(X0)
XX1.append(X1)
YY0.append(Y0)
YY1.append(Y1)
#############################################
try:
m_prof_edge, c_prof_edge = line(XX0[0], YY0[0], XX0[-1], YY0[-1])
except:
print('Plotting one profile')
###############################################################################
if flip_profile == 'yes':
transect = np.flipud(transect)
try:
df0_km = np.max(D) - df0_km
except:
print('')
print('******************************************************')
try:
gpsFile
except:
gpsFile = 'Nogps'
print('GPS velocity file:')
print(gpsFile)
print('*******************************************************')
if os.path.isfile(gpsFile):
insarData = z
del z
fileName, fileExtension = os.path.splitext(gpsFile)
#print fileExtension
#if fileExtension =='.cmm4':
# print 'reading cmm4 velocities'
# Stations, gpsData = redGPSfile_cmm4(gpsFile)
# idxRef=Stations.index(refStation)
# Lon,Lat,Ve,Vn,Se,Sn,Corr,Hrate,H12=gpsData[idxRef,:]
# Lon=Lon-360.0
# Lat,Lon,Ve,Se,Vn,Sn,Corr,NumEpochs,timeSpan,AvgEpochTimes = gpsData[idxRef,:]
# Vu=0
#else:
# Stations, gpsData = redGPSfile(gpsFile)
# idxRef=Stations.index(refStation)
# Lat,Lon,Vn,Ve,Sn,Se,Corr,Vu,Su = gpsData[idxRef,:]
Stations, Lat, Lon, Ve, Se, Vn, Sn = readGPSfile(
gpsFile, gps_source)
idxRef = Stations.index(refStation)
Length, Width = np.shape(insarData)
lat, lon, lat_step, lon_step = get_lat_lon(h5file)
IDYref, IDXref = find_row_column(Lon[idxRef], Lat[idxRef], lon,
lat, lon_step, lat_step)
if (not np.isnan(IDYref)) and (not np.isnan(IDXref)):
print('referencing InSAR data to the GPS station at : ' +
str(IDYref) + ' , ' + str(IDXref))
if not np.isnan(insarData[IDYref][IDXref]):
transect = transect - insarData[IDYref][IDXref]
insarData = insarData - insarData[IDYref][IDXref]
else:
print("""
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
WARNING: nan value for InSAR data at the refernce pixel!
reference station should be a pixel with valid value in InSAR data.
please select another GPS station as the reference station.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
""")
sys.exit(1)
else:
print('WARNING:')
print(
'Reference GPS station is out of the area covered by InSAR data'
)
print(
'please select another GPS station as the reference station.'
)
sys.exit(1)
try:
stationsList
except:
stationsList = Stations
# theta=23.0*np.pi/180.0
if os.path.isfile(incidence_file):
print('Using exact look angle for each pixel')
h5file_theta = h5py.File(incidence_file, 'r')
dset = h5file_theta['mask'].get('mask')
theta = dset[0:dset.shape[0], 0:dset.shape[1]]
theta = theta * np.pi / 180.0
else:
print('Using average look angle')
theta = np.ones(np.shape(insarData)) * 23.0 * np.pi / 180.0
heading = 193.0 * np.pi / 180.0
#unitVec=[-np.sin(theta)*np.sin(heading),-np.cos(heading)*np.sin(theta),-np.cos(theta)]
# -np.cos(theta)]
unitVec = [
np.cos(heading) * np.sin(theta),
-np.sin(theta) * np.sin(heading), 0
]
# [0.0806152480932643, 0.34918300221540616, -0.93358042649720174]
# print unitVec
# unitVec=[0.3,-0.09,0.9]
# unitVec=[-0.3,0.09,-0.9]
# unitVec=[-0.3,0.09,0]
# print '*******************************************'
# print 'unit vector to project GPS to InSAR LOS:'
# print unitVec
# print '*******************************************'
# gpsLOS_ref=unitVec[0]*Ve[idxRef]+unitVec[1]*Vn[idxRef]#+unitVec[2]*Vu[idxRef]
gpsLOS_ref = gps_to_LOS(Ve[idxRef], Vn[idxRef],
theta[IDYref, IDXref], heading)
print('%%%%%%^^^^^^^%%%%%%%%')
print(gpsLOS_ref / 1000.0)
# insarData=insarData -gpsLOS_ref/1000.0
# transect = transect -gpsLOS_ref/1000.0
GPS = []
GPS_station = []
GPSx = []
GPSy = []
GPS_lat = []
GPS_lon = []
for st in stationsList:
try:
idx = Stations.index(st)
#gpsLOS = unitVec[0]*Ve[idx]+unitVec[1]*Vn[idx]#+unitVec[2]*Vu[idx]
#gpsLOS = gps_to_LOS(Ve[idx],Vn[idx],theta[idx],heading)
#gpsLOS=gpsLOS-gpsLOS_ref
IDY, IDX = find_row_column(Lon[idx], Lat[idx], lon, lat,
lon_step, lat_step)
print(theta[IDY, IDX])
gpsLOS = gps_to_LOS(Ve[idx], Vn[idx], theta[IDY, IDX],
heading)
#gpsLOS = gpsLOS-gpsLOS_ref
if which_gps == 'all':
if theta[IDY, IDX] != 0.0:
GPS.append(gpsLOS - gpsLOS_ref)
GPS_station.append(st)
GPSx.append(IDX)
GPSy.append(IDY)
GPS_lat.append(Lat[idx])
GPS_lon.append(Lon[idx])
elif not np.isnan(insarData[IDY][IDX]):
if theta[IDY, IDX] != 0.0:
GPS.append(gpsLOS - gpsLOS_ref)
GPS_station.append(st)
GPSx.append(IDX)
GPSy.append(IDY)
GPS_lat.append(Lat[idx])
GPS_lon.append(Lon[idx])
except:
NoInSAR = 'yes'
DistGPS = []
GPS_in_bound = []
GPS_in_bound_st = []
GPSxx = []
GPSyy = []
for i in range(len(GPS_station)):
gx = GPSx[i]
gy = GPSy[i]
if which_gps in ['all', 'insar']:
check_result = 'True'
else:
check_result = check_st_in_box(gx, gy, x0, y0, x1, y1, X0,
Y0, X1, Y1)
if check_result == 'True':
check_result2 = check_st_in_box2(gx, gy, x0, y0, x1, y1,
X0, Y0, X1, Y1)
GPS_in_bound_st.append(GPS_station[i])
GPS_in_bound.append(GPS[i])
GPSxx.append(GPSx[i])
GPSyy.append(GPSy[i])
# gy=y0+1
# gx=x0+1
# gxp,gyp=get_intersect(m,c,gx,gy)
# Dx=dx*(gx-gxp);Dy=dy*(gy-gyp)
# print gxp
# print gyp
# distance of GPS station from the first profile line
dg = dist_point_from_line(m, c, gx, gy, 1, 1)
# DistGPS.append(np.hypot(Dx,Dy))
# X0=dg/np.sqrt(1+m1**2)+x0
# Y0=m1*(X0-x0)+y0
# DistGPS.append(np.hypot(dx*(gx-X0), dy*(gy-Y0)))
DistGPS.append(
dist_point_from_line(m_prof_edge, c_prof_edge, GPSx[i],
GPSy[i], dx, dy))
print('****************************************************')
print('GPS stations in the profile area:')
print(GPS_in_bound_st)
print('****************************************************')
GPS_in_bound = np.array(GPS_in_bound)
DistGPS = np.array(DistGPS)
#axes[1].plot(DistGPS/1000.0, -1*GPS_in_bound/1000, 'bo')
if gpsFile == 'Nogps':
insarData = z
GPSxx = []
GPSyy = []
GPSx = []
GPSy = []
GPS = []
XX0[0] = x0
XX1[0] = x1
YY0[0] = y0
YY1[0] = y1
print('****************')
print('flip up-down')
print(flip_updown)
if flip_updown == 'yes' and gpsFile != 'Nogps':
print('Flipping up-down')
transect = -1 * transect
GPS_in_bound = -1 * GPS_in_bound
elif flip_updown == 'yes':
print('Flipping up-down')
transect = -1 * transect
if flip_profile == 'yes' and gpsFile != 'Nogps':
GPS = np.flipud(GPS)
GPS_in_bound = np.flipud(GPS_in_bound)
DistGPS = np.flipud(max(D) - DistGPS)
fig, axes = plt.subplots(nrows=2)
axes[0].imshow(insarData)
for i in range(ntrans):
axes[0].plot([XX0[i], XX1[i]], [YY0[i], YY1[i]], 'r-')
axes[0].plot(GPSx, GPSy, 'b^')
axes[0].plot(GPSxx, GPSyy, 'k^')
if gpsFile != 'Nogps':
axes[0].plot(IDXref, IDYref, 'r^')
axes[0].axis('image')
axes[1].plot(D / 1000.0, transect, 'ko', ms=1)
avgInSAR = np.array(nanmean(transect, axis=1))
stdInSAR = np.array(nanstd(transect, axis=1))
# std=np.std(transect,1)
# axes[1].plot(D/1000.0, avgInSAR, 'r-')
try:
axes[1].plot(DistGPS / 1000.0,
-1 * GPS_in_bound / 1000,
'b^',
ms=10)
except:
print('')
# pl.fill_between(x, y-error, y+error,alpha=0.6, facecolor='0.20')
# print transect
#############################################################################
fig2, axes2 = plt.subplots(nrows=1)
axes2.imshow(insarData)
# for i in range(ntrans):
axes2.plot([XX0[0], XX1[0]], [YY0[0], YY1[0]], 'k-')
axes2.plot([XX0[-1], XX1[-1]], [YY0[-1], YY1[-1]], 'k-')
axes2.plot([XX0[0], XX0[-1]], [YY0[0], YY0[-1]], 'k-')
axes2.plot([XX1[0], XX1[-1]], [YY1[0], YY1[-1]], 'k-')
try:
axes2.plot([Xf0, Xf1], [Yf0, Yf1], 'k-')
except:
FaultLine = 'None'
axes2.plot(GPSx, GPSy, 'b^')
axes2.plot(GPSxx, GPSyy, 'k^')
if gpsFile != 'Nogps':
axes2.plot(IDXref, IDYref, 'r^')
axes2.axis('image')
figName = 'transect_area_' + str(Np) + '.png'
print('writing ' + figName)
plt.savefig(figName)
#############################################################################
fig = plt.figure()
fig.set_size_inches(10, 4)
ax = plt.Axes(
fig,
[0., 0., 1., 1.],
)
ax = fig.add_subplot(111)
if display_InSAR in ['on', 'On', 'ON']:
ax.plot(D / 1000.0,
transect * 1000,
'o',
ms=1,
mfc='Black',
linewidth='0')
############################################################################
# save the profile data:
if save_to_mat in ['ON', 'on', 'On']:
import scipy.io as sio
matFile = 'transect' + str(Np) + '.mat'
dataset = {}
dataset['datavec'] = transect
try:
dataset['lat'] = transect_lat
dataset['lon'] = transect_lon
except:
dataset['lat'] = 'Nan'
dataset['lon'] = 'Nan'
dataset['Unit'] = 'm'
dataset['Distance_along_profile'] = D
print('*****************************************')
print('')
print('writing transect to >>> ' + matFile)
sio.savemat(matFile, {'dataset': dataset})
print('')
print('*****************************************')
#############################################################################
if display_Standard_deviation in ['on', 'On', 'ON']:
for i in np.arange(0.0, 1.01, 0.01):
# ,color='#DCDCDC')#'LightGrey')
ax.plot(D / 1000.0, (avgInSAR - i * stdInSAR) * 1000,
'-',
color='#DCDCDC',
alpha=0.5)
for i in np.arange(0.0, 1.01, 0.01):
ax.plot(D / 1000.0, (avgInSAR + i * stdInSAR) * 1000,
'-',
color='#DCDCDC',
alpha=0.5) # 'LightGrey')
#############################################################################
if display_Average in ['on', 'On', 'ON']:
ax.plot(D / 1000.0, avgInSAR * 1000, 'r-')
###########
try:
ax.plot(DistGPS / 1000.0,
-1 * GPS_in_bound,
'^',
ms=10,
mfc='Cyan')
except:
print('')
ax.set_ylabel('LOS velocity [mm/yr]', fontsize=26)
ax.set_xlabel('Distance along profile [km]', fontsize=26)
###################################################################
# lower and higher bounds for diplaying the profile
try:
lbound
hbound
except:
lbound = np.nanmin(transect) * 1000
hbound = np.nanmax(transect) * 1000
###################################################################
# To plot the Fault location on the profile
ax.plot([df0_km / 1000.0, df0_km / 1000.0], [lbound, hbound],
'--',
color='black',
linewidth='2')
###################################################################
try:
ax.set_ylim(lbound, hbound)
except:
ylim = 'no'
try:
ax.set_xlim(x_lbound, x_hbound)
except:
xlim = 'no'
##########
# Temporary To plot DEM
# majorLocator = MultipleLocator(5)
# ax.yaxis.set_major_locator(majorLocator)
# minorLocator = MultipleLocator(1)
# ax.yaxis.set_minor_locator(minorLocator)
# plt.tick_params(which='major', length=15,width=2)
# plt.tick_params(which='minor', length=6,width=2)
# try:
# for tick in ax.xaxis.get_major_ticks():
# tick.label.set_fontsize(26)
# for tick in ax.yaxis.get_major_ticks():
# tick.label.set_fontsize(26)
#
# plt.tick_params(which='major', length=15,width=2)
# plt.tick_params(which='minor', length=6,width=2)
# except:
# print 'couldn not fix the ticks! '
figName = 'transect_' + str(Np) + '.png'
print('writing ' + figName)
plt.savefig(figName)
print('')
print('________________________________')
def demo(image_name, image_no, image_index, net):
conf_thresh = 0.3
min_boxes = 15
max_boxes = 15
indexes = []
cfg.TEST.NMS = 0.6
im = cv2.imread(
os.path.join(
"/media/sadaf/e4da0f25-29be-4c9e-a432-3193ff5f5baf/Code/AWA_data/Animals_with_Attributes2/clean_images",
image_name))
scores, boxes, attr_scores, rel_scores = im_detect(net, im)
# Keep the original boxes, don't worry about the regression bbox outputs
rois = net.blobs['rois'].data.copy()
# unscale back to raw image space
blobs, im_scales = _get_blobs(im, None)
cls_boxes = rois[:, 1:5] / im_scales[0]
print(len(cls_boxes))
cls_prob = net.blobs['cls_prob'].data
attr_prob = net.blobs['attr_prob'].data
pool5 = net.blobs['pool5_flat'].data
# Keep only the best detections
max_conf = np.zeros((rois.shape[0]))
for cls_ind in range(1, cls_prob.shape[1]):
cls_scores = scores[:, cls_ind]
dets = np.hstack(
(cls_boxes, cls_scores[:, np.newaxis])).astype(np.float32)
keep = np.array(nms(dets, cfg.TEST.NMS))
max_conf[keep] = np.where(cls_scores[keep] > max_conf[keep],
cls_scores[keep], max_conf[keep])
keep_boxes = np.where(max_conf >= conf_thresh)[0]
if len(keep_boxes) < min_boxes:
keep_boxes = np.argsort(max_conf)[::-1][:min_boxes]
elif len(keep_boxes) > max_boxes:
keep_boxes = np.argsort(max_conf)[::-1][:max_boxes]
############################
att_unique = np.unique(att_names[image_index * scale:(image_index * scale +
scale)])
print(att_unique)
att_unique_adv = np.unique(
att_names_adv[image_index * scale:(image_index * scale + scale)])
cls_unique = np.unique(att_cls[image_index * scale:(image_index * scale +
scale)])
print(cls_unique)
cls_unique_adv = np.unique(
att_cls_adv[image_index * scale:(image_index * scale + scale)])
im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)
sizes = np.shape(im)
height = float(sizes[0])
width = float(sizes[1])
fig = plt.figure()
fig.set_size_inches(width / height, 1, forward=False)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
plt.imshow(im)
boxes = cls_boxes[keep_boxes]
#print (boxes)
#print (keep_boxes)
objects = np.argmax(cls_prob[keep_boxes][:, 1:], axis=1)
attr_thresh = 0.1
attr = np.argmax(attr_prob[keep_boxes][:, 1:], axis=1)
attr_conf = np.max(attr_prob[keep_boxes][:, 1:], axis=1)
count_box = 0
colors = [
"blue", "green", "red", "cyan", "magenta", "yellow", "black", "white",
"darkblue", "orchid", "springgreen", "lime", "deepskyblue",
"mediumvioletred", "maroon", "orangered"
]
for i in range(len(keep_boxes)):
bbox = boxes[i]
if bbox[0] == 0:
bbox[0] = 1
if bbox[1] == 0:
bbox[1] = 1
#cls = classes[objects[i]+1]
if attr_conf[i] > attr_thresh:
#for k in range (len(att_unique)):
# for l in range (len(cls_unique)):
#if attributes[attr[i]+1]==att_unique[k]:
# if classes[objects[i]+1] == cls_unique[l]:
#if attributes[attr[i]+1] not in att_unique_adv:
#if classes[objects[i]+1] not in cls_unique_adv:
if attributes[attr[i] + 1] in att_unique:
#cls = attributes[attr[i]+1] + " " + classes[objects[i]+1]
cls = attributes[attr[i] + 1]
count_box = count_box + 1
plt.gca().add_patch(
plt.Rectangle((bbox[0], bbox[1]),
bbox[2] - bbox[0],
bbox[3] - bbox[1],
fill=False,
edgecolor=colors[i],
linewidth=0.3,
alpha=0.5))
plt.gca().text(bbox[0],
bbox[1] + 30,
'%s' % (cls),
bbox=dict(facecolor='blue',
alpha=0,
linewidth=0.2),
fontsize=2,
color=colors[i])
# if classes[objects[i]+1] in att_unique:
#
# cls1 =classes[objects[i]+1]
#
# plt.gca().add_patch(plt.Rectangle((bbox[0], bbox[1]),bbox[2] - bbox[0],bbox[3] - bbox[1], fill=False,edgecolor='red', linewidth=0.3, alpha=0.5))
# plt.gca().text(bbox[2]-30, bbox[3],'%s' % (cls1),bbox=dict(facecolor='blue', alpha=0,linewidth=0.2),fontsize=1.5, color='red')
plt.savefig(
'/media/sadaf/e4da0f25-29be-4c9e-a432-3193ff5f5baf/Code/AWA_data/Animals_with_Attributes2/clean_images_1/clean_bb{}.jpg'
.format(image_no),
dpi=1500)
#plt.savefig('/media/sadaf/e4da0f25-29be-4c9e-a432-3193ff5f5baf/Code/Pytorch_Code/transfer_learn/pytorch-adversarial_box/plots_AT_NoAT/adv_bb_AT/adv_bb_AT{}_25.jpg'.format(image_no), dpi = 1500)
plt.close()
def vis_one_image(im,
im_name,
output_dir,
boxes,
segms=None,
keypoints=None,
body_uv=None,
thresh=0.9,
kp_thresh=2,
dpi=200,
box_alpha=0.0,
dataset=None,
show_class=False,
ext='jpg',
frame_no=None):
"""Visual debugging of detections."""
if not os.path.exists(output_dir):
os.makedirs(output_dir)
if isinstance(boxes, list):
boxes, segms, keypoints, classes = convert_from_cls_format(
boxes, segms, keypoints)
if boxes is None or boxes.shape[0] == 0 or max(boxes[:, 4]) < thresh:
print("Box:None, Shape:0 or MaxBox below thresh")
return
dataset_keypoints, _ = keypoint_utils.get_keypoints()
if segms is not None and len(segms) > 0:
masks = mask_util.decode(segms)
optime = time.time()
color_list = colormap(rgb=True) / 255
kp_lines = kp_connections(dataset_keypoints)
cmap = plt.get_cmap('rainbow')
colors = [cmap(i) for i in np.linspace(0, 1, len(kp_lines) + 2)]
fig = plt.figure(frameon=False)
fig.set_size_inches(im.shape[1] / dpi, im.shape[0] / dpi)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.axis('off')
fig.add_axes(ax)
ax.imshow(im)
# Display in largest to smallest order to reduce occlusion
areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
sorted_inds = np.argsort(-areas)
mask_color_id = 0
for i in sorted_inds:
bbox = boxes[i, :4]
score = boxes[i, -1]
if score < thresh:
continue
# show box (off by default)
ax.add_patch(
plt.Rectangle((bbox[0], bbox[1]),
bbox[2] - bbox[0],
bbox[3] - bbox[1],
fill=False,
edgecolor='g',
linewidth=0.5,
alpha=box_alpha))
if show_class:
ax.text(bbox[0],
bbox[1] - 2,
get_class_string(classes[i], score, dataset),
fontsize=10,
family='serif',
bbox=dict(facecolor='g',
alpha=0.4,
pad=0,
edgecolor='none'),
color='white')
# show mask
if segms is not None and len(segms) > i:
img = np.ones(im.shape)
color_mask = color_list[mask_color_id % len(color_list), 0:3]
mask_color_id += 1
w_ratio = .4
for c in range(3):
color_mask[c] = color_mask[c] * (1 - w_ratio) + w_ratio
for c in range(3):
img[:, :, c] = color_mask[c]
e = masks[:, :, i]
_, contour, hier = cv2.findContours(e.copy(), cv2.RETR_CCOMP,
cv2.CHAIN_APPROX_NONE)
for c in contour:
polygon = Polygon(c.reshape((-1, 2)),
fill=True,
facecolor=color_mask,
edgecolor='w',
linewidth=1.2,
alpha=0.5)
ax.add_patch(polygon)
# show keypoints
if keypoints is not None and len(keypoints) > i:
kps = keypoints[i]
plt.autoscale(False)
for l in range(len(kp_lines)):
i1 = kp_lines[l][0]
i2 = kp_lines[l][1]
if kps[2, i1] > kp_thresh and kps[2, i2] > kp_thresh:
x = [kps[0, i1], kps[0, i2]]
y = [kps[1, i1], kps[1, i2]]
line = plt.plot(x, y)
plt.setp(line, color=colors[l], linewidth=1.0, alpha=0.7)
if kps[2, i1] > kp_thresh:
plt.plot(kps[0, i1],
kps[1, i1],
'.',
color=colors[l],
markersize=3.0,
alpha=0.7)
if kps[2, i2] > kp_thresh:
plt.plot(kps[0, i2],
kps[1, i2],
'.',
color=colors[l],
markersize=3.0,
alpha=0.7)
# add mid shoulder / mid hip for better visualization
mid_shoulder = (
kps[:2, dataset_keypoints.index('right_shoulder')] +
kps[:2, dataset_keypoints.index('left_shoulder')]) / 2.0
sc_mid_shoulder = np.minimum(
kps[2, dataset_keypoints.index('right_shoulder')],
kps[2, dataset_keypoints.index('left_shoulder')])
mid_hip = (kps[:2, dataset_keypoints.index('right_hip')] +
kps[:2, dataset_keypoints.index('left_hip')]) / 2.0
sc_mid_hip = np.minimum(
kps[2, dataset_keypoints.index('right_hip')],
kps[2, dataset_keypoints.index('left_hip')])
if (sc_mid_shoulder > kp_thresh
and kps[2, dataset_keypoints.index('nose')] > kp_thresh):
x = [mid_shoulder[0], kps[0, dataset_keypoints.index('nose')]]
y = [mid_shoulder[1], kps[1, dataset_keypoints.index('nose')]]
line = plt.plot(x, y)
plt.setp(line,
color=colors[len(kp_lines)],
linewidth=1.0,
alpha=0.7)
if sc_mid_shoulder > kp_thresh and sc_mid_hip > kp_thresh:
x = [mid_shoulder[0], mid_hip[0]]
y = [mid_shoulder[1], mid_hip[1]]
line = plt.plot(x, y)
plt.setp(line,
color=colors[len(kp_lines) + 1],
linewidth=1.0,
alpha=0.7)
# DensePose Visualization Starts!!
## Get full IUV image out
IUV_fields = body_uv[1]
#
All_Coords = np.zeros(im.shape)
All_inds = np.zeros([im.shape[0], im.shape[1]])
K = 26
##
inds = np.argsort(boxes[:, 4])
##
for i, ind in enumerate(inds):
entry = boxes[ind, :]
if entry[4] > 0.65:
entry = entry[0:4].astype(int)
####
output = IUV_fields[ind]
####
All_Coords_Old = All_Coords[entry[1]:entry[1] + output.shape[1],
entry[0]:entry[0] + output.shape[2], :]
All_Coords_Old[All_Coords_Old == 0] = output.transpose(
[1, 2, 0])[All_Coords_Old == 0]
All_Coords[entry[1]:entry[1] + output.shape[1],
entry[0]:entry[0] + output.shape[2], :] = All_Coords_Old
###
CurrentMask = (output[0, :, :] > 0).astype(np.float32)
All_inds_old = All_inds[entry[1]:entry[1] + output.shape[1],
entry[0]:entry[0] + output.shape[2]]
All_inds_old[All_inds_old ==
0] = CurrentMask[All_inds_old == 0] * i
All_inds[entry[1]:entry[1] + output.shape[1],
entry[0]:entry[0] + output.shape[2]] = All_inds_old
#
All_Coords[:, :, 1:3] = 255. * All_Coords[:, :, 1:3]
All_Coords[All_Coords > 255] = 255.
All_Coords = All_Coords.astype(np.uint8)
All_inds = All_inds.astype(np.uint8)
# pdb.set_trace()
#draw frame and contours to canvas
plt.contour(All_Coords[:, :, 1] / 256., 10, linewidths=1)
plt.contour(All_Coords[:, :, 2] / 256., 10, linewidths=1)
plt.contour(All_inds, linewidths=3)
plt.axis('off')
fig.canvas.draw()
# convert canvas to image
img = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
img = img.reshape(fig.canvas.get_width_height()[::-1] + (3, ))
# img is rgb, convert to opencv's default bgr
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
# display image with opencv
cv2.imshow("plot", img)
cv2.waitKey(1)
print('\t-Visualized in {: .3f}s'.format(time.time() - optime))
output_name = os.path.basename(im_name) + '.' + ext
filetime = time.time()
out_dir = os.path.join(output_dir, 'vid')
if not os.path.exists(out_dir):
os.mkdir(out_dir)
out_file = 'file%02d.png' % frame_no
fig.savefig(os.path.join(out_dir, out_file), dpi=dpi)
print('\t-Output file wrote in {: .3f}s'.format(time.time() - filetime))
plt.close('all')
return True
print('\nPlotting results')
#fig = plt.figure(figsize=(10, 1.2),frameon= False)
#gs = gridspec.GridSpec(1, 10, wspace=0.05, hspace=0.05)
label = np.argmax(y_tmp, axis=1)
proba = np.max(y_tmp, axis=1)
for i in range(10):
probab = "-".join(str(proba[i]).split("."))
Shape = X_tmp[i].shape
fig = plt.figure(figsize=(Shape[1] / 100, Shape[0] / 100),
dpi=100,
frameon=False)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
im = plt.imshow(X_tmp[i])
fig.savefig("img/{}_{}".format(label[i], probab),
bbbox_inches='tight',
pad_inches=0,
dpi=100)
plt.show()
# ax = fig.add_subplot(gs[0, i])
#
# plt.show(x_tmp[i])
# ax.imshow(X_tmp[i], cmap='gray', interpolation='none')
# ax.set_xticks([])
# ax.set_yticks([])
# ax.set_xlabel('{0} ({1:.2f})'.format(label[i], proba[i]),
def __init__(self, sequence):
super().__init__()
self.sequence = sequence
self.frames = load_frames('sequences/' + self.sequence)
self.num_frames, self.height, self.width = self.frames.shape[:3]
# # init model
self.model = model(self.frames)
# set window
self.setWindowTitle('Demo: Interaction-and-Propagation Network')
self.setGeometry(100, 100, self.width, self.height + 100)
# buttons
self.prev_button = QPushButton('Prev')
self.prev_button.clicked.connect(self.on_prev)
self.next_button = QPushButton('Next')
self.next_button.clicked.connect(self.on_next)
self.play_button = QPushButton('Play')
self.play_button.clicked.connect(self.on_play)
self.run_button = QPushButton('Propagate!')
self.run_button.clicked.connect(self.on_run)
# LCD
self.lcd = QTextEdit()
self.lcd.setReadOnly(True)
self.lcd.setMaximumHeight(28)
self.lcd.setMaximumWidth(100)
self.lcd.setText('{: 3d} / {: 3d}'.format(0, self.num_frames - 1))
# slide
self.slider = QSlider(Qt.Horizontal)
self.slider.setMinimum(0)
self.slider.setMaximum(self.num_frames - 1)
self.slider.setValue(0)
self.slider.setTickPosition(QSlider.TicksBelow)
self.slider.setTickInterval(1)
self.slider.valueChanged.connect(self.slide)
# combobox
self.combo = QComboBox(self)
self.combo.addItem("fade")
self.combo.addItem("davis")
self.combo.addItem("checker")
self.combo.addItem("color")
self.combo.currentTextChanged.connect(self.set_viz_mode)
# canvas
self.fig = plt.Figure()
self.ax = plt.Axes(self.fig, [0., 0., 1., 1.])
self.ax.set_axis_off()
self.fig.add_axes(self.ax)
self.canvas = FigureCanvas(self.fig)
self.cidpress = self.fig.canvas.mpl_connect('button_press_event',
self.on_press)
self.cidrelease = self.fig.canvas.mpl_connect('button_release_event',
self.on_release)
self.cidmotion = self.fig.canvas.mpl_connect('motion_notify_event',
self.on_motion)
# navigator
navi = QHBoxLayout()
navi.addWidget(self.lcd)
navi.addWidget(self.prev_button)
navi.addWidget(self.play_button)
navi.addWidget(self.next_button)
navi.addStretch(1)
navi.addWidget(QLabel('Overlay Mode'))
navi.addWidget(self.combo)
navi.addStretch(1)
navi.addWidget(self.run_button)
layout = QVBoxLayout()
layout.addWidget(self.canvas)
layout.addWidget(self.slider)
layout.addLayout(navi)
layout.setStretchFactor(navi, 1)
layout.setStretchFactor(self.canvas, 0)
self.setLayout(layout)
# timer
self.timer = QTimer()
self.timer.setSingleShot(False)
self.timer.timeout.connect(self.on_time)
# initialize visualize
self.viz_mode = 'fade'
self.current_mask = np.zeros(
(self.num_frames, self.height, self.width), dtype=np.uint8)
self.cursur = 0
self.on_showing = None
self.show_current()
# initialize action
self.reset_scribbles()
self.pressed = False
self.on_drawing = None
self.drawn_strokes = []
self.show()
