def show_inference(self, model, 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 = np.array(Image.open(image_path))
# Actual detection.
output_dict = self.run_inference_for_single_image(model, image_np)
# print(output_dict)
# Visualization of the results of a detection.
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
output_dict['detection_boxes'],
output_dict['detection_classes'],
output_dict['detection_scores'],
self.category_index,
instance_masks=output_dict.get('detection_masks_reframed', None),
use_normalized_coordinates=True,
line_thickness=8)
scores = output_dict['detection_scores']
classes = output_dict['detection_classes']
final_score = np.squeeze(scores)
count = 0
for i in range(len(scores)):
if len(scores) == 1:
if final_score > 0.5 and classes[i] == 1:
count = count + 1
elif scores is None or final_score[i] > 0.5 and classes[i] == 1:
count = count + 1
print(count)
self.count_person.append(count)
display(Image.fromarray(image_np))
def get_classification(self, img):
# Bounding Box Detection.
try:
with self.detection_graph.as_default():
category_index = self.labelify()
# Expand dimension since the model expects image to have shape [1, None, None, 3].
img_expanded = np.expand_dims(img, axis=0)
(boxes, scores, classes, num) = self.sess.run(
[self.d_boxes, self.d_scores, self.d_classes, self.num_d],
feed_dict={self.image_tensor: img_expanded})
vis_util.visualize_boxes_and_labels_on_image_array(
img,
np.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores),
category_index,
use_normalized_coordinates=True,
line_thickness=8)
boxes = self.detection_graph.get_tensor_by_name(
'detection_boxes:0')
scores = self.detection_graph.get_tensor_by_name(
'detection_scores:0')
classes = self.detection_graph.get_tensor_by_name(
'detection_classes:0')
num_detections = self.detection_graph.get_tensor_by_name(
'num_detections:0')
return img
except Exception as e:
print("Exception during classification", e)
return
def predict_fun(self):
image = Image.open(
os.path.join(self.folder_path, self.files[self.n_curr]))
image_np = self.load_image_into_array(image)
image_np_expand = np.expand_dims(image_np, axis=0)
output_dict = self.run_inference_for_single_image(image_np)
print(self.filter_class)
if (self.filter_class != None):
output_dict['detection_boxes'] = np.squeeze(
output_dict['detection_boxes'])
output_dict['detection_classes'] = np.squeeze(
output_dict['detection_classes'])
output_dict['detection_scores'] = np.squeeze(
output_dict['detection_scores'])
indices = 1
if (self.filter_class == 'Person'):
indices = np.argwhere(output_dict['detection_classes'] == 1)
elif (self.filter_class == 'Dog'):
indices = np.argwhere(output_dict['detection_classes'] == 18)
elif (self.filter_class == 'Cat'):
indices = np.argwhere(output_dict['detection_classes'] == 17)
elif (self.filter_class == 'Bottle'):
indices = np.argwhere(output_dict['detection_classes'] == 44)
elif (self.filter_class == 'Chair'):
indices = np.argwhere(output_dict['detection_classes'] == 62)
print(indices)
output_dict['detection_boxes'] = np.squeeze(
output_dict['detection_boxes'][indices])
output_dict['detection_classes'] = np.squeeze(
output_dict['detection_classes'][indices])
output_dict['detection_scores'] = np.squeeze(
output_dict['detection_scores'][indices])
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
output_dict['detection_boxes'],
output_dict['detection_classes'],
output_dict['detection_scores'],
self.category_index[0],
instance_masks=output_dict.get('detection_masks'),
use_normalized_coordinates=True,
min_score_thresh=self.threshold,
line_thickness=8)
fig = plt.figure(figsize=(7, 5), frameon=False)
ax = plt.Axes(fig, [0., 0., 1., 1.])
ax.set_axis_off()
fig.add_axes(ax)
ax.imshow(image_np, aspect='auto')
fig.savefig("output.png", bbox_inches='tight', dpi=fig.dpi)
self.pixmap = QPixmap('output.png')
self.labelImage.setPixmap(self.pixmap)
print("done")
def show_inference(model, image_np):
#image_np = np.array(Image.open(image_path))
output_dict = run_inference_for_single_image(model, image_np)
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
output_dict['detection_boxes'],
output_dict['detection_classes'],
output_dict['detection_scores'],
category_index,
instance_masks=output_dict.get('detection_masks_reframes', None),
use_normalized_coordinates=True,
line_thickness=8)
cv2.imshow('object detection', cv2.resize(image_np, (800, 600)))
def show_inference(model, image_path):
image_np = np.array(Image.open(image_path))
output_dict = run_inference_for_single_image(model, image_np)
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
output_dict['detection_boxes'],
output_dict['detection_classes'],
output_dict['detection_scores'],
category_index,
instance_masks=output_dict.get('detection_masks_reframes', None),
use_normalized_coordinates=True,
line_thickness=8)
plt.imshow(image_np)
plt.axis('off')
plt.savefig("./ProcessedImages/Processed_" +
str(image_path).split("/")[-1] + ".jpg")
def test_detection(tfrecords_filename, tfrecords_num, detect_fn):
image_tensors = tensors_from_tfrecord(tfrecords_filename,
tfrecords_num,
dtype=tf.uint8)
for image_tensor in image_tensors:
image_np = image_tensor.numpy()
# The model expects a batch of images, so add an axis with `tf.newaxis`.
input_tensor = tf.expand_dims(image_tensor, 0)
detections = detect_fn(input_tensor)
# All outputs are batches tensors.
# Convert to numpy arrays, and take index [0] to remove the batch dimension.
# We're only interested in the first num_detections.
num_detections = int(detections.pop('num_detections'))
detections = {
key: value[0, :num_detections].numpy()
for key, value in detections.items()
}
detections['num_detections'] = num_detections
# detection_classes should be ints.
detections['detection_classes'] = (
detections['detection_classes'].astype(np.int64))
image_np_with_detections = image_np.astype(int).copy()
visualization_utils.visualize_boxes_and_labels_on_image_array(
image_np_with_detections,
detections['detection_boxes'],
detections['detection_classes'],
detections['detection_scores'],
category_index,
use_normalized_coordinates=True,
max_boxes_to_draw=100,
min_score_thresh=.3,
agnostic_mode=False)
plt.figure(figsize=(8, 8))
plt.imshow(image_np_with_detections)
plt.show()
def gen():
myrtmp_addr = "rtmp://localhost/live/indycar live=1"
cap = cv2.VideoCapture(myrtmp_addr)
while True:
ret, frame = cap.read()
if not ret:
print('Input source error!')
break
image_np = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
# 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.
output_dict = sess.run(tensor_dict,
feed_dict={image_tensor: image_np_expanded})
# all outputs are float32 numpy arrays, so convert types as appropriate
output_dict['num_detections'] = int(output_dict['num_detections'][0])
output_dict['detection_classes'] = output_dict['detection_classes'][
0].astype(np.uint8)
output_dict['detection_boxes'] = output_dict['detection_boxes'][0]
output_dict['detection_scores'] = output_dict['detection_scores'][0]
if 'detection_masks' in output_dict:
output_dict['detection_masks'] = output_dict['detection_masks'][0]
# Visualization of the results of a detection.
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
output_dict['detection_boxes'],
output_dict['detection_classes'],
output_dict['detection_scores'],
category_index,
instance_masks=output_dict.get('detection_masks'),
use_normalized_coordinates=True,
line_thickness=8)
frame = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
ret, jpeg = cv2.imencode('.jpg', frame)
frame = jpeg.tobytes()
yield (b'--frame\r\n'
b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n\r\n')
def predict(file, filename):
PATH_TO_IMAGE = file
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)
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.GraphDef()
with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
sess = tf.Session(graph=detection_graph)
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')
detection_classes = detection_graph.get_tensor_by_name(
'detection_classes:0')
num_detections = detection_graph.get_tensor_by_name('num_detections:0')
image = cv2.imread(PATH_TO_IMAGE)
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image_expanded = np.expand_dims(image_rgb, axis=0)
(boxes, scores, classes, num) = sess.run(
[detection_boxes, detection_scores, detection_classes, num_detections],
feed_dict={image_tensor: image_expanded})
vis_util.visualize_boxes_and_labels_on_image_array(
image,
np.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores),
category_index,
use_normalized_coordinates=True,
line_thickness=8,
min_score_thresh=0.60)
cv2.imwrite('uploads/' + filename + 'result.jpg', image)
return 0
def visualize_detections(image_np, detections, category_index):
image_np_with_detections = image_np.copy()
#labels_path = download_labels('mscoco_label_map.pbtxt')
#category_index = label_map_util.create_category_index_from_labelmap(labels_path, use_display_name=True)
boxes = np.asarray(detections["detection_boxes"][0])
classes = np.asarray(detections["detection_classes"][0]).astype(np.int64)
scores = np.asarray(detections["detection_scores"][0])
mask = np.asarray(detections["detection_masks_reframed"])
# Visualizing the results
vis_utils.visualize_boxes_and_labels_on_image_array(
image_np_with_detections,
boxes,
classes,
scores,
category_index,
instance_masks=mask,
use_normalized_coordinates=True,
line_thickness=3)
return image_np_with_detections
def print_image(image_path, IMAGE_SIZE, detection_graph, category_index):
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.
output_dict = run_inference_for_single_image(image_np, detection_graph)
# Visualization of the results of a detection.
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
output_dict['detection_boxes'],
output_dict['detection_classes'],
output_dict['detection_scores'],
category_index,
instance_masks=output_dict.get('detection_masks'),
use_normalized_coordinates=True,
line_thickness=8)
# IMAGE_SIZE == tuple | Size, in inches, of the output images.
plt.figure(figsize=IMAGE_SIZE)
plt.imshow(image_np)
def test_object_detection():
# Create the label/category maps for drawing the bbox objects.
label_map = label_map_util.load_labelmap(config.PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(
label_map, max_num_classes=config.NUM_CLASSES, use_display_name=True)
category_index = label_map_util.create_category_index(categories)
# Load the model.
model = odl.load_model()
# Get test images.
test_image = get_test_images()[TEST_IMAGE]
# Feed the model and the first images to the inference runner.
output_dict = odl.run_inference_for_single_image(test_image, model)
# Log the detections.
objs = set()
scores = output_dict['detection_scores']
classes = output_dict['detection_classes']
for i in range(len(scores)):
score = scores[i]
c = classes[i]
if score >= 0.2:
objs.add(category_index[c]['name'])
print("Objects detected: %s" % str(objs))
# Save the output.
vis_util.visualize_boxes_and_labels_on_image_array(
test_image,
output_dict['detection_boxes'],
output_dict['detection_classes'],
output_dict['detection_scores'],
category_index,
instance_masks=output_dict.get('detection_masks'),
use_normalized_coordinates=True,
line_thickness=8,
min_score_thresh=0.4)
vis_util.save_image_array_as_png(test_image, 'test_screens/test_image.png')
def show_inference(model, 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 = np.array(PIL.Image.open(image_path))
# image_np = np.array(PIL.Image.open("C:/Users/dell/Desktop/images.jpg"))
# Actual detection.
output_dict = run_inference_for_single_image(model, image_np)
# Visualization of the results of a detection.
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
output_dict['detection_boxes'],
output_dict['detection_classes'],
output_dict['detection_scores'],
category_index,
instance_masks=output_dict.get('detection_masks_reframed', None),
use_normalized_coordinates=True,
line_thickness=5)
# display(Image.fromarray(image_np)) #Bunu aşağıdaki kodla değiştirdim.
img = Image.fromarray(image_np, "RGB")
img.show()
print("esra")
def print_image(image_path, IMAGE_SIZE, detection_graph, category_index):
'''DOCSTRING
Displays the image using matplotlib with bounding boxes and the class in
the image.
#todo: come back and resize the detecion class displayed on the image
--------------
INPUTS:
image_path: the path to the image you want to load
IMAGE_SIZE: the desired output size
detection_graph: the detection graph of the model you want to use to
predict on the image
category_index: the category_index that will be used to go from class id
to class name
--------------
Returns:
None, but it does print a pretty image
'''
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.
output_dict = run_inference_for_single_image(image_np, detection_graph)
# Visualization of the results of a detection.
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
output_dict['detection_boxes'],
output_dict['detection_classes'],
output_dict['detection_scores'],
category_index,
instance_masks=output_dict.get('detection_masks'),
use_normalized_coordinates=True,
line_thickness=8)
# IMAGE_SIZE == tuple | Size, in inches, of the output images.
plt.figure(figsize=IMAGE_SIZE)
plt.imshow(image_np)
def detect_objects(image_np, sess, detection_graph, categories_to_detect=[]):
# 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})
detected = dict()
for i in categories_to_detect:
detected[i] = 0
for j in range(len(scores)):
detected[i] = max(detected[i], scores[0][i])
# Visualization of the results of a detection.
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
np.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores),
category_index,
use_normalized_coordinates=True,
line_thickness=8)
return image_np, detected
def detect_object():
# start = time.time()
data = request.data.decode("utf-8")
# return data
# params = json.loads(data)
imgdata = base64.b64decode(data)
print (len(imgdata))
# start = time.time()
# 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='')
# print (time.time() - start)
with detection_graph.as_default():
with tf.Session(graph=detection_graph) as sess:
image = Image.open(io.BytesIO(imgdata))
image_np = load_image_into_numpy_array(image)
# 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})
# 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)
#json_data = json.dumps({'image': image_np.tolist()})
# with open('/Users/ashishyadav/Desktop/out.txt', 'w') as outfile:
# json.dump(json_data, outfile)
#return json_data
# print (image_np.tobytes())
im = Image.fromarray(image_np)
imbyte = io.BytesIO()
im.save(imbyte, format='PNG')
return base64.b64encode(imbyte.getvalue())
class_dict[entry.id] = {'name': entry.name}
raw_dataset = list(tf.data.TFRecordDataset(config.TRAIN_RECORD))
random.shuffle(raw_dataset)
fig, ax = plt.subplots(2, 5, figsize=(15, 5))
for i, raw_record in enumerate(raw_dataset[:10]):
example = decoder.decode(raw_record)
image = example['image'].numpy()
boxes = example['groundtruth_boxes'].numpy()
classes = example['groundtruth_classes'].numpy()
scores = np.ones(boxes.shape[0])
visualization_utils.visualize_boxes_and_labels_on_image_array(
image,
boxes,
classes,
scores,
class_dict,
max_boxes_to_draw=None,
use_normalized_coordinates=True)
ax.flat[i].axis('off')
ax.flat[i].imshow(image)
fig.tight_layout()
def get_localization(self, image, visual=False):
"""Determines the locations of the cars in the image
Args:
image: camera image
Returns:
list of bounding boxes: coordinates [y_up, x_left, y_down, x_right]
"""
category_index = {
1: {
'id': 1,
'name': u'person'
},
2: {
'id': 2,
'name': u'bicycle'
},
3: {
'id': 3,
'name': u'car'
},
4: {
'id': 4,
'name': u'motorcycle'
},
5: {
'id': 5,
'name': u'airplane'
},
6: {
'id': 6,
'name': u'bus'
},
7: {
'id': 7,
'name': u'train'
},
8: {
'id': 8,
'name': u'truck'
},
9: {
'id': 9,
'name': u'boat'
},
10: {
'id': 10,
'name': u'traffic light'
},
11: {
'id': 11,
'name': u'fire hydrant'
},
13: {
'id': 13,
'name': u'stop sign'
},
14: {
'id': 14,
'name': u'parking meter'
}
}
with self.detection_graph.as_default():
image_expanded = np.expand_dims(image, axis=0)
(boxes, scores, classes, num_detections) = self.sess.run(
[self.boxes, self.scores, self.classes, self.num_detections],
feed_dict={self.image_tensor: image_expanded})
if visual == True:
vis_utils.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,
min_score_thresh=.4,
line_thickness=3)
plt.figure(figsize=(9, 6))
plt.imshow(image)
plt.show()
boxes = np.squeeze(boxes)
classes = np.squeeze(classes)
scores = np.squeeze(scores)
cls = classes.tolist()
# The ID for car in COCO data set is 3
idx_vec = [
i for i, v in enumerate(cls)
if ((v == 3) and (scores[i] > 0.3))
]
if len(idx_vec) == 0:
print('no detection!')
self.car_boxes = []
else:
tmp_car_boxes = []
for idx in idx_vec:
dim = image.shape[0:2]
box = self.box_normal_to_pixel(boxes[idx], dim)
box_h = box[2] - box[0]
box_w = box[3] - box[1]
ratio = box_h / (box_w + 0.01)
if ((ratio < 0.8) and (box_h > 20) and (box_w > 20)):
tmp_car_boxes.append(box)
print(box, ', confidence: ', scores[idx], 'ratio:',
ratio)
else:
print('wrong ratio or wrong size, ', box,
', confidence: ', scores[idx], 'ratio:', ratio)
self.car_boxes = tmp_car_boxes
return self.car_boxes
# Extract detection scores
scores = detection_graph.get_tensor_by_name('detection_scores:0')
# Extract detection classes
classes = detection_graph.get_tensor_by_name('detection_classes:0')
# Extract number of detectionsd
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)
out.write(image_np)
# Display output
cv2.imshow('object detection', image_np)
if cv2.waitKey(25) & 0xFF == ord('q'):
break
# Clean up
cap.release()
out.release()
tensor_name = key + ':0'
if tensor_name in all_tensor_names:
tensor_dict[key] = tf.compat.v1.get_default_graph(
).get_tensor_by_name(tensor_name)
while True:
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)
# Actual detection.
output_dict = run_inference_for_single_image(
image_np, detection_graph)
# Visualization of the results of a detection.
vis_util.visualize_boxes_and_labels_on_image_array(
image_np,
output_dict['detection_boxes'],
output_dict['detection_classes'],
output_dict['detection_scores'],
category_index,
instance_masks=output_dict.get('detection_masks'),
use_normalized_coordinates=True,
line_thickness=8)
cv2.imshow('object_detection', cv2.resize(image_np, (800, 600)))
if cv2.waitKey(25) & 0xFF == ord('q'):
cap.release()
cv2.destroyAllWindows()
break
# printscreen_extended = np.expand_dims(cap, axis=0)
def Detect(self):
# Get frame, frame is given in 3d array of RGB values
ret1, frame1 = self.video1.read()
if not ret1: return None # Exit with empty values if
frame1 = imutils.rotate(frame1, angle=180)
ret2, frame2 = self.video2.read()
if not ret2: return None # Exit with empty values if
frame2 = imutils.rotate(frame2, angle=90)
# Map colors on image for openCV
frame_rgb1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2RGB)
frame_expanded1 = np.expand_dims(frame_rgb1, axis=0)
frame_rgb2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2RGB)
frame_expanded2 = np.expand_dims(frame_rgb2, axis=0)
# This is the part with the actual detection
(boxes1, scores1, classes1, num1) = self.sess.run(
[self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections],
feed_dict={self.image_tensor: frame_expanded1})
(boxes2, scores2, classes2, num2) = self.sess.run(
[self.detection_boxes, self.detection_scores, self.detection_classes, self.num_detections],
feed_dict={self.image_tensor: frame_expanded2})
# Define predicted class from the highest confidence guess of the image
predicted_class1 = self.category_index[int(classes1[0][0])]['name']
try:
predicted_class2 = self.category_index[int(classes2[0][0])]['name']
except KeyError:
print("Error: ", classes2[0][0], "when should be in: ", self.category_index)
raise KeyError
results = {"video1": {"boxes": boxes1[0][0].tolist(), "scores": scores1[0][0], "classes": predicted_class1},
"video2": {"boxes": boxes2[0][0].tolist(), "scores": scores2[0][0], "classes": predicted_class2},
"hand_val": predicted_class1}
#print(category_index)
# Draw the bounding box and prediction
vis_util.visualize_boxes_and_labels_on_image_array(
frame1,
np.squeeze(boxes1),
np.squeeze(classes1).astype(np.int32),
np.squeeze(scores1),
self.category_index,
use_normalized_coordinates=True,
line_thickness=8,
min_score_thresh=0.60)
# Draw the bounding box and prediction
vis_util.visualize_boxes_and_labels_on_image_array(
frame2,
np.squeeze(boxes2),
np.squeeze(classes2).astype(np.int32),
np.squeeze(scores2),
self.category_index,
use_normalized_coordinates=True,
line_thickness=8,
min_score_thresh=0.60)
print("going to coors")
#results["coors"] = self.cclass.Filter(self.cclass.GetCoors(boxes1[0][0], boxes2[0][0]))
results["coors"] = self.cclass.GetCoors(boxes1[0][0], boxes2[0][0])
print("done")
print(results)
#time.sleep(DELAY)
if self.Verbose:
text1 = "Top View Values: {} , {} , {}".format(results["coors"][0], results["coors"][1], results["hand_val"])
text2 = "Side View Values: {}".format(results["coors"][2])
frame1 = cv2.putText(frame1, text1, org, font,
fontScale, color, thickness, cv2.LINE_AA)
frame2 = cv2.putText(frame2, text2, org, font,
fontScale, color, thickness, cv2.LINE_AA)
# cv2.imshow("Obj Detect 1: {} , {} , {} , {}".format(results["coors"][0], results["coors"][1], results["coors"][2], results["hand_val"]), frame1)
# cv2.imshow("Obj Detect 2: {} , {} , {} , {}".format(results["coors"][0], results["coors"][1], results["coors"][2], results["hand_val"]), frame2)
cv2.imshow("Obj Detect 1", frame1)
cv2.imshow("Obj Detect 2", frame2)
if cv2.waitKey(1) == ord('q'):
return None
return results
def browse_mul_image_file(self, _):
self.selected_image_file = tkFileDialog.askopenfilename(
initialdir="~/Downloads",
title="Select file",
filetypes=(("jpeg files", "*.jpg"), ("all files", "*.*")))
if self.selected_image_file:
self.mul_image_file_entry.delete(0, END)
self.mul_image_file_entry.insert(0, self.selected_image_file)
#def object_detect_show(self):
CWD_PATH = os.getcwd()
#IMAGE_NAME = '000001.jpg'
PATH_TO_CKPT = os.path.join(CWD_PATH, 'models', 'research',
'object_detection', 'inference_graph',
'frozen_inference_graph.pb')
# Path to label map file
PATH_TO_LABELS = os.path.join(CWD_PATH, 'models', 'research',
'object_detection', 'training',
'labelmap.pbtxt')
# Path to image
PATH_TO_IMAGE = self.selected_image_file
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)
# 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')
image_detected = 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)
#image = Image.open(image)
'''self.tk_image = ImageTk.PhotoImage(image)
self.main_panel.config(
width=max(image.width(), 256), height=max(image.width(), 256))
self.main_panel.create_image(0, 0, image=self.tk_image, anchor=NW)'''
cv2.imwrite(os.path.join(CWD_PATH, 'waka.jpg'), image)
image = Image.open(os.path.join(CWD_PATH, 'waka.jpg'))
self.tk_image = ImageTk.PhotoImage(image)
self.main_panel.config(width=max(self.tk_image.width(), 256),
height=max(self.tk_image.height(), 256))
self.main_panel.create_image(0, 0, image=self.tk_image, anchor=NW)
