def prepare_model(self, input_type):
"""
prepares DeepLab model
input_type: must be 'image' or 'video'
"""
assert input_type in ['image',
'video'], "only image or video input possible"
super(DeepLabModel, self).prepare_model()
self.input_type = input_type
# fixed input sizes as model needs resize either way
# Input configurations
self.category_index = None
if self.input_type is 'video':
self._input_stream = VideoStream(self.config.VIDEO_INPUT,
self.config.WIDTH,
self.config.HEIGHT).start()
elif self.input_type is 'image':
self._input_stream = ImageStream(self.config.IMAGE_PATH,
self.config.LIMIT_IMAGES).start()
if self.config.WRITE_TIMELINE:
self._run_options = tf.RunOptions(
trace_level=tf.RunOptions.FULL_TRACE)
self._run_metadata = tf.RunMetadata()
self._timeliner = TimeLiner()
print("> Building Graph")
with self.detection_graph.as_default():
with tf.Session(graph=self.detection_graph,
config=self._tf_config) as self._sess:
return self
def segmentation(model,config):
images = load_images(config.IMAGE_PATH,config.LIMIT_IMAGES)
# Tf Session + Timeliner
tf_config = model.tf_config
detection_graph = model.detection_graph
if config.WRITE_TIMELINE:
options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
timeliner = TimeLiner()
else:
options = tf.RunOptions(trace_level=tf.RunOptions.NO_TRACE)
run_metadata = False
timer = Timer().start()
print("> Starting Segmentaion")
with detection_graph.as_default():
with tf.Session(graph=detection_graph, config=tf_config) as sess:
for image in images:
# input
frame = cv2.imread(image)
height, width, channels = frame.shape
resize_ratio = 1.0 * 513 / max(width,height)
target_size = (int(resize_ratio * width), int(resize_ratio * height))
frame = cv2.resize(frame, target_size)
timer.tic()
batch_seg_map = sess.run('SemanticPredictions:0',
feed_dict={'ImageTensor:0': [cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)]},
options=options, run_metadata=run_metadata)
timer.toc()
if config.WRITE_TIMELINE:
timeliner.write_timeline(run_metadata.step_stats,
'{}/timeline_{}.json'.format(
config.RESULT_PATH,config.DL_DISPLAY_NAME))
seg_map = batch_seg_map[0]
#boxes = []
#labels = []
#ids = []
map_labeled = measure.label(seg_map, connectivity=1)
for region in measure.regionprops(map_labeled):
if region.area > config.MINAREA:
box = region.bbox
id = seg_map[tuple(region.coords[0])]
label = config.LABEL_NAMES[id]
#boxes.append(box)
#labels.append(label)
#ids.append(id)
if config.VISUALIZE:
draw_single_box_on_image(frame,box,label,id,config.DISCO_MODE)
vis = visualize_deeplab(frame,seg_map,timer.get_frame(),config.MAX_FRAMES,timer.get_fps(),
config.PRINT_INTERVAL,config.PRINT_TH,config.DL_DISPLAY_NAME,
config.VISUALIZE,config.VIS_FPS,config.DISCO_MODE,config.ALPHA)
if not vis:
break
if config.SAVE_RESULT:
cv2.imwrite('{}/{}_{}.jpg'.format(config.RESULT_PATH,timer.get_frame(),config.DL_DISPLAY_NAME),frame)
cv2.destroyAllWindows()
timer.stop()
def segmentation(model,config):
images = load_images(config.IMAGE_PATH,config.LIMIT_IMAGES)
# Tf Session + Timeliner
tf_config = tf.ConfigProto(allow_soft_placement=True)
tf_config.gpu_options.allow_growth=True
detection_graph = model.detection_graph
if config.WRITE_TIMELINE:
options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
timeliner = TimeLiner()
else:
options = tf.RunOptions(trace_level=tf.RunOptions.NO_TRACE)
run_metadata = False
timer = Timer().start()
print("> Starting Segmentaion")
with detection_graph.as_default():
with tf.Session(graph=detection_graph, config=tf_config) as sess:
for image in images:
# input
frame = cv2.imread(image)
height, width, channels = frame.shape
resize_ratio = 1.0 * 513 / max(width,height)
target_size = (int(resize_ratio * width), int(resize_ratio * height))
frame = cv2.resize(frame, target_size)
timer.tic()
batch_seg_map = sess.run('SemanticPredictions:0',
feed_dict={'ImageTensor:0': [cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)]},
options=options, run_metadata=run_metadata)
timer.toc()
if config.WRITE_TIMELINE:
timeliner.write_timeline(run_metadata.step_stats,
'test_results/timeline_{}{}.json'.format(
config.OD_MODEL_NAME,config.DEVICE))
# visualization
if config.VISUALIZE:
seg_map = batch_seg_map[0]
seg_image = create_colormap(seg_map).astype(np.uint8)
cv2.addWeighted(seg_image,config.ALPHA,frame,1-config.ALPHA,0,frame)
vis_text(frame,"fps: {}".format(timer.get_fps()),(10,30))
# boxes (ymin, xmin, ymax, xmax)
if config.BBOX:
map_labeled = measure.label(seg_map, connectivity=1)
for region in measure.regionprops(map_labeled):
if region.area > config.MINAREA:
box = region.bbox
p1 = (box[1], box[0])
p2 = (box[3], box[2])
cv2.rectangle(frame, p1, p2, (77,255,9), 2)
vis_text(frame,config.LABEL_NAMES[seg_map[tuple(region.coords[0])]],(p1[0],p1[1]-10))
cv2.imshow('segmentation',frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
cv2.destroyAllWindows()
timer.stop()
def prepare_timeliner(self):
"""
prepares timeliner and sets tf Run options
"""
self._run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
self._run_metadata = tf.RunMetadata()
self.timeliner = TimeLiner()
def detection(model, config):
# Tf Session
tf_config = model.tf_config
detection_graph = model.detection_graph
category_index = model.category_index
print("> Building Graph")
with detection_graph.as_default():
with tf.Session(graph=detection_graph, config=tf_config) as sess:
# start Videostream
# Define Input and Ouput tensors
tensor_dict = model.get_tensordict([
'num_detections', 'detection_boxes', 'detection_scores',
'detection_classes', 'detection_masks'
])
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
# Mask Transformations
if 'detection_masks' in tensor_dict:
# Reframe is required to translate mask from box coordinates to image coordinates and fit the image size.
detection_boxes = tf.squeeze(tensor_dict['detection_boxes'],
[0])
detection_masks = tf.squeeze(tensor_dict['detection_masks'],
[0])
real_num_detection = tf.cast(tensor_dict['num_detections'][0],
tf.int32)
detection_boxes = tf.slice(detection_boxes, [0, 0],
[real_num_detection, -1])
detection_masks = tf.slice(detection_masks, [0, 0, 0],
[real_num_detection, -1, -1])
detection_masks_reframed = utils_ops.reframe_box_masks_to_image_masks(
detection_masks, detection_boxes, config.HEIGHT,
config.WIDTH)
detection_masks_reframed = tf.cast(
tf.greater(detection_masks_reframed, 0.5), tf.uint8)
# Follow the convention by adding back the batch dimension
tensor_dict['detection_masks'] = tf.expand_dims(
detection_masks_reframed, 0)
if config.SPLIT_MODEL:
score_out = detection_graph.get_tensor_by_name(
'Postprocessor/convert_scores:0')
expand_out = detection_graph.get_tensor_by_name(
'Postprocessor/ExpandDims_1:0')
score_in = detection_graph.get_tensor_by_name(
'Postprocessor/convert_scores_1:0')
expand_in = detection_graph.get_tensor_by_name(
'Postprocessor/ExpandDims_1_1:0')
# Threading
score = model.score
expand = model.expand
# Timeliner
if config.WRITE_TIMELINE:
options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
timeliner = TimeLiner()
else:
options = tf.RunOptions(trace_level=tf.RunOptions.NO_TRACE)
run_metadata = False
images = load_images(config.IMAGE_PATH, config.LIMIT_IMAGES)
timer = Timer().start()
print('> Starting Detection')
for image in images:
if config.SPLIT_MODEL:
# split model in seperate gpu and cpu session threads
masks = None # No Mask Detection possible yet
frame = cv2.resize(cv2.imread(image),
(config.WIDTH, config.HEIGHT))
frame_expanded = np.expand_dims(cv2.cvtColor(
frame, cv2.COLOR_BGR2RGB),
axis=0)
timer.tic()
# GPU Session
score, expand = sess.run(
[score_out, expand_out],
feed_dict={image_tensor: frame_expanded},
options=options,
run_metadata=run_metadata)
timer.tictic()
if config.WRITE_TIMELINE:
timeliner.write_timeline(
run_metadata.step_stats,
'test_results/timeline_{}{}{}{}.json'.format(
config.OD_MODEL_NAME, '_SM1', config._DEV,
config._OPT))
timer.tic()
# CPU Session
boxes, scores, classes, num = sess.run(
[
tensor_dict['detection_boxes'],
tensor_dict['detection_scores'],
tensor_dict['detection_classes'],
tensor_dict['num_detections']
],
feed_dict={
score_in: score,
expand_in: expand
},
options=options,
run_metadata=run_metadata)
timer.toc()
if config.WRITE_TIMELINE:
timeliner.write_timeline(
run_metadata.step_stats,
'test_results/timeline_{}{}{}{}.json'.format(
config.OD_MODEL_NAME, '_SM2', config._DEV,
config._OPT))
else:
# default session
frame = cv2.resize(cv2.imread(image),
(config.WIDTH, config.HEIGHT))
frame_expanded = np.expand_dims(cv2.cvtColor(
frame, cv2.COLOR_BGR2RGB),
axis=0)
timer.tic()
output_dict = sess.run(
tensor_dict,
feed_dict={image_tensor: frame_expanded},
options=options,
run_metadata=run_metadata)
timer.toc()
if config.WRITE_TIMELINE:
timeliner.write_timeline(
run_metadata.step_stats,
'test_results/timeline_{}{}{}.json'.format(
config.OD_MODEL_NAME, config._DEV,
config._OPT))
num = output_dict['num_detections'][0]
classes = output_dict['detection_classes'][0]
boxes = output_dict['detection_boxes'][0]
scores = output_dict['detection_scores'][0]
if 'detection_masks' in output_dict:
masks = output_dict['detection_masks'][0]
else:
masks = None
# reformat detection
num = int(num)
boxes = np.squeeze(boxes)
classes = np.squeeze(classes).astype(np.uint8)
scores = np.squeeze(scores)
# Visualization
vis = vis_detection(frame, boxes, classes,
scores, masks, category_index,
timer.get_fps(), config.VISUALIZE,
config.DET_INTERVAL, config.DET_TH,
config.MAX_FRAMES, None,
config.OD_MODEL_NAME + config._OPT)
if not vis:
break
cv2.destroyAllWindows()
timer.stop()
class DeepLabModel(Model):
def __init__(self, config):
super(DeepLabModel, self).__init__(config)
def prepare_model(self, input_type):
"""
prepares DeepLab model
input_type: must be 'image' or 'video'
"""
assert input_type in ['image',
'video'], "only image or video input possible"
super(DeepLabModel, self).prepare_model()
self.input_type = input_type
# fixed input sizes as model needs resize either way
# Input configurations
self.category_index = None
if self.input_type is 'video':
self._input_stream = VideoStream(self.config.VIDEO_INPUT,
self.config.WIDTH,
self.config.HEIGHT).start()
elif self.input_type is 'image':
self._input_stream = ImageStream(self.config.IMAGE_PATH,
self.config.LIMIT_IMAGES).start()
if self.config.WRITE_TIMELINE:
self._run_options = tf.RunOptions(
trace_level=tf.RunOptions.FULL_TRACE)
self._run_metadata = tf.RunMetadata()
self._timeliner = TimeLiner()
print("> Building Graph")
with self.detection_graph.as_default():
with tf.Session(graph=self.detection_graph,
config=self._tf_config) as self._sess:
return self
def detect(self):
"""
DeepLab Detection function
"""
self.frame = self._input_stream.read()
height, width, _ = self.frame.shape
resize_ratio = 1.0 * 513 / max(self._input_stream.real_width,
self._input_stream.real_height)
target_size = (int(resize_ratio * self._input_stream.real_width),
int(resize_ratio * self._input_stream.real_height)
) #(513, 342)?(513,384)
self.frame = self._visualizer.resize_image(self.frame, target_size)
batch_seg_map = self._sess.run(
'SemanticPredictions:0',
feed_dict={
'ImageTensor:0':
[self._visualizer.convertRGB_image(self.frame)]
},
options=self._run_options,
run_metadata=self._run_metadata)
if self.config.WRITE_TIMELINE and self.input_type is 'image':
self._timeliner.write_timeline(
self._run_metadata.step_stats,
'{}/timeline_{}.json'.format(self.config.RESULT_PATH,
self.config.DISPLAY_NAME))
seg_map = batch_seg_map[0]
self.boxes = []
self.labels = []
self.ids = []
if self.config.BBOX:
map_labeled = measure.label(seg_map, connectivity=1)
for region in measure.regionprops(map_labeled):
if region.area > self.config.MINAREA:
box = region.bbox
id = seg_map[tuple(region.coords[0])]
label = self.config.LABEL_NAMES[id]
self.boxes.append(box)
self.labels.append(label)
self.ids.append(id)
# workaround
self.num = len(self.boxes)
self.classes = self.ids
self.scores = self.labels
self.masks = seg_map
def prepare_model(self, input_type):
"""
prepares Object_Detection model
input_type: must be 'image' or 'video'
"""
assert input_type in ['image', 'video'
], "only 'image' or 'video' input possible"
super(ObjectDetectionModel, self).prepare_model()
self.input_type = input_type
# Tracker
if self.config.USE_TRACKER:
sys.path.append(os.getcwd() + '/rod/kcf')
import KCF
self._tracker = KCF.kcftracker(False, True, False, False)
self._tracker_counter = 0
self._track = False
print("> Building Graph")
with self.detection_graph.as_default():
with tf.Session(graph=self.detection_graph,
config=self._tf_config) as self._sess:
# Input Configuration
if self.input_type is 'video':
self._input_stream = VideoStream(
self.config.VIDEO_INPUT, self.config.WIDTH,
self.config.HEIGHT).start()
height = self._input_stream.real_height
width = self._input_stream.real_width
elif self.input_type is 'image':
self._input_stream = ImageStream(
self.config.IMAGE_PATH, self.config.LIMIT_IMAGES,
(self.config.WIDTH, self.config.HEIGHT)).start()
height = self.config.HEIGHT
width = self.config.WIDTH
# Timeliner for image detection
if self.config.WRITE_TIMELINE:
self._run_options = tf.RunOptions(
trace_level=tf.RunOptions.FULL_TRACE)
self._run_metadata = tf.RunMetadata()
self.timeliner = TimeLiner()
# Define Input and Ouput tensors
self._tensor_dict = self.get_tensordict([
'num_detections', 'detection_boxes', 'detection_scores',
'detection_classes', 'detection_masks'
])
self._image_tensor = self.detection_graph.get_tensor_by_name(
'image_tensor:0')
# Mask Transformations
if 'detection_masks' in self._tensor_dict:
# Reframe is required to translate mask from box coordinates to image coordinates and fit the image size.
detection_boxes = tf.squeeze(
self._tensor_dict['detection_boxes'], [0])
detection_masks = tf.squeeze(
self._tensor_dict['detection_masks'], [0])
real_num_detection = tf.cast(
self._tensor_dict['num_detections'][0], tf.int32)
detection_boxes = tf.slice(detection_boxes, [0, 0],
[real_num_detection, -1])
detection_masks = tf.slice(detection_masks, [0, 0, 0],
[real_num_detection, -1, -1])
detection_masks_reframed = reframe_box_masks_to_image_masks(
detection_masks, detection_boxes, height, width)
detection_masks_reframed = tf.cast(
tf.greater(detection_masks_reframed, 0.5), tf.uint8)
self._tensor_dict['detection_masks'] = tf.expand_dims(
detection_masks_reframed, 0)
if self.config.SPLIT_MODEL:
self._score_out = self.detection_graph.get_tensor_by_name(
'{}:0'.format(self.config.SPLIT_NODES[0]))
self._expand_out = self.detection_graph.get_tensor_by_name(
'{}:0'.format(self.config.SPLIT_NODES[1]))
self._score_in = self.detection_graph.get_tensor_by_name(
'{}_1:0'.format(self.config.SPLIT_NODES[0]))
self._expand_in = self.detection_graph.get_tensor_by_name(
'{}_1:0'.format(self.config.SPLIT_NODES[1]))
# Threading
self._gpu_worker = SessionWorker("GPU",
self.detection_graph,
self._tf_config)
self._cpu_worker = SessionWorker("CPU",
self.detection_graph,
self._tf_config)
self._gpu_opts = [self._score_out, self._expand_out]
self._cpu_opts = [
self._tensor_dict['detection_boxes'],
self._tensor_dict['detection_scores'],
self._tensor_dict['detection_classes'],
self._tensor_dict['num_detections']
]
return self
class ObjectDetectionModel(Model):
"""
object_detection model class
"""
def __init__(self, config):
super(ObjectDetectionModel, self).__init__(config)
def prepare_model(self, input_type):
"""
prepares Object_Detection model
input_type: must be 'image' or 'video'
"""
assert input_type in ['image', 'video'
], "only 'image' or 'video' input possible"
super(ObjectDetectionModel, self).prepare_model()
self.input_type = input_type
# Tracker
if self.config.USE_TRACKER:
sys.path.append(os.getcwd() + '/rod/kcf')
import KCF
self._tracker = KCF.kcftracker(False, True, False, False)
self._tracker_counter = 0
self._track = False
print("> Building Graph")
with self.detection_graph.as_default():
with tf.Session(graph=self.detection_graph,
config=self._tf_config) as self._sess:
# Input Configuration
if self.input_type is 'video':
self._input_stream = VideoStream(
self.config.VIDEO_INPUT, self.config.WIDTH,
self.config.HEIGHT).start()
height = self._input_stream.real_height
width = self._input_stream.real_width
elif self.input_type is 'image':
self._input_stream = ImageStream(
self.config.IMAGE_PATH, self.config.LIMIT_IMAGES,
(self.config.WIDTH, self.config.HEIGHT)).start()
height = self.config.HEIGHT
width = self.config.WIDTH
# Timeliner for image detection
if self.config.WRITE_TIMELINE:
self._run_options = tf.RunOptions(
trace_level=tf.RunOptions.FULL_TRACE)
self._run_metadata = tf.RunMetadata()
self.timeliner = TimeLiner()
# Define Input and Ouput tensors
self._tensor_dict = self.get_tensordict([
'num_detections', 'detection_boxes', 'detection_scores',
'detection_classes', 'detection_masks'
])
self._image_tensor = self.detection_graph.get_tensor_by_name(
'image_tensor:0')
# Mask Transformations
if 'detection_masks' in self._tensor_dict:
# Reframe is required to translate mask from box coordinates to image coordinates and fit the image size.
detection_boxes = tf.squeeze(
self._tensor_dict['detection_boxes'], [0])
detection_masks = tf.squeeze(
self._tensor_dict['detection_masks'], [0])
real_num_detection = tf.cast(
self._tensor_dict['num_detections'][0], tf.int32)
detection_boxes = tf.slice(detection_boxes, [0, 0],
[real_num_detection, -1])
detection_masks = tf.slice(detection_masks, [0, 0, 0],
[real_num_detection, -1, -1])
detection_masks_reframed = reframe_box_masks_to_image_masks(
detection_masks, detection_boxes, height, width)
detection_masks_reframed = tf.cast(
tf.greater(detection_masks_reframed, 0.5), tf.uint8)
self._tensor_dict['detection_masks'] = tf.expand_dims(
detection_masks_reframed, 0)
if self.config.SPLIT_MODEL:
self._score_out = self.detection_graph.get_tensor_by_name(
'{}:0'.format(self.config.SPLIT_NODES[0]))
self._expand_out = self.detection_graph.get_tensor_by_name(
'{}:0'.format(self.config.SPLIT_NODES[1]))
self._score_in = self.detection_graph.get_tensor_by_name(
'{}_1:0'.format(self.config.SPLIT_NODES[0]))
self._expand_in = self.detection_graph.get_tensor_by_name(
'{}_1:0'.format(self.config.SPLIT_NODES[1]))
# Threading
self._gpu_worker = SessionWorker("GPU",
self.detection_graph,
self._tf_config)
self._cpu_worker = SessionWorker("CPU",
self.detection_graph,
self._tf_config)
self._gpu_opts = [self._score_out, self._expand_out]
self._cpu_opts = [
self._tensor_dict['detection_boxes'],
self._tensor_dict['detection_scores'],
self._tensor_dict['detection_classes'],
self._tensor_dict['num_detections']
]
return self
def run_default_sess(self):
"""
runs default session
"""
# default session)
self.frame = self._input_stream.read()
output_dict = self._sess.run(
self._tensor_dict,
feed_dict={
self._image_tensor:
self._visualizer.expand_and_convertRGB_image(self.frame)
},
options=self._run_options,
run_metadata=self._run_metadata)
self.num = output_dict['num_detections'][0]
self.classes = output_dict['detection_classes'][0]
self.boxes = output_dict['detection_boxes'][0]
self.scores = output_dict['detection_scores'][0]
if 'detection_masks' in output_dict:
self.masks = output_dict['detection_masks'][0]
def run_thread_sess(self):
"""
runs seperate gpu and cpu session threads
"""
if self._gpu_worker.is_sess_empty():
# put new queue
self.frame = self._input_stream.read()
gpu_feeds = {
self._image_tensor:
self._visualizer.expand_and_convertRGB_image(self.frame)
}
if self.config.VISUALIZE:
gpu_extras = self.frame # for visualization frame
else:
gpu_extras = None
self._gpu_worker.put_sess_queue(self._gpu_opts, gpu_feeds,
gpu_extras)
g = self._gpu_worker.get_result_queue()
if g is None:
# gpu thread has no output queue. ok skip, let's check cpu thread.
pass
else:
# gpu thread has output queue.
score, expand, self._frame = g["results"][0], g["results"][1], g[
"extras"]
if self._cpu_worker.is_sess_empty():
# When cpu thread has no next queue, put new queue.
# else, drop gpu queue.
cpu_feeds = {self._score_in: score, self._expand_in: expand}
cpu_extras = self.frame
self._cpu_worker.put_sess_queue(self._cpu_opts, cpu_feeds,
cpu_extras)
c = self._cpu_worker.get_result_queue()
if c is None:
# cpu thread has no output queue. ok, nothing to do. continue
self._wait_thread = True
return # If CPU RESULT has not been set yet, no fps update
else:
self._wait_thread = False
self.boxes, self.scores, self.classes, self.num, self.frame = c[
"results"][0], c["results"][1], c["results"][2], c["results"][
3], c["extras"]
def run_split_sess(self):
"""
runs split session WITHOUT threading
optional: timeline writer
"""
self.frame = self._input_stream.read()
score, expand = self._sess.run(
self._gpu_opts,
feed_dict={
self._image_tensor:
self._visualizer.expand_and_convertRGB_image(self.frame)
},
options=self._run_options,
run_metadata=self._run_metadata)
if self.config.WRITE_TIMELINE:
self.timeliner.write_timeline(
self._run_metadata.step_stats,
'{}/timeline_{}_SM1.json'.format(self.config.RESULT_PATH,
self.config.DISPLAY_NAME))
# CPU Session
self.boxes, self.scores, self.classes, self.num = self._sess.run(
self._cpu_opts,
feed_dict={
self._score_in: score,
self._expand_in: expand
},
options=self._run_options,
run_metadata=self._run_metadata)
if self.config.WRITE_TIMELINE:
self.timeliner.write_timeline(
self._run_metadata.step_stats,
'{}/timeline_{}_SM2.json'.format(self.config.RESULT_PATH,
self.config.DISPLAY_NAME))
def run_tracker(self):
"""
runs KCF tracker on videoStream frame
!does not work on images, obviously!
"""
self.frame = self._input_stream.read()
if self._first_track:
self._trackers = []
self._tracker_boxes = self.boxes
for box in self.boxes[~np.all(self.boxes == 0, axis=1)]:
self._tracker.init(
conv_detect2track(box, self._input_stream.real_width,
self._input_stream.real_height),
self.tracker_frame)
self._trackers.append(self._tracker)
self._first_track = False
for idx, self._tracker in enumerate(self._trackers):
tracker_box = self._tracker.update(self.frame)
self._tracker_boxes[idx, :] = conv_track2detect(
tracker_box, self._input_stream.real_width,
self._input_stream.real_height)
self._tracker_counter += 1
self.boxes = self._tracker_boxes
# Deactivate Tracker
if self._tracker_counter >= self.config.TRACKER_FRAMES:
self._track = False
self._tracker_counter = 0
def reformat_detection(self):
"""
reformats detection
"""
self.num = int(self.num)
self.boxes = np.squeeze(self.boxes)
self.classes = np.squeeze(self.classes).astype(np.uint8)
self.scores = np.squeeze(self.scores)
def detect(self):
"""
Object_Detection Detection function
optional: multi threading split session, timline writer
"""
if not (self.config.USE_TRACKER and self._track):
if self.config.SPLIT_MODEL:
if self.config.MULTI_THREADING:
self.run_thread_sess()
if self._wait_thread: # checks if thread has output
return
else:
self.run_split_sess()
else:
self.run_default_sess()
if self.config.WRITE_TIMELINE and self.input_type is 'image':
self.timeliner.write_timeline(
self._run_metadata.step_stats,
'{}/timeline_{}.json'.format(self.config.RESULT_PATH,
self.config.DISPLAY_NAME))
self.reformat_detection()
# Activate Tracker
if self.config.USE_TRACKER and self.num <= self.config.NUM_TRACKERS and self.input_type is 'video':
self.tracker_frame = self.frame
self._track = True
self._first_track = True
# Tracking
else:
self.run_tracker()
def segmentation(model, config):
images = load_images(config.IMAGE_PATH, config.LIMIT_IMAGES)
# Tf Session + Timeliner
tf_config = model.tf_config
detection_graph = model.detection_graph
if config.WRITE_TIMELINE:
options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
timeliner = TimeLiner()
else:
options = tf.RunOptions(trace_level=tf.RunOptions.NO_TRACE)
run_metadata = False
timer = Timer().start()
print("> Starting Segmentaion")
with detection_graph.as_default():
with tf.Session(graph=detection_graph, config=tf_config) as sess:
for image in images:
# input
frame = cv2.imread(image)
height, width, channels = frame.shape
resize_ratio = 1.0 * 513 / max(width, height)
target_size = (int(resize_ratio * width),
int(resize_ratio * height))
frame = cv2.resize(frame, target_size)
timer.tic()
batch_seg_map = sess.run(
'SemanticPredictions:0',
feed_dict={
'ImageTensor:0':
[cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)]
},
options=options,
run_metadata=run_metadata)
timer.toc()
if config.WRITE_TIMELINE:
timeliner.write_timeline(
run_metadata.step_stats,
'{}/timeline_{}.json'.format(config.RESULT_PATH,
config.DL_DISPLAY_NAME))
seg_map = batch_seg_map[0]
#boxes = []
#labels = []
#ids = []
map_labeled = measure.label(seg_map, connectivity=1)
for region in measure.regionprops(map_labeled):
if region.area > config.MINAREA:
box = region.bbox
id = seg_map[tuple(region.coords[0])]
label = config.LABEL_NAMES[id]
#boxes.append(box)
#labels.append(label)
#ids.append(id)
if config.VISUALIZE:
draw_single_box_on_image(frame, box, label, id,
config.DISCO_MODE)
vis = visualize_deeplab(frame, seg_map,
timer.get_frame(), config.MAX_FRAMES,
timer.get_fps(), config.PRINT_INTERVAL,
config.PRINT_TH,
config.DL_DISPLAY_NAME,
config.VISUALIZE, config.VIS_FPS,
config.DISCO_MODE, config.ALPHA)
if not vis:
break
if config.SAVE_RESULT:
cv2.imwrite(
'{}/{}_{}.jpg'.format(config.RESULT_PATH,
timer.get_frame(),
config.DL_DISPLAY_NAME), frame)
cv2.destroyAllWindows()
timer.stop()
def detection(model,config):
# Tf Session
tf_config = model.tf_config
detection_graph = model.detection_graph
category_index = model.category_index
print("> Building Graph")
with detection_graph.as_default():
with tf.Session(graph=detection_graph,config=tf_config) as sess:
# start Videostream
# Define Input and Ouput tensors
tensor_dict = model.get_tensordict(['num_detections', 'detection_boxes', 'detection_scores','detection_classes', 'detection_masks'])
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
# Mask Transformations
if 'detection_masks' in tensor_dict:
# Reframe is required to translate mask from box coordinates to image coordinates and fit the image size.
detection_boxes = tf.squeeze(tensor_dict['detection_boxes'], [0])
detection_masks = tf.squeeze(tensor_dict['detection_masks'], [0])
real_num_detection = tf.cast(tensor_dict['num_detections'][0], tf.int32)
detection_boxes = tf.slice(detection_boxes, [0, 0], [real_num_detection, -1])
detection_masks = tf.slice(detection_masks, [0, 0, 0], [real_num_detection, -1, -1])
detection_masks_reframed = reframe_box_masks_to_image_masks(
detection_masks, detection_boxes, config.HEIGHT, config.WIDTH)
detection_masks_reframed = tf.cast(tf.greater(detection_masks_reframed, 0.5), tf.uint8)
# Follow the convention by adding back the batch dimension
tensor_dict['detection_masks'] = tf.expand_dims(detection_masks_reframed, 0)
if config.SPLIT_MODEL:
score_out = detection_graph.get_tensor_by_name('Postprocessor/convert_scores:0')
expand_out = detection_graph.get_tensor_by_name('Postprocessor/ExpandDims_1:0')
score_in = detection_graph.get_tensor_by_name('Postprocessor/convert_scores_1:0')
expand_in = detection_graph.get_tensor_by_name('Postprocessor/ExpandDims_1_1:0')
# Threading
score = model.score
expand = model.expand
# Timeliner
if config.WRITE_TIMELINE:
options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
timeliner = TimeLiner()
else:
options = tf.RunOptions(trace_level=tf.RunOptions.NO_TRACE)
run_metadata = False
images = load_images(config.IMAGE_PATH,config.LIMIT_IMAGES)
timer = Timer().start()
print('> Starting Detection')
for image in images:
if config.SPLIT_MODEL:
# split model in seperate gpu and cpu session threads
masks = None # No Mask Detection possible yet
frame = cv2.resize(cv2.imread(image),(config.WIDTH,config.HEIGHT))
frame_expanded = np.expand_dims(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), axis=0)
timer.tic()
# GPU Session
score, expand = sess.run([score_out, expand_out],
feed_dict={image_tensor: frame_expanded},
options=options, run_metadata=run_metadata)
timer.tictic()
if config.WRITE_TIMELINE:
timeliner.write_timeline(run_metadata.step_stats,
'{}/timeline_{}_SM1.json'.format(
config.RESULT_PATH,config.OD_DISPLAY_NAME))
timer.tic()
# CPU Session
boxes, scores, classes, num = sess.run(
[tensor_dict['detection_boxes'], tensor_dict['detection_scores'], tensor_dict['detection_classes'], tensor_dict['num_detections']],
feed_dict={score_in:score, expand_in: expand},
options=options, run_metadata=run_metadata)
timer.toc()
if config.WRITE_TIMELINE:
timeliner.write_timeline(run_metadata.step_stats,
'{}/timeline_{}_SM2.json'.format(
config.RESULT_PATH,config.OD_DISPLAY_NAME))
else:
# default session
frame = cv2.resize(cv2.imread(image),(config.WIDTH,config.HEIGHT))
frame_expanded = np.expand_dims(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), axis=0)
timer.tic()
output_dict = sess.run(tensor_dict,
feed_dict={image_tensor: frame_expanded},
options=options, run_metadata=run_metadata)
timer.toc()
if config.WRITE_TIMELINE:
timeliner.write_timeline(run_metadata.step_stats,
'{}/timeline_{}.json'.format(
config.RESULT_PATH,config.OD_DISPLAY_NAME))
num = output_dict['num_detections'][0]
classes = output_dict['detection_classes'][0]
boxes = output_dict['detection_boxes'][0]
scores = output_dict['detection_scores'][0]
if 'detection_masks' in output_dict:
masks = output_dict['detection_masks'][0]
else:
masks = None
# reformat detection
num = int(num)
boxes = np.squeeze(boxes)
classes = np.squeeze(classes).astype(np.uint8)
scores = np.squeeze(scores)
# Visualization
vis = visualize_objectdetection(frame,boxes,classes,scores,masks,category_index,timer.get_frame(),
config.MAX_FRAMES,timer.get_fps(),config.PRINT_INTERVAL,config.PRINT_TH,
config.OD_DISPLAY_NAME,config.VISUALIZE,config.VIS_FPS,config.DISCO_MOE,config.ALPHA)
if not vis:
break
if config.SAVE_RESULT:
cv2.imwrite('{}/{}_{}.jpg'.format(config.RESULT_PATH,timer.get_frame(),config.OD_DISPLAY_NAME),frame)
cv2.destroyAllWindows()
timer.stop()