######################### with GRAPH.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(GRAPH_PATH, "rb") as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name="") ######################### PRINTER.info_text("Indexing detection categories") LABEL_MAP = label_map_util.load_labelmap(LABEL_PATH) 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) ######################### PRINTER.info_text("Importing images") if INSTRUMENT == "aia": number_of_images = len( next(os.walk("%s/resources/aia-images" % MAIN_DIR))[2]) - 2 names = os.listdir("%s/resources/aia-images" % MAIN_DIR) names.sort() cutout_path = [ os.path.join("%s/resources/aia-images" % MAIN_DIR, "{}".format(name)) for name in names if name.endswith(".jpg") ] elif INSTRUMENT == "hmi": number_of_images = len(
def detect(imgname): # This is needed since the notebook is stored in the object_detection folder. OBJECT_DETECTION_PATH = '/home/wu/Documents/respo/models/research/object_detection' sys.path.append("/home/wu/Documents/respo/models/research/object_detection") # Object detection imports # Variables # What model to download. MODEL_NAME = 'ssd_mobilenet_v1_coco_11_06_2017' MODEL_FILE = os.path.join(OBJECT_DETECTION_PATH, MODEL_NAME + '.tar.gz') DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/' # Path to frozen detection graph. This is the actual model that is used for the object detection. PATH_TO_CKPT = os.path.join(OBJECT_DETECTION_PATH, MODEL_NAME + '/frozen_inference_graph.pb') # List of the strings that is used to add correct label for each box. PATH_TO_LABELS = os.path.join(OBJECT_DETECTION_PATH, 'data', 'mscoco_label_map.pbtxt') NUM_CLASSES = 90 # Download Model opener = urllib.request.URLopener() if not os.path.exists(MODEL_FILE): print('download model') opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE) else: print('model existed') tar_file = tarfile.open(MODEL_FILE) for file in tar_file.getmembers(): file_name = os.path.basename(file.name) if 'frozen_inference_graph.pb' in file_name: tar_file.extract(file, OBJECT_DETECTION_PATH) # Load a (frozen) Tensorflow model into memory. detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') # Loading label map 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) # Detection # For the sake of simplicity we will use only 2 images: # image1.jpg # image2.jpg # If you want to test the code with your images, just add path to the images to the TEST_IMAGE_PATHS. #PATH_TO_TEST_IMAGES_DIR = os.path.join(OBJECT_DETECTION_PATH, 'test_images') #TEST_IMAGE_PATHS = [os.path.join(PATH_TO_TEST_IMAGES_DIR, 'image{}.jpg'.format(i)) for i in range(5, 6)] TEST_IMAGE_PATHS =[imgname] # Size, in inches, of the output images. 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') for image_path in TEST_IMAGE_PATHS: # the array based representation of the image will be used later in order to prepare the # result image with boxes and labels on it. image_np = skimage.io.imread(image_path) # 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=8) #plt.figure(figsize=IMAGE_SIZE) #plt.axis('off') #plt.imshow(image_np) afterdetect_name='dected_'+imgname.strip('./') print (afterdetect_name) #plt.savefig(afterdetect_name) skimage.io.imsave(afterdetect_name,image_np) print ('dectect over') return afterdetect_name
def main(_): PATH_TO_CKPT = FLAGS.path_to_ckpt NUM_CLASSES = FLAGS.num_classes PATH_TO_LABELS = FLAGS.path_to_labels PATH_TO_TEST_IMAGES_DIR = FLAGS.path_to_test_imgs RESULT_VIS_PATH = FLAGS.saved_path # Step 1: Load a frozen graph detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') # Step 2: Load label map 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) # Step 3: Get the list of image names TEST_IMAGE_PATHS = glob.glob(os.path.join(PATH_TO_TEST_IMAGES_DIR, '*.jpg')) # Size, in inches, of the output images. IMAGE_SIZE = (12, 8) if not os.path.exists(RESULT_VIS_PATH): os.makedirs(RESULT_VIS_PATH) # Record inference time of each frame inferece_time = [] with detection_graph.as_default(): with tf.Session(graph=detection_graph) as sess: 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') for image_path in TEST_IMAGE_PATHS: image = Image.open(image_path) # the array based representation of the image will be used in order to prepare the # result image with boxes and labels on it. image_np = load_image_into_numpy_array(image) # expand dimensions since the model expects image to have shape [1, None, None, 3] image_np_expanded = np.expand_dims(image_np, axis=0) # Actual detection. start_time = time.time() (boxes, scores, classes, num) = sess.run( [detection_boxes, detection_scores, detection_classes, num_detections], feed_dict={image_tensor: image_np_expanded} ) elapse_time = time.time() - start_time inferece_time.append(elapse_time) 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=3) plt.imsave(os.path.join(RESULT_VIS_PATH, os.path.basename(image_path)), image_np) print ("Time elapsed for each frame = {}".format(inferece_time)) print ("Speed of testing is {} seconds/frame".format(np.mean(inferece_time[1:])))
NUM_OCTAVES = 2.5 ######################################################################## # Model information MODEL_NAME = 'ssd_mobilenet_v2_fpn_320' PATH_TO_SAVED_MODEL = os.path.join(os.getcwd(), 'model_data', MODEL_NAME, 'saved_model') PATH_TO_LABELS = os.path.join(os.getcwd(), 'model_data', MODEL_NAME, 'label_map.pbtxt') print("Loading saved model ...") detect_fn = tf.saved_model.load(PATH_TO_SAVED_MODEL) print("Model Loaded!") # Load label map and obtain class names and ids label_map = label_map_util.load_labelmap(PATH_TO_LABELS) category_index = label_map_util.create_category_index( label_map_util.convert_label_map_to_categories(label_map, max_num_classes=1, use_display_name=True)) def visualise_on_image(image, bboxes, labels, scores, score_thresh, vert_thresh): (h, w, d) = image.shape for bbox, label, score in zip(bboxes, labels, scores): if score > score_thresh and bbox[0] > vert_thresh: xmin, ymin = int(bbox[1] * w), int(bbox[0] * h) xmax, ymax = int(bbox[3] * w), int(bbox[2] * h) cv2.rectangle(image, (xmin, ymin), (xmax, ymax), (0, 255, 0), 2) cv2.circle(image, ((xmin + xmax) // 2, (ymin + ymax) // 2), 3, (0, 255, 0), -1) cv2.putText(image, f"{label}: {int(score*100)} %", (xmin, ymin),
def loopimg(name="Picture 150.png"): IMAGE_NAME = str(name) print(name) PATH_TO_IMAGE = os.path.join(CWD_PATH, IMAGE_NAME) # Number of classes the object detector can identify NUM_CLASSES = 4 # Load the label map. # # Here we use internal utility functions, but anything that returns a # dictionary mapping integers to appropriate string labels would be fine 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) # Load the Tensorflow model into memory. detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') sess = tf.Session(graph=detection_graph) # Define input and output tensors (i.e. data) for the object detection classifier # Input tensor is the image image_tensor = detection_graph.get_tensor_by_name('image_tensor:0') # Output tensors are the detection boxes, scores, and classes # 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 represents level of confidence for each of the objects. # The 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') # Number of objects detected num_detections = detection_graph.get_tensor_by_name('num_detections:0') # Load image using OpenCV and # expand image dimensions to have shape: [1, None, None, 3] # i.e. a single-column array, where each item in the column has the pixel RGB value image = cv2.imread(PATH_TO_IMAGE) image_expanded = np.expand_dims(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: image_expanded}) printcount = 0 it = 0 boxesFiltered = [] final_score = np.squeeze(scores) count = 0 for i in range(100): if scores is None or final_score[i] > 0.5: count = count + 1 for i in classes[0]: printcount = printcount + 1 if (category_index[i]['name'] == "serialreadable"): print("cheese") checkingSerial = True coordinates = vis_util.return_coordinates( image, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=8, min_score_thresh=0.90) print(category_index[i]['name']) print("cheese") if (coordinates != None): print(coordinates) print(i) it += 1 x = int(coordinates[2]) y = int(coordinates[0]) w = int(coordinates[3]) h = int(coordinates[1]) #im2, contours, hierarchy = cv2.findContours(frame,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE) #x, y, w, h = cv2.boundingRect(contours[i]) roi = image[y:y + h, x:x + w] #gaussian_3 = cv2.GaussianBlur(roi, (9,9), 10.0) #unsharp_image = cv2.addWeighted(roi, 1.5, gaussian_3, -0.5, 0, roi) roi = cv2.resize(roi, None, fx=4, fy=4, interpolation=cv2.INTER_CUBIC) cv2.fastNlMeansDenoisingColored(roi, None, 15, 15, 7, 21) roi = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY) kernel = np.zeros((3, 3), np.uint8) #roi = cv2.dilate(roi, kernel, iterations=1) roi = cv2.erode(roi, kernel, iterations=3) #roi = cv2.bilateralFilter(roi,9,75,75) roi = cv2.medianBlur(roi, 3) #edges = cv2.Canny(roi,100,200) #img_dilation = c_m.dilate(edges,N=3,iterations=2) #kernel = np.ones((5,5), np.uint8) #img_dilation = cv2.dilate(roi, kernel, iterations=2) roi = cv2.adaptiveThreshold(roi, 245, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 115, 1) #ret,roi = cv2.threshold(roi,127,255,cv2.THRESH_BINARY_INV) #plt.subplot(121),plt.imshow(roi,cmap = 'gray') #plt.title('Original Image'), plt.xticks([]), plt.yticks([]) #plt.subplot(122),plt.imshow(edges,cmap = 'gray') #plt.title('Edge Image'), plt.xticks([]), plt.yticks([]) roi = cv2.medianBlur(roi, 3) #roi = cv2.bilateralFilter(roi,9,75,75) cv2.imwrite(str(name) + "zaca.png", roi) print("zaca") #contours=c_m.find_components(edges) #c_m.process_image(str(it)+"roi.jpg",str(it)+"roi.jpg") #API.SetVariable("classify_enable_learning","0"); #API.SetVariable("classify_enable_adaptive_matcher","0") #API. r = 0 text = readtext.readtext(roi, r) print("{}\n".format(text)) if (text == None): text = str('') else: img2 = np.zeros((512, 512, 3), np.uint8) font = cv2.FONT_HERSHEY_SIMPLEX cv2.putText(img2, text, (10, 500), font, 1, (255, 255, 255), 2, cv2.LINE_AA) cv2.imshow("Results", img2) checkingSerial = False else: break return name if (printcount == count): break return name # Draw the results of the detection (aka 'visulaize the results') vis_util.visualize_boxes_and_labels_on_image_array( image, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=8, min_score_thresh=0.80)
def a(IM_name): IMAGE_NAME = 'object_detection/' + IM_name # Grab path to current working directory CWD_PATH = os.getcwd() # Path to frozen detection graph .pb file, which contains the model that is used # for object detection. PATH_TO_CKPT = os.path.join(CWD_PATH, MODEL_NAME, 'frozen_inference_graph.pb') # Path to label map file PATH_TO_LABELS = os.path.join(CWD_PATH, 'training', 'labelmap.pbtxt') # Path to image PATH_TO_IMAGE = os.path.join(CWD_PATH, IMAGE_NAME) # Number of classes the object detector can identify NUM_CLASSES = 1 # Load the label map. # Label maps map indices to category names, so that when our convolution # network predicts `5`, we know that this corresponds to `king`. # Here we use internal utility functions, but anything that returns a # dictionary mapping integers to appropriate string labels would be fine 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) # Load the Tensorflow model into memory. detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.compat.v1.GraphDef() with tf.io.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') sess = tf.compat.v1.Session(graph=detection_graph) # Define input and output tensors (i.e. data) for the object detection classifier # Input tensor is the image image_tensor = detection_graph.get_tensor_by_name('image_tensor:0') # Output tensors are the detection boxes, scores, and classes # 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 represents level of confidence for each of the objects. # The 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') # Number of objects detected num_detections = detection_graph.get_tensor_by_name('num_detections:0') # Load image using OpenCV and # expand image dimensions to have shape: [1, None, None, 3] # i.e. a single-column array, where each item in the column has the pixel RGB value image = cv2.imread(PATH_TO_IMAGE) image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) image_expanded = np.expand_dims(image_rgb, 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: image_expanded}) # Draw the results of the detection (aka 'visulaize the results') vis_util.visualize_boxes_and_labels_on_image_array( image, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=8, min_score_thresh=0.60) # new added pAth = CWD_PATH + "/output/" + IMAGE_name print(pAth) cv2.imwrite(pAth, image)
import numpy as np import tensorflow as tf import sys from PIL import Image import cv2 cap = cv2.VideoCapture(0) from utils import label_map_util from utils import visualization_utils as vis_util # ------------------ Face Model Initialization ------------------------------ # face_label_map = label_map_util.load_labelmap('training_face/labelmap.pbtxt') face_categories = label_map_util.convert_label_map_to_categories( face_label_map, max_num_classes=2, use_display_name=True) face_category_index = label_map_util.create_category_index(face_categories) face_detection_graph = tf.Graph() with face_detection_graph.as_default(): face_od_graph_def = tf.GraphDef() with tf.gfile.GFile('inference_graph_face_ssd/frozen_inference_graph.pb', 'rb') as fid: face_serialized_graph = fid.read() face_od_graph_def.ParseFromString(face_serialized_graph) tf.import_graph_def(face_od_graph_def, name='') face_session = tf.Session(graph=face_detection_graph) face_image_tensor = face_detection_graph.get_tensor_by_name('image_tensor:0') face_detection_boxes = face_detection_graph.get_tensor_by_name( 'detection_boxes:0')
def detectObject(): import numpy as np import os import six.moves.urllib as urllib import sys import tarfile import tensorflow as tf import win32 from PIL import Image # This is needed since the notebook is stored in the object_detection folder. sys.path.append("..") from object_detection.utils import ops as utils_ops if tf.__version__ < '1.4.0': raise ImportError( 'Please upgrade your tensorflow installation to v1.4.* or later!') import cv2 cap = cv2.VideoCapture(0) # ## Env setup from utils import label_map_util from utils import visualization_utils as vis_util # # Model preparation # ## Variables # # Any model exported using the `export_inference_graph.py` tool can be loaded here simply by changing `PATH_TO_FROZEN_GRAPH` to point to a new .pb file. # # By default we use an "SSD with Mobilenet" model here. See the [detection model zoo](https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/detection_model_zoo.md) for a list of other models that can be run out-of-the-box with varying speeds and accuracies. # What model to download. MODEL_NAME = 'ssd_mobilenet_v1_coco_2017_11_17' MODEL_FILE = MODEL_NAME + '.tar.gz' DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/' # Path to frozen detection graph. This is the actual model that is used for the object detection. PATH_TO_FROZEN_GRAPH = MODEL_NAME + '/frozen_inference_graph.pb' # List of the strings that is used to add correct label for each box. PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt') NUM_CLASSES = 90 # ## Download Model # Check the frozen_inference_graph is exists at path. # If not ssd_mobilenet_v1_coco_2017_11_17 model is downloaded and frozen_inference_graph.pb moved to path. if os.path.exists(PATH_TO_FROZEN_GRAPH): print( "ssd_mobilenet_v1_coco_2017_11_17/frozen_inference_graph.pb Exists at path. Skipping download... " ) else: opener = urllib.request.URLopener() opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE) tar_file = tarfile.open(MODEL_FILE) for file in tar_file.getmembers(): file_name = os.path.basename(file.name) if 'frozen_inference_graph.pb' in file_name: tar_file.extract(file, os.getcwd()) # ## Load a (frozen) Tensorflow model into memory. detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.compat.v1.GraphDef() with tf.io.gfile.GFile(PATH_TO_FROZEN_GRAPH, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') # ## Loading label map # Label maps map indices to category names, so that when our convolution network predicts `5`, we know that this corresponds to `airplane`. Here we use internal utility functions, but anything that returns a dictionary mapping integers to appropriate string labels would be fine 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) # # Detection def run_inference_for_single_image(image, graph): with graph.as_default(): with tf.compat.v1.Session() as sess: # Get handles to input and output tensors ops = tf.compat.v1.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.compat.v1.get_default_graph( ).get_tensor_by_name(tensor_name) if 'detection_masks' in tensor_dict: # The following processing is only for single image detection_boxes = tf.squeeze( tensor_dict['detection_boxes'], [0]) detection_masks = tf.squeeze( tensor_dict['detection_masks'], [0]) # Reframe is required to translate mask from box coordinates to image coordinates and fit the image size. real_num_detection = tf.cast( tensor_dict['num_detections'][0], tf.int32) detection_boxes = tf.slice(detection_boxes, [0, 0], [real_num_detection, -1]) detection_masks = tf.slice(detection_masks, [0, 0, 0], [real_num_detection, -1, -1]) detection_masks_reframed = utils_ops.reframe_box_masks_to_image_masks( detection_masks, detection_boxes, image.shape[0], image.shape[1]) detection_masks_reframed = tf.cast( tf.greater(detection_masks_reframed, 0.5), tf.uint8) # Follow the convention by adding back the batch dimension tensor_dict['detection_masks'] = tf.expand_dims( detection_masks_reframed, 0) image_tensor = tf.compat.v1.get_default_graph( ).get_tensor_by_name('image_tensor:0') # Run inference output_dict = sess.run( tensor_dict, feed_dict={image_tensor: np.expand_dims(image, 0)}) # all outputs are float32 numpy arrays, so convert types as appropriate output_dict['num_detections'] = int( output_dict['num_detections'][0]) output_dict['detection_classes'] = output_dict[ 'detection_classes'][0].astype(np.uint8) output_dict['detection_boxes'] = output_dict[ 'detection_boxes'][0] output_dict['detection_scores'] = output_dict[ 'detection_scores'][0] if 'detection_masks' in output_dict: output_dict['detection_masks'] = output_dict[ 'detection_masks'][0] return output_dict while True: ret, image_np = cap.read() # Actual detection. output_dict = run_inference_for_single_image(image_np, detection_graph) # Visualization of the results of a detection. 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) #print(output_dict['detection_scores']) lbl = output_dict['detection_classes'][0] #print(category_index[lbl]['name']) win32.voice(category_index[lbl]['name']) cv2.imshow('Image Detction', cv2.resize(image_np, (1280, 720))) if cv2.waitKey(25) & 0xFF == ord('q'): cv2.destroyAllWindows() break
def accident_detection(): print("car crash detection") MODEL_NAME = 'inference_graph' CWD_PATH = os.getcwd() PATH_TO_CKPT = os.path.join(CWD_PATH, MODEL_NAME, 'frozen_inference_graph.pb') PATH_TO_LABELS = os.path.join(CWD_PATH, 'training', 'labelmap.pbtxt') NUM_CLASSES = 2 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) detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') sess = tf.Session(graph=detection_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') count = 1 cap = cv2.VideoCapture( 'C:\\TensorflowModels\\models\\research\\object_detection\\test_video\\acc6.mp4' ) while (cap.isOpened()): ret, frame = cap.read() image_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_expanded}) # if args.textual: print("\n\n" + "=" * 50 + " Results " + "=" * 50 + "\n\n") print(" Class Surety") print() count = 0 for i in range(scores.shape[1]): if scores[0, i] > 0.8: print(" " + str(i + 1) + ". " + str(category_index.get(classes[0, i])['name']) + " ==> " + str(scores[0, i] * 100) + ' %') print() count += 1 if (str(category_index.get(classes[0, i])['name']) == "crashed"): winsound.Beep(440, 500) print("\n Total " + str(count) + " objects classified.\n") 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=0.80) cv2.imshow('Object detector', frame) count += 1 cv2.waitKey(1) cap.release() cv2.destroyAllWindows()
def upload(): target = os.path.join(APP_ROOT, 'images') if not os.path.isdir(target): os.mkdir(target) for file in request.files.getlist("file"): filename = file.filename destination = '/'.join([target, filename]) file.save(destination) MODEL_NAME = 'inference_graph' IMAGES = os.listdir('C:/Users/MY PC/Desktop/FlaskApp/images') IMAGE_NAME = IMAGES[0] IMAGE_PATH = 'C:/Users/MY PC/Desktop/FlaskApp/images' CWD_PATH = 'E:/miniproject' PATH_TO_CKPT = os.path.join(CWD_PATH, MODEL_NAME, 'frozen_inference_graph.pb') PATH_TO_LABELS = os.path.join(CWD_PATH, 'training', 'labelmap.pbtxt') PATH_TO_IMAGE = os.path.join(IMAGE_PATH, IMAGE_NAME) NUM_CLASSES = 1 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) detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') sess = tf.Session(graph=detection_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') image = cv2.imread(PATH_TO_IMAGE) image_expanded = np.expand_dims(image, axis=0) (boxes, scores, classes, num) = sess.run([ detection_boxes, detection_scores, detection_classes, num_detections ], feed_dict={image_tensor: image_expanded}) vis_util.visualize_boxes_and_labels_on_image_array( image, 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.65) cv2.imshow('Object detector', image) cv2.imwrite('new_img.jpg', image) cv2.waitKey(0) cv2.destroyAllWindows() os.remove(PATH_TO_IMAGE) return render_template('predict.html')
def load_category(self, label_file): label_map = label_map_util.load_labelmap(label_file) categories = label_map_util.convert_label_map_to_categories( label_map, max_num_classes=20, use_display_name=True) category_index = label_map_util.create_category_index(categories) return category_index
def detect_in_video(): detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') 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) with detection_graph.as_default(): with tf.Session(graph=detection_graph) as sess: 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') videogen = skvideo.io.vreader('myVideo.mkv') frames = list(videogen) for i, frame in enumerate(frames[:500]): if i % 100 == 0: print(f'{i}/{len(frames)}') 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}) 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=2, min_score_thresh=.20) frames2.append(frame) if cv2.waitKey(1) & 0xFF == ord('q'): break skvideo.io.vwrite("outputVideoX.mkv", frames2) print('Complete!')
def detect_in_video(): # VideoWriter is the responsible of creating a copy of the video # used for the detections but with the detections overlays. Keep in # mind the frame size has to be the same as original video. #fourcc = cv2.VideoWriter_fourcc(*'XVID') #out = cv2.VideoWriter('gun.mp4', cv2.VideoWriter_fourcc('m', 'p', '4', 'v'), 250, (1280, 720)) out = cv2.VideoWriter('gun7.avi', cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 30, (1280, 720)) #Load a (frozen) Tensorflow model into memory. detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') #Loading label map 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) 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') #cv2.VideoCapture (): 0 is the default camera of the computer, 1 can change the source. #for example: direct access to surveillance cameras cap = cv2.VideoCapture( 'C:\\Users\\28771\\models\\research\\object_detection\\test_images1\\video7.mp4' ) while (cap.isOpened()): # Read the frame and capture frame-by-frame ret, frame = cap.read() # Recolor the frame. By default, OpenCV uses BGR color space. detect_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) image_np_expanded = np.expand_dims(detect_frame, 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. # note: perform the detections using a higher threshold vis_util.visualize_boxes_and_labels_on_image_array( detect_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=.20) #cv2.imshow('detect_output', detect_frame) output_rgb = cv2.cvtColor(detect_frame, cv2.COLOR_RGB2BGR) cv2.imshow('detect_output', output_rgb) out.write(output_rgb) #The number in waitKey(1) represents the invalid time before waiting for the key input. #The unit is milliseconds. During this time period, the key 'q' will not be recorded. #In other words, after the invalid time, it is detected whether the key 'q' is pressed in the time period of the last image display. #If not, it will jump out of the if statement and capture and display the next frame of image. #The return value of cv2.waitkey (1) is more than 8 bits, but only the last 8 bits are actually valid. # To avoid interference, the remaining position is 0 through the '&' operation if cv2.waitKey(1) & 0xFF == ord('q'): break #when everything done , release the capture out.release() cap.release()
else: print('Coco Model Already Exists!!!') detection_graph = tf.Graph() #load the graph with detection_graph.as_default(): od_graph_def = tf.compat.v1.GraphDef() #define the graph with tf.io.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() # read the graph od_graph_def.ParseFromString(serialized_graph) #formating of the data tf.import_graph_def(od_graph_def, name='') label_map = label_map_util.load_labelmap(PATH_TO_LABELS) #load the labels categories = label_map_util.convert_label_map_to_categories( label_map, max_num_classes=NUM_CLASSES, use_display_name=True) #divide labels in different classes categories_index = label_map_util.create_category_index( categories) #give the index to the category ################### MODULE 2 ############################ def load_image_into_numpy_array( image): #load the image and convert the image data into numpy array (im_width, im_height) = image.size return np.array(image.getdata()).reshape( (im_height, im_width, 3)).astype(np.uint8) PATH_TO_TEST_IMAGES_DIR = 'C:/Users/it/PycharmProjects/objectdetection-master/objectdetection-master/object_recognition_detection/object_recognition_detection/test_images/' #load images for testing TEST_IMAGE_PATH = [ os.path.join(PATH_TO_TEST_IMAGES_DIR, 'image{}.jpg'.format(i)) for i in range(1, 10)
def camara(): tamanoMax = 768 movimiento = False count = 0 #file = tkinter.filedialog.askopenfilename(defaultextension="*.avi", title="Control: diropenbox",initialdir="C:/Users/DANI/Desktop/object_recognition_detection",parent=None) cam = cv2.VideoCapture(1) if (cam.isOpened() == False): print("ERROR: Camara no operativa") cam = cv2.VideoCapture(0) if (cam.isOpened() == False): exit(-1) # Error acceso a la camara # Llamada al método fgbg = cv2.createBackgroundSubtractorKNN(history=500, dist2Threshold=400, detectShadows=False) # Deshabilitamos OpenCL, si no hacemos esto no funciona cv2.ocl.setUseOpenCL(False) contadorMovimiento = 0 ret = True #cargarTensorflow() # # Model preparation # Any model exported using the `export_inference_graph.py` tool can be loaded here simply by changing `PATH_TO_CKPT` to point to a new .pb file. # By default we use an "SSD with Mobilenet" model here. See the [detection model zoo](https://github.com/tensorflow/models/blob/master/object_detection/g3doc/detection_model_zoo.md) for a list of other models that can be run out-of-the-box with varying speeds and accuracies. # What model to download. MODEL_NAME = 'ssd_mobilenet_v1_coco_11_06_2017' MODEL_FILE = MODEL_NAME + '.tar.gz' DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/' # Path to frozen detection graph. This is the actual model that is used for the object detection. PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb' # List of the strings that is used to add correct label for each box. PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt') NUM_CLASSES = 90 # ## Download Model if not os.path.exists(MODEL_NAME + '/frozen_inference_graph.pb'): print('Downloading the model') opener = urllib.request.URLopener() opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE) tar_file = tarfile.open(MODEL_FILE) for file in tar_file.getmembers(): file_name = os.path.basename(file.name) if 'frozen_inference_graph.pb' in file_name: tar_file.extract(file, os.getcwd()) print('Download complete') else: print('Model already exists') # ## Load a (frozen) Tensorflow model into memory. detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: # aqui le da el modelo de datos serialized_graph = fid.read() # lee od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') # ## Loading label map # Label maps map indices to category names, so that when our convolution network predicts `5`, we know that this corresponds to `airplane`. Here we use internal utility functions, but anything that returns a dictionary mapping integers to appropriate string labels would be fine 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) # estaba true category_index = label_map_util.create_category_index(categories) fourcc = cv2.VideoWriter_fourcc(*'XVID') out = cv2.VideoWriter( "GRABACIONES/" + time.strftime("%d_%m_%y_%H%M%S") + '.avi', fourcc, 20.0, (640, 480)) #out1=cv2.VideoWriter("GRABACIONES/"+"contorno_"+time.strftime("%d_%m_%y_%H%M%S")+'.avi', fourcc, 20.0, (640, 480)) logging.basicConfig( level=logging.DEBUG, format='%(asctime)s : %(levelname)s : %(message)s', filename=("GRABACIONES/" + "Indicencias_" + time.strftime("%d_%m_%y_%H%M%S") + '.log'), filemode='w', ) logging.debug('REGISTRO DE INCIDENCIAS.') instanteInicial = time.time() instanteFinal = time.time() with detection_graph.as_default(): with tf.Session(graph=detection_graph) as sess: while True: ret, frame = cam.read() contornosimg = frame if ret == True: movimiento = False frame = cv2.resize(frame, (640, 480)) contornosimg = cv2.resize(contornosimg, (640, 480)) # IMPORTADO TUTORIAL MOVIMIENTO # Aplicamos el algoritmo fgmask = fgbg.apply(frame) # Copiamos el umbral para detectar los contornos contornosimg = fgmask.copy() # Buscamos contorno en la imagen im, contornos, hierarchy = cv2.findContours( contornosimg, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # Recorremos todos los contornos encontrados for c in contornos: # Eliminamos los contornos más pequeños if cv2.contourArea(c) < 500: continue else: movimiento = True # Obtenemos el bounds del contorno, el rectángulo mayor que engloba al contorno (x, y, w, h) = cv2.boundingRect(c) # Dibujamos el rectángulo del bounds cv2.rectangle(contornosimg, (x, y), (x + w, y + h), (0, 255, 0), 2) #image_np = cv2.resize(image_np, (640, 480)) print(movimiento) if count > 3: if ret == True: # frame = cv2.flip(frame,0) contadorMovimiento = 1 timestamp = datetime.datetime.now() ts = timestamp.strftime("%d %B %Y %I:%M:%S%p") cv2.rectangle(frame, (2, 220), (185, 235), (0, 0, 0), -1) cv2.putText(frame, ts, (5, 230), cv2.FONT_ITALIC, 0.35, (255, 111, 255)) detectarObjetos(frame, detection_graph, category_index, sess) print("grabando") for x in range(20): out.write(frame) #out1.write(contornosimg) #cv2.imshow("ventana", frame) #else: #movimiento=False if movimiento == True: count += 1 print("mov") instanteInicial = time.time() if count % 15 == 0: print("movimiento a la hora " + time.strftime("%y_%m_%d_%H%M%S")) nombre = "namepattern-" + time.strftime( "%y-%m-%d- %H:%M:%S") + ".jpg" else: count = 0 instanteFinal = time.time() tiempo = instanteFinal - instanteInicial # Devuelve un objeto timedelta print(tiempo) if (tiempo > 2): #cuando vuelva a haber movimiento empezara un nuevo video #out = cv2.VideoWriter("GRABACIONES/"+time.strftime("%d_%m_%y_%H%M%S") + '.avi', fourcc, 20.0, (640, 480)) instanteInicial = instanteFinal contadorMovimiento = 0 else: if (contadorMovimiento == 1): print("grabando") #detectarObjetos(frame, detection_graph, category_index,sess) timestamp = datetime.datetime.now() ts = timestamp.strftime("%d %B %Y %I:%M:%S%p") cv2.rectangle(frame, (2, 220), (185, 235), (0, 0, 0), -1) cv2.putText(frame, ts, (5, 230), cv2.FONT_ITALIC, 0.35, (255, 111, 255)) out.write(frame) #out1.write(contornosimg) #cv2.imshow("ventana",frame) movimiento = False print("camara")
def main(): print("starting program . . .") if not checkIfNecessaryPathsAndFilesExist(): return # end if # this next comment line is necessary to avoid a false PyCharm warning # noinspection PyUnresolvedReferences if StrictVersion(tf.__version__) < StrictVersion('1.5.0'): raise ImportError('Please upgrade your tensorflow installation to v1.5.* or later!') # end if # load a (frozen) TensorFlow model into memory detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(FROZEN_INFERENCE_GRAPH_LOC, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') # end with # end with # Loading label map # Label maps map indices to category names, so that when our convolution network predicts `5`, we know that this corresponds to `airplane`. Here we use internal utility functions, but anything that returns a dictionary mapping integers to appropriate string labels would be fine label_map = label_map_util.load_labelmap(LABELS_LOC) 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) imageFilePaths = [] for imageFileName in os.listdir(TEST_IMAGE_DIR): if imageFileName.endswith(".jpg"): imageFilePaths.append(TEST_IMAGE_DIR + "/" + imageFileName) # end if # end for with detection_graph.as_default(): with tf.Session(graph=detection_graph) as sess: for image_path in imageFilePaths: print(image_path) image_np = cv2.imread(image_path) if image_np is None: print("error reading file " + image_path) continue # end if # 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') # 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=8) cv2.imshow("image_np", image_np) cv2.waitKey()
def main(image_url): # Path to frozen detection graph. This is the actual model that is used for the object detection. # PATH_TO_CKPT = 'trainedModels/ssd_mobilenet_RoadDamageDetector.pb' PATH_TO_CKPT = 'model/sim.pb' # List of the strings that is used to add correct label for each box. # PATH_TO_LABELS = 'trainedModels/crack_label_map.pbtxt' PATH_TO_LABELS = 'model/sim.pbtxt' NUM_CLASSES = 8 detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') 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_SIZE = (12, 8) 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_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 = Image.open(image_url) # the array based representation of the image will be used later in order to prepare the # result image with boxes and labels on it. image_np = load_image_into_numpy_array(image) # 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, min_score_thresh=0.2, use_normalized_coordinates=True, line_thickness=8) plt.figure(figsize=IMAGE_SIZE) plt.imshow(image_np) count = 0 print(scores) print(classes) for score in range(scores[0].shape[0]): if (scores[0][score] > 0.2): print('s:', scores[0][score], 'damage: ', classes[0][score]) count += 1 name = image_url.split('/')[2].split('.')[0] name = name + '_predicted.png' plt.savefig('media/images/' + name) return (name, count)
def dealVideo(): global size q.empty() ''' 检测视频中的目标 ''' cap = cv2.VideoCapture( '/Users/hongyanma/gitspace/python/python/data/1.avi') # 打开摄像头 size = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)), int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))) #fourcc = cv2.VideoWriter_fourcc(*'DIVX') #fps = cap.get(cv2.CAP_PROP_FPS) #videoWriter = cv2.VideoWriter('/Users/hongyanma/gitspace/python/python/data/output.mp4', fourcc, fps, size) ##################### Download Model # What model to download. ''' MODEL_NAME = 'ssd_inception_v2_coco_11_06_2017' MODEL_NAME = 'rfcn_resnet101_coco_11_06_2017' MODEL_NAME = 'faster_rcnn_resnet101_coco_11_06_2017' MODEL_NAME = 'faster_rcnn_inception_resnet_v2_atrous_coco_11_06_2017' ''' # MODEL_NAME = 'ssd_mobilenet_v1_coco_2017_11_17' # MODEL_NAME = 'ssd_resnet' MODEL_NAME = 'ssd_mobilenet_v1_coco_2018_01_28' MODEL_FILE = MODEL_NAME + '.tar.gz' DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/' # Path to frozen detection graph. This is the actual model that is used for the object detection. PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb' # List of the strings that is used to add correct label for each box. PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt') NUM_CLASSES = 90 # Download model if not already downloaded if not os.path.exists(PATH_TO_CKPT): print('Downloading model... (This may take over 5 minutes)') opener = urllib.request.URLopener() opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE) print('Extracting...') tar_file = tarfile.open(MODEL_FILE) for file in tar_file.getmembers(): file_name = os.path.basename(file.name) if 'frozen_inference_graph.pb' in file_name: tar_file.extract(file, os.getcwd()) else: print('Model already downloaded.') ##################### Load a (frozen) Tensorflow model into memory. print('Loading model...') detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') ##################### Loading label map print('Loading label map...') 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) print('Detecting...') #test # path = '/Users/hongyanma/gitspace/python/python/data/test.mp4' # with open(path, 'rb') as fmp3: # data = fmp3.read(1024) # while data: # data = fmp3.read(1024) # q.put(data) #test image_container = {} #cv2.namedWindow('Image') with detection_graph.as_default(): with tf.Session(graph=detection_graph) as sess: while True: ret, image_np = cap.read() # 从摄像头中获取每一帧图像 #print('aaa') #def generate(): #data = bytes(image_np) #yield data #q.put(data) #print('sss') image_np_expanded = np.expand_dims(image_np, axis=0) image_tensor = detection_graph.get_tensor_by_name( 'image_tensor:0') boxes = detection_graph.get_tensor_by_name('detection_boxes:0') 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. if not ret: print('end of video !! ret flag') break if not image_np_expanded.size: print('end of video !!') break try: (boxes, scores, classes, num_detections) = sess.run( [boxes, scores, classes, num_detections], feed_dict={image_tensor: image_np_expanded}) except: print('error!!!') break extractData(image_np, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, image_container) 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) q.put(image_np) # data = bytes(image_np) # yield data #videoWriter.write(image_np) global video_end_flag video_end_flag = True cap.release()
def api_detection_view(request): detection = Detection.objects.all() if request.method == 'POST': serializer = DetectionSerializers MODEL_NAME = 'inference_graph' IMAGE_NAME = 'P10.jpg' CWD_PATH = os.getcwd() PATH_TO_CKPT = os.path.join(CWD_PATH, MODEL_NAME, 'frozen_inference_graph.pb') PATH_TO_LABELS = os.path.join(CWD_PATH, 'training', 'labelmap.pbtxt') PATH_TO_IMAGE = os.path.join(CWD_PATH, IMAGE_NAME) NUM_CLASSES = 3 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) detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') sess = tf.Session(graph=detection_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') image = cv2.imread(PATH_TO_IMAGE) image_expanded = np.expand_dims(image, axis=0) (boxes, scores, classes, num) = sess.run([ detection_boxes, detection_scores, detection_classes, num_detections ], feed_dict={image_tensor: image_expanded}) vis_util.visualize_boxes_and_labels_on_image_array( image, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=8, min_score_thresh=0.60) cv2.imshow('Object detector', image) cv2.waitKey(0) cv2.destroyAllWindows() serializer.save() return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def _load_label_map(self): label_map = label_map_util.load_labelmap(self.PATH_TO_LABELS) categories = label_map_util.convert_label_map_to_categories( label_map, max_num_classes=self.NUM_CLASSES, use_display_name=True) category_index = label_map_util.create_category_index(categories) return category_index
def objectDetectionCap(): import cv2 import numpy as np import os import six.moves.urllib as urllib import sys import tarfile import tensorflow as tf import zipfile from collections import defaultdict from io import StringIO from matplotlib import pyplot as plt from PIL import Image # This is needed since the notebook is stored in the object_detection folder. #cwd = os.getcwd() #os.chdir('../lib') #sys.path.append("..") os.chdir('../lib') from object_detection.utils import ops as utils_ops if tf.__version__ < '1.4.0': raise ImportError('Please upgrade your tensorflow installation to v1.4.* or later!') # ## Env setup # This is needed to display the images. get_ipython().magic('matplotlib inline') # ## Object detection imports # Here are the imports from the object detection module. os.chdir('../lib/object_detection') from utils import label_map_util from utils import visualization_utils as vis_util # # Model preparation # ## Variables # # Any model exported using the `export_inference_graph.py` tool can be loaded here simply by changing `PATH_TO_CKPT` to point to a new .pb file. # # By default we use an "SSD with Mobilenet" model here. See the [detection model zoo](https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/detection_model_zoo.md) for a list of other models that can be run out-of-the-box with varying speeds and accuracies. # What model to download. MODEL_NAME = 'ssd_mobilenet_v1_coco_2017_11_17' MODEL_FILE = MODEL_NAME + '.tar.gz' DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/' # Path to frozen detection graph. This is the actual model that is used for the object detection. PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb' # List of the strings that is used to add correct label for each box. PATH_TO_LABELS = os.path.join('data', 'mscoco_label_map.pbtxt') NUM_CLASSES = 90 # ## Download Model # opener = urllib.request.URLopener() # opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE) # tar_file = tarfile.open(MODEL_FILE) # for file in tar_file.getmembers(): # file_name = os.path.basename(file.name) # if 'frozen_inference_graph.pb' in file_name: # tar_file.extract(file, os.getcwd()) # ## Load a (frozen) Tensorflow model into memory. detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') # ## Loading label map # Label maps map indices to category names, so that when our convolution network predicts `5`, we know that this corresponds to `airplane`. Here we use internal utility functions, but anything that returns a dictionary mapping integers to appropriate string labels would be fine 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) cap = cv2.VideoCapture(0) with detection_graph.as_default(): with tf.Session(graph=detection_graph) as sess: ret = True while (ret): ret,image_np = cap.read() image_np_expanded = np.expand_dims(image_np, axis=0) image_tensor = detection_graph.get_tensor_by_name('image_tensor:0') boxes = detection_graph.get_tensor_by_name('detection_boxes:0') 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') (boxes, scores, classes, num_detections) = sess.run( [boxes, scores, classes, num_detections], feed_dict={image_tensor: image_np_expanded}) 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('image', cv2.resize(image_np,(1280,800))) if cv2.waitKey(25) & 0xFF == ord('q'): cv2.destroyAllWindows() cap.release() break os.chdir('../../doc')
def main(): # detection result folder detection_folder = '/media/yujiang/Data/Seedling/Experiments/counting_results_rgb/Final_model' # video folder video_folder = '/media/yujiang/Data/Seedling/Datasets/TestVideos' # folder for saving counted videos saving_folder = '/media/yujiang/Data/Seedling/Experiments/counting_videos_rgb/Final_model' # label map PATH_TO_LABELS = '/media/yujiang/Data/Seedling/Datasets/TFrecords/pascal_label_map.pbtxt' NUM_CLASSES = 2 # DO NOT change this, the number of classess identified by the detection model # Create label map 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) video_prefix_config_dict = { 'TAMU_2015': { 'iou_th':0.1, 'tracking_lifetime_th':9, 'is_transpose': False, 'resize_fx':0.5, 'resize_fy':0.5, 'output_fps':5.0, 'is_display':True}, 'UGA_2015': { 'iou_th':0.1, 'tracking_lifetime_th':15, 'is_transpose': False, 'resize_fx':0.5, 'resize_fy':0.5, 'output_fps':5.0, 'is_display':True}, 'UGA_2018': { 'iou_th':0.1, 'tracking_lifetime_th':9, 'is_transpose': True, 'resize_fx':0.5, 'resize_fy':0.5, 'output_fps':5.0, 'is_display':True}} # Output video codec fourcc_codec = cv2.VideoWriter_fourcc('M', 'J', 'P', 'G') for video_prefix, counting_config in video_prefix_config_dict.items(): # tracking and counting parameters is_transpose = counting_config['is_transpose'] iou_th = counting_config['iou_th'] tracking_lifetime_th = counting_config['tracking_lifetime_th'] resize_fx = counting_config['resize_fx'] resize_fy = counting_config['resize_fy'] output_fps = counting_config['output_fps'] is_display = counting_config['is_display'] # get testing videos with the video prefix video_list = os.listdir(video_folder) video_list = [f for f in video_list if f.startswith(video_prefix) and f.endswith('.mp4')] for video_file in video_list: video_name = video_file.split('.')[0] detection_file_path = osp.join(detection_folder, '{0}_detection.json'.format(video_name)) video_file_path = osp.join(video_folder, video_file) output_video_filepath = osp.join(saving_folder, '{0}.avi'.format(video_file[:-4])) # tracking list seedling_id_list = list() seedling_lifetime = dict() # load detection results with open(detection_file_path,'r') as fid: jstr = json.load(fid) res_list = json.loads(jstr) # load video for rendering tracking result cap = cv2.VideoCapture(video_file_path) frame_num = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) # generate output video writer fr_width = cap.get(cv2.CAP_PROP_FRAME_WIDTH) fr_height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT) if is_transpose: vd_writer = cv2.VideoWriter(output_video_filepath, fourcc_codec, output_fps, (int(fr_height*resize_fy), int(fr_width*resize_fx))) else: vd_writer = cv2.VideoWriter(output_video_filepath, fourcc_codec, output_fps, (int(fr_width*resize_fx), int(fr_height*resize_fy))) # initialize the Kalman filter based tracking algorithm mot_tracker = sort.Sort(iou_th=iou_th) # process individual frames for i in range(frame_num-1): ret, frame = cap.read() frame = cv2.resize(frame,None,fx=resize_fx, fy=resize_fy, interpolation = cv2.INTER_CUBIC) image_np = frame if is_transpose: image_np = image_np.transpose((1,0,2)) # load detection result for the current frame detection_res = res_list[i] frame_bbox = detection_res['bbox'] frame_bbox_array = np.array(frame_bbox, dtype=np.float32) frame_cls = detection_res['box_cls'] frame_cls = np.array([int(i) for i in frame_cls]) frame_scores = np.asarray(detection_res['box_scores']).reshape((-1,1)) if len(frame_bbox_array) != 0: dets = np.concatenate((frame_bbox_array, frame_scores), axis=1) else: dets = np.array([]) # update trackers trackers = mot_tracker.update(dets) # update tracker names frame_bbox_array_new = trackers[:,0:4] frame_cls_new = list() category_index_new = dict() for d_index, d in enumerate(trackers[:, 4]): if d not in seedling_id_list: seedling_id_list.append(d) # max_cls_id = len(seedling_id_list) cur_d = seedling_id_list.index(d)+1 if cur_d not in list(seedling_lifetime.keys()): seedling_lifetime[cur_d] = list() seedling_lifetime[cur_d].append(i) frame_cls_new.append(cur_d) category_index_new[cur_d] = {'id':d_index, 'name':'Plant'+str(cur_d)} # Visualization of the results of a detection. vis_util.visualize_boxes_and_labels_on_image_array( image_np, frame_bbox_array_new, frame_cls_new, frame_scores, category_index_new, # previously use 'category_index' use_normalized_coordinates=True, line_thickness=2) # write to the output video vd_writer.write(image_np) # if is_display is True: cv2.imshow('video_window',image_np) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() vd_writer.release() cv2.destroyAllWindows() print('Processed the video {0} and saved as {1}.\n'.format( video_file_path, output_video_filepath))
def main(): print("starting program . . .") if not checkIfNecessaryPathsAndFilesExist(): return # end if classifications = [] # for each line in the label file . . . for currentLine in tf.gfile.GFile(RETRAINED_LABELS_TXT_FILE_LOC): # remove the carriage return classification = currentLine.rstrip() # and append to the list classifications.append(classification) # this next comment line is necessary to avoid a false PyCharm warning # noinspection PyUnresolvedReferences if StrictVersion(tf.__version__) < StrictVersion('1.5.0'): raise ImportError( 'Please upgrade your tensorflow installation to v1.5.* or later!') # end if # load a (frozen) TensorFlow model into memory detection_graph = tf.Graph() with detection_graph.as_default(): with tf.gfile.GFile(FROZEN_INFERENCE_GRAPH_LOC, 'rb') as fid: od_graph_def = tf.GraphDef() serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') # end with # end with classification_graph = tf.Graph() with classification_graph.as_default(): with tf.gfile.FastGFile(RETRAINED_GRAPH_PB_FILE_LOC, 'rb') as retrainedGraphFile: # instantiate a GraphDef object graphDef = tf.GraphDef() # read in retrained graph into the GraphDef object graphDef.ParseFromString(retrainedGraphFile.read()) # import the graph into the current default Graph, note that we don't need to be concerned with the return value tf.import_graph_def(graphDef, name='') # end with # Loading label map # Label maps map indices to category names, so that when our convolution network predicts `5`, we know that this corresponds to `airplane`. Here we use internal utility functions, but anything that returns a dictionary mapping integers to appropriate string labels would be fine label_map = label_map_util.load_labelmap(LABELS_LOC) 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) with tf.Session(graph=detection_graph) as sessd: with tf.Session(graph=classification_graph) as sessc: for imageFileName in os.listdir(TEST_IMAGE_DIR): if not imageFileName.endswith(".jpg"): continue image_path = TEST_IMAGE_DIR + "/" + imageFileName print(image_path) image_np = cv2.imread(image_path) if image_np is None: print("error reading file " + image_path) continue # end if # 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') # Expanded 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) = sessd.run([ detection_boxes, detection_scores, detection_classes, num_detections ], feed_dict={image_tensor: image_np_expanded}) # Visualization of the results of a detection. img_height, img_width, img_channel = image_np.shape THRESHOLD = 0.4 #print(scores[0]) i = 0 while scores[0][i] >= THRESHOLD and i <= 99: ymin, xmin, ymax, xmax = boxes[0][i] x_up = int(xmin * img_width) y_up = int(ymin * img_height) x_down = int(xmax * img_width) y_down = int(ymax * img_height) cropped_image = image_np[y_up:y_down, x_up:x_down] detected_ocr = OCR.ocr(cropped_image) # get the final tensor from the graph finalTensor = sessc.graph.get_tensor_by_name( 'final_result:0') # convert the OpenCV image (numpy array) to a TensorFlow image tfImage = np.array(cropped_image)[:, :, 0:3] # run the network to get the predictions predictions = sessc.run(finalTensor, {'DecodeJpeg:0': tfImage}) # sort predictions from most confidence to least confidence sortedPredictions = predictions[0].argsort( )[-len(predictions[0]):][::-1] prediction = sortedPredictions[0] strClassification = classifications[prediction] if strClassification.endswith("s"): strClassification = strClassification[:-1] confidence = predictions[0][prediction] scoreAsAPercent = confidence * 100.0 label = strClassification + ", " + "{0:.2f}".format( scoreAsAPercent) cv2.putText(image_np, label, (int(x_up), int(y_down)), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 0, 0), 1) #cv2.putText(image_np, detected_ocr, (int((x_down+x_up)/2), int(y_up), cv2.FONT_HERSHEY_SIMPLEX,0.8, (255, 0, 0),1) i = i + 1 #cropped_image_path = os.getcwd() + "/detected_number_plates/" + imageFileName[:-4] + str(i) + ".jpg" #cv2.imwrite(cropped_image_path, cropped_image) 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=3) # cv2.imshow("image_np", image_np) # while cv2.waitKey() != 32: # pass cv2.imwrite(results_dir + imageFileName, image_np)
def main(_): print(time.ctime()) host, port = FLAGS.server.split(':') channel = implementations.insecure_channel(host, int(port)) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) # Send request IMAGE_NAME = '/home/rice/tensorflow1/models/research/object_detection/test_image/' TEST_IMAGE_PATHS = glob.glob(os.path.join(IMAGE_NAME, '*.*')) for image_path in TEST_IMAGE_PATHS: print(image_path) image = Image.open(image_path) # the array based representation of the image will be used later in order to prepare the # result image with boxes and labels on it. image_np = load_image_into_numpy_array(image) image_np_expanded = np.expand_dims(image_np, axis=0) print(image_np_expanded.shape) request = predict_pb2.PredictRequest() request.model_spec.name = 'saved_model' request.model_spec.signature_name = 'serving_default' # request.inputs['inputs'].CopyFrom( # tf.contrib.util.make_tensor_proto(image_np_expanded,shape=[1])) # print(time.ctime()) # request.inputs['inputs'].CopyFrom( # make_tensor_proto(image_np_expanded) # ) # dims = [tensor_shape_pb2.TensorShapeProto.Dim(size=1)] # tensor_shape_proto = tensor_shape_pb2.TensorShapeProto(dim=dims) tensor_proto = tensor_pb2.TensorProto( dtype=types_pb2.DT_UINT8, tensor_shape=tensor_shape.as_shape(image_np_expanded.shape).as_proto(), # string_val=[open(image_path, 'rb').read()] ) tensor_proto.tensor_content = image_np_expanded.tostring() request.inputs['inputs'].CopyFrom(tensor_proto) print(time.ctime()) start = time.time() result = stub.Predict(request, 100.0) # 10 secs timeout #print(result) print(time.time() - start) boxes = (result.outputs['detection_boxes'].float_val) classes = (result.outputs['detection_classes'].float_val) scores = (result.outputs['detection_scores'].float_val) box_np_arr = array([boxes[x:x + 4] for x in range(0, len(boxes), 4)]) class_np_arr = array([classes[x:x + 1] for x in range(0, len(classes), 1)]) score_np_arr = array([scores[x:x + 1] for x in range(0, len(scores), 1)]) # print(type(box_np_arr),len(box_np_arr)) # print(type(class_np_arr),len(classes)) # print(type(class_np_arr),len(scores)) # print(result) label_map = label_map_util.load_labelmap(PATH_TO_LABELS) categories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=14, use_display_name=True) category_index = label_map_util.create_category_index(categories) image_vis,result_box = vis_util.visualize_boxes_and_labels_on_image_array( image_np, np.squeeze(box_np_arr), np.squeeze(class_np_arr).astype(np.int32), np.squeeze(score_np_arr), category_index, use_normalized_coordinates=True, line_thickness=8, min_score_thresh=0.80) # Save inference to disk scipy.misc.imsave('%s.jpg' % (image), image_vis) for box,label_score in result_box.items(): print(label_score,',',box) break
# coding: utf-8 from __future__ import print_function import numpy as np import os # import six.moves.urllib as urllib import sys # import tarfile import tensorflow as tf # import zipfile # from collections import defaultdict # from io import StringIO # import matplotlib # matplotlib.use('TkAgg') # from matplotlib import pyplot as plt # from PIL import Image from utils import label_map_util from utils import visualization_utils as vis_util from utils import ops as utils_ops # This is needed since the notebook is stored in the object_detection folder. sys.path.append("..") if tf.__version__ < '1.4.0': raise ImportError('Please upgrade your tensorflow installation to v1.4.* or later!') # ## Variables # # Any model exported using the `export_inference_graph.py` tool can be loaded here simply by changing `PATH_TO_CKPT` to point to a new .pb file.
def apicall(): if request.method == 'POST': path = './Image' # Initialize dlib's face detector (HOG-based) and then create # The facial landmark predictor detector = dlib.get_frontal_face_detector() predictor = dlib.shape_predictor( "./models/object_detection/shape_predictor_68_face_landmarks.dat") # Image info img_file = request.files['pic'] img_name = img_file.filename img_file.save(os.path.join(app.config['UPLOAD_FOLDER'], img_name)) frame = cv2.imread(os.path.join(app.config['UPLOAD_FOLDER'], img_name)) frame1 = frame image = imutils.resize(frame, width=500) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) rects = detector(gray, 1) # Loop over the face detections for (i, rect) in enumerate(rects): shape = predictor(gray, rect) shape = face_utils.shape_to_np(shape) for (name, (i, j)) in face_utils.FACIAL_LANDMARKS_IDXS.items(): clone = image.copy() cv2.putText(clone, name, (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2) for (x, y) in shape[i:j]: cv2.circle(clone, (x, y), 1, (0, 0, 255), -1) (x, y, w, h) = cv2.boundingRect(np.array([shape[i:j]])) roi = image[y:y + h, x:x + w] roi = imutils.resize(roi, width=250, inter=cv2.INTER_CUBIC) if (name == "right_eye" or name == "left_eye" or name == "nose" or name == "mouth"): cv2.imwrite(os.path.join(path, name + ".jpg"), roi) # Custom model for under eye object detection trained using tensorflow implementation of faster-rcnn based on inception-v2 PATH_TO_CKPT = "./object_detection/inference_graph/frozen_inference_graph.pb" # Path to label map file PATH_TO_LABELS = "./object_detection/training/labelmap.pbtxt" # Number of classes the object detector can identify NUM_CLASSES = 1 # Load the label map. # Label maps map indices to category names, so that when our convolution # network predicts `5`, we know that this corresponds to `king`. # Here we use internal utility functions, but anything that returns a # dictionary mapping integers to appropriate string labels would be fine 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) # Load the Tensorflow model into memory. detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') sess = tf.Session(graph=detection_graph) # Define input and output tensors (i.e. data) for the object detection classifier # Input tensor is the image image_tensor = detection_graph.get_tensor_by_name('image_tensor:0') # Output tensors are the detection boxes, scores, and classes # 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 represents level of confidence for each of the objects. # The 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') # Number of objects detected num_detections = detection_graph.get_tensor_by_name('num_detections:0') # Load image using OpenCV and # expand image dimensions to have shape: [1, None, None, 3] # i.e. a single-column array, where each item in the column has the pixel RGB value image = cv2.imread(os.path.join(app.config['UPLOAD_FOLDER'], img_name)) image_expanded = np.expand_dims(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: image_expanded}) # Draw the results of the detection (aka 'visulaize the results') vis_util.visualize_boxes_and_labels_on_image_array( image, 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.60) # initialize the total number of frames that *consecutively* contain # santa along with threshold required to trigger the santa alarm TOTAL_CONSEC = 0 TOTAL_THRESH = 20 # initialize is the santa alarm has been triggered #SANTA = False print("[INFO] loading model...") frame = cv2.imread(os.path.join(path, "right_eye.jpg")) right_eye_img = "righteye" + img_name cv2.imwrite(os.path.join("./static", right_eye_img), frame) frame = imutils.resize(frame, width=400) # prepare the image to be classified by our deep learning network image = cv2.resize(frame, (75, 75)) image = np.float32(image / 255) image = img_to_array(image) image = np.expand_dims(image, axis=0) with graph.as_default(): right_eye = model_eye.predict(image)[0][0] frame = cv2.imread(os.path.join(path, "left_eye.jpg")) left_eye_img = "lefteye" + img_name cv2.imwrite(os.path.join("./static", left_eye_img), frame) frame = imutils.resize(frame, width=400) # prepare the image to be classified by our deep learning network image = cv2.resize(frame, (75, 75)) image = np.float32(image / 255) image = img_to_array(image) image = np.expand_dims(image, axis=0) with graph.as_default(): left_eye = model_eye.predict(image)[0][0] frame = cv2.imread(os.path.join(path, "nose.jpg")) nose_img = "nose" + img_name cv2.imwrite(os.path.join("./static", nose_img), frame) frame = imutils.resize(frame, width=400) # Prepare the image to be classified by our deep learning network image = cv2.resize(frame, (50, 50)) image = np.float32(image / 255) image = img_to_array(image) image = np.expand_dims(image, axis=0) with graph.as_default(): nose = model_nose.predict(image)[0][0] frame = cv2.imread(os.path.join(path, "mouth.jpg")) mouth_img = "mouth" + img_name cv2.imwrite(os.path.join("./static", mouth_img), frame) frame = imutils.resize(frame, width=400) # prepare the image to be classified by our deep learning network image = cv2.resize(frame, (50, 50)) image = np.float32(image / 255) image = img_to_array(image) image = np.expand_dims(image, axis=0) with graph.as_default(): mouth = model_mouth.predict(image)[0][0] frame = cv2.imread(os.path.join(path, "undereye1.jpg")) left_undereye_img = "leftundereye" + img_name cv2.imwrite(os.path.join("./static", left_undereye_img), frame) frame = imutils.resize(frame, width=400) # prepare the image to be classified by our deep learning network image = cv2.resize(frame, (50, 50)) image = np.float32(image / 255) image = img_to_array(image) image = np.expand_dims(image, axis=0) with graph.as_default(): undereye1 = model_undereye.predict(image)[0][0] frame = cv2.imread(os.path.join(path, "undereye2.jpg")) right_undereye_img = "rightundereye" + img_name cv2.imwrite(os.path.join("./static", right_undereye_img), frame) frame = imutils.resize(frame, width=400) # prepare the image to be classified by our deep learning network image = cv2.resize(frame, (50, 50)) image = np.float32(image / 255) image = img_to_array(image) image = np.expand_dims(image, axis=0) with graph.as_default(): undereye2 = model_undereye.predict(image)[0][0] frame = cv2.imread(os.path.join(path, img_name)) skin_img = "skin" + img_name cv2.imwrite(os.path.join("./static", skin_img), frame) frame = imutils.resize(frame, width=400) # prepare the image to be classified by our deep learning network image = cv2.resize(frame, (100, 100)) image = np.float32(image / 255) image = img_to_array(image) image = np.expand_dims(image, axis=0) with graph.as_default(): face = model_face.predict(image)[0][0] final_prediction = (((left_eye + right_eye) / 2) * 0.4) + (( (undereye1 + undereye2) / 2) * 0.55) + (( (nose + mouth + face) / 3) * 0.05) label = 'Final Prediction' label = "{}: {:.5f}%".format(label, final_prediction * 100) frame_final = cv2.putText(frame1, label, (10, 25), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2) cv2.imwrite(os.path.join("./static", img_name), frame_final) os.remove(os.path.join(app.config['UPLOAD_FOLDER'], img_name)) print("Right Eye: " + str(right_eye) + "\n" + "Left Eye: " + str(left_eye) + "\n" + "Nose: " + str(nose) + "\n" + "Mouth: " + str(mouth) + "\n" + "Undereye Left: " + str(undereye1) + "\n" + "Undereye Right: " + str(undereye2) + "\n" + "Face: " + str(face) + "\n" + "Final Prediction: " + str(final_prediction)) return render_template('./templates/result_final.html', right_eyep=right_eye, left_eyep=left_eye, nosep=nose, mouthp=mouth, undereye1p=undereye1, undereye2p=undereye2, facep=face, final=final_prediction, user_image=img_name, right_eye_imgp=right_eye_img, left_eye_imgp=left_eye_img, nose_imgp=nose_img, mouth_imgp=mouth_img, right_undereye_imgp=right_undereye_img, left_undereye_imgp=left_undereye_img, face_imgp=skin_img)
def execute(path): cred = credentials.Certificate( "C:/tensorflow1/models/research/object_detection/firebase/schoolai-firebase-adminsdk-78lrk-064b6e6416.json" ) firebase_admin.initialize_app( cred, {'databaseURL': 'https://schoolai.firebaseio.com'}) print(path) print(datetime.now()) MODEL_NAME = 'inference_graph' CWD_PATH = os.getcwd() PATH_TO_CKPT = os.path.join(CWD_PATH, MODEL_NAME, 'frozen_inference_graph.pb') PATH_TO_LABELS = os.path.join(CWD_PATH, 'training', 'labelmap.pbtxt') NUM_CLASSES = 2 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) detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') sess = tf.Session(graph=detection_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') ref = db.reference('KATHIR/CAM1') video = cv2.VideoCapture(path) video.set(cv2.CAP_PROP_FRAME_WIDTH, 160) video.set(cv2.CAP_PROP_FRAME_HEIGHT, 120) x = 0 while (video.isOpened()): x = x + 1 ret, frame = video.read() if (ret == True and x == 1): x = 0 frame_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: frame_expanded}) 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=0.30) now = datetime.now() ims = cv2.resize(frame, (960, 540)) cv2.imshow(path, ims) if (scores[0, 0] > 0.65): curdate = str(datetime.now()).split(" ") hrmin = curdate[1].split(":") users_ref = ref.child(curdate[0] + '/' + hrmin[0] + ':' + hrmin[1]) users_ref.set({'Flag': 1}) if cv2.waitKey(1) == ord('q'): video.release() cv2.destroyAllWindows()
def detect_in_video(): # VideoWriter is the responsible of creating a copy of the video # used for the detections but with the detections overlays. Keep in # mind the frame size has to be the same as original video. out = cv2.VideoWriter('../testing/test_output.avi', cv2.VideoWriter_fourcc( 'M', 'J', 'P', 'G'), 24, (412, 224)) detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') 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) 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') cap = cv2.VideoCapture('../testing/test_input.mp4') while(cap.isOpened()): # Read the frame ret, frame = cap.read() if ret == True: # Recolor the frame. By default, OpenCV uses BGR color space. # This short blog post explains this better: # https://www.learnopencv.com/why-does-opencv-use-bgr-color-format/ color_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) image_np_expanded = np.expand_dims(color_frame, 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. # note: perform the detections using a higher threshold vis_util.visualize_boxes_and_labels_on_image_array( color_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=.20) cv2.imshow('frame', color_frame) output_rgb = cv2.cvtColor(color_frame, cv2.COLOR_RGB2BGR) out.write(output_rgb) if cv2.waitKey(1) & 0xFF == ord('q'): break else: break out.release() cap.release() cv2.destroyAllWindows()
def foo(imgin, imgout): #%matplotlib inline sys.path.append("..") MODEL_NAME = 'carrotBeanGraph' # Path to frozen detection graph. This is the actual model that is used for the object detection. PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb' # List of the strings that is used to add correct label for each box. PATH_TO_LABELS = os.path.join('training', 'object-detection.pbtxt') # Modify this as you add classes NUM_CLASSES = 2 # Loads the frozen model into memory detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') # Loads the label map 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) # Numpy helper code def load_image_into_numpy_array(image): (im_width, im_height) = image.size return np.array(image.getdata()).reshape( (im_height, im_width, 3)).astype(np.uint8) # If you want to test the code with your images, just add path to the images to the TEST_IMAGE_PATHS. PATH_TO_TEST_IMAGES_DIR = 'test_images' # Only doing one image at a time, so change this. # TEST_IMAGE_PATHS = [ os.path.join(PATH_TO_TEST_IMAGES_DIR, 'image{}.jpg'.format(i)) for i in range(3, 8) ] # Size, in inches, of the output images. IMAGE_SIZE = (12, 8) # Algorithm to create Tensors, detect the objects, and output an image file with mappings. 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') # Don't want a for-loop in final version #for image_path in TEST_IMAGE_PATHS: image = Image.open( imgin) #change later so raw image file, rather than file path # the array based representation of the image will be used later in order to prepare the # result image with boxes and labels on it. image_np = load_image_into_numpy_array(image) # 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=8) plt.figure(figsize=IMAGE_SIZE) #plt.imshow(image_np) plt.imsave(imgout, image_np)
# Path to label map file PATH_TO_LABELS = ( 'F:/tensorflow/models/research/object_detection/training/label_map.pbtxt') # Number of classes the object detector can identify NUM_CLASSES = 6 ## Load the label map. # Label maps map indices to category names, so that when our convolution # network predicts `5`, we know that this corresponds to `king`. # Here we use internal utility functions, but anything that returns a # dictionary mapping integers to appropriate string labels would be fine 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) # Load the Tensorflow model into memory. detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') sess = tf.Session(graph=detection_graph) # Define input and output tensors (i.e. data) for the object detection classifier # Input tensor is the image
def cocomain(input_speed): initial_car_acceleration = 800 if not os.path.exists(MODEL_NAME + '/frozen_inference_graph.pb'): print ('Downloading the model') opener = urllib.request.URLopener() opener.retrieve(DOWNLOAD_BASE + MODEL_FILE, MODEL_FILE) tar_file = tarfile.open(MODEL_FILE) for file in tar_file.getmembers(): file_name = os.path.basename(file.name) if 'frozen_inference_graph.pb' in file_name: tar_file.extract(file, os.getcwd()) print('Download complete') else: print('Model already exists') # ## Load a (frozen) Tensorflow model into memory. detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') # Loading label map: # Label maps map indices to category names, so that when our convolution # network predicts `5`, we know that this corresponds to `airplane`. Here # we use internal utility functions, but anything that returns a dictionary # mapping integers to appropriate string labels would be fine 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) # Intializing the web camera device: 0 for internal and 1 for external camera # of the laptop used cap = cv2.VideoCapture(0) # Running the tensorflow session with detection_graph.as_default(): with tf.Session(graph=detection_graph) as sess: ret = True while (ret): ret,image_np = cap.read() #print(image_np) # 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_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) classes_detected = classes[scores>0.5] if 13 in classes_detected: #print('detected') car3.changeSpeed(0, initial_car_acceleration) car2.changeSpeed(0, initial_car_acceleration) #car3.changeLaneRight(250, 250) car3.setLocationChangeCallback(locationChangeCallback) #print(car3.piece) elif 10 in classes_detected: print('verkeerslicht detected') #print('detected') car3.changeSpeed(0, initial_car_acceleration) car2.changeSpeed(0, initial_car_acceleration) #car3.changeLaneRight(250, 250) car3.setLocationChangeCallback(locationChangeCallback) """ elif 1 in classes_detected: print('car detected') car3.changeSpeed(int(initial_car_speed/2), initial_car_acceleration) car2.changeSpeed(int(initial_car_speed/2), initial_car_acceleration) car3.setLocationChangeCallback(locationChangeCallback) """ else: car3.changeSpeed(input_speed, initial_car_acceleration) car2.changeSpeed(input_speed, initial_car_acceleration) car3.setLocationChangeCallback(locationChangeCallback) #print(car3.piece) #drive(cv2) #print(image_np,boxes,classes,scores,category_index) #plt.figure(figsize=IMAGE_SIZE) #plt.imshow(image_np) cv2.imshow('image',cv2.resize(image_np,(1280,960))) if cv2.waitKey(25) & 0xFF == ord('q'): cv2.destroyAllWindows() cap.release() break
def main(): print("starting program . . .") if not checkIfNecessaryPathsAndFilesExist(): return # end if # now that we've checked for the protoc compile, import the TensorFlow models repo utils content from utils import label_map_util from utils import visualization_utils as vis_util # if TensorFlow version is too old, show error message and bail # this next comment line is necessary to avoid a false warning if using the editor PyCharm # noinspection PyUnresolvedReferences if StrictVersion(tf.__version__) < StrictVersion('1.5.0'): print('error: Please upgrade your tensorflow installation to v1.5.* or later!') return # end if # if the frozen inference graph file does not already exist, download the model tar file and unzip it try: if not os.path.exists(FROZEN_INFERENCE_GRAPH_LOC): # if the model tar file has not already been downloaded, download it if not os.path.exists(os.path.join(MODEL_SAVE_DIR_LOC, MODEL_FILE_NAME)): # download the model print("downloading model . . .") # instantiate a URLopener object, then download the file opener = urllib.request.URLopener() opener.retrieve(DOWNLOAD_MODEL_FROM_LOC + MODEL_FILE_NAME, os.path.join(MODEL_SAVE_DIR_LOC, MODEL_FILE_NAME)) # end if # unzip the tar to get the frozen inference graph print("unzipping model . . .") tar_file = tarfile.open(os.path.join(MODEL_SAVE_DIR_LOC, MODEL_FILE_NAME)) for file in tar_file.getmembers(): file_name = os.path.basename(file.name) if 'frozen_inference_graph.pb' in file_name: tar_file.extract(file, MODEL_SAVE_DIR_LOC) # end if # end for # end if except Exception as e: print("error downloading or unzipping model: " + str(e)) return # end try # if the frozen inference graph does not exist after the above, show an error message and bail if not os.path.exists(FROZEN_INFERENCE_GRAPH_LOC): print("unable to get / create the frozen inference graph") return # end if # load the frozen model into memory print("loading frozen model into memory . . .") detection_graph = tf.Graph() try: with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(FROZEN_INFERENCE_GRAPH_LOC, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') # end with # end with except Exception as e: print("error loading the frozen model into memory: " + str(e)) return # end try # load the label map print("loading label map . . .") label_map = label_map_util.load_labelmap(LABEL_MAP_LOC) 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) print("starting object detection . . .") with detection_graph.as_default(): with tf.Session(graph=detection_graph) as sess: for fileName in os.listdir(TEST_IMAGES_DIR): if fileName.endswith(".jpg"): image_np = cv2.imread(os.path.join(TEST_IMAGES_DIR, fileName)) if image_np is not None: # 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') # 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=8) cv2.imshow("result", image_np) cv2.waitKey()
def load_labels(labels_path, num_classes): label_map = label_map_util.load_labelmap(labels_path) 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) return category_index
from utils import visualization_utils as vis_util detection_graph=tf.Graph() with detection_graph.as_default(): od_graph_def=tf.GraphDef() with tf.gfile.GFile(path_to_ckpt,'rb') as fid: serialized_graph=fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def,name='') 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) def load_image(): ret, frame = cap.read() array = frame array=array.astype(np.uint8) return array test_image_path=[os.path.join('/home/nvidia/data/projects/tensorflow-object-detection-api/models/research/object_detection/test_images','image{}.jpg'.format(i)) for i in range(1,2)] show_size=(12,8) i = 0 with detection_graph.as_default(): with tf.Session(graph=detection_graph) as sess:
def detection(): 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) # Load the Tensorflow model into memory. detection_graph = tf.Graph() with detection_graph.as_default(): od_graph_def = tf.GraphDef() with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid: serialized_graph = fid.read() od_graph_def.ParseFromString(serialized_graph) tf.import_graph_def(od_graph_def, name='') sess = tf.Session(graph=detection_graph) # Define input and output tensors (i.e. data) for the object detection classifier # Input tensor is the image image_tensor = detection_graph.get_tensor_by_name('image_tensor:0') # Output tensors are the detection boxes, scores, and classes # 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 represents level of confidence for each of the objects. # The 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') # Number of objects detected num_detections = detection_graph.get_tensor_by_name('num_detections:0') # Load image using OpenCV and # expand image dimensions to have shape: [1, None, None, 3] # i.e. a single-column array, where each item in the column has the pixel RGB value image = cv2.imread(PATH_TO_IMAGE) image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) image_expanded = np.expand_dims(image_rgb, 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: image_expanded}) # Draw the results of the detection (aka 'visulaize the results') vis_util.visualize_boxes_and_labels_on_image_array( image, np.squeeze(boxes), np.squeeze(classes).astype(np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=8, min_score_thresh=0.70) coordinates = vis_util.return_coordinates(image, np.squeeze(boxes), np.squeeze(classes).astype( np.int32), np.squeeze(scores), category_index, use_normalized_coordinates=True, line_thickness=8, min_score_thresh=0.70) for coordinate in coordinates: print(coordinate) #ymin,ymax,xmin,xmax (y1, y2, x1, x2, accuracy, classification) = coordinate with open(os.path.join( CWD_PATH, "json_hand/" + "script" + IMAGE_NAME.split(".")[0] + ".json"), "w", encoding='utf-8') as f: json.dump(coordinates, f, ensure_ascii=False, indent=4) f.write('\n') output = image.copy() cv2.imshow('Object detector', output) # Press any key to close the image cv2.waitKey(0) # Clean up cv2.destroyAllWindows()