def process_frame(frame):
height, width, channels = frame.shape
frame_area = width * height
draw = frame.copy()
frame = preprocess_image(frame)
frame, scale = resize_image(frame)
boxes, scores, labels, = MODEL.predict_on_batch(np.expand_dims(frame, axis=0))
boxes /= scale
box_json_array = []
for box, score, label in zip(boxes[0], scores[0], labels[0]):
b = box.astype(int)
box_area = np.abs(b[2] - b[0]) * np.abs(b[3] - b[1])
if score < CONFIDENCE_THRESHOLD or box_area > (frame_area * BOX_AREA_RATIO_TO_IGNORE) or label > MAX_CLASS_ID:
break
color = label_color(label)
draw_box(draw, b, color=color)
caption = '{} {:.3f}'.format(LABELS_TO_NAMES[label], score)
draw_caption(draw, b, caption)
box_json_array.append({
'label': caption,
'topLeft': [int(b[0]), int(b[1])],
'bottomRight': [int(b[2]), int(b[3])]
})
return draw, box_json_array
def detect(self, image_obj):
"""
通用检测对外接口
:param image_obj: 待检测图像, Pillow Image Object 类型
:return: 检测的 bounding boxes 结果, 维度: [n_boxes, 6], 第二维: [ymin, xmin, ymax, xmax, class, score]
"""
image_arr = cv2.cvtColor(np.array(image_obj), cv2.COLOR_RGB2BGR)
image_arr = preprocess_image(image_arr)
image_arr, scale = resize_image(image_arr)
with self.graph.as_default():
boxes, scores, labels = self.model.predict_on_batch(
np.expand_dims(image_arr, axis=0))
# correct for image scale
boxes /= scale
num = [
scores[0][i] for i in range(len(scores[0]))
if scores[0][i] >= self.score_thresh
]
num = len(num)
results = []
for box, score, label in zip(boxes[0][:num], scores[0][:num],
labels[0][:num]):
'''
# scores are sorted so we can break
if score < self.score_thresh:
break
'''
if self.is_useless(box, boxes[0][:num]):
continue
box = list(map(int, box))
score = round(score, 2)
results.append([
box[1], box[0], box[3], box[2], self.class_list[label], score
])
# results.append([box[1], box[0], box[3], box[2], self.class_list[0], score])
return results
def img_inference(img_path, model):
pred = []
image = read_image_bgr(img_path)
name = img_path.split('/')[-1].split('.')[0]
# copy to draw on
draw = image.copy()
draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
# preprocess image for network
image = preprocess_image(image)
# image, scale = resize_image(image)
# process image
start = time.time()
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(image, axis=0))
print("processing time: ", time.time() - start)
# correct for image scale
# boxes /= scale
# visualize detections
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
if score < 0.4:
break
color = label_color(label)
b = box.astype(int)
pred.append(str(label))
for i in b:
pred.append(str(i))
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(labels_to_names[label], score)
draw_caption(draw, b, caption)
op_name = OUTPUT + name + '_OUTPUT.png'
cv2.imwrite(op_name, draw)
# pci = calculate_pci(boxes[0])
return (op_name, pred)
def preprocess_group(self, image_group, annotations_group):
for index, (image, annotations) in enumerate(zip(image_group, annotations_group)):
# preprocess the image (subtract imagenet mean)
image = preprocess_image(image)
# randomly transform both image and annotations
image, annotations = random_transform(image, annotations, self.image_data_generator)
# resize image
image, image_scale = self.resize_image(image)
# apply resizing to annotations too
annotations[:, :4] *= image_scale
# copy processed data back to group
image_group[index] = image
annotations_group[index] = annotations
return image_group, annotations_group
def pred_img(img_path):
# 加载数据
image = read_image_bgr(img_path)
# 图像copy
draw = image.copy()
# draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
# 输入网络准备
image = preprocess_image(image)
image, scale = resize_image(image)
# 图像 inference
start = time.time()
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(image, axis=0))
print("processing time: ", time.time() - start)
# 映射到原图
boxes /= scale
# 可视化检测结果
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# 是排序额score
if score < 0.5:
break
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(labels_to_names[label], score)
draw_caption(draw, b, caption, color=color)
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(draw, "RetinaNet GPU:NVIDIA Tesla V100 32GB by XJ",
(50, 50), font, 1.2, (0, 255, 0), 3)
cv2.imwrite("./images/test_result.png", draw)
# cv2.imshow('result.jpg',draw)
cv2.waitKey(0)
cv2.destroyAllWindows()
def __next__(self):
if self.current + 1 > self.batches:
raise StopIteration('there is no more batches!')
curr_data_batch = self.data[self.current *
self.batch_size:(self.current + 1) *
self.batch_size]
processed_images = []
scales = []
for image in curr_data_batch:
processed_image = image * 255.
processed_image = preprocess_image(processed_image)
processed_image, scale = resize_image(processed_image,
min_side=512)
processed_images.append(np.expand_dims(processed_image, 0))
scales.append(scale)
processed_images = np.concatenate(processed_images, axis=0)
self.current += 1
return processed_images, scales
def predict_crop(model, crop_bgr, args):
img_ar = preprocess_image(crop_bgr)
img_ar, scale = resize_image(img_ar,
min_side=args.image_min_side,
max_side=args.image_max_side)
img_ar = np.expand_dims(img_ar, axis=0)
boxes, scores, labels = model.predict_on_batch(img_ar)
boxes /= scale
results = []
for box, score, label in zip(boxes[0], scores[0], labels[0]):
if score < args.score_threshold:
break
x1, y1, x2, y2 = box.astype(int)
results.append([x1, y1, x2, y2, label, score])
return results
def inference_img(path, show=False):
# load image
image = read_image_bgr(path)
# copy to draw on
draw = image.copy()
draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
# preprocess image for network
image = preprocess_image(image)
image, scale = resize_image(image)
# process image
start = time.time()
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(image, axis=0))
# correct for image scale
boxes /= scale
if show:
# visualize detections
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
if score < 0.5:
break
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(labels_to_names[label], score)
draw_caption(draw, b, caption)
plt.figure(figsize=(15, 15))
plt.axis('off')
plt.imshow(draw)
plt.show()
#print(scores)
idx = np.argmax(scores[0])
#print(idx)
out_label = labels[0][idx]
if out_label == -1:
out_label = 0
#print(out_label)
return out_label
def detect_one_image(image, model):
draw = image.copy()
# preprocess image for network
image = preprocess_image(image)
image, scale = resize_image(image, 540, 960)
# process image
start = time.time()
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(image, axis=0))
#print("processing time: ", time.time() - start)
# correct for image scale
boxes /= scale
# visualize detections
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
if score < 0.5:
break
(x1, y1, x2, y2) = box
x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)
if blur:
#Extracting the area to blur
region = draw[y1:y2, x1:x2]
#Create a blurred image of the area
# OBS: Region size has to be odd numbers!!!
blurred_region = cv2.blur(region, (21, 21))
#Set the area of interest to the blurred image of that area.
draw[y1:y1 + blurred_region.shape[0],
x1:x1 + blurred_region.shape[1]] = blurred_region
else:
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(labels_to_names[label], score)
draw_caption(draw, b, caption)
return draw
def run_detection_video(video_path):
count = 0
success = True
start = time.time()
while success:
if count % 100 == 0:
print("frame: ", count)
count += 1
# Read next image
success, image = vcapture.read()
if success:
draw = image.copy()
draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
image = preprocess_image(image)
image, scale = resize_image(image)
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(image, axis=0))
boxes /= scale
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
if score < 0.4:
break
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(labels_to_names[label], score)
draw_caption(draw, b, caption)
detected_frame = cv2.cvtColor(draw, cv2.COLOR_RGB2BGR)
vwriter.write(detected_frame) # overwrites video slice
vcapture.release()
vwriter.release() #
end = time.time()
print("Total Time: ", end - start)
def image_pred(model,img_path):
#files = os.walk(img_dir).next()[2]
#for file in files:
#print os.path.join(img_dir, file)
# load image
image = read_image_bgr(os.path.join(img_path))
# preprocess image for network
image = preprocess_image(image)
image, scale = resize_image(image)
# process image
_, _, detections = model.predict_on_batch(np.expand_dims(image, axis=0))
# compute predicted labels and scores
predicted_labels = np.argmax(detections[0, :, 4:], axis=1)
scores = detections[0, np.arange(detections.shape[1]), 4 + predicted_labels]
# correct for image scale
detections[0, :, :4] /= scale
bb_score= np.empty((1,6))
# store detections with confidence > 0.5
flag = 0;
for idx, (label, score) in enumerate(zip(predicted_labels, scores)):
if score < 0.5:
continue
bb = detections[0, idx, :4].astype(int)
bb_temp = np.append(bb,[label,score])
if(flag == 0):
flag =1
bb_score[0,:]=np.expand_dims(bb_temp,axis=0)
#print(np.expand_dims(bb_temp,axis=0).shape)
else:
bb_score = np.append(np.expand_dims(bb_temp,axis = 0),bb_score,axis=0)
print(bb_score.shape)
if(flag == 0):
return []
else:
return bb_score #format :[x1,y1,x2,y2,label,score]
def detect_plate(image_url, is_faulty=False):
if not os.path.exists('outputs'):
os.makedirs('outputs')
img = urllib.request.urlopen(image_url)
img = Image.open(img)
img = img.convert('RGB')
img.save(CONFIG["default_image_download_path"], "JPEG")
image = read_image_bgr(CONFIG["default_image_download_path"])
image = preprocess_image(image)
(image, scale) = resize_image(image)
image = np.expand_dims(image, axis=0)
boxes, scores, labels = faulty_model.predict_on_batch(
image) if is_faulty == True else model.predict_on_batch(image)
boxes /= scale
curr_time = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
save_file_path = f"outputs/pred_{curr_time}.png"
save_prediction(CONFIG["default_image_download_path"], save_file_path,
boxes, scores, labels)
object_detected = []
# Loop over the detections
for (box, score, label) in zip(boxes[0], scores[0], labels[0]):
# Filter out weak detections
if score < CONFIG["confidence"]:
continue
box = box.astype("int")
object_detected.append({
"label": LABELS[label],
"score": str(score),
"coord": {
"y_min": str(box[1]),
"x_min": str(box[0]),
"y_max": str(box[3]),
"x_max": str(box[2])
}
})
return object_detected, save_file_path
def process_detection(self, color_img):
H, W = color_img.shape[:2]
pre_image = preprocess_image(color_img)
res_image, scale = resize_image(pre_image)
batch_image = np.expand_dims(res_image, axis=0)
print batch_image.shape
print batch_image.dtype
boxes, scores, labels = self.detector.predict_on_batch(batch_image)
valid_dets = np.where(scores[0] >= self.det_threshold)
boxes /= scale
scores = scores[0][valid_dets]
boxes = boxes[0][valid_dets]
labels = labels[0][valid_dets]
filtered_boxes = []
filtered_scores = []
filtered_labels = []
for box, score, label in zip(boxes, scores, labels):
box[0] = np.minimum(np.maximum(box[0], 0), W)
box[1] = np.minimum(np.maximum(box[1], 0), H)
box[2] = np.minimum(np.maximum(box[2], 0), W)
box[3] = np.minimum(np.maximum(box[3], 0), H)
bb_xywh = np.array(
[box[0], box[1], box[2] - box[0], box[3] - box[1]])
if bb_xywh[2] < 0 or bb_xywh[3] < 0:
continue
if label in filtered_labels: # only single instance for each class
continue
filtered_boxes.append(bb_xywh)
filtered_scores.append(score)
filtered_labels.append(label)
return (filtered_boxes, filtered_scores, filtered_labels)
def main():
classes = ["hat", "person"]
labels_to_names = {0: "hat", 1: "person"}
#加载模型
model_path = './model/resnet50_csv_03.h5'
model = models.load_model(model_path, backbone_name='resnet50')
img_dir = './images'
for img_path in get_image_list(img_dir):
image = read_image_bgr(img_path)
draw = image.copy()
draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
image = preprocess_image(image)
image, scale = resize_image(image)
# 模型预测
start = time.time()
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(image, axis=0))
print("processing time: ", time.time() - start)
# 矫正比例
boxes /= scale
# 目标检测可视化展示
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# 设置预测得分最低阈值
if score < 0.50:
break
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(labels_to_names[label], score)
draw_caption(draw, b, caption)
#图片展示
plt.figure(figsize=(15, 15))
plt.axis('off')
plt.imshow(draw)
new_img_path = img_path.replace('images', 'images/result')
plt.savefig(new_img_path,
format='png',
transparent=True,
pad_inches=0,
dpi=300,
bbox_inches='tight')
def run_detection_on_image(image_path, min_score=0.5):
image = read_image_bgr(image_path)
# preprocess image for network
image = preprocess_image(image)
image, scale = resize_image(image)
# process image
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(image, axis=0))
# correct for image scale
boxes /= scale
return_boxes = []
return_scores = []
return_image_name = []
# captions = list()
lala = re.sub("[A-Z a-z /.]+", "", image_path).split('_')[-2:]
# visualize detections
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
if score < min_score:
break
b = box.astype(int)
b = list(b)
absolute_boxes = [b[0], b[1], b[2], b[3], label]
return_boxes.append(absolute_boxes)
return_scores.append(score)
return_image_name.append(image_path.split('/')[-1])
# draw_box(draw, b, (0, 255, 0))
# gt = [row['xmin'], row['ymin'], row['xmax'], row['ymax']]
# draw_box(draw, gt, color=(255, 0, 0))
# caption = "{} {:.3f}".format(labels_to_names[label], score)
# captions.append(caption)
# draw_caption(draw, b, caption)
# file, ext = os.path.splitext(image_path)
# image_name = file.split('/')[-1] + ext
# output_path = os.path.join('results/', image_name)
# draw_conv = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
# cv2.imwrite(output_path, draw_conv)
return return_boxes, return_scores, return_image_name
def main(args):
# ==========================================
# Load pretrained model
# ==========================================
model = keras.models.load_model(os.path.expanduser(args.model),
custom_objects=custom_objects)
classes = load_classes(os.path.expanduser(args.classes))
# ==========================================
# Detect bounding boxes
# ==========================================
input_img = cv2.imread(os.path.expanduser(args.input_img))
output_img = input_img.copy()
# preprocess image for network
input_img = preprocess_image(input_img)
input_img, scale = resize_image(input_img)
input_img = np.expand_dims(input_img, axis=0)
# detect bounding boxes
_, _, boxes, nms_classification = model.predict_on_batch(input_img)
num_detected_boxes = len(boxes[0, :, :])
# visualize
for i in range(num_detected_boxes):
class_id = np.argmax(nms_classification[0, i, :])
score = nms_classification[0, i, class_id]
if score < args.score_threshold:
continue
# draw bounding box on a copy of the original input image
color = label_color(class_id)
coord = boxes[0, i, :] / scale
draw_box(output_img, coord, color=color)
# draw caption for the above box
caption = '%s %.3f' % (classes[class_id], score)
draw_caption(output_img, coord, caption=caption)
# save output image
cv2.imwrite(os.path.expanduser(args.output_img), output_img)
def detect(self, img_path, min_prob=0.6):
image = read_image_bgr(img_path)
image = preprocess_image(image)
image, scale = resize_image(image)
boxes, scores, labels = self.detection_model.predict_on_batch(
np.expand_dims(image, axis=0))
boxes /= scale
processed_boxes = []
for box, score, label in zip(boxes[0], scores[0], labels[0]):
if score < min_prob:
continue
box = box.astype(int).tolist()
label = self.classes[label]
processed_boxes.append({
"box": box,
"score": score,
"label": label
})
return processed_boxes
def detect_objects(image):
detected_objects = []
image = preprocess_image(image)
global model
if model is None:
model_path = "/tmp/debris_model_v3_10_6.h5"
model = models.load_model(model_path, backbone_name='resnet50')
boxes, scores, labels = model.predict_on_batch(np.expand_dims(image, axis=0))
detected_label =set()
for box, score, label in zip(boxes[0], scores[0], labels[0]):
#only shows the highest confidence box
if label in detected_label:
continue
detected_label.add(label)
if score < 0.15:
break
color = label_color(label)
b = box.astype(int)
detected_objects.append({'x1':b[0], 'y1':b[1], 'x2': b[2], 'y2':b[3],'label':label, 'label_name': label_lookup[label], 'score':float(score)})
return detected_objects
def run_detection_image(model, labels_to_names, data):
print("start predict {}")
with graph.as_default():
imgdata = base64.b64decode(data)
npImage = np.asarray(Image.open(BytesIO(imgdata)).convert('RGB'))
image = npImage[:, :, ::-1].copy()
# preprocess image for network
image = preprocess_image(image)
image, scale = resize_image(image)
# process image
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(image, axis=0))
# correct for image scale
boxes /= scale
objects = []
reaponse = {'objects': objects}
# visualize detections
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
if score < 0.5:
break
b = np.array(box.astype(int)).astype(int)
# x1 y1 x2 y2
obj = {
'name': labels_to_names[label],
'score': str(score),
'xmin': str(b[0]),
'ymin': str(b[1]),
'xmax': str(b[2]),
'ynax': str(b[3])
}
objects.append(obj)
#caption += "output= {} {} {} {} {} {:.3f}\n".format(b[0], b[1], b[2], b[3], labels_to_names[label], score)
reaponse_json = json.dumps(reaponse)
print("done {}", reaponse_json)
return reaponse_json
def mainDataset(dataset, output, name, weights, fichClass):
# load the class label mappings
LABELS = open(fichClass).read().strip().split("\n")
LABELS = {int(L.split(",")[1]): L.split(",")[0] for L in LABELS}
# load the model from disk and grab all input image paths
model = models.load_model(weights, backbone_name=name)
imagePaths = list(paths.list_images(dataset))
# loop over the input image paths
for (i, imagePath) in enumerate(imagePaths):
# load the input image (in BGR order), clone it, and preprocess it
print("[INFO] predicting on image {} of {}".format(
i + 1, len(imagePaths)))
# load the input image (in BGR order), clone it, and preprocess it
image = read_image_bgr(imagePath)
wI, hI, d = image.shape
output = image.copy()
image = preprocess_image(image)
(image, scale) = resize_image(image)
image = np.expand_dims(image, axis=0)
# detect objects in the input image and correct for the image scale
(boxes, scores, labels) = model.predict_on_batch(image)
boxes /= scale
boxes1 = []
for (box, score, label) in zip(boxes[0], scores[0], labels[0]):
if score < confidence:
continue
boxes1.append(([LABELS[label], box], score))
# parse the filename from the input image path, construct the
# path to the output image, and write the image to disk
filename = imagePath.split(os.path.sep)[-1]
#outputPath = os.path.sep.join([args["output"], filename])
file = open(imagePath[0:imagePath.rfind(".")] + ".xml", "w")
file.write(
generateXML(imagePath[0:imagePath.rfind(".")], imagePath, hI, wI,
d, boxes1))
file.close()
def predict_chunked_image(img_path: str,
model: keras.models.Model,
chunk_sizes: Tuple[int, int] = (500, 500)):
print("Reading Image")
image = read_image_bgr(img_path)
print("Processing Image")
image = preprocess_image(image)
img_gen = chunk_image_generator(image,
chunk_size=chunk_sizes,
displacement=chunk_sizes)
results = []
i = 0
print("Predicting")
for x_start, y_start, chunk in img_gen:
chunk, scale = resize_image(chunk)
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(chunk, axis=0))
boxes /= scale
out_dict = {
'x_start': x_start,
'y_start': y_start,
'scale': scale,
'boxes': boxes,
'scores': scores,
'labels': labels
}
i += 1
print("Done with image {i} at x:{x}, y:{y}".format(i=i,
x=x_start,
y=y_start))
results.append(out_dict)
return (results)
def automate(self):
self.processingLabel.config(text="Processing ")
self.processingLabel.update_idletasks()
open_cv_image = np.array(self.img)
# Convert RGB to BGR
opencvImage= open_cv_image[:, :, ::-1].copy()
# opencvImage = cv2.cvtColor(np.array(self.img), cv2.COLOR_RGB2BGR)
image = preprocess_image(opencvImage)
boxes, scores, labels = model.predict_on_batch(np.expand_dims(image, axis=0))
for idx, (box, label, score) in enumerate(zip(boxes[0], labels[0], scores[0])):
curr_label_list = self.labelListBox.get(0, END)
curr_label_list = list(curr_label_list)
if score < 0.5:
continue
if config.labels_to_names[label] not in curr_label_list:
continue
b = box.astype(int)
self.bboxId = self.canvas.create_rectangle(b[0], b[1],
b[2], b[3],
width=2,
outline=config.COLORS[len(self.bboxList) % len(config.COLORS)])
self.bboxList.append((b[0], b[1], b[2], b[3]))
o1 = self.canvas.create_oval(b[0] - 3, b[1] - 3, b[0] + 3, b[1] + 3, fill="red")
o2 = self.canvas.create_oval(b[2] - 3, b[1] - 3, b[2] + 3, b[1] + 3, fill="red")
o3 = self.canvas.create_oval(b[2] - 3, b[3] - 3, b[2] + 3, b[3] + 3, fill="red")
o4 = self.canvas.create_oval(b[0] - 3, b[3] - 3, b[0] + 3, b[3] + 3, fill="red")
self.bboxPointList.append(o1)
self.bboxPointList.append(o2)
self.bboxPointList.append(o3)
self.bboxPointList.append(o4)
self.bboxIdList.append(self.bboxId)
self.bboxId = None
self.objectLabelList.append(str(config.labels_to_names[label]))
self.objectListBox.insert(END, '(%d, %d) -> (%d, %d)' % (b[0], b[1], b[2], b[3]) + ': ' +
str(config.labels_to_names[label]))
self.objectListBox.itemconfig(len(self.bboxIdList) - 1,
fg=config.COLORS[(len(self.bboxIdList) - 1) % len(config.COLORS)])
self.processingLabel.config(text="Done ")
def run_detection_image(filepath):
image = read_image_bgr(filepath)
# print(image.shape)
# print(image)
# copy to draw on
draw = image.copy()
draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
# preprocess image for network
image = preprocess_image(image)
image, scale = resize_image(image)
# process image
start = time.time()
boxes, scores, labels = model.predict_on_batch(np.expand_dims(image, axis=0))
print("processing time: ", time.time() - start)
# correct for image scale
boxes /= scale
# visualize detections
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
if score < 0.5:
break
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(labels_to_names[label], score)
draw_caption(draw, b, caption)
file, ext = os.path.splitext(filepath)
image_name = file.split('/')[-1] + ext
output_path = '/home/jetsontx2/mahmoud/aerial_pedestrian_detection/output_UC3M/'+ image_name
print(output_path)
draw_conv = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
cv2.imwrite(output_path, draw_conv)
def predict(image_path):
#image = read_image_bgr('/
image = read_image_bgr(image_path)
draw = image.copy()
draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
# preprocess image for network
image = preprocess_image(image)
image, scale = resize_image(image)
# process image
start = time.time()
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(image, axis=0))
#boxes, labels = model.predict_on_batch(np.expand_dims(image, axis=0))
print("processing time: ", time.time() - start)
#print(labels)
# correct for image scale
boxes /= scale
# visualize detections
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
if score < 0.5:
break
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
caption = "{} {:.2f}".format(labels_to_names[label], score)
draw_caption(draw, b, caption)
print(label)
print(score)
plt.figure(figsize=(15, 15))
plt.axis('off')
plt.imshow(draw)
plt.show()
def object_detection():
print("PERFORMING OBJECT DETECTION")
global p0, boxes, scores, labels
p0 = np.array([[[0, 0]]], dtype=np.float32)
keras.backend.tensorflow_backend.set_session(get_session())
model_path = 'saved_good_files/player_detection_inference_model.h5'
model = models.load_model(model_path, backbone_name='resnet50')
# load image
image = read_image_bgr("snap.jpg")
# copy to draw on
draw = image.copy()
draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
# preprocess image for network
image = preprocess_image(image)
image, scale = resize_image(image)
# process image
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(image, axis=0))
# correct for image scale
boxes /= scale
# visualize detections
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
if score < 0.5:
break
color = label_color(label)
b = box.astype(int)
center = [(b[0] + b[2]) / 2, (b[1] + b[3]) / 2]
p1 = np.array([[[center[0], center[1]]]], dtype=np.float32)
p0 = np.concatenate((p0, p1))
draw_box(draw, b, color=color)
"""
def show_image_with_predictionss(filepath, threshold=0.5):
im = np.array(Image.open(filepath))
print("im.shape:", im.shape)
# if there's a PNG it will have alpha channel
im = im[:,:,:3]
### plot predictions ###
# get predictions
imp = preprocess_image(im)
imp, scale = resize_image(im)
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(imp, axis=0)
)
# standardize box coordinates
boxes /= scale
# loop through each prediction for the input image
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can quit as soon
# as we see a score below threshold
if score < threshold:
break
box = box.astype(np.int32)
color = label_color(label)
draw_box(im, box, color=color)
class_name = label_map[label]
caption = f"{class_name} {score:.2f}"
draw_caption(im, box, caption)
plt.axis('off')
plt.imshow(im)
plt.show()
def run_detection(model, filepath, labels_file="data/labels.csv"):
labels = [i.split(",") for i in open(labels_file).read().split("\n")]
labels_to_names = dict([(int(str_id), name) for name, str_id in labels])
image = read_image_bgr(filepath)
# copy to draw on
draw = image.copy()
draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
# preprocess image for network
image = preprocess_image(image)
image, scale = resize_image(image)
# process image
start = time.time()
boxes, scores, labels = model.predict_on_batch(np.expand_dims(image, axis=0))
print("processing time: ", time.time() - start)
# correct for image scale
boxes /= scale
# visualize detections
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
print(box, score, label)
if (label == 0 and score < .3) or score < .5:
break
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(labels_to_names[label], score)
draw_caption(draw, b, caption)
plt.figure(figsize=(15, 15))
plt.axis('off')
plt.imshow(draw)
plt.savefig("ouptut_run_detection.png")
def load_model(load=False):
if load:
try:
print('loading the model...............')
model = keras_retinanet.models.load_model(MODEL_PATH,
backbone_name='resnet50',
convert=True)
image_path = '/home/syh/commdity_recognition/development/server/static/download/train_20180307_1725.jpg'
image = read_image_bgr(image_path)
image = preprocess_image(image)
image, scale = resize_image(image)
model.predict_on_batch(np.expand_dims(image, axis=0))
print('finished load the model...............')
# print(model.summary())
except ImportError as ex:
print("Can't load the model: %s" % ex)
else:
return None
return model
def detect(self, cv2_image):
"""Run predict on the image after preprocessing."""
# Convert image for network
# img_inf = cv2.cvtColor(cv2_image, cv2.COLOR_BGR2RGB)
img_inf = preprocess_image(cv2_image)
img_inf, scale = resize_image(img_inf)
# Run inference
boxes, scores, labels = self.model.predict_on_batch(
np.expand_dims(img_inf, axis=0))
# Convert bbox into image position
boxes /= scale
# Clean prediction output
bbox, scores, classes_pred = self.filter_prediction(
boxes[0], scores[0], labels[0])
# Convert to Signate frame output here:
signate_detection = self.convert_to_signate(bbox, scores, classes_pred)
return ([bbox, scores, classes_pred, signate_detection])
def predict_on_image(model, labels_to_names, image, thresh):
# copy to draw on
draw = image.copy()
# draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB, dst=draw)
# preprocess image for network
image = preprocess_image(image)
# image, scale = resize_image(image)
image, scale = image, 1
# process image
start = time.time()
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(image, axis=0))
print("processing time: ", time.time() - start)
# correct for image scale
boxes /= scale
# visualize detections
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
if score < thresh:
break
# color = label_color(label)
if score < 0.99:
color = (0, 0, 255)
elif label == 1:
color = (0, 255, 0)
else:
color = (0, 255, 255)
b = np.round(box, 0).astype(int)
draw_box(draw, b, color=color, thickness=1)
# caption = f"{labels_to_names[label]} {score:.2f}"
# draw_caption(draw, b, caption)
# return cv2.cvtColor(draw, cv2.COLOR_RGB2BGR, dst=draw)
return draw
def save_img(filename, dest, com):
# load image
image = read_image_bgr(filename)
# copy to draw on
draw = image.copy()
draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
# preprocess image for network
image = preprocess_image(image)
image, scale = resize_image(image)
# process image
start = time.time()
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(image, axis=0))
print("processing time: ", time.time() - start)
# correct for image scale
boxes /= scale
# visualize detections
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
if score < tresh:
break
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(id_to_class[label], score)
draw_caption(draw, b, caption)
plt.figure(figsize=(30, 30))
plt.axis('off')
plt.imshow(draw)
title, ext = os.path.splitext(os.path.basename(filename))
plt.savefig(dest + title + com + ext)
