def predict_data_set(model, save_path, data, label_dict, conf_thresh):
"""
Loop through (test) dataset, make bounding box predictions on each image, and save the updated images
"""
for i in tqdm(range(data.shape[0])):
# Original (O.G.) image
og_img = np.expand_dims(data[i, :, :, CONTEXT_FRAMES], axis=2)
og_img = np.tile(og_img, (1, 1, 3))
# Make prediction
inputs = tf.expand_dims(data[i, :, :, :], axis=0)
prediction = model.predict(inputs, steps=1)
boxes = convert_matrix_to_dict(prediction, conf_thresh)
# Plot predicted boxes
pred_img = draw_boxes(og_img * 255, boxes[0])
pred_img = np.squeeze(pred_img)
# Plot true boxes
# Replace class values which can be 0, 1, or 2 for true labels with 1 indicating 100% confidence
og_labels = [(np.array(boxes[:-1]) / DOWNSCALE_FACTOR).tolist() + [1]
for boxes in label_dict[i]]
true_img = draw_boxes(og_img * 255, og_labels)
true_img = np.squeeze(true_img)
# Plot and save both predicted and true images side by side
compare_img = np.vstack((pred_img, true_img))
compare_img = compare_img.astype('uint8')
save_img = Image.fromarray(compare_img, 'RGB')
save_img.save(save_path + str(i) + '.png', 'PNG')
def bbox_detector_single_frame(detector, frame):
img = Image.fromarray(frame)
pil_image = ImageOps.fit(img, (256, 256), Image.ANTIALIAS)
pil_image_rgb = pil_image.convert("RGB")
converted_img = tf.image.convert_image_dtype(
np.array(img), dtype=tf.float32)[tf.newaxis, ...]
print('converted_img - type: {} shape: {}'.format(type(converted_img), converted_img.shape))
result = detector(converted_img)
result = {key: value.numpy() for key, value in result.items()}
print("Found %d objects." % len(result["detection_scores"]))
detection_class_entities = result["detection_class_entities"]
detection_scores = result['detection_scores']
detection_boxes = result['detection_boxes']
person_detection_scores = []
person_class_entities = []
person_bounding_boxes = []
for i, entity in enumerate(detection_class_entities):
if detection_class_entities[i] == b'Person':
person_class_entities.append(detection_class_entities[i])
person_bounding_boxes.append(detection_boxes[i])
person_detection_scores.append(detection_scores[i])
image_with_boxes = draw_boxes(
np.array(img),
np.array(person_bounding_boxes),
np.array(person_class_entities),
np.array(person_detection_scores))
display_image(image_with_boxes)
return result
def gen_image(I):
global recorrelate, corr, heatmaps, map_out
if recorrelate:
heatmaps = np.zeros((len(filters_ind), I.shape[0], I.shape[1]), dtype=np.float32)
for j, i in enumerate(filters_ind):
heatmaps[j] = correlate(I, filters[i], step=2)
recorrelate = False
corr = np.max(heatmaps, axis=0)
map_out = CMAP(corr)[:,:,:3] * 255
print(np.max(corr))
boxes = []
output = np.zeros(I.shape[:2], dtype=np.float32)
for j, i in enumerate(filters_ind):
mask = (heatmaps[j] > heat_thresh[i]) * corr
output = np.maximum(output, mask)
mask_boxes = get_boxes(mask)
boxes += min_box_size(mask_boxes,
filters[i].shape[0], filters[i].shape[1],
I.shape[0], I.shape[1])
I = draw_boxes(I, boxes)
left = np.concatenate((I, gray2rgb(output > 0) * I), 0)
right = np.concatenate((gray2rgb(corr * 255).astype(np.uint8),
map_out.astype(np.uint8)), 0)
height_diff = right.shape[0] - compound_filter.shape[0]
filter_image = np.pad(compound_filter, [(0,height_diff), (0,0), (0,0)], mode='constant')
return np.concatenate((left, right, filter_image), 1)
def __call__(self, img, show_plots=False):
hits = self.get_hits(img)
heat = make_heatmap(img.shape[0:2], hits)
if self._last_heatmap is None:
self._last_heatmap = heat
filtered_heat = (1 -
self._alpha) * self._last_heatmap + self._alpha * heat
self._last_heatmap = filtered_heat
binary = filtered_heat >= self._threshold
labels = label_image(binary)
boxes = []
for i in range(labels[1]):
y_points, x_points = np.where(labels[0] == i + 1)
box = ((np.min(x_points), np.min(y_points)), (np.max(x_points),
np.max(y_points)))
width = box[1][0] - box[0][0]
height = box[1][1] - box[0][1]
if width >= 32 and height >= 32:
boxes.append(box)
if show_plots:
f, ((a0, a1), (a2, a3)) = plt.subplots(2, 2)
a0.set_title('Raw Hits')
a0.imshow(draw_boxes(rgb(img, self._cspace), hits))
a1.set_title('Heatmap')
a1.imshow(heat.astype(np.float32) / np.max(heat), cmap='gray')
a2.set_title('Thresholded Heatmap')
a2.imshow(binary, cmap='gray')
a3.set_title('Label Image')
a3.imshow(labels[0], cmap='gray')
return boxes
def show_results(result, labels, scores=None, show_size=False):
from util import draw_boxes, get_image_from_s3
mid2label = joblib.load(os.path.join('data', 'mid2label.joblib'))
for k in range(len(result)):
print(result[k][0])
print(
sorted([(mid2label[labels[matched_index]], mid2label[label], score)
for score, matched_index, label in zip(
result[k][8], result[k][1], result[k][4])],
key=lambda x: -x[2]))
print([mid2label[label] for label in result[k][5]])
print(result[k][9])
image = get_image_from_s3(result[k][0])
draw_boxes(image,
result[k][2],
result[k][4],
scores=scores,
uid=result[k][3],
show=True,
show_size=show_size)
def predict_data_point(model, data, label_dict, index, conf_thresh):
"""
Predict bounding boxes around hair follicles for a single data point at index
"""
og_img = np.expand_dims(data[index, :, :, CONTEXT_FRAMES], axis=2)
og_img = np.tile(og_img, (1, 1, 3))
# Add batch dimension
inputs = tf.expand_dims(data[index, :, :, :], axis=0)
# Feed the input to the model
prediction = model.predict(inputs, steps=1)
# Transform network output ONLY for YOLO loss!!!
# prediction = sigmoid(prediction)
# Convert predictions from matrix form to dictionary
boxes = convert_matrix_to_dict(prediction, conf_thresh)
print('Predicted boxes: ', boxes)
# fig, axes = plt.subplots(nrows=2, ncols=1)
# Plot predicted boxes
pred_img = draw_boxes(og_img, boxes[0])
pred_img = np.squeeze(pred_img)
# axes[0].imshow(pred_img)
# Plot true bounding boxes
# Replace class values which can be 0, 1, or 2 for true labels with 1 indicating 100% confidence
og_labels = [(np.array(boxes[:-1]) / DOWNSCALE_FACTOR).tolist() + [1]
for boxes in label_dict[index]]
true_img = draw_boxes(og_img, og_labels)
true_img = np.squeeze(true_img)
# axes[1].imshow(true_img)
# Plot predicted and true boxes on same plot for side by side comparison
compare_img = np.vstack((pred_img, true_img))
plt.imshow(compare_img)
plt.show()
def verify_data_generator(generator):
"""
Verifies that the data is correctly generated and augmented
"""
for i, (data_batch, label_batch) in enumerate(generator):
print('BATCH {}'.format(i))
print('DATA BATCH: ', data_batch.shape)
print('LABELS BATCH: ', label_batch.shape)
for j in range(BATCH_SIZE):
print('IMG {}'.format(j))
img = data_batch[j, :, :, CONTEXT_FRAMES]
img = img[:, :, np.newaxis]
img = np.tile(img, (1, 1, 3))
boxes = convert_matrix_to_dict(label_batch,
conf_thresh=CONFIDENCE_THRESHOLD)
box_img = draw_boxes(img, boxes[j])
box_img = np.squeeze(box_img)
plt.imshow(box_img)
plt.show()
box_coords = np.zeros_like(boxes)
box_coords[:, 0] = boxes[:, 0] * height
box_coords[:, 1] = boxes[:, 1] * width
box_coords[:, 2] = boxes[:, 2] * height
box_coords[:, 3] = boxes[:, 3] * width
return box_coords
def predict(self, image, confidence_cutoff=0.4):
image_np = np.expand_dims(np.asarray(image, dtype=np.uint8), 0)
result = self.predictor_fn({'inputs': image_np})
boxes = np.squeeze(result["detection_boxes"])
scores = np.squeeze(result["detection_scores"])
classes = np.squeeze(result["detection_classes"])
boxes, scores, classes = self.filter_boxes(confidence_cutoff, boxes,
scores, classes)
width, height = image.size
box_coords = self.to_image_coords(boxes, height, width)
return box_coords, classes
if __name__ == "__main__":
tld = traffic_light_detector()
image = Image.open('test_images/sample1.jpg')
box_coords, classes = tld.predict(image)
util.draw_boxes(image, box_coords, thickness=2)
plt.imshow(np.asarray(image, dtype=np.uint8))
plt.title(classes)
plt.show()
# Load input images
data_path = 'data/RedLights2011_Medium'
# Load predictions
preds_path = 'data/hw02_preds'
preds_file = 'preds_test.json' # TODO: Change this as needed
data = None
with open(os.path.join(preds_path, preds_file), 'r') as f:
data = json.load(f)
assert data is not None
# Draw and save bounding boxes for each file
i = 0
n = len(data)
printProgressBar(0, n, prefix='Progress:', suffix='Complete', length=50)
for file_name, boxes in data.items():
# Read image using PIL
I = np.asarray(Image.open(os.path.join(data_path, file_name)))
result = draw_boxes(I, boxes)
# Save new image
Image.fromarray(result).save(os.path.join(out_path, file_name))
printProgressBar(i,
n,
prefix='Progress:',
suffix='Complete',
length=50)
i += 1
os.path.join('..', 'open_images_', 'validation-images-with-rotation.csv'))
meta.set_index('ImageID', inplace=True)
print('data loaded')
for index, row in meta.iterrows():
if index not in id2url:
continue
#if not np.isnan(row.Rotation):
if row.Rotation != 270:
continue
'''
image_url = id2url[index]
try:
image = get_image(image_url, rotate=id2rot[index])
except:
print('error downloading: ' + image_url)
continue
'''
image = get_image_from_s3(index)
result = get_image_boxes(objects, index)
print(row.Rotation)
print(result)
image_with_boxes = draw_boxes(image, result["detection_boxes"],
result["detection_class_names"])
display_image(image_with_boxes)
zip(result["detection_scores"], result["detection_boxes"],
result["detection_class_names"]),
reverse=True)
if x[0] > suppression_threshold and box_area(x[1]) >= min_area
][:suppression_topk]))
if len(results) == 0:
shutil.rmtree(folder)
print('No detected objects found above thresholds - skipping')
continue
result["detection_scores"], result["detection_boxes"], result[
"detection_class_names"] = results
image_with_boxes = draw_boxes(image,
result["detection_boxes"],
result["detection_class_names"],
scores=result["detection_scores"],
style='new',
save_path=os.path.join(
folder, 'input_overlay.jpg'),
show=show_overlay,
show_size=show_size)
if get_twitter:
timestamp = timestamps[cnt]
else:
timestamp = datetime.utcnow().isoformat(' ')
height, width = image.shape[:2]
input_list = [{
'bbox': [
int(box[1] * width),
int(box[0] * height),
int(box[3] * width),
int(box[2] * height)
