def main(args):
process_fps = args['process_fps'] if 'process_fps' in args else None
video = VideoReader(args['filename'], process_fps)
video.seek(args['start'])
# video.seek(5*60)
# video.seek(7625/25)
# First frame: 4:32 - 16:10
frames = []
for i in range(args['frames']):
print("pos: ", video.current_frame)
pos, img = video.next_frame()
timestamp = pos
args['image'] = img
# show_image(img)
try:
balls = process(args)
except:
continue
frames.append({
# 'game_id': args['filename'],
'timestamp': timestamp,
'balls': list(map(raw_ball, balls))
})
print("Successfully processed frames: ", len(frames))
# write_json(frames, "result.json")
return json.dumps(frames)
def __init__(self, camera):
self.initModel()
self.initTwitter()
self.frameTime = 0
self.frames = 0
self.lastImageTime = 0
self.fps = 30
self.lastTweetTime = 0
self.vr = VideoReader(camera, self.fps)
def test_iter(tmp_path):
from videoreader import VideoReader
import numpy as np
video_path = make_test_video(tmp_path)
vr = VideoReader(video_path)
for frame_number, frame in enumerate(vr[:]):
brightness = np.mean(frame)
assert brightness >= frame_number - 2 and brightness <= frame_number + 2
def test_index(tmp_path):
from videoreader import VideoReader
import numpy as np
video_path = make_test_video(tmp_path)
vr = VideoReader(video_path)
for frame_number in range(vr.number_of_frames):
frame = vr[frame_number]
brightness = np.mean(frame)
assert brightness >= frame_number - 2 and brightness <= frame_number + 2
def test_slice(tmp_path):
from videoreader import VideoReader
import numpy as np
video_path = make_test_video(tmp_path)
vr = VideoReader(video_path)
step = 10
for index, frame in enumerate(vr[::step]):
frame_number = index * step
brightness = np.mean(frame)
assert brightness >= frame_number - 2 and brightness <= frame_number + 2
def test_frame_attrs(tmp_path):
import cv2
from videoreader import VideoReader
video_path = make_test_video(tmp_path)
vr = VideoReader(video_path)
assert vr.frame_width == 480
assert vr.frame_height == 640
assert vr.frame_rate == 25.0
assert vr.fourcc == cv2.VideoWriter_fourcc(*'MJPG')
assert vr.frame_format == 0
assert vr.number_of_frames == 255
assert vr.frame_shape == (480, 640, 3)
assert vr.current_frame_pos == 0.0
def __init__(self,
filename: str,
window_title: str,
reverse=False,
qsize=16,
worker_type='thread'):
video_reader = VideoReader(filename, reverse, qsize, worker_type)
print(
f'{filename} / {video_reader.frame_size} / {video_reader.fps} fps')
cv.namedWindow(window_title)
self._window_title = window_title
self._video_reader = video_reader
self._rendered_frames = 0
self._interval = 1 / video_reader.fps
self._next_execution = 0
self._loop = asyncio.get_event_loop()
# for performance measuring
self._play_start_time = self._report_time = 0
def test_export_boxes():
vr = VideoReader(path_to_video)
frames = list(vr[100:110])
nb_flies = 3
box_centers = 400 + np.ones((1000, nb_flies, 2))
box_centers[100, 0, :] = [10, 10]
box_centers[100, 2, :] = [900, 900]
box_angles = np.zeros((1000, nb_flies, 1))
box_angles[101, 0, 0] = 45
box_angles[101, 2, 0] = -60
box_size = np.array([100, 100])
boxes, fly_id, fly_frames = export_boxes(frames, box_centers, box_angles=box_angles, box_size=box_size)
assert np.all(boxes.shape == (len(frames) * nb_flies, *box_size, vr.frame_channels))
boxes, fly_id, fly_frames = export_boxes(frames, box_centers, box_angles=box_angles, box_size=box_size)
assert np.all(boxes.shape == (len(frames) * nb_flies, *box_size, vr.frame_channels))
plt.subplot(4, 1, 1)
plt.plot(fly_id)
plt.subplot(4, 1, 2)
plt.plot(fly_frames)
plt.subplot(4, 3, 7)
plt.imshow(boxes[0, :, :, 0])
plt.subplot(4, 3, 8)
plt.imshow(boxes[1, :, :, 0])
plt.subplot(4, 3, 9)
plt.imshow(boxes[2, :, :, 0])
plt.subplot(4, 3, 10)
plt.imshow(boxes[3, :, :, 0])
plt.subplot(4, 3, 11)
plt.imshow(boxes[4, :, :, 0])
plt.subplot(4, 3, 12)
plt.imshow(boxes[5, :, :, 0])
plt.pause(2)
def main(trackfilename: str,
*,
frame_start: int = 0,
frame_stop: int = None,
frame_step: int = 1,
batch_size: int = 100,
save_interval: int = 100,
start_over: bool = False):
expID = os.path.basename(trackfilename).partition('_tracks.h5')[0]
track_path = f"{res_path}/{expID}/{expID}_tracks.h5"
data_path = root + 'chainingmic/dat'
video_path = f"{data_path}/{expID}/{expID}.mp4"
if not os.path.exists(video_path):
data_path = root + 'chainingmic/dat.processed'
video_path = f"{data_path}/{expID}/{expID}.mp4"
if not os.path.exists(video_path):
raise FileNotFoundError('video file not found.')
trackfixed_path = f"{res_path}/{expID}/{expID}_tracks_fixed.h5"
pose_path = f"{res_path}/{expID}/{expID}_poses.h5"
try:
os.mkdir(os.path.dirname(trackfixed_path))
except FileExistsError as e:
logging.debug(e)
if not os.path.exists(trackfixed_path):
logging.info(f" fixing tracks.")
fix_tracks(track_path, trackfixed_path)
else:
logging.info(f" fixed tracks exist")
logging.info(f" opening video {video_path}.")
vr = VideoReader(video_path)
logging.info(f" loading tracks from {trackfixed_path}.")
try:
data = dd.io.load(trackfixed_path)
centers = data['centers'][:] # nframe, channel, fly id, coordinates
tracks = data['lines']
chbb = data['chambers_bounding_box'][:]
heads = tracks[:, 0, :, 0, ::-1] # nframe, fly id, coordinates
tails = tracks[:, 0, :, 1, ::-1] # nframe, fly id, coordinates
heads = heads + chbb[1][0][:] # nframe, fly id, coordinates
tails = tails + chbb[1][0][:] # nframe, fly id, coordinates
box_angles = angles(heads, tails)
box_centers = centers[:, 0, :, :] # nframe, fly id, coordinates
box_centers = box_centers + chbb[1][0][:]
nb_flies = box_centers.shape[1]
logging.info(f" nflies: {nb_flies}.")
except OSError as e:
logging.error(f' could not load tracks.')
logging.debug(e)
if frame_stop is None:
frame_stop = data['frame_count']
logging.info(f' Setting frame_stop: {frame_stop}.')
frame_numbers = range(frame_start, frame_stop, frame_step)
batch_idx = list(range(0, len(frame_numbers), batch_size))
batch_idx.append(
frame_stop - frame_start - 1
) # ADRIAN TESTING THINGS, SHOULD BE REMOVED IF COMMITED ####################################
logging.info(f" frame range: {frame_start}:{frame_stop}:{frame_step}.")
logging.info(
f" processing frames in {len(batch_idx)-1} batches of size {batch_size}."
)
box_size = [120, 120]
network = load_network(network_path, image_size=box_size)
priors_data = dd.io.load(priors_path)
priors = priors_data['priors']
nb_frames = len(frame_numbers)
nb_parts = network.output_shape[-1]
nb_boxes = nb_frames * nb_flies
logging.info(f" loading network from {network_path}.")
too_small = False
if not start_over and os.path.exists(pose_path):
logging.info(f'loading existing results from {pose_path}.')
d0 = dd.io.load(pose_path)
if 'last_saved_batch' not in d0:
logging.info(
f" existing results are from an old version - starting over."
)
start_over = True
elif d0['positions'].shape[0] < nb_boxes:
logging.info(
f" results structure too small for nboxes: {d0['positions'].shape[0]} < {nb_boxes} - starting and copying over."
)
start_over = True
too_small = True
else:
d = d0
del (d0)
logging.info(f" continuing from batch {d['last_saved_batch']}.")
if start_over or not os.path.exists(pose_path):
logging.info(f'initializing new results dictionary.')
d = {
'positions': np.zeros((nb_boxes, nb_parts, 2), dtype=np.uint16),
'confidence': np.zeros((nb_boxes, nb_parts, 1), dtype=np.float16),
'expID': expID,
'fixed_angles': np.zeros((nb_boxes, 1), dtype=np.float16),
'frame_numbers': frame_numbers,
'fly_id': np.zeros((nb_boxes, ), dtype=np.uintp),
'fly_frame': np.zeros((nb_boxes, ), dtype=np.uintp),
'bad_boxes': np.zeros((nb_boxes, 1), dtype=np.bool),
'last_saved_batch': 0,
'prior_idxs': np.zeros((nb_boxes, ), dtype=np.bool)
}
if too_small:
logging.info(f' copying old results to new results dictionary.')
last_box = batch_idx[d['last_saved_batch']] * nb_flies
d['positions'][:last_box, ...] = d0['positions'][:last_box, ...]
d['confidence'][:last_box, ...] = d0['confidence'][:last_box, ...]
d['fixed_angles'][:last_box, ...] = d0['fixed_angles'][:last_box, ...]
d['bad_boxes'][:last_box, ...] = d0['bad_boxes'][:last_box, ...]
d['fly_id'][:last_box] = d0['fly_id'][:last_box]
d['fly_frame'][:last_box] = d0['fly_frame'][:last_box]
d['prior_idxs'][:last_box] = d0['prior_idxs'][:last_box]
del (d0)
for batch_num in range(d['last_saved_batch'], len(batch_idx) - 1):
logging.info(f"PROCESSING BATCH {batch_num}.")
batch_frame_numbers = list(
range(frame_numbers[batch_idx[batch_num]],
frame_numbers[batch_idx[batch_num + 1]]))
batch_box_numbers = list(
range(batch_idx[batch_num] * nb_flies,
batch_idx[batch_num + 1] * nb_flies))
logging.info(
f" loading frames {batch_frame_numbers[0]}:{batch_frame_numbers[-1]}."
)
frames = [frame[:, :, :1] for frame in vr[batch_frame_numbers]
] # keep only one color channel
d['positions'][batch_box_numbers, ...], d['confidence'][
batch_box_numbers, ...], _, d['bad_boxes'][
batch_box_numbers, ...], d['fly_id'][batch_box_numbers], d[
'fly_frame'][batch_box_numbers], _, d['fixed_angles'][
batch_box_numbers, ...], d['prior_idxs'][
batch_box_numbers] = process_batch(
network, frames,
box_centers[batch_frame_numbers, ...],
box_angles[batch_frame_numbers,
...], box_size, priors)
if batch_num % save_interval == 0:
logging.info(
f" saving intermediate results after {batch_num} to {pose_path}."
)
dd.io.save(pose_path, d)
d['last_saved_batch'] = batch_num
logging.info(f" saving poses to {pose_path}.")
dd.io.save(pose_path, d)
class Detector:
def __init__(self, camera):
self.initModel()
self.initTwitter()
self.frameTime = 0
self.frames = 0
self.lastImageTime = 0
self.fps = 30
self.lastTweetTime = 0
self.vr = VideoReader(camera, self.fps)
def initModel(self):
self.interpreter = tf.lite.Interpreter(model_path=MODEL_FILE)
self.interpreter.allocate_tensors()
self.input_details = self.interpreter.get_input_details()
self.output_details = self.interpreter.get_output_details()
self.model_height = self.input_details[0]['shape'][1]
self.model_width = self.input_details[0]['shape'][2]
self.floating_model = (self.input_details[0]['dtype'] == np.float32)
def initTwitter(self):
with open(TWITTER_CONFIG) as f:
data = json.load(f)
auth = tweepy.OAuthHandler(data['apiKey'], data['apiSecret'])
auth.set_access_token(data['token'], data['tokenSecret'])
self.twitter = tweepy.API(auth)
def detect(self, image):
image = image.copy()
# Test model on random input data.
input_shape = self.input_details[0]['shape']
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image_resized = cv2.resize(image_rgb,
(self.model_width, self.model_height))
input_data = np.expand_dims(image_resized, axis=0)
if self.floating_model:
input_data = (np.float32(input_data) - INPUT_MEAN) / INPUT_STD
self.interpreter.set_tensor(self.input_details[0]['index'], input_data)
# Run the network
self.interpreter.invoke()
boxes = self.interpreter.get_tensor(self.output_details[0]['index'])[0]
classes = self.interpreter.get_tensor(
self.output_details[1]['index'])[0]
scores = self.interpreter.get_tensor(
self.output_details[2]['index'])[0]
return boxes, scores, classes
def triggerDetection(self, frame, orig_frame):
self.log('Norppa detected!')
self.lastDetectTime = time.time()
# Only react every 30 seconds
if (time.time() - self.lastImageTime) < 30:
return
# Save the original image and frame with detection boxes
filename = "images/frame%s.jpg" % datetime.now().strftime(
"%Y%m%d-%H%M%S")
o_filename = "images/orig_frame%s.jpg" % datetime.now().strftime(
"%Y%m%d-%H%M%S")
cv2.imwrite(filename, frame)
cv2.imwrite(o_filename, orig_frame)
self.log("Wrote %s" % filename)
# Tweet
self.tweetNorppaIsLive(frame)
self.lastImageTime = time.time()
def tweetNorppaIsLive(self, frame):
# only tweet every TWEET_TIME_MINUTES minutes
if time.time() - self.lastTweetTime < TWEET_TIME_MINUTES * 60:
return
# Get random message from messages.json
with open(MESSAGES_FILE, 'r') as f:
messages = json.load(f)
randomMessage = random.choices(messages)[0].replace('#', 'hashtag-')
filename = 'uploaded_image.jpg'
cv2.imwrite(filename, frame)
self.twitter.update_with_media(filename, status=randomMessage)
self.log('Tweeted: %s' % randomMessage)
os.remove(filename)
self.lastTweetTime = time.time()
def checkCoordinates(self, x, y, x2, y2):
# You can add coordinate & width/height checks here
width = x2 - x
height = y2 - y
area = width * height
return area < 350000 and area > 10000
def log(self, msg):
date = datetime.now().strftime("%Y-%m-%d-%H:%M:%S")
print(date, msg)
def run(self):
print("Ready")
self.vr.start()
self.startTime = time.time()
frameCounter = 0
lastFrameTime = 0
detected = False
detections = 0
# Wait for the stream to start
while not self.vr.more() or time.time() - self.startTime > 10:
time.sleep(0.5)
frame = None
while True:
if not self.vr.more():
print('asd')
break
# Read the latest frame
frame = np.copy(self.vr.read())
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
frameCounter += 1
lastFrameTime = time.time()
orig_frame = frame.copy()
detected = False
# Get detection boxes and scores from tensorflow
boxes, scores, classes = self.detect(frame)
# Debug logging
if scores[0] > 0.4:
self.log(scores[0])
# Go through the boxes
for i in range(len(scores)):
score = scores[i]
box = boxes[i]
y = int(box[0] * HEIGHT)
x = int(box[1] * WIDTH)
y2 = int(box[2] * HEIGHT)
x2 = int(box[3] * WIDTH)
if score < THRESHOLD:
continue
# Some sanity checks
if not self.checkCoordinates(x, y, x2, y2):
continue
# Norppa detected here!
detected = True
self.log(score)
print((x, y), (x2, y2))
# Draw the detection box to the frame
cv2.rectangle(frame, (x, y), (x2, y2), (0, 255, 0), 2)
label = '%s: %d%%' % ('norppa', int(score * 100))
labelSize, baseLine = cv2.getTextSize(label,
cv2.FONT_HERSHEY_SIMPLEX,
0.7, 2)
label_ymin = max(y, labelSize[1] + 10)
# Draw white box to put label text in
cv2.rectangle(frame, (x, label_ymin - labelSize[1] - 10),
(x + labelSize[0], label_ymin + baseLine - 10),
(255, 255, 255), cv2.FILLED)
cv2.putText(frame, label, (x, label_ymin - 7),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 0), 2)
if detected:
detections += 1
else:
detections = 0
# Only detect after the second frame in a row that breaks the threshold
if detections >= 2:
self.triggerDetection(frame, orig_frame)
if frameCounter % 1000 == 0:
self.log('1000 frames')
frameCounter = 0
frameTime = time.time() - lastFrameTime
if frameTime < 1 / self.fps:
time.sleep(1 / self.fps - frameTime)
self.vr.stop()
time.sleep(1)
from io_parser import IOParser
# video io
from videoreader import VideoReader
from videowriter import VideoWriter
# OpenCV
import cv2
if __name__ == '__main__':
parser = IOParser()
reader = VideoReader(parser.input_file)
writer = VideoWriter(parser.output_file, reader.fps, (reader.width, reader.height), color=False)
'''
OpenCV allows for you to easily switch between colorspaces using the cvtColor method
Note - no video players will be able to play a single channel grayscale video so each channel, R,G,B are
given the same intensity values to represent grayscale.
'''
for frame in reader:
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
'''
if we didn't specify that our VideoWriter is grayscale, we would have to convert back to BGR to output a
playable version.
'''
# to_bgr = cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)
writer.write_frame(gray)
writer.close()
reader.close()
if filepath_timestamps is None:
filepath_timestamps = Path(root, dat_path, datename,
f'{datename}_timeStamps.h5')
# Create samplestamps object
ss = None
if os.path.exists(filepath_daq) and os.path.exists(filepath_timestamps):
ss, last_sample_number, sampling_rate = ld.load_times(
filepath_timestamps, filepath_daq)
if sampling_rate is None:
sampling_rate = audio_sampling_rate
path_tried = (filepath_daq, filepath_timestamps)
elif os.path.exists(filepath_video): # Video (+tracks) only
# if there is only the video, generate fake timestamps for video and samples from fps
from videoreader import VideoReader
vr = VideoReader(filepath_video)
frame_times = np.arange(0, vr.number_of_frames, 1) / vr.frame_rate
if target_sampling_rate == 0 or target_sampling_rate is None:
resample_video_data = False
target_sampling_rate = vr.frame_rate
frame_times[-1] = frame_times[
-2] # for auto-monotonize to not mess everything up
sampling_rate = 2 * target_sampling_rate # vr.frame_rate
sample_times = np.arange(0, vr.number_of_frames,
1 / sampling_rate) / vr.frame_rate
last_sample_number = len(sample_times)
ss = SampStamp(sample_times, frame_times)
path_tried = (filepath_video)
elif os.path.exists(filepath_daq) and not os.path.exists(
filepath_timestamps): # Audio (+ annotations) only
# if there is no video and no timestamps - generate fake from samplerate and number of samples
def main(expID: str = 'localhost-20180720_182837',
frame_start: int = 1000,
frame_stop: int = 2000,
frame_step: int = 100):
## Fix tracks
# Paths
trackPath = f"{resPath}\{expID}\{expID}_tracks.h5"
videoPath = f"{dataPath}\{expID}\{expID}.mp4"
trackfixedPath = f"{resPath}\{expID}\\{expID}_tracks_fixed.h5"
savingPath = f"{resPath}\{expID}"
posePath = f"{savingPath}\{expID}_pose.h5"
fixedBoxesPath = f"{savingPath}\{expID}_fixedBoxes.h5"
# Do not fix if they are already fixed
if not os.path.exists(trackfixedPath):
logging.info(f" doing adrian_fix_tracks")
adrian_fix_tracks(trackPath, trackfixedPath)
else:
logging.info(f" fixed tracks already exist")
## Load video
logging.info(f" loading video from {videoPath}.")
vr = VideoReader(videoPath)
## Load track
logging.info(f" loading tracks from {trackfixedPath}.")
has_tracks = False
try:
data = dd.io.load(trackfixedPath)
centers = data['centers'][:] # nframe, channel, fly id, coordinates
tracks = data['lines']
chbb = data['chambers_bounding_box'][:]
heads = tracks[:, 0, :, 0, ::-1] # nframe, fly id, coordinates
tails = tracks[:, 0, :, 1, ::-1] # nframe, fly id, coordinates
heads = heads + chbb[1][0][:] # nframe, fly id, coordinates
tails = tails + chbb[1][0][:] # nframe, fly id, coordinates
has_tracks = True
box_centers = centers[:, 0, :, :] # nframe, fly id, coordinates
box_centers = box_centers + chbb[1][0][:]
nb_flies = box_centers.shape[1]
logging.info(f" nflies: {nb_flies}.")
except OSError as e:
logging.error(f' could not load tracks.')
## Specifications for boxes
if frame_stop == 0:
frame_stop = data['frame_count']
logging.info(f' Setting frame_stop: {0}.'.format(frame_stop))
frame_range = range(frame_start, frame_stop, frame_step)
logging.info(f" frame range: {frame_start}:{frame_stop}:{frame_step}.")
## Create list of frames
logging.info(f" getting frames from video.")
frames = list(vr[frame_start:frame_stop:frame_step])
nb_frames = len(frames)
## Calculate angle for export boxes
logging.info(f" calculating box angles.")
box_angles = get_angles(heads[frame_range, ...], tails[frame_range, ...])
## Export boxes function
logging.info(f" exporting boxes of {expID}.")
boxes, fly_id, fly_frame = export_boxes(frames,
box_centers[frame_range, ...],
box_size=np.array([120, 120]),
box_angles=box_angles)
boxes = normalize_boxes(boxes)
# boxes = np.rot90(boxes,2,(1,2)) # Flips boxes, in case network expected fly images in the other direction
## Predictions
logging.info(f" doing predictions.")
confmaps = predict_confmaps(networkPath, boxes[:, :, :, :1])
logging.info(f" processing confidence maps.")
positions, confidence = process_confmaps_simple(confmaps)
## Recalculation of angles for further orientation fix
logging.info(f" recalculating box angles.")
newbox_angles, bad_boxes = detect_bad_boxes_byAngle(positions)
logging.info(
f" found {np.sum(bad_boxes)} cases of boxes with angles above threshold."
)
box_angles = box_angles + newbox_angles
logging.info(f" re-exporting boxes of {expID}.")
boxes, fly_id, fly_frame = export_boxes(frames,
box_centers[frame_range, ...],
box_size=np.array([120, 120]),
box_angles=box_angles)
boxes = normalize_boxes(boxes)
## Final predictions
logging.info(f" re-doing predictions.")
confmaps = predict_confmaps(networkPath, boxes[:, :, :, :1])
logging.info(f" re-processing confidence maps.")
positions, confidence = process_confmaps_simple(confmaps)
## Saving data
logging.info(f" saving pose predictions to: {posePath}.")
posedata = {
'positions': positions,
'confidence': confidence,
'confmaps': confmaps,
'expID': expID,
'frame_range': frame_range,
'fly_id': fly_id,
'fly_frame': fly_frame,
'bad_boxes': bad_boxes
}
dd.io.save(posePath, posedata)
logging.info(f" saving fixed boxes to: {fixedBoxesPath}.")
fixedBoxesdata = {'boxes': boxes, 'fly_id': fly_id, 'fly_frame': fly_frame}
dd.io.save(fixedBoxesPath, fixedBoxesdata)
## Play movie of the exported boxes
if play_boxes:
logging.info(f" playing video of boxes.")
vplay(boxes[fly_id == 0, ...])
def main(video, json_logger=None, visualise_callback=False, mode=None, inferencer=None, model_name=None, image_size=None, model_alpha=None, shot_name=None, preset_name=None, prob_threshold=None, iou_threshold=None, union_threshold=None, model_precision=None, inference_device=None, num_shots_hint=None, video_descriptor=None, gender_estimation=False, emotions_recognision=False, run_faceid=False, create_feauture_list=None, faceid_search=False):
if faceid_search:
run_faceid = True
if not(create_feauture_list is None):
feauture_list = []
run_faceid = True
if preset_name is None:
preset_name = 'accuracy'
if not(mode is None):
try:
mode = str(mode)
except (TypeError, ValueError):
raise ErrorSignal(invalid_argument_value)
else:
mode = default_mode
if not(json_logger is None):
try:
json_logger = str(json_logger)
except (TypeError, ValueError):
raise ErrorSignal(invalid_argument_value)
exit_code = 1
reader = VideoReader(video, width_hint, height_hint)
detector = FaceDetection(reader.get_width(), reader.get_height(), inferencer=inferencer, model_name=model_name, image_size=image_size, model_alpha=model_alpha, shot_name=shot_name, preset_name=preset_name, prob_threshold=prob_threshold, iou_threshold=iou_threshold, union_threshold=union_threshold, model_precision=model_precision, inference_device=inference_device, num_shots_hint=num_shots_hint)
if gender_estimation:
gender_estimatior = GenderEstimation(reader.get_width(), reader.get_height(), inferencer=inferencer)
if run_faceid:
faceid = FaceID(reader.get_width(), reader.get_height(), inferencer=inferencer)
if emotions_recognision:
emotions_recogniser = EmotionsRecognision(reader.get_width(), reader.get_height(), inferencer=inferencer)
if faceid_search:
try:
faceid_dict_f = open(faceid_dict, "r")
except IOError:
raise ErrorSignal(faceid_dict_missing)
faceid_json = json.load(faceid_dict_f)
faceid_dict_f.close()
faceids = []
for name in faceid_json:
faceids.append((name, faceid_json[name]['threshold'], np.array(faceid_json[name]['feautures'])))
callbacks = []
if visualise_callback:
callbacks.append(Visualiser(reader.get_width(), reader.get_height()))
if not(json_logger is None):
callbacks.append(JSONLogger(reader.get_width(), reader.get_height(), json_logger))
if len(callbacks) == 0:
reader.release()
raise ErrorSignal(nothing_to_do)
if mode == 'byframe':
frame_number = 0
try:
while True:
frame = reader.read()
boxes = detector.detect(frame)
genders = None
faceid_feautures = None
emotions = None
names = None
if gender_estimation:
genders = gender_estimatior.estimate(frame, boxes)
if emotions_recognision:
emotions = emotions_recogniser.recognise(frame, boxes)
if run_faceid:
faceid_feautures = faceid.feautures(frame, boxes)
if faceid_search:
names = []
for i in range(faceid_feautures.shape[0]):
face_names = []
for fid in faceids:
d = np.min(cosine_dist_norm(faceid_feautures[i].reshape(1, 128), fid[2]))
if d < fid[1]:
face_names.append(fid[0])
names.append(face_names)
if not(create_feauture_list is None):
if faceid_feautures.shape[0] > 1:
raise ErrorSignal(only_one_face_required_in_create_feauture_list_mode)
elif faceid_feautures.shape[0] == 1:
feauture_list.append(faceid_feautures[0])
frame_number += 1
for callback in callbacks:
try:
callback.call(video=video, frame=frame, boxes=boxes, frame_number=frame_number, genders=genders, emotions=emotions, faceid_feautures=faceid_feautures, names=names)
except QuitSignal as ret:
exit_code = int(ret)
break
else:
continue
break
except KeyboardInterrupt:
exit_code = 0
pass
reader.release()
for callback in callbacks:
callback.destroy()
elif mode == 'realtime':
raise NotImplementedError()
else:
raise ErrorSignal(unknown_mode)
if not(create_feauture_list is None):
try:
create_feauture_list = str(create_feauture_list)
except (KeyError, ValueError):
raise ErrorSignal(invalid_argument_value)
feautures, threshold = feauture_select(feauture_list)
try:
faceid_dict_f = open(faceid_dict, "r")
except IOError:
raise ErrorSignal(faceid_dict_missing)
faceid_json = json.load(faceid_dict_f)
faceid_dict_f.close()
faceid_json[create_feauture_list] = {
'threshold': float(threshold),
'feautures': feautures.tolist()
}
try:
faceid_dict_f = open(faceid_dict, "w")
except IOError:
raise ErrorSignal(faceid_dict_missing)
json.dump(faceid_json, faceid_dict_f)
faceid_dict_f.close()
print(faceid_success_prefix + create_feauture_list + faceid_success_suffix)
return exit_code
from io_parser import IOParser
# video io
from videoreader import VideoReader
from videowriter import VideoWriter
# OpenCV
import cv2
# numpy
import numpy as np
if __name__ == '__main__':
parser = IOParser()
reader = VideoReader(parser.input_file)
writer = VideoWriter(parser.output_file, reader.fps,
(reader.width, reader.height))
'''
OpenCV 3 offers a high-level tracking API that features several tracking algorithms you can experiment with.
For now we'll use the Kernelized Correlation Filters tracker (KCF), which uses a Bag of Features (like Bag of Words)
approach to define positive and negative 'patches' to differentiate between the foreground and background. This
is used to set up the Appearance Model of our tracker (how our tracked region looks) as well as the Motion Model
a predictive estimation of where the object will be based on its velocity and location in previous frames.
'''
# initialize the tracker
tracker = cv2.Tracker_create('KCF')
# bounding boxes are represented as x, y, w, h
bounding_box = (400, 230, 30, 40)
