def buildHeatMap(pointsList, circlesCoordsList, planePath, imgFile_path):
mapimg = Image.open(imgFile_path)
draw = ImageDraw.Draw(mapimg)
# draw line of plane moving
if len(planePath
) == 2 and planePath[0] is not None and planePath[1] is not None:
length = 2000
starty = planePath[0][1] - length * math.sin(planePath[1])
startx = planePath[0][0] - length * math.cos(planePath[1])
endy = planePath[0][1] + length * math.sin(planePath[1])
endx = planePath[0][0] + length * math.cos(planePath[1])
draw.line(xy=[(startx, starty), (endx, endy)],
width=3,
fill=(0, 255, 255))
for coordsAndRadius in circlesCoordsList:
draw.ellipse([
coordsAndRadius[0][0] - coordsAndRadius[1], coordsAndRadius[0][1] -
coordsAndRadius[1], coordsAndRadius[0][0] + coordsAndRadius[1],
coordsAndRadius[0][1] + coordsAndRadius[1]
],
outline='white')
heatmapper = Heatmapper(point_diameter=25, point_strength=0.2, opacity=0.7)
heatmapImg = heatmapper.heatmap_on_img(pointsList, mapimg)
return heatmapImg
def heatmap_generator(img_dir, heatmap_dir, histo_datafile):
# Enter Directory of all images
#img_dir = "./output_frames"
data_path = os.path.join(img_dir,'*g')
files = glob.glob(data_path)
# print(files)
#
heatmapper = Heatmapper(
point_diameter=90, # the size of each point to be drawn
point_strength=0.8, # the strength, between 0 and 1, of each point to be drawn
opacity=0.65, # the opacity of the heatmap layer
colours='default', # 'default' or 'reveal'
# OR a matplotlib LinearSegmentedColorMap object
# OR the path to a horizontal scale image
grey_heatmapper='PIL' # The object responsible for drawing the points
# Pillow used by default, 'PySide' option available if installed
)
professions_dict = points.getCordinatesDict(histo_datafile)
for k, v in professions_dict.items():
# print(k, v)
if k == "frame":
continue
frame = Image.open(img_dir + "/" + k)
heatmap = heatmapper.heatmap_on_img(v, frame)
dest_path = heatmap_dir + "/" + k + ".png"
#dest_path = os.path.join(".\\destination\\", '*g')
# print(dest_path)
heatmap.save(dest_path)
def buildTimedHeatMap(pointsList, circlesCoords, redCoords, planePath, imgFile_path):
mapimg = Image.open(imgFile_path).convert('RGBA')
game_events_image = Image.new('RGBA', mapimg.size, (255,255,255,0))
draw = ImageDraw.Draw(game_events_image)
if redCoords[1] > 0:
draw.ellipse([redCoords[0][0] - redCoords[1], redCoords[0][1] - redCoords[1],
redCoords[0][0] + redCoords[1], redCoords[0][1] + redCoords[1]],
fill=(255, 0, 0, 50))
# draw line of plane moving
if len(planePath) == 2 and planePath[0] is not None and planePath[1] is not None:
length = 2000
starty = planePath[0][1] - length * math.sin(planePath[1])
startx = planePath[0][0] - length * math.cos(planePath[1])
endy = planePath[0][1] + length * math.sin(planePath[1])
endx = planePath[0][0] + length * math.cos(planePath[1])
draw.line(xy=[(startx, starty), (endx, endy)], width=3, fill=(0, 255, 255))
draw.ellipse([circlesCoords[0][0] - circlesCoords[1], circlesCoords[0][1] - circlesCoords[1],
circlesCoords[0][0] + circlesCoords[1], circlesCoords[0][1] + circlesCoords[1]],
outline='white')
mapimg = Image.alpha_composite(mapimg, game_events_image)
heatmapper = Heatmapper(point_diameter=25, point_strength=0.5, opacity=0.7)
heatmapImg = heatmapper.heatmap_on_img(pointsList, mapimg)
return heatmapImg
def newHeatmapper(point_diameter=50):
heatmapper_cutout = Heatmapper(
point_diameter=point_diameter, # the size of each po int to be drawn
point_strength=
0.005, # the strength, between 0 and 1, of each point to be drawn
opacity=1, # the opacity of the heatmap layer
colours='reveal', # 'default' or 'reveal'
# OR a matplotlib LinearSegmentedColorMap object
# OR the path to a horizontal scale image
grey_heatmapper='PIL' # The object responsible for drawing the points
# Pillow used by default, 'PySide' option available if installed
)
heatmapper = Heatmapper(
point_diameter=point_diameter, # the size of each point to be drawn
point_strength=
0.02, # the strength, between 0 and 1, of each point to be drawn
opacity=1, # the opacity of the heatmap layer
colours='default', # 'default' or 'reveal'
# OR a matplotlib LinearSegmentedColorMap object
# OR the path to a horizontal scale image
grey_heatmapper='PIL' # The object responsible for drawing the points
# Pillow used by default, 'PySide' option available if installed
)
return heatmapper_cutout, heatmapper
def __init__(self):
self.heatmapper = Heatmapper(
point_diameter=15,
point_strength=0.05,
opacity=3,
colours='reveal',
)
self.heatmap_name = 'heatmap.png'
self.detector = CENSURE()
def cal_heatmap(icam, frame, startFrame, find_ind):
# draw the image for heatmap
heatmap_value = []
path = 'D:/Code/DeepCC/DeepCC/src/visualization/data/background' + str(
icam) + '.jpg'
background_img = Image.open(path)
for i in find_ind:
center_x = int(data_part[i][3] + (data_part[i][5] / 2))
center_y = int(data_part[i][4] + (data_part[i][6] / 2))
heatmap_value.append((center_x, center_y))
heatmapper = Heatmapper()
heatmap = heatmapper.heatmap_on_img(heatmap_value, background_img)
img = cv2.cvtColor(np.asarray(heatmap), cv2.COLOR_RGB2BGR)
return img
def drawing_heatmap(bucket_name, destination_key, key, point_list) :
try:
s3.Object(bucket_name=bucket_name, key=key).load()
is_image_exists(bucket_name, key)
except botocore.exceptions.ClientError:
return None
obj = s3.Object(bucket_name=bucket_name, key=key)
obj_body = obj.get()['Body'].read()
#이미지 등록
img = Image.open(BytesIO(obj_body))
heatmapper = Heatmapper()
heatmap = heatmapper.heatmap_on_img(point_list, img)
buffer = BytesIO()
heatmap.save(buffer, 'PNG')
buffer.seek(0)
obj = s3.Object(bucket_name=bucket_name, key=destination_key)
obj.put(Body=buffer, ContentType='image/png')
return "https://{bucket}.s3.amazonaws.com/{destination_key}".format(bucket=bucket_name, destination_key=destination_key)
def main():
example_base_img = os.path.join('assets', 'cat.jpg')
img_heatmapper = Heatmapper(colours='default', point_strength=0.6)
video_heatmapper = VideoHeatmapper(img_heatmapper)
heatmap_video = video_heatmapper.heatmap_on_image_path(
base_img_path=example_base_img,
points=_example_random_points(),
duration_s=40,
keep_heat=True)
heatmap_video.write_videofile('out_on_image.mp4', bitrate="5000k", fps=24)
def heatmap_calculator(video_class):
print('heatmap one time')
plano_ori_heat = Image.open('images/square_plane.jpg')
heatmapper = Heatmapper(point_diameter=50,
point_strength=0.25,
opacity=0.65,
colours='default',
grey_heatmapper='PIL')
while True:
points = copy.copy(video_class.points)
if len(points) != 0:
heatmap_img = heatmapper.heatmap_on_img(points, plano_ori_heat)
heatmap_img = np.asarray(heatmap_img)
heatmap_img = cv2.cvtColor(heatmap_img, cv2.COLOR_BGR2RGB)
video_class.heatmap_img = heatmap_img
else:
heatmap_img = np.asarray(plano_ori_heat)
heatmap_img = cv2.cvtColor(heatmap_img, cv2.COLOR_BGR2RGB)
video_class.heatmap_img = heatmap_img
if video_class.stopped:
return
def apply_heatmap(self):
'''
Uses the heatmappy library to add points from self.heat_points to the
video in self.video_path. Takes no args and returns nothing, but creates
a video with an overlaid heatmap at self.out_path.
'''
header = ['x', 'y', 'ms', 'x_std', 'y_std', 'ms_std']
self.export_data('distributions.csv', self.distributions, header)
self.export_data('samples.csv', self.heat_points, header[:3])
img_hm = Heatmapper()
video_hm = VideoHeatmapper(img_hm)
video_out = video_hm.heatmap_on_video_path(video_path=self.video_path,
points=self.heat_points)
video_out.write_videofile(self.out_path, bitrate="5000k", fps=24)
plt.imshow(frame_bw, cmap="gray")
plt.show()
process_frame(frame_bw, frame_clr, Pt, area=500)
plt.figure()
plt.title(run_name)
plt.imshow(frame_clr)
plt.show()
#%% Save final view and heatmap
npstack = Pt.get_drawable_tracks_npstack()
df = pd.DataFrame(npstack, columns=['x','y','time','track'])
paths = df[['x','y']]
write_name = run_name + str(frame_idx) + "_"
cv2.imwrite(base_dir + 'outputFiles/' + write_name + 'final_img.png', frame_clr)
ret, frame_clr = Dataset.get_next_frame(frame_idx)
pil_img = Image.fromarray(frame_clr)
heatmapper = Heatmapper()
heatmap = heatmapper.heatmap_on_img(paths.values.tolist(), pil_img)
heatmap.save(base_dir + 'outputFiles/' + write_name + 'heatmap.png')
from heatmappy import Heatmapper
from PIL import Image
example_points = [(100, 20), (120, 25), (200, 50), (60, 300), (170, 250)]
example_img_path = 'default-cat.png'
example_img = Image.open(example_img_path)
heatmapper = Heatmapper()
heatmap = heatmapper.heatmap_on_img(example_points, example_img)
heatmap.save('heatmapbasic.png')
heatmapper = Heatmapper(opacity=0.9, colours='reveal')
heatmap = heatmapper.heatmap_on_img_path(example_points, example_img_path)
heatmap.save('heatmapreveal.png')
(337, 112), (92, 253), (92, 253), (92, 253), (92, 253),
(92, 253), (92, 253), (92, 253), (92, 253), (92, 253),
(92, 253), (459, 191), (459, 191), (459, 162), (92, 270),
(459, 285), (213, 112), (337, 96), (92, 85), (459, 347),
(213, 112), (213, 112), (92, 253), (92, 253), (92, 180),
(92, 180), (92, 180), (92, 118), (337, 67), (337, 67),
(337, 67), (337, 67), (92, 118), (213, 112), (213, 112),
(92, 302), (459, 130), (337, 96), (337, 112), (213, 96),
(459, 118), (459, 118), (459, 118), (459, 146), (459, 118),
(459, 118), (459, 118), (92, 191), (459, 375), (459, 375),
(459, 285), (459, 162), (459, 162), (459, 180), (459, 180),
(337, 112), (92, 302), (92, 302), (92, 302), (92, 302),
(92, 118), (92, 180), (92, 118), (459, 118), (459, 118),
(459, 60), (92, 302), (92, 302), (92, 69), (459, 191),
(459, 207), (459, 253), (459, 253), (92, 118), (92, 69),
(459, 191), (459, 253), (459, 191), (459, 253), (459, 253),
(92, 69), (337, 112), (459, 60), (459, 60), (92, 101),
(92, 101), (92, 101), (92, 101), (92, 101), (92, 101),
(92, 101), (92, 101), (459, 180), (459, 180), (459, 180),
(92, 101), (459, 180), (459, 180), (459, 180), (92, 101),
(459, 180), (459, 180), (459, 180), (92, 101), (459, 130),
(459, 130), (459, 130), (92, 331), (92, 331), (337, 67),
(92, 331), (337, 67), (337, 67), (459, 130), (459, 130),
(459, 330), (92, 163), (92, 163), (459, 330), (459, 146),
(92, 163), (92, 223), (459, 330)]
example_img_path = '/Users/jimhahn/Desktop/input-map-undergrad_2018-03-26_V1.0.png'
example_img = Image.open(example_img_path)
heatmapper = Heatmapper()
heatmap = heatmapper.heatmap_on_img(wayfinder_points, example_img)
heatmap.save('/Users/jimhahn/Desktop/wayfinder-only_2018-03-26_V1.0.png')
def test(self, heatmap=True):
"""
Test the model on the held-out test data.
"""
# load the best checkpoint
self.load_checkpoint(best=True)
self.model.eval()
with torch.no_grad():
losses = []
accuracies = []
confusion_matrix = torch.zeros(self.num_classes, self.num_classes)
heat_points = [[[] for i in range(self.num_glimpses)]
for j in range(self.num_digits + 1)]
heat_mean = torch.zeros(self.num_digits, *self.im_size)
var_means = torch.zeros(self.num_glimpses, len(self.test_loader))
loss_means = torch.zeros(self.num_glimpses, len(self.test_loader))
count_hits = torch.zeros(self.num_glimpses, 2)
var_dist = torch.zeros(len(self.test_loader.dataset),
self.num_glimpses, self.im_size[-1],
self.im_size[-1])
err_dist = torch.zeros(len(self.test_loader.dataset),
self.num_glimpses, self.im_size[-1],
self.im_size[-1])
labels = torch.zeros(len(self.test_loader.dataset))
dist = PairwiseDistance(2)
dists = torch.zeros(len(self.test_loader.dataset),
self.num_glimpses)
run_idx = 0
for i, (_, x, y) in enumerate(self.test_loader):
if self.use_gpu:
x = x.cuda()
y = y.cuda()
true = y.detach().argmax(1)
# initialize location vector and hidden state
self.batch_size = x.shape[0]
s_t, _, l_t = self.reset()
targets = torch.zeros(self.num_glimpses, 3, *x.shape[2:])
glimpses = torch.zeros(self.num_glimpses, 3, *x.shape[2:])
means = torch.zeros(self.num_glimpses, 3, *x.shape[2:])
vars = torch.zeros(self.num_glimpses, 3, *x.shape[2:])
locs = torch.zeros(self.batch_size, self.num_glimpses, 2)
acc_loss = 0
sub_dir = self.plot_dir / f"{i:06d}_dir"
if not sub_dir.exists() and i < 10:
sub_dir.mkdir(parents=True)
for t in range(self.num_glimpses):
# forward pass through model
locs[:, t] = l_t.clone().detach()
s_t, l_pred, r_t, out_t, mu, logvar = self.model(
x,
l_t,
s_t,
samples=self.samples,
classify=self.classify,
)
draw = x[0].expand(3, -1, -1)
extent = self.patch_size
for patch in range(self.num_patches):
draw = draw_glimpse(
draw,
l_t[0],
extent=extent,
)
extent *= self.glimpse_scale
targets[t] = draw
glimpses[t] = self.model.sensor.glimpse[0][0].expand(
3, -1, -1)
means[t] = r_t[0][0].expand(3, -1, -1)
vars[t] = convert_heatmap(
r_t.var(0)[0].squeeze().cpu().numpy())
if t == 0:
var_first = r_t.var(0).squeeze().cpu().numpy()
var_last = r_t.var(0).squeeze().cpu().numpy()
loc_prev = loc = denormalize(x.size(-1), l_t)
l_t = get_loc_target(r_t.var(0),
max=self.use_amax).type(l_t.type())
loc = denormalize(x.size(-1), l_t)
dists[run_idx:run_idx + len(x),
t] = dist.forward(loc_prev.float(),
loc.float()).detach().cpu()
var_dist[run_idx:run_idx + len(x),
t] = r_t.var(0).detach().cpu().squeeze()
temp_loss = torch.zeros(self.batch_size,
*err_dist.shape[2:])
for s in range(self.samples):
temp_loss += F.binary_cross_entropy(
r_t[s], x, reduction='none').detach().cpu(
).squeeze() / self.samples
err_dist[run_idx:run_idx + len(x), t] = temp_loss
for k, l in enumerate(loc):
if x.squeeze()[k][l[0], l[1]] > 0:
count_hits[t, 0] += 1
else:
count_hits[t, 1] += 1
imgs = [targets[t], glimpses[t], means[t], vars[t]]
filename = sub_dir / f"{i:06d}_glimpse{t:01d}.png"
if i < 10:
torchvision.utils.save_image(
imgs,
filename,
nrow=1,
normalize=True,
pad_value=1,
padding=1,
scale_each=True,
)
var = r_t.var(0).reshape(self.batch_size, -1)
var_means[t, i] = var.max(-1)[0].mean(0)
loss_means[t, i] = temp_loss.mean()
for j in range(self.num_digits):
heat_points[j][t].extend(
denormalize(x.size(-1), l_t[true == j]).tolist())
heat_points[-1][t].extend(loc.tolist())
labels[run_idx:run_idx + len(true)] = true
run_idx += len(x)
for s in range(self.samples):
loss = F.mse_loss(r_t[s], x) / self.samples
acc_loss += loss.item() # store
if self.classify:
if self.num_classes == 1:
pred = out_t.detach().squeeze().round()
target = (y.argmax(1) == self.target_class).float()
else:
pred = out_t.detach().argmax(1)
target = true
for p, tr in zip(pred.view(-1), target.view(-1)):
confusion_matrix[tr.long(), p.long()] += 1
accuracies.append(
torch.sum(pred == target).float().item() / len(y))
for j in range(self.num_digits):
if len(x[true == j]):
heat_mean[j] += x[true == j].mean(0).cpu()
losses.append(acc_loss)
imgs = [targets, glimpses, means, vars]
for im in imgs:
im = (im - im.min()) / (im.max() - im.min())
# store images + reconstructions of largest scale
filename = self.plot_dir / f"{i:06d}.png"
if i < 10:
torchvision.utils.save_image(
torch.cat(imgs, 0),
filename,
nrow=6,
normalize=False,
pad_value=1,
padding=3,
scale_each=False,
)
pkl.dump(dists, open(self.file_dir / 'dists.pkl', 'wb'))
pkl.dump(var_dist, open(self.file_dir / 'var_dist.pkl', 'wb'))
pkl.dump(err_dist, open(self.file_dir / 'err_dist.pkl', 'wb'))
pkl.dump(heat_points, open(self.file_dir / 'locs.pkl', 'wb'))
pkl.dump(labels, open(self.file_dir / 'labels.pkl', 'wb'))
pkl.dump(heat_mean, open(self.file_dir / 'mean.pkl', 'wb'))
print(count_hits[:, 0] / count_hits.sum(1))
sn.set(font="serif",
font_scale=2,
context='paper',
style='dark',
rc={"lines.linewidth": 2.5})
errs = err_dist.view(len(self.test_loader.dataset),
self.num_glimpses, -1).cpu().numpy()
vars = var_dist.view(len(self.test_loader.dataset),
self.num_glimpses, -1).cpu().numpy()
f, ax = plt.subplots(2, 1, sharex=True, figsize=(9, 12))
ax[0].plot(range(self.num_glimpses),
errs.mean((0, -1)),
marker='o',
markersize=10,
c=PLOT_COLOR)
ax[0].set_ylabel('Prediction Error')
ax[1].plot(range(self.num_glimpses),
vars.max(-1).mean(0),
marker='o',
markersize=10,
c=PLOT_COLOR)
ax[1].set_xlabel('Saccade number')
ax[1].set_ylabel('Uncertainty')
f.tight_layout()
f.savefig(self.plot_dir / f"comb_var_err.pdf",
bbox_inches='tight',
pad_inches=0,
dpi=600)
print("#######################")
if self.classify:
print(confusion_matrix)
print(confusion_matrix.diag() / confusion_matrix.sum(1))
plot_confusion_matrix(confusion_matrix,
self.plot_dir / f"confusion_matrix.png")
pkl.dump(confusion_matrix,
open(self.file_dir / 'conf_matrix.pkl', 'wb'))
#create heatmaps
flatten = lambda l, i: [
item for sublist in l for item in sublist[i]
]
for i in range(self.num_digits):
img = array2img(heat_mean[i])
points = np.array(heat_points[i])
first = points[:3].reshape(-1, 2)
heatmapper = Heatmapper(
point_diameter=1, # the size of each point to be drawn
point_strength=
0.3, # the strength, between 0 and 1, of each point to be drawn
opacity=0.85,
)
heatmap = heatmapper.heatmap_on_img(first, img)
heatmap.save(self.plot_dir / f"heatmap_bef{i}.png")
last = points[3:-1].reshape(-1, 2)
heatmap = heatmapper.heatmap_on_img(last, img)
heatmap.save(self.plot_dir / f"heatmap_aft{i}.png")
for j in range(self.num_glimpses):
heatmap = heatmapper.heatmap_on_img(heat_points[i][j], img)
heatmap.save(self.plot_dir /
f"heatmap_class{i}_glimpse{j}.png")
self.logger.info(
f"[*] Test loss: {np.mean(losses)}, Test accuracy: {np.mean(accuracies)}"
)
return np.mean(losses)
(83.2964724, 206.3611842), (83.2964724, 206.3611842),
(83.2964724, 206.3611842), (83.2964724, 206.3611842),
(83.2964724, 206.3611842), (83.2964724, 206.3611842),
(83.2964724, 206.3611842), (83.2964724, 206.3611842),
(90.58982342, 208.9370392), (90.58982342, 208.9370392),
(90.58982342, 208.9370392), (90.58982342, 208.9370392),
(90.58982342, 208.9370392), (90.58982342, 208.9370392),
(90.58982342, 208.9370392), (90.58982342, 208.9370392),
(90.58982342, 208.9370392), (90.58982342, 208.9370392),
(90.58982342, 208.9370392), (90.58982342, 208.9370392),
(90.58982342, 208.9370392), (85.85770642, 190.939349),
(85.85770642, 190.939349), (85.85770642, 190.939349),
(85.85770642, 190.939349), (85.85770642, 190.939349),
(85.85770642, 190.939349), (85.85770642, 190.939349),
(85.85770642, 190.939349), (85.85770642, 190.939349),
(85.85770642, 190.939349), (85.85770642, 190.939349),
(85.85770642, 190.939349), (85.85770642, 190.939349),
(128.1527387, 198.9594999), (128.1527387, 198.9594999),
(128.1527387, 198.9594999), (128.1527387, 198.9594999),
(128.1527387, 198.9594999), (128.1527387, 198.9594999),
(128.1527387, 198.9594999), (128.1527387, 198.9594999),
(128.1527387, 198.9594999), (128.1527387, 198.9594999),
(128.1527387, 198.9594999), (128.1527387, 198.9594999),
(128.1527387, 198.9594999)]
rec_img_path = '/Users/jimhahn/Desktop/wayfinder-only_2018-03-26_V1.0.png'
rec_img = Image.open(rec_img_path)
heatmapper = Heatmapper(opacity=0.3, colours='reveal')
#heatmapper = Heatmapper()
heatmap = heatmapper.heatmap_on_img(rec_points, rec_img)
heatmap.save(
'/Users/jimhahn/Desktop/rec-and-wayfinder-heatmap_2018-03-26_V1.0.png')
class LogoFinder:
def __init__(self):
self.heatmapper = Heatmapper(
point_diameter=15,
point_strength=0.05,
opacity=3,
colours='reveal',
)
self.heatmap_name = 'heatmap.png'
self.detector = CENSURE()
@staticmethod
def read_image(image_path):
image = cv2.imread(image_path)
bgr = image
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
return bgr, rgb, gray
def make_heatmap(self, image_path):
bgr_heatmap, rgb_heatmap, gray_heatmap = self.read_image(image_path)
# Find contours and edges
contours = find_contours(gray_heatmap,
100,
fully_connected='high',
positive_orientation='high')
edge_roberts = roberts(gray_heatmap)
edge_sobel = sobel(gray_heatmap)
self.detector.detect(gray_heatmap)
thresh = threshold_otsu(gray_heatmap)
bw = closing(gray_heatmap > thresh, square(3))
cleared = clear_border(bw)
label_image = label(cleared)
image_label_overlay = label2rgb(label_image, image=gray_heatmap)
edges = edge_roberts / 2 + edge_sobel / 2
dots = list()
for x in range(edges.shape[1]):
for y in range(edges.shape[0]):
for i in range(int(edges[y][x] * 2)):
dots.append([x, y])
for n, point in enumerate(self.detector.keypoints):
for i in range(self.detector.scales[n] * 10):
dots.append([
point[1] + (random.random() - 0.5) * 10,
point[0] + (random.random() - 0.5) * 10
])
for n, contour in enumerate(contours):
if len(contour) > 50:
for dot in contour:
dots.append([dot[1], dot[0]])
for region in regionprops(label_image):
# take regions with large enough areas
if region.area >= 100:
# draw rectangle around segmented coins
minr, minc, maxr, maxc = region.bbox
for x in range(minc, maxc):
for y in range(minr, maxr, 8):
dots.append([x, y])
heatmap = self.heatmapper.heatmap_on_img_path(dots, image_path)
heatmap.save(self.heatmap_name)
bgr_heatmap, rgb_heatmap, gray_heatmap = self.read_image(
self.heatmap_name)
thresh = threshold_otsu(gray_heatmap)
bw = closing(gray_heatmap > thresh, square(3))
cleared = clear_border(bw)
label_image = label(cleared)
image_label_overlay = label2rgb(label_image, image=gray_heatmap)
for n, region in enumerate(regionprops(label_image)):
minr, minc, maxr, maxc = region.bbox
if maxr - minr > 30 and maxc - minc > 30:
yield minr, minc, maxr, maxc
# Ensure script is run on python 3.5.2 and above
try:
assert sys.version_info >= (3, 5, 2)
except AssertionError:
print('Please use Python 3.6 : https://www.python.org/downloads/ \n')
raise
# Read original data
filename = askopenfilename()
with open(filename) as temp:
newdata = temp.read()
data = json.loads(newdata)
coord_img_list = []
coord_vid_list = []
for key, value in data.items():
x_coord = float(value.pop('x_coord', None))
y_coord = float(value.pop('y_coord', None))
coord_pair = (x_coord, y_coord)
coord_triple = (x_coord, y_coord,
float(value.pop('timestamp', None)) * 1000)
coord_img_list.append(coord_pair)
example_img_path = 'test.jpg'
example_img = Image.open(example_img_path)
heatmap.save('heatmapnottest.png')
heatmapper = Heatmapper(point_diameter=40, point_strength=0.1)
heatmap = heatmapper.heatmap_on_img(coord_img_list, example_img)
from heatmappy import Heatmapper
from PIL import Image
import cv2
import os
import pandas as pd
coorList = list()
csv = "workdir/mot.mp4.csv" # csv file to use
csvData = pd.read_csv(csv, header=0) # csv import
video = "workdir/mot.mp4" # video file to use
heatmapper = Heatmapper(
point_diameter=35, # the size of each point to be drawn
point_strength=0.2, # the strength, between 0 and 1, of each point to be drawn
opacity=0.65, # the opacity of the heatmap layer
colours='default', # 'default' or 'reveal'
# OR a matplotlib LinearSegmentedColorMap object
# OR the path to a horizontal scale image
grey_heatmapper='PIL' # the object responsible for drawing the points
# pillow used by default, 'PySide' option available if installed
)
assert os.path.isfile(csv), \
'csv {} does not exist'.format(csv)
assert os.path.isfile(video), \
'video {} does not exist'.format(video)
# Capture the first frame of the video
videoFeed = cv2.VideoCapture(video)
assert videoFeed.isOpened(), \
'Cannot capture source'
