def image_processing(graph, category_index, image_file_name, show_video_window): img = cv2.imread(image_file_name) image_expanded = np.expand_dims(img, axis=0) with graph.as_default(): ops = tf.get_default_graph().get_operations() all_tensor_names = {output.name for op in ops for output in op.outputs} tensor_dict = {} for key in [ 'num_detections', 'detection_boxes', 'detection_scores', 'detection_classes', 'detection_masks' ]: tensor_name = key + ':0' if tensor_name in all_tensor_names: tensor_dict[key] = tf.get_default_graph().get_tensor_by_name( tensor_name) with tf.Session() as sess: output_dict = run_inference_for_single_image(image_expanded, sess, tensor_dict) vis_utils.visualize_boxes_and_labels_on_image_array( img, output_dict['detection_boxes'], output_dict['detection_classes'], output_dict['detection_scores'], category_index, instance_masks=output_dict.get('detection_masks'), use_normalized_coordinates=True, line_thickness=4) if show_video_window: cv2.imshow('ppe', img) cv2.waitKey(5000)
def detect(self, frame): frame_expanded = np.expand_dims(frame, axis=0) # Perform the actual detection by running the model with the image as input (boxes, scores, classes, num) = self.sess.run([self.db, self.ds, self.dc, self.nd], feed_dict={self.it: frame_expanded}) # Draw the results of the detection (aka 'visulaize the results') vis_util.visualize_boxes_and_labels_on_image_array( frame, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), self.category_index, use_normalized_coordinates=True, line_thickness=self.line_thickness, min_score_thresh=self.min_score_thresh, max_boxes_to_draw=self.max_objects) # publish what we think we saw and the locations objects = list(zip(boxes, scores, classes)) objects.sort(key=lambda x: x[1], reverse=true) # sort in ascending order recogniseable_objects = [] for i, obj in enumerate(objects): if obj[1] < self.min_score_thresh or i >= self.max_objects: break recogniseable_objects.append( get_object_position(classes[i], boxes[i])) return recogniseable_objects
def image_output(outputs, ctx): detection_boxes = outputs["detection_boxes"].reshape([-1, 4]) detection_scores = outputs["detection_scores"].reshape([-1]) detection_classes = np.int32((outputs["detection_classes"])).reshape([-1]) ctx.image = ctx.image.convert('RGB') image_arr = np.array(ctx.image) LOG.info( 'Visualization params: threshold %f, line_thickness %d, max_boxes %d, skip_labels %r, skip_scores %r' % (ctx.threshold, ctx.line_thickness, ctx.max_boxes, ctx.skip_labels, ctx.skip_scores)) vis_utils.visualize_boxes_and_labels_on_image_array( image_arr, detection_boxes, detection_classes, detection_scores, category_index, use_normalized_coordinates=True, max_boxes_to_draw=ctx.max_boxes, min_score_thresh=ctx.threshold, agnostic_mode=False, line_thickness=ctx.line_thickness, skip_labels=ctx.skip_labels, skip_scores=ctx.skip_scores, ) from_arr = Image.fromarray(image_arr) image_bytes = io.BytesIO() from_arr.save(image_bytes, format='PNG') outputs['output'] = image_bytes.getvalue() return outputs
def main(): parser = argparse.ArgumentParser() parser.add_argument("--url", help='The url to send the request') parser.add_argument("--input_image", default='image1.jpg') parser.add_argument("--output_image", default='output.jpg') args = parser.parse_args() img = Image.open(args.input_image) img = img.resize((WIDTH, HEIGHT), Image.ANTIALIAS) img_np = np.array(img) res = requests.post( args.url, data=json.dumps({"instances": [{"inputs": img_np.tolist()}]})) if res.status_code != 200: print('Failed: {}'.format(res.text)) return output_dict = json.loads(res.text).get('predictions')[0] vis_util.visualize_boxes_and_labels_on_image_array( img_np, np.array(output_dict['detection_boxes']), map(int, output_dict['detection_classes']), output_dict['detection_scores'], {}, instance_masks=output_dict.get('detection_masks'), use_normalized_coordinates=True, line_thickness=8) output_image = Image.fromarray(img_np) output_image.save(args.output_image)
def detect_rcnn(): if flask.request.method == "POST": if flask.request.files.get("image"): image = Image.open(flask.request.files["image"]) image_np = load_image_into_numpy_array(image) #image_np_expanded = np.expand_dims(image_np, axis=0) output_dict = run_inference_for_single_image( image_np, detection_graph) category_index = {0: {"name": "pothole"}, 1: {"name": "pothole"}} vis_util.visualize_boxes_and_labels_on_image_array( image_np, output_dict['detection_boxes'], output_dict['detection_classes'], output_dict['detection_scores'], category_index, instance_masks=output_dict.get('detection_masks'), use_normalized_coordinates=True, line_thickness=8, skip_scores=True, skip_labels=True) img = Image.fromarray(image_np.astype("uint8")) img = img.resize((128, 128)) rawBytes = io.BytesIO() img.save(rawBytes, "JPEG") rawBytes.seek(0) return rawBytes.getvalue() else: return "Could not find image" return "Please use POST method"
def detection(image_np, cap): stime = time.time() # 计算起始时间 # Expand dimensions since the model expects images to have shape: [1, None, None, 3] image_np_expanded = np.expand_dims(image_np, axis=0) # print('image_np_expanded', image_np_expanded.shape) # print('image_np_expanded.ndim', image_np_expanded.ndim) image_tensor = detection_graph.get_tensor_by_name('image_tensor:0') # Each box represents a part of the image where a particular object was detected. boxes = detection_graph.get_tensor_by_name('detection_boxes:0') # Each score represent how level of confidence for each of the objects. # Score is shown on the result image, together with the class label. scores = detection_graph.get_tensor_by_name('detection_scores:0') classes = detection_graph.get_tensor_by_name('detection_classes:0') num_detections = detection_graph.get_tensor_by_name('num_detections:0') # Actual detection. (boxes, scores, classes, num_detections) = sess.run([boxes, scores, classes, num_detections], feed_dict={image_tensor: image_np_expanded}) # Visualization of the results of a detection. vis_util.visualize_boxes_and_labels_on_image_array( image_np, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=8) cv2.imshow('object detection', cv2.resize(image_np, (800, 600))) fps = 1 / (time.time() - stime) process_time = time.time() - stime if cap == 1: return image_np, process_time else: return image_np, fps
def detect_objects(self, frame, visualize=False): small_frame = frame height, width, depth = frame.shape frame_size = (width, height) rgb_small_frame = small_frame[:, :, ::-1] # self.reframe_mask( frame_size) //사이즈 유동적으로 할 때 # Only process every other frame of video to save time if self.time_to_run_inference(): self.output_dict = self.run_inference(rgb_small_frame) if visualize: vis_util.visualize_boxes_and_labels_on_image_array( frame, self.output_dict['detection_boxes'], self.output_dict['detection_classes'], self.output_dict['detection_scores'], self.category_index, instance_masks=self.output_dict.get('detection_masks'), use_normalized_coordinates=True, min_score_thresh=self.threshold, line_thickness=1) return frame
def detect_objects(image_np, sess, detection_graph): # Expand dimensions since the model expects images to have shape: [mscoco_label_map.pbtxt, None, None, 3] image_np_expanded = np.expand_dims(image_np, axis=0) image_tensor = detection_graph.get_tensor_by_name('image_tensor:0') # Each box represents a part of the image where a particular object was detected. boxes = detection_graph.get_tensor_by_name('detection_boxes:0') # Each score represent how level of confidence for each of the objects. # Score is shown on the result image, together with the class label. scores = detection_graph.get_tensor_by_name('detection_scores:0') classes = detection_graph.get_tensor_by_name('detection_classes:0') num_detections = detection_graph.get_tensor_by_name('num_detections:0') # Actual detection. (boxes, scores, classes, num_detections) = sess.run([boxes, scores, classes, num_detections], feed_dict={image_tensor: image_np_expanded}) # Visualization of the results of a detection. vis_util.visualize_boxes_and_labels_on_image_array( image_np, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=8) return image_np
def Detect(self, frame): self.frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) self.frame_expanded = np.expand_dims(self.frame_rgb, axis=0) (boxes, scores, classes, num) = self.sess.run( [ self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections ], feed_dict={self.image_tensor: self.frame_expanded}) vis_util.visualize_boxes_and_labels_on_image_array( frame, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), self.category_index, use_normalized_coordinates=True, line_thickness=8, min_score_thresh=0.60) scores = scores[0][:3] classes = classes[0][:3] name = "" seen = [] for x in range(3): if (scores[x] > 0.6 and (not classes[x] in seen)): name += f'{self.map[classes[x]]}&' seen.append(classes[x]) if (name): print('Object Detected saving image') self.Store_Search.SaveDetected(frame, name)
def __displayDetectedImage(self, item): dcmFileName = item.data(0, Qt.UserRole) self.ui.statusBar.showMessage(dcmFileName) #预处理 dcmFile = pydicom.read_file(dcmFileName) origin = dcmFile.pixel_array # type:numpy.ndarray intercept = dcmFile.RescaleIntercept slope = dcmFile.RescaleSlope origin = origin * slope + intercept origin[origin < -100] = -100 # 去除低亮部分 origin[origin > 750] = 750 # 去除高亮部分 # 归一化到0-255 origin = cv2.normalize(origin, None, 0, 255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8UC3) image_np = np.expand_dims(origin, -1) # 将origin增加一个维度 image_np = np.repeat(image_np, 3, 2) # 将二维矩阵重复三次 #plt.imsave("output/undetected.jpg", image_np) NUM_CLASSES = 6 PATH_TO_LABELS = 'label_map.pbtxt' label_map = label_map_util.load_labelmap(PATH_TO_LABELS) categories = label_map_util.convert_label_map_to_categories( label_map, max_num_classes=NUM_CLASSES, use_display_name=True) category_index = label_map_util.create_category_index(categories) result = item.data(1, Qt.UserRole) boxes = result[1] scores = result[2] classes = result[3] vis_util.visualize_boxes_and_labels_on_image_array( image_np, boxes, classes, scores, category_index, use_normalized_coordinates=True, line_thickness=1) #plt.imsave("output/detected.jpg", image_np) image = QImage(image_np, image_np.shape[1], image_np.shape[0], QImage.Format_RGB888) self.curPixmap = QPixmap(image) self.on_actZoomFitH_triggered() self.ui.actZoomIn.setEnabled(True) self.ui.actZoomOut.setEnabled(True) self.ui.actZoomRealSize.setEnabled(True) self.ui.actZoomFitW.setEnabled(True) self.ui.actZoomFitH.setEnabled(True)
def show_result_image(self, image_np, scores, boxes, classes): # Visualization of the results of a detection. import visualization_utils as vis_util from matplotlib import pyplot as plt vis_util.visualize_boxes_and_labels_on_image_array( image_np, boxes, classes.astype(np.int32), scores, self.category_index, use_normalized_coordinates=True, line_thickness=8) plt.figure(figsize=(12, 8)) plt.imshow(image_np) plt.show()
def make_and_show_inference(img, interpreter, input_details, output_details, category_index, nms=True, score_thresh=0.6, iou_thresh=0.5): """ Generate and draw inference on image Parameters ---------- img : Array of uint8 Original Image to find predictions on. interpreter : tensorflow.lite.python.interpreter.Interpreter tflite model interpreter input_details : list input details of interpreter output_details : list output details of interpreter category_index : dict dictionary of labels nms : bool, optional To perform non-maximum suppression or not. The default is True. score_thresh : int, optional score above predicted class is accepted. The default is 0.6. iou_thresh : int, optional Intersection Over Union Threshold. The default is 0.5. Returns ------- NONE """ img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img_rgb = cv2.resize(img_rgb, (300, 300), cv2.INTER_AREA) img_rgb = img_rgb.reshape([1, 300, 300, 3]) interpreter.set_tensor(input_details[0]['index'], img_rgb) interpreter.invoke() output_dict = get_output_dict(img_rgb, interpreter, output_details, nms, iou_thresh, score_thresh) # Visualization of the results of a detection. vis_util.visualize_boxes_and_labels_on_image_array( img, output_dict['detection_boxes'], output_dict['detection_classes'], output_dict['detection_scores'], category_index, use_normalized_coordinates=True, min_score_thresh=score_thresh, line_thickness=3)
def draw_boxes(frame, bundled_np, min_score_thresh=0.5): [boxes, classes, scores] = bundled_np vis_util.visualize_boxes_and_labels_on_image_array( frame, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=8, min_score_thresh=min_score_thresh) return frame
def draw_detection_result(self, image_np, boxes, classes, scores, category, predict_chars=None): vis_util.visualize_boxes_and_labels_on_image_array( image_np, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category, max_boxes_to_draw=100, use_normalized_coordinates=True, line_thickness=5, predict_chars=predict_chars )
def get_classification(self, image): """Determines the color of the traffic light in the image Args: image (cv::Mat): image containing the traffic light Returns: int: ID of traffic light color (specified in styx_msgs/TrafficLight) """ image_np_expanded = np.expand_dims(image, axis=0) # rospy.logwarn('path %s', self.path) with self.detection_graph.as_default(): with tf.Session(graph=self.detection_graph) as sess: t0 = rospy.Time.now() out = self.sess.run([self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections], feed_dict={self.image_tensor: image_np_expanded}) dt = rospy.Time.now() - t0 rospy.loginfo('Classification CPU Time (s): %f', dt.to_sec()) boxes, scores, classes, num = out # create np arrays boxes = np.squeeze(boxes) scores = np.squeeze(scores) classes = np.squeeze(classes).astype(np.int32) vis_util.visualize_boxes_and_labels_on_image_array( image, boxes, classes, scores, self.category_index, use_normalized_coordinates=True, line_thickness=4) if self.save_images == True and self.saved_image_counter <= self.saved_image_limit: if not (os.path.exists("./tl_images_infer")): os.mkdir("./tl_images_infer") cv2.imwrite("./tl_images_infer/infer_image{0:0>4}.jpeg".format(self.saved_image_counter),cv2.cvtColor(image,cv2.COLOR_RGB2BGR)) self.saved_image_counter += 1 self.current_light = TrafficLight.UNKNOWN if scores is not None and scores[0] > CLASSIFICATION_THRESHOLD: # If highest score is above 50% it's a hit if classes[0] == 1: self.current_light = TrafficLight.RED elif classes[0] == 2: self.current_light = TrafficLight.YELLOW elif classes[0] == 3: self.current_light = TrafficLight.GREEN return self.current_light
def draw_boxes(config, frame: FrameType, bundled_data: bytes) -> FrameType: min_score_thresh = config.args['min_score_thresh'] [boxes, classes, scores] = pickle.loads(bundled_data) vis_util.visualize_boxes_and_labels_on_image_array( frame, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=8, min_score_thresh=min_score_thresh) return frame
def visualize_detection_result(image_np, boxes, classes, scores, category): vis_util.visualize_boxes_and_labels_on_image_array( image_np, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category, max_boxes_to_draw=100, use_normalized_coordinates=True, line_thickness=5, min_score_thresh=.4, predict_chars=None) img_show = PIL.Image.fromarray(image_np) img_show.show()
def object_detaction_infer2(inference_url,imageFile,signature_name,jobParams): # method 1 # image = Image.open(BytesIO(imageFile)).convert("RGB") # (im_width, im_height) = image.size # image_data = np.array(image.getdata()).reshape((im_height, im_width, 3)).astype(np.uint8) # method 2 img_np_arr = np.frombuffer(imageFile, np.uint8) image_data = cv2.imdecode(img_np_arr, cv2.IMREAD_COLOR) image_data_yolo_list = image_data[np.newaxis, :].tolist() headers = {"Content-type": "application/json","Host":"{}-predictor-default.kfserving-pod.example.com".format(inference_url.split("/endpoints/v3/v1/models/")[1].split(":")[0])} service_ip = query_service_domain('istio-ingressgateway.istio-system.svc.cluster.local') inference_url = "http://{}/v1/models/".format(service_ip)+inference_url.split("/endpoints/v3/v1/models/")[1] r = requests.post(inference_url,headers=headers, data=json.dumps({"signature_name": "serving_default","instances":image_data_yolo_list}), ) if r.status_code!=200: logging.error(r.content) r = r.json() output_dict = r['predictions'][0] class_name_path = re.sub("^/home", "/dlwsdata/work", os.path.join(jobParams["model_base_path"], "class_names.json")) if not os.path.exists(class_name_path): class_name_path = "/DLWorkspace/src/utils/coco.names" category_index = read_class_names2(class_name_path) if "logits" in output_dict: length = len(output_dict['logits']) return {"data":[[v["name"],output_dict["logits"][k-1] if k<=length else [v["name"],None] ]for k,v in category_index.items()],"type":"classify"} else: output_dict['num_detections'] = int(output_dict['num_detections']) output_dict['detection_classes'] = np.array([int(class_id) for class_id in output_dict['detection_classes']]) output_dict['detection_boxes'] = np.array(output_dict['detection_boxes']) output_dict['detection_scores'] = np.array(output_dict['detection_scores']) visualization_utils.visualize_boxes_and_labels_on_image_array( image_data, output_dict['detection_boxes'], output_dict['detection_classes'], output_dict['detection_scores'], category_index, instance_masks=output_dict.get('detection_masks'), use_normalized_coordinates=True, line_thickness=1, ) Image.fromarray(image_data).show() image = Image.fromarray(image_data) imgByteArr = io.BytesIO() image.save(imgByteArr,format='JPEG') imgByteArr = imgByteArr.getvalue() imgByteArr = base64.b64encode(imgByteArr) return {"data":imgByteArr,"type":"detection"}
def process(self, image_np): with self.od_graph_def.as_default(): with tf.Session(graph=self.graph) as sess: # Definite input and output Tensors for detection_graph image_tensor = detection_graph.get_tensor_by_name( 'image_tensor:0') # Each box represents a part of the image where a particular object was detected. detection_boxes = detection_graph.get_tensor_by_name( 'detection_boxes:0') # Each score represent how level of confidence for each of the objects. # Score is shown on the result image, together with the class label. detection_scores = detection_graph.get_tensor_by_name( 'detection_scores:0') detection_classes = detection_graph.get_tensor_by_name( 'detection_classes:0') num_detections = detection_graph.get_tensor_by_name( 'num_detections:0') # cap = cv2.VideoCapture(0) #window = cv2.namedWindow('frame') # Capture frame-by-frame # ret, image_np = cap.read() if image_np is None: return # Expand dimensions since the model expects images to have shape: [1, None, None, 3] image_np_expanded = np.expand_dims(image_np, axis=0) # Actual detection. (boxes, scores, classes, num) = sess.run([ detection_boxes, detection_scores, detection_classes, num_detections ], feed_dict={image_tensor: image_np_expanded}) # Visualization of the results of a detection. vis_util.visualize_boxes_and_labels_on_image_array( image_np, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=4, min_score_thresh=0.6) # Display the resulting frame cv2.imshow(self.frame, image_np) try: self.image_pub.publish( self.bridge.cv2_to_imgmsg(image_np, "bgr8")) except CvBridgeError as e: print e
def generate(image_tensor, boxes, scores, classes, num_detections): ret, frame = vid_source.read() # Peformance fix process_this_frame = True # tensor code while ret: if process_this_frame: #image_np = client._load_image_into_numpy_array(frame) image_np_expanded = np.expand_dims(frame, axis=0) (boxes_t, scores_t, classes_t, num_detections_t) = client.sess.run( [boxes, scores, classes, num_detections], feed_dict={image_tensor: image_np_expanded}) image, labels = vis_util.visualize_boxes_and_labels_on_image_array( frame, np.squeeze(boxes_t), np.squeeze(classes_t).astype(np.int32), np.squeeze(scores_t), client.category_index, use_normalized_coordinates=True, line_thickness=8) # print(labels) speak_labels(labels) #image_pil = Image.fromarray(np.uint8(frame)).convert('RGB') payload = cv2.imencode('.jpg', frame)[1].tobytes() yield (b'--frame\r\n' b'Content-Type: image/jpeg\r\n\r\n' + payload + b'\r\n') process_this_frame = not process_this_frame ret, frame = vid_source.read()
def gen_classified_image(trash_classifier, category_index, img, min_score_thresh): # Open image then convert to numpy array img_np = load_image_into_numpy_array(img) # Get bounding boxes (boxes, scores, classes, num) = trash_classifier.get_classification(img_np) # Draw bounding boxes on image img_out_np = visualize_boxes_and_labels_on_image_array( image = img_np, boxes = np.squeeze(boxes), classes = np.squeeze(classes), scores = np.squeeze(scores), category_index = category_index, use_normalized_coordinates = True, skip_labels = False, agnostic_mode = False, min_score_thresh=min_score_thresh ) # Save image with bounding boxes img_out = Image.fromarray(img_out_np) byteio = io.BytesIO() img_out.save(byteio, format='jpeg') imbytes = byteio.getvalue() imageBytesEnc = bytearray(imbytes) score_vals = scores[0] detection_count = len(score_vals[score_vals > min_score_thresh]) return imageBytesEnc, detection_count, num[0]
def img_inference(img_path): with detection_graph.as_default(): with tf.Session(graph=detection_graph) as sess: # Definite input and output Tensors for detection_graph image_tensor = detection_graph.get_tensor_by_name('image_tensor:0') # Each box represents a part of the image where a particular object was detected. detection_boxes = detection_graph.get_tensor_by_name( 'detection_boxes:0') # Each score represent how level of confidence for each of the objects. # Score is shown on the result image, together with the class label. detection_scores = detection_graph.get_tensor_by_name( 'detection_scores:0') detection_classes = detection_graph.get_tensor_by_name( 'detection_classes:0') num_detections = detection_graph.get_tensor_by_name( 'num_detections:0') image = PIL.Image.open(img_path) image_np = load_image_into_numpy_array(image) image_np_expanded = np.expand_dims(image_np, axis=0) (boxes, scores, classes, num) = sess.run([ detection_boxes, detection_scores, detection_classes, num_detections ], feed_dict={image_tensor: image_np_expanded}) pci = calculate_pci(scores, classes) vis_util.visualize_boxes_and_labels_on_image_array( image_np, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, min_score_thresh=0.5, use_normalized_coordinates=True, line_thickness=8) plt.figure(figsize=IMAGE_SIZE) plt.title('Pavement Condition Index (PCI): ' + str(round(pci))) plt.imshow(image_np) name = img_path.split('/')[-1].split('.')[0] op_name = PATH + '/imgs/' + name + '_OUTPUT.png' cv2.imwrite(op_name, image_np) # pci = calculate_pci(boxes[0]) return (op_name, pci)
def get_classification(self, image): """Determines the color of the traffic light in the image Args: image (cv::Mat): image containing the traffic light Returns: int: ID of traffic light color (specified in styx_msgs/TrafficLight) """ #TODO implement light color prediction image_np_expanded = np.expand_dims(image, axis=0) (boxes, scores, classes, num) = self.sess.run([ self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections ], feed_dict={self.image_tensor: image_np_expanded}) boxes = np.squeeze(boxes) scores = np.squeeze(scores) classes = np.squeeze(classes).astype(np.int32) vis_util.visualize_boxes_and_labels_on_image_array( image, boxes, classes, scores, self.category_index, use_normalized_coordinates=True, line_thickness=6) self.boxed_image = image if (scores[0] > 0.2): rospy.logwarn("Classes: {}, Scores: {}".format( classes[0], scores[0])) if (classes[0] == 1): return TrafficLight.RED elif (classes[0] == 2): return TrafficLight.YELLOW elif (classes[0] == 3): return TrafficLight.GREEN return TrafficLight.UNKNOWN
def run_detection(test_image_path, threshold): with tf.Session() as sess: detection_graph = tf.get_default_graph() image_tensor = detection_graph.get_tensor_by_name('image_tensor:0') detection_boxes = detection_graph.get_tensor_by_name( 'detection_boxes:0') detection_scores = detection_graph.get_tensor_by_name( 'detection_scores:0') detection_classes = detection_graph.get_tensor_by_name( 'detection_classes:0') num_detections = detection_graph.get_tensor_by_name('num_detections:0') # weights = detection_graph.get_tensor_by_name('FeatureExtractor/MobilenetV1/Conv2d_0/weights:0') # print("images",test_image_path) for image_path in test_image_path: # print("images") image = Image.open(image_path) image_np = load_image_into_numpy_array(image) # print(np.shape(image_np)) image_np_expanded = np.expand_dims(image_np, axis=0) # print(np.shape(image_np_expanded)) (boxes, scores, classes, num) = sess.run([ detection_boxes, detection_scores, detection_classes, num_detections ], feed_dict={image_tensor: image_np_expanded}) print("======================") print("Number of Detection ", num) print("Classes : ", classes) print("Scores : ", scores) viz_util.visualize_boxes_and_labels_on_image_array( image_np, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=8, min_score_thresh=threshold) plt.figure(figsize=IMAGE_SIZE) plt.imshow(image_np) plt.show()
def _visualize_detections(self, image, boxes, classes, scores): # Visualization of the results of a detection. return vis_util.visualize_boxes_and_labels_on_image_array( image, boxes, classes, scores, self.category_index, use_normalized_coordinates=True, line_thickness=4)
def run_detection_camera(): cam = cv2.VideoCapture(0) with tf.Session() as sess: detection_graph = tf.get_default_graph() image_tensor = detection_graph.get_tensor_by_name('image_tensor:0') detection_boxes = detection_graph.get_tensor_by_name( 'detection_boxes:0') detection_scores = detection_graph.get_tensor_by_name( 'detection_scores:0') detection_classes = detection_graph.get_tensor_by_name( 'detection_classes:0') num_detections = detection_graph.get_tensor_by_name('num_detections:0') # weights = detection_graph.get_tensor_by_name('FeatureExtractor/MobilenetV1/Conv2d_0/weights:0') while (True): ret, frame = cam.read() # image_np = load_image_into_numpy_array_frame(frame) # print(np.shape(image_np)) image_np_expanded = np.expand_dims(frame, axis=0) (boxes, scores, classes, num) = sess.run([ detection_boxes, detection_scores, detection_classes, num_detections ], feed_dict={image_tensor: image_np_expanded}) viz_util.visualize_boxes_and_labels_on_image_array( frame, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=8) cv2.imshow('Object Detection', frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cam.release() cv2.destroyAllWindows()
def main(_): # step 2: send a request options = [('grpc.max_send_message_length', 1000 * 1024 * 1024), ('grpc.max_receive_message_length', 1000 * 1024 * 1024)] channel = grpc.insecure_channel(FLAGS.server, options=options) stub = prediction_service_pb2_grpc.PredictionServiceStub(channel) request = predict_pb2.PredictRequest() request.model_spec.name = 'model' request.model_spec.signature_name = 'serving_default' # step 1: prepare input img = cv2.imread(FLAGS.image) h, w = img.shape[:2] if compress: ratio = w / h h1 = height w1 = round(h1 * ratio) scaled_img = cv2.resize(img, (w1, h1), interpolation=cv2.INTER_AREA) tensor = tf.contrib.util.make_tensor_proto(scaled_img, shape=[1] + list(scaled_img.shape)) else: tensor = tf.contrib.util.make_tensor_proto(img, shape=[1] + list(img.shape)) request.inputs['inputs'].CopyFrom(tensor) start = time.time() # step 3: get the results result_future = stub.Predict.future(request, 10.0) # 10 secs timeout result = result_future.result() stop = time.time() print('time is ', stop - start) NUM_CLASSES = 30 label_map = label_map_util.load_labelmap('annotations/label_map.pbtxt') categories = label_map_util.convert_label_map_to_categories( label_map, max_num_classes=NUM_CLASSES, use_display_name=True) category_index = label_map_util.create_category_index(categories) boxes = result.outputs['detection_boxes'].float_val classes = result.outputs['detection_classes'].float_val scores = result.outputs['detection_scores'].float_val result = vis_util.visualize_boxes_and_labels_on_image_array( img, np.reshape(boxes, [100, 4]), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=8) cv2.imwrite('result.jpg', result)
def get_labeled_image(image_path, path_to_labels, num_classes, boxes, classes, scores): label_map = label_map_util.load_labelmap(path_to_labels) categories = label_map_util.convert_label_map_to_categories( label_map, max_num_classes=num_classes, use_display_name=True) category_index = label_map_util.create_category_index(categories) image = Image.open(image_path) image_np = load_image_into_numpy_array(image) image_process = vis_util.visualize_boxes_and_labels_on_image_array( image_np, boxes, classes, scores, category_index) return image_process
def camThread(): # Wait for a coherent pair of frames: depth and color frames = pipeline.wait_for_frames() depth_frame = frames.get_depth_frame() color_frame = frames.get_color_frame() if not depth_frame or not color_frame: return # Convert images to numpy arrays depth_image = np.asanyarray(depth_frame.get_data()) color_image = np.asanyarray(color_frame.get_data()) height = color_image.shape[0] width = color_image.shape[1] frame_expanded = np.expand_dims(color_image, axis=0) # Perform the actual detection by running the model with the image as input (boxes, scores, classes, num) = sess.run( [detection_boxes, detection_scores, detection_classes, num_detections], feed_dict={image_tensor: frame_expanded}) # Draw the results of the detection (aka 'visulaize the results') img = vis_util.visualize_boxes_and_labels_on_image_array( color_image, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=2, min_score_thresh=0.55, depth_frame=depth_frame, height=height, width=width) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) glColor3f(1.0, 1.0, 1.0) glEnable(GL_TEXTURE_2D) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR) glBegin(GL_QUADS) glTexCoord2d(0.0, 1.0) glVertex3d(-1.0, -1.0, 0.0) glTexCoord2d(1.0, 1.0) glVertex3d(1.0, -1.0, 0.0) glTexCoord2d(1.0, 0.0) glVertex3d(1.0, 1.0, 0.0) glTexCoord2d(0.0, 0.0) glVertex3d(-1.0, 1.0, 0.0) glEnd() glFlush() glutSwapBuffers()
def _draw_detections(image_np, detections, category_index): """Draws detections on to the image. Args: image_np: Image in the form of uint8 numpy array. detections: a dictionary that contains the detection outputs. category_index: contains the mapping between indexes and the category names. Returns: Does not return anything but draws the boxes on the """ vis_util.visualize_boxes_and_labels_on_image_array( image_np, detections['detection_boxes'], detections['detection_classes'], detections['detection_scores'], category_index, use_normalized_coordinates=True, max_boxes_to_draw=1000, min_score_thresh=.0, agnostic_mode=False)