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 retinanet_test(): test_images = [ 'fe1b92a1-faaaa1eb.jpg', 'fe1cc363-a3f36598.jpg', 'fe1d74f0-5cdc4057.jpg', 'fe1d74f0-6969bdb5.jpg', 'fe1d9184-cd999efe.jpg', 'fe1d9184-d144106a.jpg', 'fe1d9184-dec09b65.jpg', 'fe1f2409-5b415eb7.jpg', 'fe1f2409-c16ea1ed.jpg', 'fe1f55fa-19ba3600.jpg' ] model = kr_models.load_model(retinanet_h5_path + 'densenet121_bdd10k_18.h5', backbone_name='densenet121') kr_models.check_training_model(model) inference_model = kr_models.convert_model(model) labels_to_names = bu.get_label_names(bdd100k_labels_path + 'class_mapping.csv') # load image image = read_image_bgr(bdd100k_val_path + test_images[2]) # 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 = inference_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) plt.figure(figsize=(15, 15)) plt.axis('off') plt.imshow(draw) plt.show()
def predict_image(model, image_path, score_threshold=0.1, max_detections=200, return_plot=True): """ Predict an image return_plot: Logical. If true, return a image object, else return bounding boxes """ #predict raw_image = cv2.imread(image_path) image = image_utils.preprocess_image(raw_image) image, scale = keras_retinanet_image.resize_image(image) if keras.backend.image_data_format() == 'channels_first': image = image.transpose((2, 0, 1)) # run network boxes, scores, labels = model.predict_on_batch( np.expand_dims(image, axis=0))[:3] # correct boxes for image scale boxes /= scale # select indices which have a score above the threshold indices = np.where(scores[0, :] > score_threshold)[0] # select those scores scores = scores[0][indices] # find the order with which to sort the scores scores_sort = np.argsort(-scores)[:max_detections] # select detections image_boxes = boxes[0, indices[scores_sort], :] image_scores = scores[scores_sort] image_labels = labels[0, indices[scores_sort]] image_detections = np.concatenate([ image_boxes, np.expand_dims(image_scores, axis=1), np.expand_dims(image_labels, axis=1) ], axis=1) if return_plot: draw_detections(raw_image, image_boxes, image_scores, image_labels, label_to_name=label_to_name, score_threshold=score_threshold) return raw_image else: return image_boxes
def predict(image): image = preprocess_image(image.copy()) image, scale = resize_image(image) boxes, scores, labels = model.predict_on_batch( np.expand_dims(image, axis=0) ) boxes /= scale return boxes, scores, labels
def run(image_path, model, host='localhost', port=8500, signature_name='serving_default'): options=[ ('grpc.max_send_message_length', 50 * 1024 * 1024), ('grpc.max_receive_message_length', 50 * 1024 * 1024) ] channel = grpc.insecure_channel('{host}:{port}'.format(host=host, port=port), options = options) stub = prediction_service_pb2_grpc.PredictionServiceStub(channel) image = read_image_bgr(image_path) image = preprocess_image(image.copy()) image, scale = resize_image(image) data = np.array(image).astype(tf.keras.backend.floatx()) start = time.time() request = predict_pb2.PredictRequest() request.model_spec.name = model request.model_spec.signature_name = signature_name print('Shape of data going in to inputs',data.shape) request.inputs['input_image'].CopyFrom(make_tensor_proto(data, shape=[1, data.shape[0], data.shape[1], 3])) result = stub.Predict(request, 10.0) end = time.time() time_diff = end - start print('time elapased: {}'.format(time_diff)) print(type(result)) # print('classes',result.outputs['classes']) bboxes_proto = result.outputs["filtered_detections/map/TensorArrayStack/TensorArrayGatherV3:0"] # print('bboxes proto',bboxes_proto) bboxes_proto_shape = tf.TensorShape(bboxes_proto.tensor_shape) # print('bboxes_proto_shape',bboxes_proto.tensor_shape) bboxes = tf.constant(bboxes_proto.float_val, shape=bboxes_proto_shape)/scale print(bboxes.numpy().shape) confidences_proto = result.outputs["filtered_detections/map/TensorArrayStack_1/TensorArrayGatherV3:0"] confidences_proto_shape = tf.TensorShape(confidences_proto.tensor_shape) confidences = tf.constant(confidences_proto.float_val, shape=confidences_proto_shape) labels_proto = result.outputs["filtered_detections/map/TensorArrayStack_2/TensorArrayGatherV3:0"] labels_shape = tf.TensorShape(labels_proto.tensor_shape) labels = tf.constant(labels_proto.int_val, shape=labels_shape) return bboxes.numpy(), confidences.numpy(), labels.numpy()
def get_localization(self, image, visual=False): """Determines the locations of the traffic light in the image Args: image: camera image Returns: list of bounding boxes: coordinates [y_up, x_left, y_down, x_right] """ bgr = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) image = preprocess_image(bgr) image, scale = resize_image(image) # preprocess image for network boxes, scores, classes = self.model.predict_on_batch( np.expand_dims(image, axis=0)) boxes /= scale boxes = np.squeeze(boxes) classes = np.squeeze(classes) scores = np.squeeze(scores) cls = classes.tolist() # The ID for car is 1 idx_vec = [ i for i, v in enumerate(cls) if ((v == 1) and (scores[i] > 0.3)) ] if len(idx_vec) == 0: print('no detection!') else: tmp_car_boxes = [] for idx in idx_vec: #dim = image.shape[0:2] #box = self.box_normal_to_pixel(boxes[idx], dim) box = boxes[idx].astype(int) box_w = box[2] - box[0] box_h = box[3] - box[1] ratio = box_h / (box_w + 0.01) if ((ratio < 0.8) and (box_h > 20) and (box_w > 20) and scores[idx] > 0.5): tmp_car_boxes.append(box) print(box, ', confidence: ', scores[idx], 'ratio:', ratio) else: print('wrong ratio or wrong size or low confidence, ', box, ', confidence: ', scores[idx], 'ratio:', ratio) self.car_boxes = tmp_car_boxes return self.car_boxes
def main(args=None): args = parse_args(args) model_bin = args.bin img_fn = args.img predict_count = args.count backbone = args.backbone print("loading model...") if args.gpu: setup_gpu(0) model = models.load_model(model_bin, backbone_name=backbone) print(f'model input shape: {model.inputs[0].shape}') start_time = time.time() image = cv2.imread(img_fn) image, scale = resize_image(image) image = preprocess_image(image) print("prepoocess image at {} s".format(time.time() - start_time)) labels_to_names = {0: 'Pedestrian'} print(f'make {predict_count} predictions:') for _ in range(0, predict_count): start_time = time.time() boxes, scores, labels = model.predict_on_batch( np.expand_dims(image, axis=0)) print("\t{} s".format(time.time() - start_time)) print("*" * 20) print('bboxes:', boxes.shape) print('scores:', scores.shape) print('labels:', labels.shape) boxes /= scale objects_count = 0 print("*" * 20) 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 print(f'{labels_to_names[label]}:') print(f'\tscore: {score}') print(f'\tbox: {b[0]} {b[1]} {b[2]} {b[3]}') objects_count = objects_count + 1 print(f'found objects: {objects_count}')
def run_detection_video(video_path): count = 0 success = True start = time.time() while success: if count % 100 == 0: print("frame: ", count) count += 1 # see what frames you are at # Read next image success, image = vcapture.read() if success: # so we can keep orig image scale draw = image.copy() draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB) # image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) # preprocess image for network image = preprocess_image(image) image, scale = resize_image(image) # Do compute 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.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) vwriter.write(draw) # overwrites video slice vcapture.release() vwriter.release() # end = time.time() print("Total Time: ", end - start)
def object_detection(model, inputData_list, dataset_path, output_path): for img_name in inputData_list: print("handling " + img_name) imagePath = dataset_path + img_name image = read_image_bgr(imagePath) print('image shape:', image.shape) # copy to draw on draw = image.copy() draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB) # 모델에 입력전에 이미지 사전 처리. keras-retinanet은 image image = preprocess_image(image) image, scale = resize_image(image) print('resized image size:', image.shape, 'scale:', scale) # 이미지에 대해 Object Detection 수행. start = time.time() boxes, scores, labels = model.predict_on_batch( np.expand_dims(image, axis=0)) print(boxes.shape, scores.shape, labels.shape) 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 labels_to_num[label] += 1 b = box.astype(int) #print(b) object_img = draw[b[1]:b[3], b[0]:b[2]] #print(object_img) object_img = Image.fromarray(object_img) imagePath_str = imagePath.replace('/', '-') # 객체 dump # os.chdir(output_path) object_img.save(output_path + "{}_path: ({}).jpg".format( labels_to_names_seq[label] + str(labels_to_num[label]), imagePath_str)) # os.chdir('../') print("detection 완료!")
def model_predict(img_path, model): im = np.array(Image.open(img_path)) imp = preprocess_image(im) imp, scale = resize_image(im) boxes, scores, labels = model.predict(np.expand_dims(imp, axis=0)) predictions = [] for box, score, label in zip(boxes[0], scores[0], labels[0]): if score < 0.5: break class_name = label_map[str(label)] predictions.append(class_name) return predictions
def load_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) return image, draw, scale
def test_gen(image_ids, bs = 2, size=672,test = True): imgs = [] scale = None idx = 0 if test: path = 'C:\\Users\\Pawan\\Downloads\\dataset_test_rgb\\rgb\\test\\' else: path = 'C:\\Users\\Pawan\\Downloads\\dataset_test_rgb\\rgb\\test\\' while idx < len(image_ids): if len(imgs) < bs: imgs.append(resize_image(preprocess_image(read_image_bgr(path + image_ids[idx] + '.png')),min_side=size,max_side=size)[0]) if scale is None: scale = resize_image(preprocess_image(read_image_bgr(path + image_ids[idx] + '.png')),min_side=size,max_side=size)[1] idx += 1 else: yield np.array(imgs),scale imgs = [] if len(imgs) > 0: yield np.array(imgs),scale
def face(img_path): coordinate = [] label_name_vector = [] # load image 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) # process image start = time.time() _, _, detections = model.predict_on_batch(np.expand_dims(image, axis=0)) print("processing time: ", time.time() - start) # 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 # visualize detections for idx, (label, score) in enumerate(zip(predicted_labels, scores)): if score < 0.5: continue b = detections[0, idx, :4].astype(int) cv2.rectangle(draw, (b[0], b[1]), (b[2], b[3]), (0, 0, 255), 3) caption = "{:.3f}".format(score) cv2.putText(draw, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1.5, (0, 0, 0), 3) cv2.putText(draw, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1.5, (255, 255, 255), 2) coordinate.append(b[0]) coordinate.append(b[1]) coordinate.append(b[2]) coordinate.append(b[3]) label_name_vector.append(labels_to_names[label]) write_output(label_name_vector, coordinate) plt.figure(figsize=(15, 15)) plt.axis('off') plt.imshow(draw) img_output_path = os.path.join('output', 'retina_net_face.jpg') plt.imsave(img_output_path, draw) plt.show() return(img_output_path)
def predict(image_list): ret_detection = [] draws = [] x = 0 for img in image_list: # load image if (x % 50 == 0): print("Image No.: %d out of %d images(RetinaNet)" % (x, len(image_list))) image = read_image_bgr(img) # 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) labels, scores, boxes = slice_frcnn_list(labels, scores, boxes, 0.35) # correct for image scale boxes[0] /= scale new = [] for item in boxes: i = item.astype(int) new.append(i) labels = np.asarray(labels) scores = np.asarray(scores) boxes = np.asarray(boxes) # plot_pred(boxes, scores, labels, draw) ret_detection.append( np.atleast_2d( np.squeeze(format_retina_output(labels, scores, boxes)))) draws.append(draw) x += 1 ret_detection = convert_list_array_to_list_list(ret_detection) return ret_detection, draws
def find_objects_single(model, image, min_side=800, max_side=1333): """Short method to detect objects. Only supports batch size = 1.""" if isinstance(image, str): image = read_image_bgr(image) else: image = image.copy() image = preprocess_image(image) image, scale = resize_image(image, min_side=min_side, max_side=max_side) boxes, scores, labels = model.predict_on_batch( np.expand_dims(image, axis=0)) boxes[0, :, :] /= scale # Taking in account the resizing factor return boxes, scores, labels
def predict(image): 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: ", str(1000 * (time.time() - start)) + " ms") # correct for image scale boxes /= scale return boxes, scores, labels
def Draw_out(path): # load image image = read_image_bgr(path) # copy to draw ondraw = image.copy() 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',scale) # process image start = time.time() boxes, scores, labels = model.predict_on_batch( np.expand_dims(image, axis=0)) #boxes是检测到的可能目标的框框 #print ('boxes',boxes) #是对应的分值 #print ('scores',scores) #对应的第几个标签 #print ('labels',labels) #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) #print ('label',label) b = box.astype(int) #b是box取整 #print ('b ',b) draw_box(draw, b, color=color) caption = "{} {:.3f}".format(labels_to_names[label], score) #single 0.431 是标签和分值 #print ('caption ',caption) draw_caption(draw, b, caption) plt.figure(figsize=(10, 10)) plt.axis('on') plt.imshow(draw) #plt.show() plt.savefig("static/js/powerbank_out.png") return caption
def test_gen(image_ids, test_path , bs = 1, min_size = 1000, max_size = 1400, test = True): imgs = [] scale = None idx = 0 if test: path = test_path else: path = 'training_data/images/' while idx < len(image_ids): if len(imgs) < bs: image_id_iter = image_ids[idx] imgs.append(resize_image(preprocess_image(load_image_file(path + "/" + image_ids[idx] + '.jpg')),min_side=min_size,max_side=max_size)[0]) scale = resize_image(preprocess_image(load_image_file(path + "/" + image_ids[idx] + '.jpg')),min_side=min_size,max_side=max_size)[1] idx += 1 else: yield image_id_iter, np.array(imgs), scale imgs = [] if len(imgs) > 0: yield image_id_iter, np.array(imgs), scale
def run_detection_image(model, image): with graph.as_default(): # 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 return boxes, scores, labels
def get_boxes(img, model): img = img.copy() preprocess_image(img) img, scale = resize_image(img, min_side=1024, max_side=1024) # process image start = time.time() boxes, scores, labels = model.predict_on_batch(np.expand_dims(img, axis=0)) print("processing time: ", time.time() - start) # correct for image scale boxes /= scale return boxes, scores, labels
def get_retinanet_predictions(model, image): from keras_retinanet.utils.image import preprocess_image, resize_image show_debug_images = False show_mirror_predictions = False if show_debug_images: # 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, min_side=600, max_side=800) # Add mirror if 1: image = np.stack((image, image[:, ::-1, :]), axis=0) else: image = np.array([image]) # process image start = time.time() print('Image shape: {} Scale: {}'.format(image.shape, scale)) boxes, scores, labels = model.predict_on_batch(image) print('Detections shape: {} {} {}'.format(boxes.shape, scores.shape, labels.shape)) print("Processing time: {:.2f} sec".format(time.time() - start)) if show_debug_images: if show_mirror_predictions: draw = draw[:, ::-1, :] boxes_init = boxes.copy() boxes_init /= scale boxes[:, :, 0] /= image.shape[2] boxes[:, :, 2] /= image.shape[2] boxes[:, :, 1] /= image.shape[1] boxes[:, :, 3] /= image.shape[1] if show_debug_images: if show_mirror_predictions: show_image_debug(draw.astype(np.uint8), boxes_init[1:], scores[1:], labels[1:]) else: show_image_debug(draw.astype(np.uint8), boxes_init[:1], scores[:1], labels[:1]) return boxes, scores, labels
def predict_save(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)): # for i in range(1): img_name = test_img_list[i] img_path = os.path.join(test_img_fold, img_name) 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) # process image start = time.time() # print(image.shape) # print(scale) 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 if score < 0.5: 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) caption = "{} {:.3f}".format(labels_to_names[label], score) draw_caption(draw, b, caption) imsave('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) submit.to_pickle('submit.pkl')
def callback(self, imageMsg): image = self.bridge.imgmsg_to_cv2(imageMsg, "bgr8") image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) image = image[:, :, ::-1].copy() # copy to draw on draw = image.copy() draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB) # Image formatting specific to Retinanet image = preprocess_image(image) image, scale = resize_image(image) # Run the inferencer try: with self.session.as_default(): with self.session.graph.as_default(): boxes, scores, labels = self.model.predict_on_batch(np.expand_dims(image, axis=0)) except Exception as e: rospy.logerr(e) rospy.logwarn("WARNING: Has your model been converted to an inference model yet? " "see https://github.com/fizyr/keras-retinanet#converting-a-training-model-to-inference-model") return # 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 < self.confidence_cutoff: break # Add boxes and captions b = np.array(box).astype(int) cv2.rectangle(draw, (b[0], b[1]), (b[2], b[3]), self.color, self.thickness, cv2.LINE_AA) if (label > len(self.labels_to_names)): print("WARNING: Got unknown label, using 'detection' instead") caption = "Detection {:.3f}".format(score) else: caption = "{} {:.3f}".format(self.labels_to_names[label], score) cv2.putText(draw, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1, (0, 0, 0), 2) cv2.putText(draw, caption, (b[0], b[1] - 10), cv2.FONT_HERSHEY_PLAIN, 1, (255, 255, 255), 1) # Write out image image_message_out = self.bridge.cv2_to_imgmsg(draw, encoding="rgb8") self.img_pub.publish(image_message_out)
def detect_single(img_path, min_prob=0.4): image = read_image_bgr(img_path) image = preprocess_image(image) image, scale = resize_image(image) boxes, scores, labels = 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 = classes[label] processed_boxes.append({'box': box, 'score': float(score), 'label': label}) return processed_boxes
def predict(self,img_path): image = read_image_bgr(img_path) image = preprocess_image(image) image, scale = resize_image(image) print(scale) boxes, scores, labels = self.model.predict_on_batch(np.expand_dims(image, axis=0)) result = [] result_score = [] for box, score, label in zip(boxes[0], scores[0], labels[0]): if score < self.PREDICTION_CONFIDENCE: break else: result.append(label) result_score.append(score) return self.process_prediction(result)
def evaluate(file_path, model, return_image=False, debug=False): """ Keras-RetinaNet evaluation adapted from github.com/fizyr/keras-retinanet :param model: loaded pretrained model. We ideally load this only once :param file_path: path to temp file :param return_image: Whether to return annotated image :param debug: Whether to return classification confidence scores :return: """ image = read_image_bgr(file_path) if return_image: draw = image.copy() draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB) image = preprocess_image(image) image, scale = resize_image(image) _, _, boxes, nms_class = model.predict_on_batch( np.expand_dims(image, axis=0)) predicted_labels = np.argmax(nms_class[0, :, :], axis=1) scores = nms_class[0, np.arange(nms_class.shape[1]), predicted_labels] boxes /= scale classes_found = [] for i in np.where(scores > THRESHOLD)[0]: label = labels_to_classes[predicted_labels[i]] score = scores[i] classes_found.append(label) # TODO: write own version with better presentation if return_image: colour = label_colour(predicted_labels[i]) b = boxes[0, i, :].astype(int) if debug: caption = "{} {:.3f}".format(label, score) else: caption = "{}".format(label) draw_box(draw, b, color=colour) draw_caption(draw, b, caption) return {'classes': classes_found, 'image': draw if return_image else None}
def object_detector(file, detector_model, score_threshold): """runs object detector on images to detect trees Args: file : path to image detector_model : tree detector model score_threshold : score threshold for non-max suppression Returns: detector_output : tuple contanining detector output """ image = read_image_bgr(file) image = preprocess_image(image) image, scale = resize_image(image) unscaled_image = np.asarray(Image.open(file)) # convert grayscale image to a 3-channel image if np.ndim(unscaled_image) == 2 or unscaled_image.shape[2] == 1: unscaled_image = np.repeat(unscaled_image[:, :, np.newaxis], 3, axis=2) # drop alpha channel unscaled_image = unscaled_image[:, :, :3] # bgr to rgb unscaled_image[:, :, ::-1].copy() # run detector on image start = time.time() boxes, scores, labels = detector_model.predict_on_batch( np.expand_dims(image, axis=0)) print("detection time: ", time.time() - start) # extract tree patches from image boxes /= scale tree_patches = extract_patches(unscaled_image, boxes[0], scores[0], score_threshold) valid_boxes = [ box for i, box in enumerate(boxes[0]) if scores[0][i] > score_threshold ] valid_scores = [ score for i, score in enumerate(scores[0]) if scores[0][i] > score_threshold ] detector_output = (tree_patches, unscaled_image, valid_boxes, valid_scores, score_threshold) return detector_output
def auto_label_coco(self): # use this to change which GPU to use gpu = 0 # set the modified tf session as backend in keras setup_gpu(gpu) model_path = self.retina_weight model = models.load_model(model_path, backbone_name='resnet50') pic_list = os.listdir(self.pic_dir) no_label_img_list = [] for pic_name in pic_list: pic_start = time.time() mpos = [] mclass = [] mscore = [] pic_fullpath = Path(self.pic_dir).joinpath(pic_name) print("[INFO]picfullpath:", pic_fullpath, type(pic_fullpath)) image = read_image_bgr(pic_fullpath) image = preprocess_image(image) image, scale = resize_image(image) boxes, scores, labels = model.predict_on_batch( np.expand_dims(image, axis=0)) boxes /= scale class_dict = {} if self.coco_classes != "all": class_dict = self.coco_classes 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 < float(self.retina_threshold): break involed_class = labels_to_names[label] if self.coco_classes != "all" and involed_class not in class_dict: continue mpos.append(box) mclass.append(involed_class) mscore.append(score) no_label_img = annotation_single_img(self.pic_dir, pic_name, self.xml_dir, mclass, mpos) pic_end = time.time() print("[INFO]single pic time:", str(pic_end - pic_start)) if no_label_img != None: no_label_img_list.append(no_label_img) if no_label_img_list != []: print("[WARNING] There are some picture which have no label, Please remove them:", \ str(no_label_img_list))
def get_labels_from_model(images, read_image_path, save_image_path, model): Labels = [] # load label to names mapping for visualization purposes labels_to_names = {0: 'round_single', 1: 'round_double', 2: 'unclear_single', 3: 'unclear_double', 4: 'hexagonal_single', 5: 'square_single', 6: 'trigonal_single', 7: 'void_single', 8: 'bubbles_single'} for image in images: # change image.split("/") to "\\" if used on windows path_separated = image.split("/") image_name = path_separated[len(path_separated) - 1] print(image_name) image = read_image_bgr(read_image_path + image_name) # copy to draw on draw = image.copy() draw = cv2.cvtColor(draw, cv2.COLOR_BGR2RGB) # preprocess image for network image = preprocess_image(image) print('image preprocessed') 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 boxes and store annotations to array Labels for idx, (box, score, label) in enumerate(zip(boxes[0], scores[0], labels[0])): if score < 0.5: continue b = boxes[0, idx, :4].astype(int) Labels.append([image_name, b, labels_to_names[label], score]) color = label_color(label) draw_box(draw, b, color=color) caption = "{} {:.3f}".format(labels_to_names[label], score) draw_caption(draw, b, caption) save_image_name = image_name.split(".")[0] + '_pred' cv2.imwrite(os.path.join(save_image_path, '{}.jpg'.format(save_image_name)), draw) return Labels
def run_inference(path): 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, min_side=val_gen.image_min_side, max_side=val_gen.image_max_side) # process image start = time.time() boxes, scores, labels = prediction_model.predict_on_batch(np.expand_dims(image, axis=0)) boxes /=scale return boxes[0], scores[0], labels[0]
def decode_image_retinanet(img_path,max_height=None): ## Going to read the image via retinanet helper- the original way start = timer() image = read_image_bgr(img_path) # preprocess image for network image = preprocess_image(image) image, scale = resize_image(image) end = timer() print("decode time=",end - start) #('decode time=', 0.028119802474975586) # these are the best scores #('Label', 'person', ' at ', array([409, 167, 728, 603]), ' Score ', 0.9681119) #('Label', 'person', ' at ', array([ 0, 426, 512, 785]), ' Score ', 0.8355836) #('Label', 'person', ' at ', array([ 723, 475, 1067, 791]), ' Score ', 0.72344124) #('Label', 'tie', ' at ', array([527, 335, 569, 505]), ' Score ', 0.525432) return image,image