def img_de(IMAGE_NAME,MODEL_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(MODEL_NAME,'frozen_inference_graph.pb')
# Path to label map file
PATH_TO_LABELS = os.path.join(CWD_PATH,'training','object-detection.pbtxt')
# Path to image
PATH_TO_IMAGE = os.path.join(CWD_PATH,IMAGE_NAME)
# Number of classes the object detector can identify
NUM_CLASSES = 5
# 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(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})
# 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)
# All the results have been drawn on image. Now display the image.
cv2.imshow('Object detector', image)
# Press any key to close the image
cv2.waitKey(0)
# Clean up
cv2.destroyAllWindows()
import matplotlib.pyplot as plt
from utils import visualization_utils as vis_util
from utils import label_map_util
from multiprocessing.dummy import Pool as ThreadPool
MAX_NUMBER_OF_BOXES = 10
MINIMUM_CONFIDENCE = 0.9
PATH_TO_LABELS = 'annotations/label_map.pbtxt'
PATH_TO_TEST_IMAGES_DIR = 'test_images'
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(
label_map, max_num_classes=sys.maxsize, use_display_name=True)
CATEGORY_INDEX = label_map_util.create_category_index(categories)
# Path to frozen detection graph. This is the actual model that is used for the object detection.
MODEL_NAME = 'output_inference_graph'
PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb'
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)
def detect_objects(image_path):
image = Image.open(image_path)
def slika(image):
def load_image_into_numpy_array(image1):
(im_width, im_height) = image1.size
return np.array(image1.getdata()).reshape(
(im_height, im_width, 3)).astype(np.uint8)
sys.path.append("..")
PATH_TO_CKPT = 'inference_graph/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', 'labelmap')
NUM_CLASSES = 2
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')
slika = Image.open(image)
image_np = load_image_into_numpy_array(slika)
# 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, # True
line_thickness=4,
min_score_thresh=0.8,
agnostic_mode=False)
image_return = Image.fromarray(image_np)
image_return.save("mysite/image_return2.jpg")
return image_return
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 Object_Classification(image):
# This is needed since the notebook is stored in the object_detection folder.
sys.path.append("..")
# Import utilites
from utils import label_map_util
# Name of the directory containing the object detection module we're using
MODEL_NAME = 'inference_graph'
IMAGE_NAME = 'test6.jpg'
# 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 = 4
# 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_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})
animals = [0, 0, 0, 0]
lengthc = np.size(classes)
lengths = np.size(scores)
if lengthc == lengths:
for i in range(lengths):
if scores[0, i] > .7:
if classes[0, i] == 1:
animals[0] += 1
elif classes[0, i] == 2:
animals[1] += 1
elif classes[0, i] == 3:
animals[2] += 1
elif classes[0, i] == 4:
animals[3] += 1
else:
break
return animals
def RunObjectRecognitionModel():
pathToCheck = os.path.join(os.getcwd(), Model().ModelName, Model().Graph)
if not os.path.exists(pathToCheck):
print("Downloading Model...please wait...")
Model().Download()
GraphPath = Model().GetCKPT_Path()
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(GraphPath, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
LabelsPath = Model().GetLabelsPath()
label_map = label_map_util.load_labelmap(LabelsPath)
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)
TEST_IMAGE_PATHS = _LoadImages()
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')
return_dict = {}
for image_n, image_path in enumerate(_LoadImages()):
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)
# 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})
img_number, avg_score, angle = FindDetectedObjects(
category_index, np.squeeze(boxes), np.squeeze(classes),
np.squeeze(scores), image_path, 'person')
if avg_score > 0.0 or avg_score != 0:
return_dict[img_number] = {"Score": avg_score, "Angle": angle}
else:
pass
# Visualization of the results of a detection.
# vis_util.visualize_boxes_and_labels_on_image_array(
# image_np,
# np.squeeze(boxes),
# np.squeeze(classes).astype(np.int32),
# np.squeeze(scores),
# category_index,
# use_normalized_coordinates=True,
# line_thickness=4)
# plt.imshow(image_np)
# plt.show()
print(return_dict)
return return_dict
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()
cv2.imwrite("image_np.jpg", 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
def process_image(image):
#Retain the initial image before ssd bounding boxes are drawn.
#create a deep copy
imgo = copy.deepcopy(image)
# 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
#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)
# 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')
with detection_graph.as_default():
with tf.Session(graph=detection_graph) as sess:
# Expand dimensions since the model expects images to have shape: [1, None, None, 3]
image_np_expanded = np.expand_dims(image, 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.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores),
category_index,
use_normalized_coordinates=True,
line_thickness=8)
#print("Tensorflow image process: boxes: {}".format(boxes))
#print("scores: {}".format(scores))
#print("classes: {}".format(classes))
#print("num: {}".format(num))
#plt.imshow(image)
#plt.show()
##from my code in Udacity CapstoneProject for traffic light color classification########
#initialize all variables
yellowLight = False
redLight = False
greenLight = False
yellowImg = image
redImg = image
greenImg = image
result = image
#The size of one traffic light is about 50 in x direction,125 in y direction
#The center of the image is:
x = image.shape[1]/2
y = image.shape[0]/2
tl_loc = traffic_light_location(boxes, scores, classes, image.shape)
#print(tl_loc)
# No traffic lights found, look in Bernards original location.
if len(tl_loc) == 0:
tl_loc = 0 #print("No Lights found by NN!")
else:
###################green color detection##########
# define range of green color in HSV
lower_green = np.array([60,125,125]) #100,100])
upper_green = np.array([120,255,255])
[clr_ID, greenImg] = get_light_color(image, imgo, tl_loc, lower_green, upper_green)
if (clr_ID == "GREEN"):
greenLight = True
##################red color detection#################
# define range of red color in HSV
lower_red = np.array([170,125,125])
upper_red = np.array([179,255,255])
[clr_ID, redImg] = get_light_color(image, imgo, tl_loc, lower_red, upper_red)
if (clr_ID == "RED"):
redLight = True
###########yellow traffic light detection###########
# define range of orange color in HSV
lower_yellow = np.array([5,150,150])
upper_yellow = np.array([15,255,255]) #real amber traffic light works 15,255,255])
[clr_ID, yellowImg] = get_light_color(image, imgo, tl_loc, lower_yellow, upper_yellow)
if (clr_ID == "YELLOW"):
yellowLight = True
if ((yellowLight == True) and (redLight == False)
and (greenLight == False)):
clr_ID = "YELLOW"
result = yellowImg
elif ((yellowLight == False) and (redLight == True)
and (yellowLight == False)):
clr_ID = "RED"
result = redImg
elif ((yellowLight == False) and (redLight == False)
and (greenLight == True)):
clr_ID = "GREEN"
result = greenImg
else:
clr_ID = "UNKNOWN"
result = image
#plt.imshow(result)
#plt.show()
#print("Traffic Light color_ID: {}".format(clr_ID))
return result
def load_models():
# load models 시작시간
code_start = time.time()
config = tf.compat.v1.ConfigProto()
config.gpu_options.allow_growth = True
session = tf.compat.v1.Session(config=config)
# Name of the directory containing the object detection module we're using
MODEL_NAME = 'models'
LABELMAP_NAME = 'labelmap'
# 결과 출력(cv.imwrite)해서 확인하려면 output 경로 수정
# output_dir = "test_images_output\\"
# Grab path to current working directory
CWD_PATH = os.getcwd()
model_list = os.listdir(CWD_PATH + "\\" + MODEL_NAME)
labelmap_list = os.listdir(CWD_PATH + "\\" + LABELMAP_NAME)
# =========================================================================
# model 에 따라서 바뀌는 값들 배열
sess = {}
detection_graph = {}
categories = {}
category_index = {}
i = 0
# 모델 불러오는 부분 => 반복 (여러 모델 불러오기)
for model, labelmap in zip(model_list, labelmap_list):
# print(str(len(model_list))+"개 중에 "+str(i+1)+"번째 모델 불러오는 중")
# print(model+", "+labelmap)
# 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, model)
# print("model_path : "+PATH_TO_CKPT)
# Path to label map file
PATH_TO_LABELS = os.path.join(CWD_PATH, LABELMAP_NAME, labelmap)
# print("label_path : "+PATH_TO_LABELS)
# Number of classes the object detector can identify
# max_num_classes 를 지정해주는 값
# 최대 라벨 개수로 지정해주면 될 것 같음
# label class 개수보다 작은 값이 들어가면 N/A 라고 나옴
NUM_CLASSES = 2
# Load the label map.
# Label maps map indices to category names
# 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[i] = label_map_util.convert_label_map_to_categories(
label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
category_index[i] = label_map_util.create_category_index(categories[i])
# print(category_index[i])
# Load the Tensorflow model into memory.
# Tensorflow 모델을 메모리에 로드
# detection_graph 배열로 만들어서 이름 바꿔주면서 image 넣기
detection_graph[i] = tf.Graph()
with detection_graph[i].as_default():
od_graph_def = tf.compat.v1.GraphDef()
with tf.io.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
# print(PATH_TO_CKPT)
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
sess[i] = tf.Session(graph=detection_graph[i])
i = i + 1
# print("모델 불러오는데 걸리는 시간 : "+str(round(time.time() - code_start,5)))
# ==========================================================================
return sess, detection_graph, category_index
# The path to the current directory
CURRENT_DIR = os.getcwd()
# The path to the Frozen Inference Graph
FIG_DIR = os.path.join(CURRENT_DIR, FIG_MODEL_FOLDERNAME, FIG_FILENAME)
# The path to the Labelmap
LABELMAP_DIR = os.path.join(CURRENT_DIR, LABELMAP_FOLDERNAME,
LABELMAP_FILENAME)
# The path to the Video file
VIDEO_DIR = os.path.join(CURRENT_DIR, VIDEO_NAME)
# Load the labelmap to convert ID numbers the model uses into usable category names
labelmap = lmu.load_labelmap(LABELMAP_DIR)
categories = lmu.convert_label_map_to_categories(
labelmap, max_num_classes=NUMBER_OF_CLASSES, use_display_name=True)
cat_index = lmu.create_category_index(categories)
print("Loaded directories, starting to load Tensorflow Model")
# Load the Tensorflow model
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(FIG_DIR, '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)
def main(argv=None):
os.environ['CUDA_VISIBLE_DEVICES'] = FLAGS.gpu_list
try:
os.makedirs(FLAGS.output_dir)
except OSError as e:
if e.errno != 17:
raise
MODEL_NAME = FLAGS.checkpoint_path
PATH_TO_CKPT = MODEL_NAME + '/frozen_inference_graph.pb'
print(FLAGS.test_data_path, FLAGS.output_dir)
# List of the strings that is used to add correct label for each box.
PATH_TO_LABELS = os.path.join('data', 'oid_bbox_trainable_label_map.pbtxt')
NUM_CLASSES = 1000
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 a (frozen) Tensorflow model into memory.
# In[6]:
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='')
classes_detected = dict()
# In[26]:
with detection_graph.as_default():
with tf.Session() as sess:
# Get handles to input and output tensors
ops = tf.get_default_graph().get_operations()
all_tensor_names = {output.name for op in ops for output in op.outputs}
tensor_dict = {}
for key in [
'num_detections', 'detection_boxes', 'detection_scores',
'detection_classes', 'detection_masks'
]:
tensor_name = key + ':0'
if tensor_name in all_tensor_names:
tensor_dict[key] = tf.get_default_graph().get_tensor_by_name(
tensor_name)
image_tensor = tf.get_default_graph().get_tensor_by_name('image_tensor:0')
TEST_IMAGE_PATHS = get_images()
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.
start = time.time()
image = cv2.imread(image_path)
# Expand dimensions since the model expects images to have shape: [1, None, None, 3]
# Run inference
output_dict = sess.run(tensor_dict,
feed_dict={image_tensor: np.expand_dims(image, 0)})
# print('[Net timing] {}'.format(time.time()-start))
# start = time.time()
# all outputs are float32 numpy arrays, so convert types as appropriate
classes = output_dict[
'detection_classes'][0].astype(np.uint8)
boxes = output_dict['detection_boxes'][0]
scores = output_dict['detection_scores'][0]
output_list = []
for i in range(boxes.shape[0]):
if scores is None or scores[i] > 0.1:
if classes[i] in category_index.keys():
class_name = category_index[classes[i]]['name']
else:
class_name = 'N/A'
display_str = str(class_name)
# ymin, xmin, ymax, xmax = box
# box_coord = (left, right, top, bottom)
try:
classes_detected[display_str] += 1
except KeyError:
classes_detected[display_str] = 1
output_list.append(
str(classes[i]) + ',' + "{0:.2f}".format(scores[i]) + ',' + display_str + ':' + ','.join(
map(str, boxes[i])))
if len(output_list) > 0:
res_file = os.path.join(
FLAGS.output_dir,
'{}.txt'.format(
os.path.basename(image_path).split('.')[0]))
with open(res_file, 'w') as f:
f.write('\n'.join(output_list))
# print('[Writing timing] {}'.format(time.time() - start))
res_file = os.path.join(
FLAGS.output_dir,'{}.txt'.format('meta-classes'))
with open(res_file, 'w') as f:
for key, value in sorted(classes_detected.items()):
f.write(str(key) + ',' + str(value) + '\n')
def main(argv):
ops_shop_id=""
ops_gpu=0
#ops_date=""
try:
opts, args = getopt.getopt(argv,"hd:g:s:f:t",["interval=","gpu=","shop_id=","from=","to="])
except getopt.GetoptError:
print ('detection_8_off.py -d 2019-05-22 -g 0 -s 0 -f 0 -t 100')
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print ('detection_8_off.py -d 2019-05-22 -g 0 -s 0 -f 0 -t 100')
sys.exit()
elif opt in ("-d", "--date"):
ops_date = arg
elif opt in ("-g", "--gpu"):
ops_gpu = int(arg)
elif opt in ("-s", "--shop_id"):
ops_shop_id = int(arg)
elif opt in ("-f", "--from"):
ops_from = int(arg)
elif opt in ("-t", "--to"):
ops_from = int(arg)
#print ('Interval: ', ops_interval)
#print ('Gpu: ', ops_gpu)
os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID" # see issue #152
os.environ["CUDA_VISIBLE_DEVICES"]=str(ops_gpu)
#os.environ["CUDA_VISIBLE_DEVICES"]='XLA_GPU:0'
screenshots_path = "/home/alex/storage/shop_screens/video/"
processed_path = "/home/alex/storage/shop_screens/video/processed/"
save_images_path = "/home/alex/storage/rcimages/"
shop_names = ["Altuf","Avangard","Mar","Tag"]
NUM_CLASSES = 18
PATH_TO_CKPT = '../../inference_v7_12097/frozen_inference_graph.pb'
PATH_TO_LABELS = '../training/mscoco_label_map.pbtxt'
score_limit = 0.7
sizeMin = 10
sizeMax = 1090
font = cv2.FONT_HERSHEY_SIMPLEX
#with tf.device('/device:XLA_GPU:0'):
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)
file_date=filedate()
# ==== Temporary code
# query = "SELECT path FROM files where path<>'' ORDER BY path"
# cursor.execute(query)
# sql_answer=cursor.fetchall()
# # == prepare array
# files_from_sql=[]
# for record_current in sql_answer:
# files_from_sql.append(record_current[0])
# print("Recognized files array size: "+str(len(files_from_sql)))
with detection_graph.as_default():
with tf.Session(graph=detection_graph) as sess:
conn = pymssql.connect(server='10.2.4.25', user='******', password='******', database='shopEvents')
cursor = conn.cursor()
#step in every shop
#if (True):
#for shop_id in range(4):
#if ops_shop_id!="" and shop_id!=int(ops_shop_id):
# continue
#dtnow=datetime.datetime.now()
#today=dtnow.strftime("%Y-%m-%d_08-56")
#files = os.listdir(screenshots_path+shop_names[shop_id]+"/grabs/")
#images = list(filter(lambda x: today in x, files))
#if len(files)>0:
# send_to_telegram(chat,str(len(files))+" "+shop_names[shop_id]+" begin")
while (True):
detectedImagesCount = 0
query = "SELECT file_full_path,shop_id,file_name FROM files_to_process where gpu_id = "+str(ops_gpu)+" ORDER BY file_id"
cursor.execute(query)
sql_answer=cursor.fetchall()
# == prepare array
#files_from_sql=[]
#files=[]
#bar = progressbar.ProgressBar(maxval=len(sql_answer), widgets=[progressbar.Bar('=', '[', ']'), ' ', progressbar.Percentage()])
#bar.start()
###send_to_telegram(chat,"detection "+str(len(sql_answer))+" files started")
print("len(sql_answer)",len(sql_answer))
for record_current in sql_answer:
file_full_path = record_current[0]
shop_id = record_current[1]
#file_id = record_current[2]
file_name_sql = record_current[2]
# files_from_sql.append(record_current[0])
#print("Recognized files array size: "+str(len(files_from_sql)))
#print("file_full_path",file_full_path)
#files=files.sort()
#files = natsorted(files, alg=ns.PATH)
#print("Processing "+str(len(files))+" files of "+shop_names[shop_id])
#for file_id in range(len(files)):
#bar.update(file_id+1)
file_sql_query = ""
#file_full_path = screenshots_path+shop_names[shop_id]+"/grabs/"+files[file_id]
if not os.path.isfile(file_full_path):
#print(file_full_path)
#exit()
continue
#if os.stat(file_full_path).st_size==0:
#drop file
# os.remove(file_full_path)
#print(files[file_id],"removed as empty")
# continue
#if file_full_path.find(".jpg")==-1:
#print(files[file_id],"skipped as not jpg file")
# continue
#file_date.update(files[file_id])
file_date.update(file_name_sql)
# Temporary code
# if file_full_path in files_from_sql:
# file_full_path_new = processed_path+shop_names[shop_id]+"_"+files[file_id]
# os.rename(file_full_path,file_full_path_new)
# move_sql_query = "INSERT INTO files (path,date,shop_id) VALUES ('"+file_full_path_new+"','"+file_date.sqlFormat()+"',"+str(shop_id)+");"
# cursor.execute(move_sql_query)
# conn.commit()
# continue
# ============ print(shop_id,"recognizing:",files[file_id],file_id,"of",len(files))
#print(file_date.sqlFormat())
#print("y",file_date.year)
#print("date extracted from filename")
#exit()
image_np = cv2.imread(file_full_path)
#image_original = image_np
image_original = image_np.copy()
#image_original = copy.deepcopy(image_np)
#RECOGNIZE++
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})
final_score = np.squeeze(scores)
#get objects detected count
objectsDetectedCount = 0
score_summ = 0
npsboxes=np.squeeze(boxes)
imageheight, imagewidth = image_np.shape[:2]
for i in range(100):
current_class_id = np.squeeze(classes).astype(np.int32)[i]
current_class_name = category_index[current_class_id]['name']
if (scores is None or final_score[i] > score_limit) and "banknotes" in current_class_name:
rx1=int(npsboxes[i][1]*imagewidth) #1 xLeft
ry1=int(npsboxes[i][0]*imageheight) #0 yTop
rx2=int(npsboxes[i][3]*imagewidth) #3 xRight
ry2=int(npsboxes[i][2]*imageheight) #2 yBottom
xlen=rx2-rx1
ylen=ry2-ry1
if xlen>sizeMin and xlen<sizeMax and ylen>sizeMin and ylen<sizeMax:
#file_name = files[file_id].replace(".jpg","")
file_name = file_name_sql.replace(".jpg","")
file_name_all_boxes = file_name+"_all_boxes.jpg"
save_path_all_boxes = save_images_path+str(shop_id)+"/original/"+file_name_all_boxes
file_name_original = file_name+".jpg"
save_path_original = save_images_path+str(shop_id)+"/original/"+file_name_original
file_name_box = file_name+"_"+str(objectsDetectedCount)+".jpg"
save_path_box = save_images_path+str(shop_id)+"/boxed/"+file_name_box
#file_sql_query = file_sql_query + "INSERT INTO files (path,date,shop_id) VALUES ('"+save_path_original+"','"+file_date.sqlFormat()+"',"+str(shop_id)+");"
#file_sql_query = file_sql_query + "INSERT INTO files (path,date,shop_id) VALUES ('"+save_path_all_boxes+"','"+file_date.sqlFormat()+"',"+str(shop_id)+");"
file_sql_query = file_sql_query + "INSERT INTO files (path,date,shop_id) VALUES ('"+save_path_box+"','"+file_date.sqlFormat()+"',"+str(shop_id)+");"
query = "INSERT INTO events (eventDate,objectsCount,middleScore,FileName,shop_id,box_id,box_left,box_right,box_top,box_bottom,filename_original,filename_box,file_source_path) VALUES ('"+file_date.sqlFormat()+"',1,"+str(final_score[i])+",'"+file_name_all_boxes+"',"+str(shop_id)+","+str(objectsDetectedCount)+","+str(rx1)+","+str(rx2)+","+str(ry1)+","+str(ry2)+",'"+file_name_original+"','"+file_name_box+"','"+file_full_path+"')"
cursor.execute(query)
conn.commit()
score_summ = score_summ+final_score[i]
image_np_current_box = image_original.copy()
#object_description = str(round(final_score[i]*100))+"% "+current_class_name
object_description = str(round(final_score[i]*100))+"%"
fontScale = 0.5
lineType = 2
#boxes
cv2.rectangle(image_np_current_box, (rx1,ry1) , (rx2,ry2) , (255,0,0) , 2) #regular box
cv2.rectangle(image_np_current_box, (rx1,ry1+1) , (rx1+200,ry1-15) , (0,255,0) , -1) #text background
cv2.rectangle(image_np, (rx1,ry1) , (rx2,ry2) , (0,255,0) , 2) #regular box
cv2.rectangle(image_np, (rx1,ry1+1) , (rx1+200,ry1-15) , (0,255,0) , -1) #text background
cv2.putText(image_np_current_box, object_description, (rx1,ry1), cv2.FONT_HERSHEY_SIMPLEX, fontScale, (0,0,0), lineType)
cv2.putText(image_np, object_description, (rx1,ry1), cv2.FONT_HERSHEY_SIMPLEX, fontScale, (0,0,0), lineType)
#save ONE BOX
cv2.imwrite(save_path_box, image_np_current_box)
print("cv2.imwrite image_np_current_box:",save_path_box)
objectsDetectedCount+=1
if objectsDetectedCount>0:
score_summString = '%.2f'%(score_summ/objectsDetectedCount)#middle
score_summStringH = '%.2f'%(score_summ/objectsDetectedCount*100)#middle
else:
score_summString = "0"
score_summStringH = "0"
cv2.putText(image_np,str(objectsDetectedCount)+":"+score_summStringH+"%",(10,150), font, 1,(255,255,255),1,cv2.LINE_AA)
#RECOGNIZE--
if objectsDetectedCount>0:
#save ORIGINAL
#cv2.imwrite(save_path_original, image_original)
#save ALL BOXES
cv2.imwrite(save_path_all_boxes, image_np)
print("cv2.imwrite image_np:",save_path_all_boxes)
detectedImagesCount+=1
#file_sql_query = file_sql_query + "INSERT INTO files (path,date,shop_id) VALUES ('"+save_path_original+"','"+file_date.sqlFormat()+"',"+str(shop_id)+");"
file_sql_query = file_sql_query + "INSERT INTO files (path,date,shop_id) VALUES ('"+save_path_all_boxes+"','"+file_date.sqlFormat()+"',"+str(shop_id)+");"
#drop source file
#os.remove(file_full_path) # <============== move
#file_full_path_new = processed_path+shop_names[shop_id]+"_"+files[file_id]
file_full_path_new = processed_path+shop_names[shop_id]+"_"+file_name_sql
os.rename(file_full_path,file_full_path_new)
print("os.rename From:",file_full_path,"To:",file_full_path_new)
# == Save filename to sql
#move_sql_query = "INSERT INTO files (path,date,shop_id) VALUES ('"+file_full_path_new+"','"+file_date.sqlFormat()+"',"+str(shop_id)+");"
file_sql_query = file_sql_query + "INSERT INTO files (path,date,shop_id) VALUES ('"+file_full_path_new+"','"+file_date.sqlFormat()+"',"+str(shop_id)+");"
#cursor.execute(move_sql_query)
cursor.execute(file_sql_query)
conn.commit()
#remove record from file_to_process
file_to_process_query = "DELETE FROM files_to_process where file_full_path='"+file_full_path+"'"
cursor.execute(file_to_process_query)
conn.commit()
#bar.finish()
#send_to_telegram(chat,str(detectedImagesCount)+" detected by "+str(ops_gpu)+" gpu")
#file_to_process_query = "DELETE FROM files_to_process where gpu_id = "+str(ops_gpu)
#cursor.execute(file_to_process_query)
#conn.commit()
print("calculating sleep time..")
task_year = (datetime.datetime.now() + datetime.timedelta(days=1)).year
task_month = (datetime.datetime.now() + datetime.timedelta(days=1)).month
task_day = datetime.datetime.now().day
task_hour = 21
task_minute = 0
sleeptime = datetime.datetime(task_year, task_month, task_day, task_hour, task_minute)-datetime.datetime.now()
print(str(ops_gpu)+" gpu job complete. sleeping",sleeptime.seconds,"seconds")
#send_to_telegram(chat,str(detectedImagesCount)+" images detected. Exit")
Going to sleep for "+str(sleeptime.seconds)+" seconds")
time.sleep(sleeptime)
# Path to label map file
PATH_TO_LABELS = os.path.join(CWD_PATH, 'training', 'labelmap.pbtxt')
# Path to video
PATH_TO_VIDEO = os.path.join(CWD_PATH, VIDEO_NAME)
# Number of classes the object detector can identify
NUM_CLASSES = 3
# 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
def main(args):
count = 0
start = False
frame_processed = 0
num_frame = args.num_frame
num_transform = args.num_transform
subfolder = args.subfolder
save_dir = os.path.join(args.save_dir, subfolder)
if not os.path.isdir(save_dir):
os.mkdir(save_dir)
labelmap_dir = args.labelmap_dir
inference_graph_dir = args.inference_graph_dir
sequence = create_sequence()
label_map = label_map_util.load_labelmap(labelmap_dir)
categories = label_map_util.convert_label_map_to_categories(
label_map, max_num_classes=2, 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(inference_graph_dir, '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')
#Font for text
font = cv2.FONT_HERSHEY_SIMPLEX
# Initialize webcam feed
video = cv2.VideoCapture(0)
ret = video.set(3, WIDTH)
ret = video.set(4, HEIGHT)
xml_tree = ET.parse(args.xml_template)
while (True):
ret, frame = video.read()
key = cv2.waitKey(1)
# Press 'q' to quit
if key == ord('q'):
break
# Press 's' to start
elif key == ord('s'):
start = True
start_time = time.time()
if not start:
cv2.putText(frame, "Waiting", (20, 40), font, 1, (0, 255, 0), 2,
cv2.LINE_AA)
cv2.putText(frame, "Press s to start", (20, 70), font, 1,
(0, 255, 0), 2, cv2.LINE_AA)
cv2.imshow('Data collector', frame)
continue
count += 1
if count % num_frame == 0:
count = 0
frame_processed += 1
frames = np.array([frame for _ in range(num_transform)],
dtype=np.uint8)
frames = sequence(images=frames)
frames = np.vstack([frames, np.expand_dims(frame, axis=0)])
img_paths, xml_paths = get_names(save_dir, subfolder,
frame_processed,
num_transform + 1)
save_imgs(frames, img_paths)
frame_processed += num_transform + 1
(boxes, scores, classes,
num) = sess.run([
detection_boxes, detection_scores, detection_classes,
num_detections
],
feed_dict={image_tensor: frames})
for i in range(boxes.shape[0]):
box = filter_boxes(boxes[i], scores[i], classes[i],
CONFIDENCE_THRESHOLD, (HEIGHT, WIDTH))
if box.shape[0] == 0:
continue
get_and_save_xml(xml_tree, img_paths[i], box[0], xml_paths[i])
text = "{:.1f}s".format(time.time() - start_time)
cv2.putText(frame, text, (20, 40), font, 1, (0, 255, 0), 2,
cv2.LINE_AA)
cv2.imshow('Data collector', frame)
# Clean up
video.release()
cv2.destroyAllWindows()
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 create_kitti_labels(output_path, label_map_path, label_dir, calib_dir,
image_dir, graph_dir, examples):
grid_map_data_resolution = 0.1
grid_map_data_origin_idx = np.array([79, 35])
label_map = label_map_util.load_labelmap(label_map_path)
categories = label_map_util.convert_label_map_to_categories(
label_map, max_num_classes=8, use_display_name=True)
category_index = label_map_util.create_category_index(categories)
path_to_graph = graph_dir
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(path_to_graph, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
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_boxes_rot = detection_graph.get_tensor_by_name(
'detection_boxes_rot: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')
for idx, example in enumerate(examples):
label_calib_name = '%06d' % (int(example)) + '.txt'
path_label = os.path.join(label_dir, label_calib_name)
label_name = '%06d' % (idx) + '.txt'
output_label = os.path.join(output_path, 'label', label_name)
output_label_gt = os.path.join(output_path, 'label_gt',
label_name)
copyfile(path_label, output_label_gt)
path_calib = os.path.join(calib_dir, label_calib_name)
velo_to_cam = read_calib(path_calib, 6)
print(velo_to_cam)
P2 = read_calib(path_calib, 3)
R0_rect = read_calib(path_calib, 5)
trans_image = P2.dot(R0_rect)
image_to_velo = np.array([[0, -1, grid_map_data_origin_idx[0]],
[-1, 0, grid_map_data_origin_idx[1]],
[0, 0, 1]])
image_name = example + '_euclidean_merge.png'
image_path = os.path.join(image_dir, image_name)
image_name_ground = example + '_euclidean_height_ground.png'
image_path_ground = os.path.join(image_dir, image_name_ground)
image_name_height_max = example + '_euclidean_height_max.png'
image_path_height_max = os.path.join(image_dir,
image_name_height_max)
image_name_height_min = example + '_euclidean_height_min.png'
image_path_height_min = os.path.join(image_dir,
image_name_height_min)
image_name_height_norm_max = example + '_euclidean_height_norm_max.png'
image_path_height_norm_max = os.path.join(
image_dir, image_name_height_norm_max)
print('Image path', image_path)
image = cv2.imread(image_path)
image = image[:, :, [2, 1, 0]]
image_ground = cv2.imread(image_path_ground, 0)
image_height_max = cv2.imread(image_path_height_max, 0)
image_height_min = cv2.imread(image_path_height_min, 0)
image_height_norm_max = cv2.imread(image_path_height_norm_max,
0)
image_np_expanded = np.expand_dims(image, axis=0)
start_time = time.time()
(boxes, boxes_rot, scores, classes,
num) = sess.run([
detection_boxes, detection_boxes_rot, detection_scores,
detection_classes, num_detections
],
feed_dict={image_tensor: image_np_expanded})
print('Inference time:', time.time() - start_time)
boxes_rot_np = np.squeeze(boxes_rot)
boxes_np = np.squeeze(boxes)
scores_np = np.squeeze(scores)
classes_np = np.squeeze(classes)
vis_util.visualize_boxes_and_labels_on_image_array(
image,
np.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores),
category_index,
boxes_rot=np.squeeze(boxes_rot),
use_normalized_coordinates=True,
line_thickness=3)
test_image_name = 'image' + str(idx) + '.png'
test_image_path = os.path.join(output_path, test_image_name)
cv2.imwrite(test_image_path, image)
file_output = open(output_label, 'w')
for i in range(scores_np.shape[0]):
if scores_np[i] > .75:
object_class = category_index[int(
classes_np[i])]['name']
box = tuple(boxes_np[i])
y_min = box[0] * image.shape[0]
x_min = box[1] * image.shape[1]
y_max = box[2] * image.shape[0]
x_max = box[3] * image.shape[1]
box_rot = tuple(boxes_rot_np[i])
print('box_rot:', box_rot)
x_c = box_rot[0] * image.shape[1]
y_c = box_rot[1] * image.shape[0]
w_s = box_rot[2]
h_s = box_rot[3]
angle = box_rot[4]
angle_rad = angle * 3.141 / 180
vec_h_x = h_s * math.cos(angle_rad) / 2.0
vec_h_y = h_s * math.sin(angle_rad) / 2.0
vec_w_x = -w_s * math.sin(angle_rad) / 2.0
vec_w_y = w_s * math.cos(angle_rad) / 2.0
x1 = (x_c - vec_w_x - vec_h_x) * image.shape[1]
x2 = (x_c - vec_w_x + vec_h_x) * image.shape[1]
x3 = (x_c + vec_w_x + vec_h_x) * image.shape[1]
y1 = (y_c - vec_w_y - vec_h_y) * image.shape[0]
y2 = (y_c - vec_w_y + vec_h_y) * image.shape[0]
y3 = (y_c + vec_w_y + vec_h_y) * image.shape[0]
l = math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) *
(y2 - y1))
w = math.sqrt((x3 - x2) * (x3 - x2) + (y3 - y2) *
(y3 - y2))
image_ground_box = image_ground[
int(round(y_min)):int(round(y_max)),
int(round(x_min)):int(round(x_max))]
if (image_ground_box[image_ground_box < 255]
).size == 0:
continue
mean_ground = image_ground_box[
image_ground_box < 255].mean()
image_height_max_box = image_height_max[
int(round(y_min)):int(round(y_max)),
int(round(x_min)):int(round(x_max))]
if (image_height_max_box[image_height_max_box < 255]
).size == 0:
continue
height_max = image_height_max_box[
image_height_max_box < 255].min()
image_height_min_box = image_height_min[
int(round(y_min)):int(round(y_max)),
int(round(x_min)):int(round(x_max))]
if (image_height_min_box[image_height_min_box < 255]
).size == 0:
continue
height_min = image_height_min_box[
image_height_min_box < 255].max()
image_height_norm_max_box = image_height_norm_max[
int(round(y_min)):int(round(y_max)),
int(round(x_min)):int(round(x_max))]
if (image_height_norm_max_box[
image_height_min_box < 255]).size == 0:
continue
height_norm_max = image_height_norm_max_box[
image_height_min_box < 255].min()
object_length = (y_max -
y_min) * grid_map_data_resolution
object_width = (x_max -
x_min) * grid_map_data_resolution
object_length_rot = l * grid_map_data_resolution
object_width_rot = w * grid_map_data_resolution
object_height = -3 * height_norm_max / 255 + 3
if object_class == 'Car':
if object_height < 1.3 or object_height > 1.9:
object_height = 1.56
# if object_width < 1.4 or object_width > 1.8:
# object_width = 1.6
# if object_length < 3.2 or object_length > 4.7:
# object_length = 3.9
object_t_rot = np.array([
x_c * grid_map_data_resolution,
y_c * grid_map_data_resolution
])
object_t_velo_rot = image_to_velo.dot(
np.append(object_t_rot, 1))
object_t_velo_rot[2] = -2 * mean_ground / 255 - 0.75
object_t_cam_rot = velo_to_cam.dot(
np.append(object_t_velo_rot, 1))
print('object_t_cam_rot:', object_t_cam_rot)
#print('object_height', object_height)
#print('object_width_rot', object_width_rot)
#print('object_length_rot', object_length_rot)
#print('object_t_velo_rot', object_t_velo_rot)
#print('object_t_cam_rot', object_t_cam_rot)
#print('angle_rad', angle_rad)
#print('')
object_corners_rot = np.array(
[[
object_length_rot / 2, object_length_rot / 2,
-object_length_rot / 2, -object_length_rot / 2,
object_length_rot / 2, object_length_rot / 2,
-object_length_rot / 2, -object_length_rot / 2
],
[
0, 0, 0, 0, -object_height, -object_height,
-object_height, -object_height
],
[
object_width_rot / 2, -object_width_rot / 2,
-object_width_rot / 2, object_width_rot / 2,
object_width_rot / 2, -object_width_rot / 2,
-object_width_rot / 2, object_width_rot / 2
], [1, 1, 1, 1, 1, 1, 1, 1]])
#corners_to_cam = np.array([[1, 0, 0, object_t_cam_rot[0]],[0, 1, 0, object_t_cam_rot[1]]
# ,[0, 0 , 1, object_t_cam_rot[2]],[0, 0, 0, 1]])
corners_to_cam = np.array([[
math.cos(angle_rad), 0,
math.sin(angle_rad), object_t_cam_rot[0]
], [0, 1, 0, object_t_cam_rot[1]],
[
-math.sin(angle_rad), 0,
math.cos(angle_rad),
object_t_cam_rot[2]
], [0, 0, 0, 1]])
object_corners_cam = corners_to_cam.dot(
object_corners_rot)
object_corners_image = trans_image.dot(
object_corners_cam)
object_corners_image_2d = np.array([
object_corners_image[0] / object_corners_image[2],
object_corners_image[1] / object_corners_image[2]
])
write_labels(file_output, object_class,
object_corners_image_2d, object_height,
object_width_rot, object_length_rot,
object_t_cam_rot, angle_rad, scores_np[i])
def cardetect():
# This is needed since the notebook is stored in the object_detection folder.
sys.path.append("..")
# Import utilites
from utils import label_map_util
from utils import visualization_utils as vis_util
# Name of the directory containing the object detection module we're using
MODEL_NAME = 'inference_graph'
# 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')
# Number of classes the object detector can identify
NUM_CLASSES = 4
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')
link=(e1.get())
video = cv2.VideoCapture("http://"+link+":4747/video")
#video=cv2.VideoCapture("http://"+link+":8080/video")for using ipwebcam
ret = video.set(3,1280)
ret = video.set(4,720)
while(True):
# Acquire frame and expand frame 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
ret, frame = video.read()
frame_expanded = np.expand_dims(frame, axis=0)
# Perform the actual detection by running the model with the image as input
(boxes, scores, classes, num) = sess.run(
[detection_boxes, detection_scores, detection_classes, num_detections],
feed_dict={image_tensor: frame_expanded})
# Draw the results of the detection (aka 'visulaize the results')
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.60)
cv2.imshow('Object detector', frame)
if cv2.waitKey(1) == ord('q'):
break
# Clean up
video.release()
cv2.destroyAllWindows()
def load_labelmap(self):
print('> Loading label map')
label_map = label_map_util.load_labelmap(self.label_path)
categories = label_map_util.convert_label_map_to_categories(
label_map, max_num_classes=self.num_classes, use_display_name=True)
self.category_index = label_map_util.create_category_index(categories)
def __init__(self):
self.boxes = []
self.classes = []
self.scores = []
self.counter = 0
# Using OpenCV to capture from device 0. If you have trouble capturing
# from a webcam, comment the line below out and use a video file
# instead.
self.video = cv2.VideoCapture('guns.mp4')
# Name of the directory containing the object detection module we're using
MODEL_NAME = '../first_try_faster_rcnn_hackhacton'
# 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, '../config',
'oid_object_detection_label_map.pbtxt')
# Number of classes the object detector can identify
NUM_CLASSES = 4
# 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
self.label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
self.categories = label_map_util.convert_label_map_to_categories(
self.label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
self.category_index = label_map_util.create_category_index(
self.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='')
self.sess = tf.Session(graph=detection_graph)
# Define input and output tensors (i.e. data) for the object detection classifier
# Input tensor is the image
self.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
self.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.
self.detection_scores = detection_graph.get_tensor_by_name(
'detection_scores:0')
self.detection_classes = detection_graph.get_tensor_by_name(
'detection_classes:0')
# Number of objects detected
self.num_detections = detection_graph.get_tensor_by_name(
'num_detections:0')
self.gun_predictions_queue = Queue()
self.frames_for_face_recognition_queue = Queue()
self.remove_duplicates_process = Process(
target=remove_duplicates,
args=[
self.gun_predictions_queue,
[
'static/images/references/gun_ref.jpg',
'static/images/references/gun_ref2.jpg',
'static/images/references/gun_ref3.jpg',
'static/images/references/gun_ref4.jpg'
]
])
self.remove_duplicates_process.start()
self.faces_recoginition_process = Process(
target=face_recognition_event_loop,
args=[
self.frames_for_face_recognition_queue,
['static/images/references/face_ref.jpg']
])
self.faces_recoginition_process.start()
def load_labels(PATH_TO_LABELS, NUM_CLASSES):
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 detected_img_crop(datedir):
detect_im_dir = os.path.join(detect_path, datedir)
results_dir = os.path.join(imsave_path, datedir)
if not os.path.isdir(results_dir):
os.makedirs(results_dir)
for crop_file in os.listdir(detect_im_dir):
if crop_file[-3:] == 'jpg':
IMAGE_NAME = crop_file
# 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(detect_im_dir, IMAGE_NAME)
print('start image : ' + IMAGE_NAME)
# Number of classes the object detector can identify
NUM_CLASSES = 5
# 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(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})
fig = plt.figure()
max_boxes_to_draw = 5
min_score_thresh = .8
sq_boxes = np.squeeze(boxes)
resultImList = set()
for i in range(min(max_boxes_to_draw, sq_boxes.shape[0])):
if scores is not None and np.squeeze(
scores)[i] > min_score_thresh:
(ymin, xmin, ymax, xmax) = tuple(sq_boxes[i].tolist())
(im_height, im_width) = image.shape[:2]
(xminn, xmaxx, yminn,
ymaxx) = (xmin * im_width, xmax * im_width,
ymin * im_height, ymax * im_height)
crop_image = tf.image.crop_to_bounding_box(
image, np.int32(yminn), np.int32(xminn),
np.int32(ymaxx - yminn), np.int32(xmaxx - xminn))
sess = tf.Session()
img_data = sess.run(crop_image)
sess.close()
fig.add_subplot()
class_name = category_index[np.squeeze(classes).astype(
np.int32)[i]]['name']
print(class_name,
str(int(100 * np.squeeze(scores)[i])) + '%')
class_name = class_name[:-1] if class_name.endswith(
'_') else class_name
if class_name is not 'leg':
img_name = IMAGE_NAME[:
-4] + '_' + class_name + IMAGE_NAME[
-4:]
resultImList.add(img_name)
plt.imsave(os.path.join(results_dir, img_name),
cv2.cvtColor(img_data, cv2.COLOR_BGR2RGB))
resultImList = list(resultImList)
if len(resultImList) != 2:
for file in os.listdir(results_dir):
if os.path.isfile(os.path.join(results_dir,
file)) and file.startswith(
IMAGE_NAME[:-4]):
print('delete file = ', file)
os.remove(os.path.join(results_dir, file))
def dealVideo():
global size
# dir = '/Users/hongyanma/Downloads/trafficvideo'
# flvurl = getFlvUrl('sxjgl_sdsdgs_370000011011001001267', 'G2_K459%2B246_右东')
# dowloadVideo('fcd1f8027f524a059c59401ef6542b81', 'G1(京哈高速)天津段天昂公司K85%2B135遥控', dir)
# flvurl = getFlvUrl('fcd1f8027f524a059c59401ef6542b81', 'G1(京哈高速)天津段天昂公司K85%2B135遥控')
# flvurl = getFlvUrl('17c821b5-0dcd-40c8-aa86-bb92f0243392', '清河北出京出口广场(遥控)')
# print(flvurl)
# cap = cv2.VideoCapture('/Users/hongyanma/Downloads/trafficvideo/sxjgl_nhugs_320500011011001001063.flv') # 打开摄像头
# response = requests.get(flvurl, stream=True)
# for chunk in response.iter_content(chunk_size=1024):
# cap = cv2.VideoCapture(chunk)
# print(cv2.CAP_XINE)
# cap = cv2.VideoCapture('https://youku.com-qq.net/20190526/494_d6346149/1000k/hls/index.m3u8')
# cap = cv2.VideoCapture('https://60-9-3-149.xiu123.cn/httpflv/v69716930-171412695.flv') #https://www.6.cn/
# cap = cv2.VideoCapture('https://ali-adaptive.pull.yximgs.com/gifshow/sgGRBqHEIW0.flv?auth_key=1581771209-0-0-77ee89696de9e928a5a0de8f47ec2db1&highTraffic=1&oidc=alihb') # 快手的地址
# print(cv2.VideoCaptureAPIs)
# cap = cv2.VideoCapture(flvurl,cv2.CAP_FFMPEG)
# cap = cv2.VideoCapture('rtmp://127.0.0.1:1935/live')
#time.sleep(1)
cap = cv2.VideoCapture(
'/Users/hongyanma/gitspace/python/python/data/视频源/源视频0.avi',
cv2.CAP_FFMPEG)
# cap.set(cv2.CAP_PROP_FPS,15)
# print(cv2.CAP_PROP_FPS)
print(cap.isOpened())
# aaa = cap.grab()
# print(aaa)
# testframe = cap.retrieve()
# print(testframe)
# cv2.imshow('mahy', testframe[1])
# for i in range(19):
# print(i, cap.get(i))
#
# if aaa is not True:
# print('error')
# exit(-1)
# while True:
# ret, image_np = cap.read()
# # if ret is not True:
# # continue
# print(ret)
# print(image_np)
# print('----------------------split')
# cv2.imshow('mahy', image_np) # 显示
# cv2.waitKey(int(1000 / int(22)))
size = (int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))
print(size)
# Path to frozen detection graph. This is the actual model that is used for the object detection.
MODEL_NAME = 'ssd_mobilenet_v1_coco_2018_01_28'
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
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...')
image_container = {}
with detection_graph.as_default():
with tf.Session(graph=detection_graph) as sess:
while True:
ret, image_np = cap.read() # 从摄像头中获取每一帧图像
# print(image_np)
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.
# print('~~~~~~~~~~~~~~')
# print(cap.isOpened())
if not cap.isOpened():
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)
cv2.imshow('mahy', image_np) # 显示
cv2.waitKey(int(1000 / int(22)))
global video_end_flag
video_end_flag = True
cap.release()
def objects():
import numpy as np
import os
import six.moves.urllib as urllib
import sys
import tarfile
import tensorflow as tf
import zipfile
from gtts import gTTS
import pyttsx3
from collections import defaultdict
from io import StringIO
from matplotlib import pyplot as plt
from PIL import Image
from utils import label_map_util
from utils import visualization_utils as vis_util
# # 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:
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
import cv2
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()
# Expand dimensions since the model expects images to have shape: [1, None, None, 3]
image_np_expanded = np.expand_dims(image_np, axis=0)
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
# Each box represents a part of the image where a particular object was detected.
boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
# Each score represent how level of confidence for each of the objects.
# Score is shown on the result image, together with the class label.
scores = detection_graph.get_tensor_by_name('detection_scores:0')
classes = detection_graph.get_tensor_by_name('detection_classes:0')
num_detections = detection_graph.get_tensor_by_name('num_detections:0')
# Actual detection.
(boxes, scores, classes, num_detections) = sess.run(
[boxes, scores, classes, num_detections],
feed_dict={image_tensor: image_np_expanded})
# Visualization of the results of a detection.
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
np.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores),
category_index,
use_normalized_coordinates=True,
line_thickness=8)
# plt.figure(figsize=IMAGE_SIZE)
# plt.imshow(image_np)
a = ([category_index.get(value) for index,value in enumerate(classes[0]) if scores[0,index] > 0.5])
#a=([category_index.get('id') for index,value in enumerate(classes[0]) if scores[0,index] > 0.5])
#x = category_index['name']
#a=str()
#b = a[]
#print(b)
engine = pyttsx3.init()
engine.say(a)
engine.say("is in front of you")
engine.runAndWait()
#tts = gTTS(a,lang='en',slow=False)
#tts.save("abc.mp3")
#os.system("abc.mp3")
#print(scores)
cv2.imshow('image',cv2.resize(image_np,(1280,960)))
if cv2.waitKey(25) & 0xFF == ord('q'):
cv2.destroyAllWindows()
cap.release()
break
# for object detection.
PATH_TO_CKPT_vehicle = os.path.join(CWD_PATH,"Vehicle_ssd",'frozen_inference_graph.pb')
PATH_TO_CKPT_LicensePlate = os.path.join(CWD_PATH,"License_PLate",'frozen_inference_graph.pb')
# Path to label map file
PATH_TO_LABELS_vehicle = os.path.join(CWD_PATH,'training','labelmap_vehicle.pbtxt')
PATH_TO_LABELS_LicensePlate = os.path.join(CWD_PATH,'training','labelmap.pbtxt')
# 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_vehicle = label_map_util.load_labelmap(PATH_TO_LABELS_vehicle)
categories_vehicle = label_map_util.convert_label_map_to_categories(label_map_vehicle, max_num_classes=2, use_display_name=True)
category_index_vehicle = label_map_util.create_category_index(categories_vehicle)
label_map_LicensePlate = label_map_util.load_labelmap(PATH_TO_LABELS_LicensePlate)
categories_LicensePlatev = label_map_util.convert_label_map_to_categories(label_map_LicensePlate, max_num_classes=1, use_display_name=True)
category_index_LicensePlate = label_map_util.create_category_index(categories_LicensePlatev)
# Load the Tensorflow model into memory.
detection_graph_vehicle = tf.Graph()
with detection_graph_vehicle.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(PATH_TO_CKPT_vehicle, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
sess_vehicle = tf.Session(graph=detection_graph_vehicle)
def __post_init__(self):
# Grab path to current working directory
self.CWD_PATH = self.OBJ_DETECT_PATH
# Path to frozen detection graph .pb file, which contains the model that is used
# for object detection.
self.PATH_TO_CKPT = os.path.join(self.CWD_PATH, self.MODEL_NAME,
'frozen_inference_graph.pb')
# Path to label map file
self.PATH_TO_LABELS = os.path.join(self.CWD_PATH, 'data',
'mscoco_label_map.pbtxt')
# Load the label map.
# Label maps map indices to category names, so that when the 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
self.label_map = label_map_util.load_labelmap(self.PATH_TO_LABELS)
self.categories = label_map_util.convert_label_map_to_categories(
self.label_map,
max_num_classes=self.NUM_CLASSES,
use_display_name=True)
self.category_index = label_map_util.create_category_index(
self.categories)
# Load the Tensorflow model into memory.
self.detection_graph = tf.Graph()
with self.detection_graph.as_default():
self.od_graph_def = tf.compat.v1.GraphDef()
with tf.io.gfile.GFile(self.PATH_TO_CKPT, 'rb') as fid:
self.serialized_graph = fid.read()
self.od_graph_def.ParseFromString(self.serialized_graph)
tf.import_graph_def(self.od_graph_def, name='')
self.sess = tf.compat.v1.Session(graph=self.detection_graph)
# Define input and output tensors (i.e. data) for the object detection classifier
# Input tensor is the image
self.image_tensor = self.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
self.detection_boxes = self.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.
self.detection_scores = self.detection_graph.get_tensor_by_name(
'detection_scores:0')
self.detection_classes = self.detection_graph.get_tensor_by_name(
'detection_classes:0')
# Number of objects detected
self.num_detections = self.detection_graph.get_tensor_by_name(
'num_detections:0')
# Initialize frame rate calculation
self.frame_rate_calc = 1
self.freq = self.cv2.getTickFrequency()
# Initialize Picamera and grab reference to the raw capture
self.camera = PiCamera()
self.camera.resolution = (self.IM_WIDTH, self.IM_HEIGHT)
self.camera.framerate = YAMLAccess.IM_FPS
self.rawCapture = PiRGBArray(self.camera,
size=(self.IM_WIDTH, self.IM_HEIGHT))
self.rawCapture.truncate(0)
def Predict(img,
detection_graph,
sess,
MODEL_FOLDER,
labels2show,
threshold=0.7):
# Grab path to current working directory
CWD_PATH = os.getcwd()
# Number of classes the object detector can identify
NUM_CLASSES = 90
# Path to label map file
PATH_TO_LABELS = os.path.join(CWD_PATH, MODEL_FOLDER,
'mscoco_complete_label_map.pbtxt')
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(
label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
category_index = label_map_util.create_category_index(categories)
# color scheeme for different classes
color_map = {
'person': 'DeepSkyBlue',
'dog': 'IndianRed',
'cat': 'yellow',
'chair': 'Cyan',
'bottle': 'Orange'
}
# 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')
# threshold of detection
thresh = threshold
items = []
coordinates = []
#if you want to resize to tune inference
#img = cv2.resize(img_org, (300,300))
img_expanded = np.expand_dims(img, axis=0)
#print(img_expanded.shape)
(boxes, scores, classes, num) = sess.run(
[detection_boxes, detection_scores, detection_classes, num_detections],
feed_dict={image_tensor: img_expanded})
objects = []
for index, value in enumerate(classes[0]):
object_dict = {}
if scores[0, index] > thresh:
object_dict[(
category_index.get(value)).get('name')] = scores[0, index]
objects.append(object_dict)
#print (objects)
#Get all the detected class labels in one list
for y in objects:
for keys in y.keys():
m = list(y.keys())[0]
items.append(m)
#Get co ordinates of the detected classes
coordinates = vis_util.return_coordinates(img,
np.squeeze(boxes),
np.squeeze(classes).astype(
np.int32),
np.squeeze(scores),
category_index,
use_normalized_coordinates=True,
line_thickness=10,
min_score_thresh=thresh)
new_items = []
new_coordinates = []
display_str_list = []
for i, item in enumerate(items):
if item.lower() in labels2show:
new_items.append(item.lower())
new_coordinates.append(coordinates[i][:-1])
display_str_list.append(
[item + ' : ' + str(int(coordinates[i][-1])) + '%'])
for i, box in enumerate(new_coordinates):
ymin, ymax, xmin, xmax = box[0], box[1], box[2], box[3]
display_str = display_str_list[i]
color = color_map[new_items[i]]
vis_util.draw_bounding_box_on_image_array(
img,
ymin,
xmin,
ymax,
xmax,
color=color,
thickness=4,
display_str_list=display_str,
use_normalized_coordinates=False)
return new_coordinates, new_items, img
def detect_traffic_lights(PATH_TO_TEST_IMAGES_DIR, MODEL_NAME, Num_images, plot_flag=False):
"""
Detect traffic lights and draw bounding boxes around the traffic lights
:param PATH_TO_TEST_IMAGES_DIR: testing image directory
:param MODEL_NAME: name of the model used in the task
"""
# --------test images------
TEST_IMAGE_PATHS = [os.path.join(PATH_TO_TEST_IMAGES_DIR, 'img_{}.jpg'.format(
i)) for i in range(1, Num_images+1)]
commands = []
# What model to download
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 = 'mscoco_label_map.pbtxt'
# number of classes for COCO dataset
NUM_CLASSES = 90
# --------Download model----------
if path.isdir(MODEL_NAME) is False:
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.compat.v2.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='')
# ----------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.compat.v1.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:
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)
# 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})
# print([category_index.get(i) for i in classes[0]])
# print(scores) # traffic lights are first
result = read_traffic_lights(image, np.squeeze(boxes), np.squeeze(
scores), np.squeeze(classes).astype(np.int32))
print(result)
# Visualization of the results of a detection.
if plot_flag:
plot_origin_image(image_np, boxes, classes,
scores, category_index)
return commands
def get_frame2():
flat=True
sys.setrecursionlimit(10000)
# What model to download.
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 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')
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)
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()
# Expand dimensions since the model expects images to have shape: [1, None, None, 3]
image_np_expanded = np.expand_dims(image_np, axis=0)
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
# Each box represents a part of the image where a particular object was detected.
boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
# Each score represent how level of confidence for each of the objects.
# Score is shown on the result image, together with the class label.
scores = detection_graph.get_tensor_by_name('detection_scores:0')
classes = detection_graph.get_tensor_by_name('detection_classes:0')
num_detections = detection_graph.get_tensor_by_name('num_detections:0')
# Actual detection.
(boxes, scores, classes, num_detections) = sess.run(
[boxes, scores, classes, num_detections],
feed_dict={image_tensor: image_np_expanded})
# Visualization of the results of a detection.
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
np.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores),
category_index,
use_normalized_coordinates=True,
line_thickness=8)
# plt.figure(figsize=IMAGE_SIZE)
# plt.imshow(image_np)
imgencode=cv2.imencode('.jpg',image_np)[1]
lb=[category_index.get(value).get('name') for index,value in enumerate(classes[0]) if scores[0,index] > 0.5]
if "car" in lb and flat==True:
cap.release()
flat=False
ins(lb)
time.sleep(2)
flat=True
cap = cv2.VideoCapture(0)
if "motorcycle" in lb and flat==True:
cap.release()
flat=False
ins(lb)
time.sleep(2)
flat=True
cap = cv2.VideoCapture(0)
if "truck" in lb and flat==True:
cap.release()
flat=False
ins(lb)
time.sleep(2)
flat=True
cap = cv2.VideoCapture(0)
if cv2.waitKey(25) & 0xFF == ord('q'):
exit()
stringData=imgencode.tostring()
yield (b'--frame\r\n'
b'Content-Type: text/plain\r\n\r\n'+stringData+b'\r\n')
def predict_image_tfapi(detection_graph,
sess,
PATH_TO_CKPT,
PATH_TO_LABELS,
PATH_TO_IMAGE,
NUM_CLASSES,
output_dir,
tfapi_min_score_thresh=1e-5,
is_show=True,
is_img_save=True,
class_model=None,
dict_class={0.0: "Car"},
class_min_score_thresh=0.5,
model_height=331,
model_width=331,
TTA=None,
TTA_rotate_deg=0,
TTA_crop_num=0):
"""
tfAPIでpredict
kerasの分類モデル引数にあればそのモデルでもpredict
Args:
PATH_TO_CKPT: path to frozen detection graph.pb
PATH_TO_LABELS: path to labelmap.pbtxt
PATH_TO_IMAGE: path to image file
NUM_CLASSES: number of classes
output: path to output directory of detected image file
tfapi_min_score_thresh: tfAPIのpredictの閾値
is_show: 検出画像表示するか
is_img_save: 検出画像保存するか
class_model: kerasの分類モデルオブジェクト
dict_class: kerasの分類モデルのクラスのidとクラス名の辞書型データ
class_min_score_thresh: kerasの分類モデルのpredictの閾値
model_height, model_width: 予測するkerasの分類モデルの入力画像サイズ（modelのデフォルトのサイズである必要あり）
TTA*:TTA option
"""
# Load the label map.
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
#print(label_map)
categories = label_map_util.convert_label_map_to_categories(
label_map, max_num_classes=NUM_CLASSES, use_display_name=True)
#print(categories)
category_index = label_map_util.create_category_index(categories)
#print(category_index)
# 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})
#print(type(classes))
#print(classes.shape)
#print(classes)
#print(type(scores))
#print(scores.shape)
#print(scores)
# -------------------- 分類モデルで予測 --------------------
if class_model is not None:
category_index = make_category_index_from_dict_class(dict_class)
boxes = np.squeeze(boxes) # np.squeeze: サイズ1の次元の削除（4次元テンソルなので3次元にする）
scores = np.squeeze(scores)
boxes_class_model = []
classes_class_id_model = []
classes_class_name_model = []
scores_class_model = []
for box, score in zip(boxes, scores):
#print(box)
ymin, xmin, ymax, xmax = box
#print(ymin, xmin, ymax, xmax)
# 位置情報無いレコードは除く
# tfAPIの予測領域は(0,0,0,0)の結果が始まったら後続のレコードもすべて(0,0,0,0)なのでbreakする
if (ymin == 0.0) & (xmin == 0.0) & (ymax == 0.0) & (xmax == 0.0):
break
# 領域予測の閾値
if score < tfapi_min_score_thresh:
continue
img_RGB = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
# (ndarray型の画像データから)検出領域切り出し
# ndarray型の切り出しは[y:y_max,x:x_max]の順番じゃないとおかしくなる
# https://qiita.com/tadOne/items/8967f046ca395669329d
dst = img_RGB[int(img_RGB.shape[0] * ymin):int(img_RGB.shape[0] *
ymax),
int(img_RGB.shape[1] *
xmin):int(img_RGB.shape[1] *
xmax)] # スライス[:]はint型でないとエラー
# ここで画像表示すると、bbox付き画像保存されない.あくまで確認用
#print(dst)
#plt.imshow(dst / 255.)
#plt.show()
# 切り出し画像を分類モデルでpredict
class_conf, class_label_id = predict_class_model(
dst,
class_model,
model_height,
model_width,
TTA=TTA,
TTA_rotate_deg=TTA_rotate_deg,
TTA_crop_num=TTA_crop_num)
#print('class_label_name :', dict_class[class_label_id])
#print('class_conf :', class_conf)
# 分類モデルの閾値
if class_conf >= class_min_score_thresh:
boxes_class_model.append(box)
classes_class_id_model.append(int(class_label_id))
classes_class_name_model.append(str(
dict_class[class_label_id]))
scores_class_model.append(float(class_conf))
boxes = np.array(boxes_class_model)
classes = np.array(
[int(c) for c in classes_class_id_model]
) # intでないと vis_util.visualize_boxes_and_labels_on_image_array()でエラーになる
classes_class_name_model = np.array(classes_class_name_model)
scores = np.array(scores_class_model)
# 元の型である4次元テンソルへ変換
boxes = np.expand_dims(boxes, axis=0)
classes = np.expand_dims(classes, axis=0)
classes_class_name_model = np.expand_dims(classes_class_name_model,
axis=0)
scores = np.expand_dims(scores, axis=0)
print('boxes.shape:', boxes.shape)
#print(boxes)
#print(type(classes))
print('classes.shape:', classes.shape)
#print(classes)
#print(type(scores))
print('scores.shape:', scores.shape)
#print(scores)
# ---------------------------------------------------------
else:
img_RGB = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
classes = classes.astype(
np.int32
) # intでないと vis_util.visualize_boxes_and_labels_on_image_array()でエラーになる
# 検出数が1のときに検出画像をだすとエラーになるのでtryで囲む
try:
# 検出画像保存するか
if is_img_save == True:
print("Draw the results of the detection......")
if boxes.shape == (1, 1, 4):
vis_boxes = boxes.reshape(
1, 4
) # 検出数が1つだけのときnp.squeezeするとclassesのshape=()となりエラーになるためreshapeでサイズ固定する
vis_classes = classes.reshape(1, )
vis_scores = scores.reshape(1, )
else:
vis_boxes = np.squeeze(boxes) # np.squeeze: サイズ1の次元の削除
vis_classes = np.squeeze(classes)
vis_scores = np.squeeze(scores)
#print(vis_boxes.shape)
#print(vis_classes.shape)
#print(vis_classes)
#print(vis_scores.shape)
# Draw the results of the detection (aka 'visulaize the results')
vis_util.visualize_boxes_and_labels_on_image_array(
image,
vis_boxes,
vis_classes,
vis_scores,
category_index,
use_normalized_coordinates=True,
line_thickness=8,
max_boxes_to_draw=int(num[0]), # 描画するbboxの最大数
min_score_thresh=tfapi_min_score_thresh # 領域予測の閾値
)
img_RGB = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
PIL.Image.fromarray(img_RGB).save(
os.path.join(output_dir,
str(Path(PATH_TO_IMAGE).stem) + '.jpg')) # ファイル出力
# 検出画像表示するか
if is_show == True:
plt.figure(figsize=(4, 4), dpi=200)
plt.imshow(image)
plt.show()
except Exception as e:
print('#### visualize_boxes Exception. img path:', PATH_TO_IMAGE,
'#####')
print(e)
# ローカル変数の存在をチェック
if 'classes_class_name_model' in locals():
# 分類モデルで予測ある時
return boxes, scores, classes_class_name_model, img_RGB
else:
# 分類モデルで予測ない時
return boxes, scores, classes, img_RGB
def object_detection_function(video_link, model_name, id):
global _folder_path
filename = "video_" + str(id) + "_upd.mp4"
#filename = "video_1_61.mp4"
print("processing..", filename)
urllib.request.urlretrieve(video_link, filename)
cap = cv2.VideoCapture(filename)
#Use these if you want to know the height and width of the video and set the ROI line Accordingly.
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
roi = int(height * 2 / 3)
if (height == 1080):
roi = 650
fps = int(cap.get(cv2.CAP_PROP_FPS))
vis_util.helper(roi)
# By default I 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 = model_name
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
# uncomment if you have not download the model yet
# 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 I 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)
outputFile = filename + "_Faster_out.avi"
total_passed_vehicle = 0
total_cars = [0] * 2
total_trucks = [0] * 2
total_bus = [0] * 2
total_person = [0] * 2
total_motorcycle = [0] * 2
speed = 'waiting...'
direction = 'waiting...'
size = 'waiting...'
color = 'waiting...'
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 all the frames that are extracted from input video
vid_writer = cv2.VideoWriter(
outputFile, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'), 30,
(width, height))
while cap.isOpened():
(ret, frame) = cap.read()
if not ret:
print('end of the video file...')
break
input_frame = frame
# Expand dimensions since the model expects images to have shape: [1, None, None, 3]
image_np_expanded = np.expand_dims(input_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.
(counter, csv_line) = \
vis_util.visualize_boxes_and_labels_on_image_array(
cap.get(1),
input_frame,
np.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores),
category_index,
use_normalized_coordinates=True,
line_thickness=4,
)
total_passed_vehicle = total_passed_vehicle + sum(counter)
if direction == 'up':
total_cars[0] = total_cars[0] + counter[0]
total_trucks[0] = total_trucks[0] + counter[1]
total_bus[0] = total_bus[0] + counter[2]
total_person[0] = total_person[0] + counter[3]
total_motorcycle[0] = total_motorcycle + counter[4]
elif direction == "down":
total_cars[1] = total_cars[1] + counter[0]
total_trucks[1] = total_trucks[1] + counter[1]
total_bus[1] = total_bus[1] + counter[2]
total_person[1] = total_person[1] + counter[3]
total_motorcycle[1] = total_motorcycle[1] + counter[4]
#print(counter)
# insert information text to video frame
font = cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(
input_frame,
'Vehicles:' + str(total_passed_vehicle) + ' Car up:' +
str(total_cars[0]) + ' C down:' + str(total_cars[1]) +
' Truck up:' + str(total_trucks[0]) + ' T down:' +
str(total_trucks[1]),
(10, 35),
font,
0.8,
(0, 0xFF, 0),
2,
cv2.FONT_HERSHEY_SIMPLEX,
)
cv2.putText(
input_frame,
'Bus up:' + str(total_bus[0]) + ' B d:' +
str(total_bus[1]) + ' P up:' + str(total_person[0]) +
' P down:' + str(total_person[1]) + ' Bike up:' +
str(total_motorcycle[0]) + ' B d:' +
str(total_motorcycle[1]),
(10, 55),
font,
0.8,
(0, 0xFF, 0),
2,
cv2.FONT_HERSHEY_SIMPLEX,
)
# when the vehicle passed over line and counted, make the color of ROI line green
if sum(counter) == 1:
cv2.line(input_frame, (0, roi), (width, roi), (0, 0xFF, 0),
5)
else:
cv2.line(input_frame, (0, roi), (width, roi), (0, 0, 0xFF),
5)
# insert information text to video frame
#cv2.rectangle(input_frame, (10, 275), (230, 337), (180, 132, 109), -1)
cv2.putText(
input_frame,
'ROI Line',
(width - 100, roi - 40),
font,
0.6,
(0, 0, 0xFF),
2,
cv2.LINE_AA,
)
vid_writer.write(input_frame.astype(np.uint8))
#cv2.imshow('vehicle detection', input_frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if csv_line != 'not_available':
with open('traffic_measurement.csv', 'a') as f:
writer = csv.writer(f)
(size, color, direction, speed) = \
csv_line.split(',')
writer.writerows([csv_line.split(',')])
cap.release()
cv2.destroyAllWindows()
#time2 = cv2.getTickCount()
#time = (time2-time1)/ cv2.getTickFrequency()
#print("Total Time taken to process the video :",time)
return ([
total_cars[0], total_cars[1], total_person[0], total_person[1],
total_motorcycle[0], total_motorcycle[1], total_trucks[0],
total_trucks[1]
])
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(path, num_classes):
label_map = label_map_util.load_labelmap(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 label_map_util
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():
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')
