async def detect_image(image_path):
# load image
image = read_image_bgr(image_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))
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)
marked_image = cv2.cvtColor(draw, cv2.COLOR_RGB2BGR)
marked_image_path = os.path.join(
os.path.split(image_path)[0], 'marked-' + os.path.split(image_path)[1])
marked_image_name = os.path.split(marked_image_path)[1]
cv2.imwrite(marked_image_path, marked_image)
return marked_image_name
def label(model, image_path, save_path, csv_path, label_name=True):
# copy to draw on
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))
# correct for image scale
boxes /= scale
# visualize detections
with open(csv_path, 'w') as csv_file:
csv_file.write('x1,y1,x2,y2')
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)
csv_file.write('{},{},{},{}'.format(*b))
draw_box(draw, b, color=color)
caption = "{:.3f}".format(score)
draw_caption(draw, b, caption)
cv.imwrite(save_path, cv.cvtColor(draw, cv.COLOR_RGB2BGR))
def visualize_detections(draw, boxes, scores, labels):
# load label to names mapping for visualization purposes
labels_to_names = {
0: 'arrabida',
1: 'camara',
2: 'clerigos',
3: 'musica',
4: 'serralves'
}
# visualize detections
for box, score, label in zip(boxes[0], scores[0], labels[0]):
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()
def run(generator, args):
# display images, one at a time
for i in range(generator.size()):
# load the data
image = generator.load_image(i)
annotations, masks = generator.load_annotations(i)
# apply random transformations
if args.random_transform:
image, annotations, masks = generator.random_transform_group_entry(
image, annotations, masks)
# resize the image and annotations
if args.resize:
image, image_scale = generator.resize_image(image)
annotations[:, :4] *= image_scale
for m in range(len(masks)):
masks[m], _ = generator.resize_image(masks[m])
# draw anchors on the image
if args.anchors:
anchors = generator.generate_anchors(image.shape)
labels, _, _ = generator.compute_anchor_targets(
anchors, [image], [annotations], generator.num_classes())
draw_boxes(image,
anchors[np.max(labels[0], axis=1) == 1], (255, 255, 0),
thickness=1)
# draw annotations on the image
if args.annotations:
# draw annotations in red
draw_annotations(image,
annotations,
color=(0, 0, 255),
label_to_name=generator.label_to_name)
# draw regressed anchors in green to override most red annotations
# result is that annotations without anchors are red, with anchors are green
anchors = generator.generate_anchors(image.shape)
labels, _, boxes = generator.compute_anchor_targets(
anchors, [image], [annotations], generator.num_classes())
draw_boxes(image, boxes[0, np.max(labels[0], axis=1) == 1],
(0, 255, 0))
# Draw masks over the image with random colours
if args.masks:
for m in range(len(masks)):
# crop the mask with the related bbox size, and then draw them
box = annotations[m, :4].astype(int)
mask = masks[m][box[1]:box[3], box[0]:box[2]]
draw_mask(image, box, mask, annotations[m, 4].astype(int))
# add the label caption
caption = '{}'.format(
generator.label_to_name(annotations[m, 4]))
draw_caption(image, box, caption)
cv2.imshow('Image', image)
if cv2.waitKey() == ord('q'):
return False
return True
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 show_image_with_boxes(df):
# pick a random image
filepath = df.sample()['image_name'].values[0]
# get all rows for this image
df2 = df[df['image_name'] == filepath]
im = np.array(Image.open(filepath))
# if there's a PNG it will have alpha channel
im = im[:,:,:3]
for idx, row in df2.iterrows():
d_class = row["class_name"]
box = [
row['x_min'],
row['y_min'],
row['x_max'],
row['y_max'],
]
print(box)
draw_box(im, box, color=(255, 0, 0))
caption = "{}".format(d_class)
draw_caption(im, box, caption)
plt.axis('off')
plt.imshow(im)
plt.show()
def pred_video(video_path):
cap = cv2.VideoCapture(video_path)
width = cap.get(3)
height = cap.get(4)
fps = cap.get(5)
print((width, height))
fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', 'v')
writer = cv2.VideoWriter()
writer.open('./images/output.mp4', fourcc, int(fps),
(int(width), int(height)))
while (cap.isOpened()):
# Capture frame-by-frame
ret, frame = cap.read()
if ret == True:
# 图像copy
draw = frame.copy()
# draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
# 输入网络准备
image = preprocess_image(frame)
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,
"Model:RetinaNet GPU:NVIDIA Tesla V100 32GB by XJ",
(40, 50), font, 0.6, (0, 0, 255), 2)
cv2.imshow('result.jpg', draw)
writer.write(draw)
# Press Q on keyboard to exit
if cv2.waitKey(25) & 0xFF == ord('q'):
break
writer.release()
cv2.destroyAllWindows()
def read_images(images_dir,model,lbls,output):
images = os.listdir(images_dir)
for im in images:
base = im
im = os.path.join(images_dir,im)
image, draw, scale =operate_image(im)
# process image
start = time.time()
boxes, scores, labels = model.predict_on_batch(np.expand_dims(image, axis=0))
# correct for image scale
boxes /= scale
print("processing time: ", time.time() - start)
# 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
label = label -1
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(lbls[label], score)
draw_caption(draw, b, caption)
out = os.path.join(output,base)
write_image(out,draw)
def main(args=None):
args = parse_args(args)
load_model(args)
cap = cv2.VideoCapture(args.capture)
while (cap.isOpened()):
ret, frame = cap.read()
draw = frame.copy()
draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
boxes, scores, labels = run_detection_image(model, frame)
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)
# Display the resulting frame
resized_image = cv2.resize(frame, (1280, 820))
cv2.imshow('Video', resized_image)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
def run():
args = parse_args()
print(args)
if not test_args(args):
return
keras.backend.tensorflow_backend.set_session(get_session())
label_map = get_labels(args.label)
model = models.load_model(args.model, backbone_name=args.backbone)
for img_file in args.image:
img = read_image_bgr(img_file)
canvas = cv2.cvtColor(img.copy(), cv2.COLOR_BGR2RGB)
img, scale = resize_image(preprocess_image(img))
start = time.time()
boxes, scores, labels = model.predict_on_batch(
np.expand_dims(img, axis=0))
print("Processing time: ", time.time() - start)
boxes /= scale
for box, score, label in zip(boxes[0], scores[0], labels[0]):
if score < args.threshold: # Labels are sorted
break
color = label_color(label)
b = box.astype(int)
draw_box(canvas, b, color=color)
caption = "{} {:.3f}".format(label_map[label], score)
draw_caption(canvas, b, caption)
canvas = cv2.cvtColor(canvas, cv2.COLOR_RGB2BGR)
out_file = args.out_prefix + os.path.split(img_file)[1]
out_full = os.path.join(args.out_dir, out_file)
cv2.imwrite(out_full, canvas)
print("Done with writing to file {:s}.".format(out_full))
def detect(image):
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.5:
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)
plt.figure(figsize=(15, 15))
plt.axis('off')
plt.imshow(draw)
plt.show()
def predict(model, class_names, image_file, predict_file):
image = read_image_bgr(image_file)
draw = image.copy()
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("File {} Processing Time {:.3f}".format(image_file,
time.time() - start))
boxes /= scale
for box, score, label in zip(boxes[0], scores[0], labels[0]):
if score < 0.5:
break
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(class_names[label], score)
draw_caption(draw, b, caption)
cv2.imwrite(predict_file, draw)
def TestSinglePic(model, image, savepath, imgname):
# copy to draw on
draw = image.copy()
draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
image = preprocess_image(image)
image, scale = resize_image(image)
boxes, scores, labels = model.predict(np.expand_dims(image, axis=0))
boxes /= scale
# visualize detections
flag = False
boxes, scores, labels = boxes_filter(boxes[0], scores[0], labels[0])
# boxes, scores, labels = boxes[0], scores[0], labels[0]
for box, score, label in zip(boxes, scores, labels):
# scores are sorted so we can break
if flag and score < 0.3:
continue
flag = True
label = label.astype(int)
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(label + 1, score)
draw_caption(draw, b, caption)
plt.figure(figsize=(15, 15))
plt.axis('off')
plt.imshow(draw)
plt.savefig(os.path.join(savepath, imgname), bbox_inches='tight')
plt.clf()
def show_image_debug(draw, boxes, scores, labels, masks, classes):
from keras_retinanet.utils.visualization import draw_box, draw_caption
from keras_maskrcnn.utils.visualization import draw_mask
from keras_retinanet.utils.colors import label_color
# visualize detections
limit_conf = 0.2
for box, score, label, mask in zip(boxes, scores, labels, masks):
# scores are sorted so we can break
if score < limit_conf:
break
color = label_color(label)
color_mask = (255, 0, 0)
b = box.astype(int)
draw_box(draw, b, color=color)
mask = mask[:, :]
draw_mask(draw, b, mask, color=color_mask)
caption = "{} {:.3f}".format(classes[label], score)
print(caption)
draw_caption(draw, b, caption)
draw = cv2.cvtColor(draw, cv2.COLOR_RGB2BGR)
show_image(draw)
def detect(graph, model, image_paths):
label_to_name = {0: 'open', 1: 'closed'}
saved = []
for path in image_paths:
img = read_image_bgr(path)
draw = img.copy()
draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
img = preprocess_image(img)
img, scale = resize_image(img)
with graph.as_default():
bs, ss, ls = model.predict_on_batch(np.expand_dims(img, axis=0))
bs /= scale
for b, s, l in zip(bs[0], ss[0], ls[0]):
if s < 0.5:
break
color = label_color(l + 5)
b = b.astype(int)
# pred = gen_prediction(l, _b, s)
# result.append(pred)
caption = '{} {:.3f}'.format(label_to_name[l], s)
draw_box(draw, b, color)
draw_caption(draw, b, caption)
dest = get_dest_with_fname(path)
# thr = Thread(target=save_det, args=(draw, dest))
# thr.start()
cv2.imwrite(dest, cv2.cvtColor(draw, cv2.COLOR_BGR2RGB))
saved.append(os.path.basename(dest))
return saved
def process(self, image):
draw = image.copy()
h, w, _ = draw.shape
# draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
image = preprocess_image(image)
image, scale = resize_image(image)
start = time.time()
boxes, scores, labels = self.model.predict_on_batch(
np.expand_dims(image, axis=0))
print("processing time: ", time.time() - start)
boxes /= scale
# visualize detections
centers = []
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break
if score < 0.5 or self.labels_to_names[label] not in ['person']:
break
x1, y1, x2, y2 = int(box[0]), int(box[1]), int(box[2]), int(box[3])
w, h = (x2 - x1), (y2 - y1)
centers.append([x1, y1, w, h])
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(self.labels_to_names[label], score)
draw_caption(draw, b, caption)
return draw, centers
def plot_pred(boxes, scores, labels, draw):
labels_to_names = {
0: 'car',
1: 'articulated_truck',
2: 'bus',
3: 'bicycle',
4: 'motorcycle',
5: 'motorized_vehicle',
6: 'pedestrian',
7: 'single_unit_truck',
8: 'work_van',
9: 'pickup_truck',
10: 'non-motorized_vehicle'
}
# 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.suptitle("Retina")
plt.imshow(draw)
def make_prediction(image):
#set id for labeling
ID = {0:'gate', 1:'flare'}
print('init fn')
draw = image.copy()
#preprocess image for model
image = preprocess_image(image)
(image, scale) = resize_image(image)
image = np.expand_dims(image, axis=0)
#make prediction
(boxes, scores, labels) = model.predict_on_batch(image)
#filtering and drawing boxes
box_out = []
label_out = []
for (box, score, label) in zip(boxes[0], scores[0], labels[0]):
#threshold score can be optimize for optimum range of results
if score < 0.3:
continue
box /= scale
box = box.astype("int")
box_out.append(box)
label_out.append(ID[label])
draw_box(draw, box, color=(0,0,255))
caption = "{} {:.3f}".format(ID[label], score) #output label
draw_caption(draw, box, caption)
return label_out, box_out, draw
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 plot(file_path):
image = read_image_bgr(file_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, 960, 1280)
label, score, box = res(file_path)
label, score, box = after_processing(label, score, box)
for box, score, label in zip(box, score, label):
color = label_color(label)
b = box
draw_box(draw, b, color=color)
caption = "{} {:.3f}".format(labels_to_names[label], score)
print(labels_to_names[label], score)
draw_caption(draw, b, caption)
plt.figure(figsize=(20, 20))
plt.axis('off')
plt.imshow(draw)
plt.show()
def predict(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
print("Item ", labels_to_names[label], score)
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)
cv2.imshow('Prediction', draw)
def draw_detections(image, boxes, scores, labels):
for index, value in enumerate(scores):
color = label_color(labels[index])
b = boxes[index].astype(int)
draw_box(image, b, color=color)
caption = "{} {:.3f}".format('License Plate', value)
draw_caption(image, b, caption)
def annotate_image(self,
path_to_image,
num_gpus=1,
min_image_dimension=800,
max_image_dimension=1024,
steps_per_epoch=100,
validation_steps=70):
labels_to_names = self._load_labels()
model = models.load_model(self._path_to_model,
backbone_name='resnet50')
# load image
image = read_image_bgr(path_to_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()
outputs = model.predict_on_batch(np.expand_dims(image, axis=0))
print("processing time: ", time.time() - start)
boxes = outputs[-4][0]
scores = outputs[-3][0]
labels = outputs[-2][0]
masks = outputs[-1][0]
# correct for image scale
boxes /= scale
# visualize detections
for box, score, label, mask in zip(boxes, scores, labels, masks):
if score < 0.5:
break
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
mask = mask[:, :, label]
draw_mask(draw, b, mask, color=label_color(label))
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()
"""config = ImageMonkeyConfig(len(labels), num_gpus, min_image_dimension, max_image_dimension, steps_per_epoch, validation_steps)
def draw_detections(image, boxes, scores, labels):
for box, score, label in zip(boxes[0], scores[0], labels[0]):
if score < THRES_SCORE:
break
color = label_color(label)
b = box.astype(int)
draw_box(image, b, color=color)
caption = "{} {:.3f}".format(labels_to_names[label], score)
draw_caption(image, b, caption)
def show_image_with_predictions(df, threshold=0.6):
# choose a random image
row = df.sample()
filepath = row['image_name'].values[0]
print("filepath:", filepath)
# get all rows for this image
df2 = df[df['image_name'] == filepath]
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 true boxes
for idx, row in df2.iterrows():
box = [
row['x_min'],
row['y_min'],
row['x_max'],
row['y_max'],
]
print(box)
draw_box(im, box, color=(255, 0, 0))
### 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:.3f}"
draw_caption(im, box, caption)
plt.axis('off')
plt.imshow(im)
plt.show()
def predict_one_image(model, img_path):
"""predict the image with the model
Args:
model: A keras.models.Model object.
img_path: the path of image
Returns:
draw: numpy.ndarray.including the box info
boxes: List, the value is a list,length is 6. 6 represent x, y, w, h, label, score
"""
starttime = time()
image = read_image_bgr(img_path)
labels_to_names, cls_index = get_labels(
metadata_dir="/home/sk49/workspace/dataset/open_images_dataset_v4/challenge2018", version="challenge2018")
print(labels_to_names)
# copy to draw on
draw = image.copy()
draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
cv2.imwrite("a.jpg", draw)
# preprocess image for network
image = preprocess_image(image)
image, scale = resize_image(image)
# process image
start = time()
boxes, scores, labels = model.predict_on_batch(np.expand_dims(image, axis=0))
print("predicting time: ", time() - start)
# correct for image scale
boxes /= scale
# visualize detections
boxes = []
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)
print(type(b), b)
cv2.imwrite("jj.jpg", draw)
draw_box(draw, b, color=color)
print("2", type(draw))
caption = "{} {:.3f}".format(labels_to_names[label], score)
draw_caption(draw, b, caption)
print("3", type(draw))
draw = cv2.cvtColor(draw, cv2.COLOR_RGB2BGR)
cv2.imwrite("jj1.jpg", draw)
print("total", (time() - starttime), "s")
return draw
def retinamask(self):
backbone = models.backbone('resnet50')
batch_size = 1
train_generator, validation_generator = Retinamask.create_generators(
batch_size, self.annotations, self.classes)
freeze_backbone = 'store_true'
weights = self.Input_weights_path
print('Creating model, this may take a second...')
model, training_model, prediction_model = Retinamask.create_models(
backbone_retinanet=backbone.maskrcnn,
num_classes=train_generator.num_classes(),
weights=weights,
freeze_backbone=freeze_backbone)
#print(model.summary())
training_model.fit_generator(generator=train_generator,
steps_per_epoch=1000,
epochs=self.epoch,
verbose=1,
max_queue_size=1)
training_model.save(self.trained_weights_path + 'retinamask.h5')
#Testing
model_path = self.trained_weights_path + 'retinamask.h5'
model = models.load_model(model_path, backbone_name='resnet50')
labels_to_names = {0: 'ship'}
# load image
image = read_image_bgr(test_image_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()
outputs = model.predict_on_batch(np.expand_dims(image, axis=0))
print("processing time: ", time.time() - start)
boxes = outputs[-4][0]
scores = outputs[-3][0]
labels = outputs[-2][0]
masks = outputs[-1][0]
# correct for image scale
boxes /= scale
# visualize detections
for box, score, label, mask in zip(boxes, scores, labels, masks):
if score < 0.5:
break
color = label_color(label)
b = box.astype(int)
draw_box(draw, b, color=color)
mask = mask[:, :, label]
draw_mask(draw, b, mask, color=label_color(label))
caption = "{} {:.3f}".format(labels_to_names[label], score)
draw_caption(draw, b, caption)
plt.imsave(self.output_image_path + 'output.jpg', draw)
def img_inference(img_path, pos_window, model, labels_to_names):
window_size = (240, 250)
over_lap_x = 100
over_lap_y = 80
list_bb = []
image = read_image_bgr(img_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)
# print(scale)
# process 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]):
box_restore = []
# scores are sorted so we can break
if score < 0.8 or labels_to_names[label] != "solar":
break
box_restore.append(box[0] + pos_window[1] *
(window_size[1] - over_lap_y))
box_restore.append(box[1] + pos_window[0] *
(window_size[0] - over_lap_x))
box_restore.append(box[2] + pos_window[1] *
(window_size[1] - over_lap_y))
box_restore.append(box[3] + pos_window[0] *
(window_size[0] - over_lap_x))
# print(box)
# print(score)
# print(labels_to_names[label])
list_bb.append(box_restore)
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=(10, 10))
plt.axis('off')
plt.imshow(draw)
plt.show()
# for box in list_bb:
# print(box)
# print(list_bb[0])
return list_bb
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
print_log = "ALERT : Identified Object : " + str(ALERT_OBJECT)
print(print_log)
logData(print_log)
cv2.imwrite(ALERT_IMAGE_NAME, image)
global IS_SEND_ALERT
print('IS_SEND_ALERT : ' + str(IS_SEND_ALERT))
if IS_SEND_ALERT == False:
sendAlertEmail()
sendAlertSMS()
IS_SEND_ALERT = True
vcapture.release()
vwriter.release() #
end = time.time()
print("Total Time: ", end - start)
def predict_img(model, test_img_fold, test_img_list):
# load image
img_name_list = []
bboxes_list = []
class_list = []
score_list = []
for i in range(len(test_img_list)):
img_name = test_img_list[i]
if ".xml" in img_name:
continue
img_path = os.path.join(test_img_fold, img_name)
# image = read_image_bgr(img_path)
image_BGR = cv2.imread(img_path)
# copy to draw on
draw = image_BGR
image = cv2.cvtColor(image_BGR, cv2.COLOR_BGR2RGB) # 不需要
image = np.asarray(image)[:, :, ::-1].copy()
# preprocess image for network
image = preprocess_image(image)
image, scale = resize_image(image)
# process image
start = time.time()
# print(image.shape)
# print(scale)
# boxes: 预测的box,scores:预测的概率，labels预测的labels
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
i = 0
for box, score, label in zip(boxes[0], scores[0], labels[0]):
# scores are sorted so we can break,概率小于0.5的被舍弃
if score < 0.2:
break
color = label_color(label)
b = box.astype(int)
img_name_list.append(img_name)
bboxes_list.append(b)
class_list.append(labels[0][i])
score_list.append(score)
i += 1
draw_box(draw, b, color=color)
print(label)
caption = "{} {:.3f}".format(labels_to_names[label], score)
draw_caption(draw, b, caption)
# imsave('result/'+img_name, draw)
# print(draw)
cv2.imwrite('result/' + img_name, draw)
submit = pd.DataFrame()
submit['img_name'] = img_name_list
submit['bbox'] = bboxes_list
submit['class'] = class_list
submit['score'] = score_list
submit.to_csv('submit.csv', index=None)
def run_detection_image(path):
image = cv2.imread(path)
# image base 64 retimag = np_to_base64(image)
# print(base64_to_pil(retimag))
# # 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.3:
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=(30, 30))
#plt.axis('off')
# abcd = plt.imshow(draw)
# #plt.show()
#
# #file, ext = os.path.splitext(filepath)
# #image_name = file.split('/')[-1] + ext
# #output_path = os.path.join('examples1/results/', image_name)
#
# draw_conv = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB)
# #cv2.imwrite(output_path, draw_conv)
# return image
retimag = np_to_base64(draw)
strimg = base64_to_pil(retimag)
strimg.save("testimg.png")
print(strimg)
return send_file('testimg.png', mimetype="image/png")
