def run_streams(self):
def push_to_bus(bus):
while True:
if len(self.list_to_push) > 0:
send_list = self.list_to_push.pop()
bus.push('/pack_batches', [send_list])
else:
time.sleep(0.01)
iter_batch = self.iter_batch()
periods = []
push_thread1 = Thread(target=push_to_bus, args=(bus, ))
push_thread2 = Thread(target=push_to_bus, args=(bus2, ))
push_thread1.start()
push_thread2.start()
while True:
start = time.time()
ts, batch_data = next(iter_batch)
self.list_to_push.insert(0, (ts, batch_data))
end = time.time()
period = end - start
periods.append(period)
if len(periods) > 1000:
avg_period = sum(periods) / len(periods)
periods = []
log.info('reader FPS = {}, queue = {} '.format(
(1 / avg_period), len(self.list_to_push)))
def __init__(self, streams=None, timeout=1, fps=25, file_time=60):
self.videos_dir = config.find('videos_path')
self.standby = cv2.imread(
os.path.join(sys.path[0],
*config.find('standby').split('/')))
self.timeout = timedelta(milliseconds=timeout)
self.file_time = config.find('video_duration') or file_time
self.fps = config.find('framerate') or fps
self.ext = config.find('ext') or 'avi'
self.ts_start = None
self.caps_list = []
self.list_to_push = []
self.lock = Lock()
for stream in config.find('streams') or streams:
log.info('reader Processing stream {}'.format(stream))
cap = {}
cap['stream'] = stream
cap['cap'] = cv2.VideoCapture(stream, cv2.CAP_GSTREAMER)
cap['cap'].set(3, 300)
cap['cap'].set(4, 300)
cap['width'] = 300
cap['height'] = 300
cap['standby'] = cv2.resize(self.standby,
(cap['width'], cap['height']))
cap['time_off'] = None
cap['writer'] = None
self.caps_list.append(cap)
def receive_batch(self, ts, batch_data):
start = time.time()
log.debug("infer Received processing batch data")
all_persons = 0
infer_time = []
for i in range(len(batch_data)):
camera_id = i
frame = batch_data[i]['frame']
filename = batch_data[i]['file_name']
frame_number = batch_data[i]['index_number']
faces_rect = None
pedestrian_rect = None
faces_features = None
nearest = None
if batch_data[i]['ret']:
start_infer = time.time()
initial, faces_rect, faces_features = frame_handler.infer_frame(frame)
initial_pedestrian, pedestrian_rect, *_ = pedestrian_frame_handler.infer_frame(frame) # NEW
end_infer = time.time()
infer_time.append(end_infer - start_infer)
if faces_rect:
init_height, init_width = initial
now = datetime.now()
all_persons += len(faces_rect)
if (now - ts) < self.alert_actual:
#log.info('set: {} path: {}'.format(features_set.p.get_ids_list(), features_set.output_path))
nearest = features_set.find_nearest(faces_features)
for j in range(len(faces_rect)):
l, t, r, b = faces_rect[j]
if nearest is not None:
label = nearest[0][j]
distance = nearest[1][j]
self.alert_send(now, ts, camera_id, label, distance, l, t, r, b,
filename, frame_number, frame)
# NEW
if pedestrian_rect:
init_ped_w, init_ped_h = initial_pedestrian
for j in range(len(pedestrian_rect)):
lp, tp, rp, bp = pedestrian_rect[j]
self.storage_save(camera_id, ts, lp, tp, rp, bp, filename, frame_number,
init_ped_h, init_ped_w)
continue
end = time.time()
self.periods.append(end - start)
if len(self.periods) > 1000:
avg_period = sum(self.periods) / len(self.periods)
self.periods = []
log.info("infer Output persons : {}, ts: {}".format(all_persons, ts))
log.info('infer cycle total FPS = {}, infer FPS = {}'.format(1/avg_period, 1/sum(infer_time)))
def write_videos(self, cap_id, ts, frame_dict):
cap = self.caps_list[cap_id]
if frame_dict['index_number'] == 0:
self.ts_start = ts
file = os.path.join(self.videos_dir, frame_dict['file_name'])
log.info('reader Starting write video for '
'stream: {} filename: {}...'.format(cap_id, file))
cap['writer'] = cv2.VideoWriter(
file, #cv2.CAP_INTEL_MFX,
cv2.VideoWriter_fourcc('H', '2', '6', '4'),
self.fps,
(self.caps_list[cap_id]['width'],
self.caps_list[cap_id]['height']))
cap['writer'].write(frame_dict['frame'])
if frame_dict['index_number'] == (self.fps * self.file_time):
cap['writer'].release()
log.info(
'reader Finished write video for stream: {}.'.format(cap_id))
import sys
from component.reader import ReaderStreams
from component.ping import ping
from scope import log
if __name__ == '__main__':
log.info('system APPLICATION STARTING...')
try:
ping.add_stage('reader', send=True)
reader = ReaderStreams()
log.info('system APPLICATION STARTED')
reader.run_streams()
except Exception as e:
log.exception(e)
log.critical('system APPLICATION CLOSED WITH ERROR {}'.format(e))
sys.exit(1)
log.info('system APPLICATION FINISHED')
def receive_alert(self, ts, camera, label, distance, left, top, right,
bottom, filename, frame_number, frame):
now = datetime.now()
prev_alert = self.prev_alerts.get(label)
if prev_alert is not None:
if (ts - prev_alert) >= self.alert_inertia:
self.prev_alerts.pop(label, None)
else:
self.prev_alerts[label] = now
prev_alert = self.prev_alerts.get(label)
if prev_alert is None:
photo_files, is_tester = executor.execute_query(
queries, 'select_filename_by_id', label=label)[0]
if is_tester:
bot = 'whitelist'
else:
bot = 'blacklist'
frame = self._image_prepared(frame, (left, top, right, bottom))
if photo_files:
origin_filename = photo_files
origin_path = os.path.join(self.photos_dir, origin_filename)
origin = self._image_prepared(origin_path)
else:
origin_filename = 'None'
origin = None
log.info(
'alerter Sending alert message for label {}...'.format(label))
messenger.subscribers = [
sub[0] for sub in executor.execute_query(
queries, 'select_telegram_subscribers_unmute', bot=bot)
]
send_alert = messenger.send_mailing(bot,
label,
int(distance * 100),
camera,
ts,
frame=frame,
origin=origin)
try:
while True:
res, user_id = next(send_alert)
if res == 403:
executor.execute_query(queries,
'telegram_subscriber_mute',
user_id=user_id,
commit=True)
except StopIteration:
log.info(
'alerter Sent alert message for label {} to messenger'.
format(label))
executor.execute_query(queries,
'insert_alerts_table',
camera_id=camera,
ts=ts,
l=left,
t=top,
r=right,
b=bottom,
label=label,
distance=distance,
frame_number=frame_number,
filename=filename,
origin=origin_filename,
is_tester=is_tester,
commit=True)
log.info(
'alerter Sent alert for label {} to database'.format(label))
self.prev_alerts[label] = now
from flask import Flask, redirect
from scope import config, log, executor, queries
import math
import cv2
import os
log.info('reporter Initializing Flask...')
app = Flask(__name__)
log.info('reporter Flask initialized')
URI = config.find('reporter/uri', '/')
VIDEOS_PATH = config.find('reader/videos_path')
IMAGE_PATH = config.find('reporter/image_path')
@app.route("/reporter/get_direction/<track_id>")
def get_direction(track_id):
try:
select_track = 'select_tracks_reporter'
track = executor.execute_query(queries,
select_track,
track_id=track_id,
commit=True)
if track:
l0_f, t0_f, r0_f, b0_f, ts0, filename0, frame0, l1_f, t1_f, r1_f, b1_f, ts1, filename1, frame1, length, camera_id = track.pop(
)
else:
return 'TRACK WITH THIS ID={} DOES NOT EXIST'.format(track_id)
image_file = '{path}/{track_id}.jpg'.format(path=IMAGE_PATH,
track_id=track_id)
f0 = '{path}/{filename0}'.format(path=VIDEOS_PATH, filename0=filename0)
def process_frames(self):
log.info('Tracker starting processing frames')
while True:
now = datetime.datetime.now()
if now - self._prev_time >= self.download_interval:
self.frames = self.executor.execute_query(
queries,
self._select_from_frames,
limit=self.select_limit,
commit=True)
self.preload_tracks(now)
self.preload_ids = self.tracker.get_all_track_ids()
self._prev_time = now
if self.frames:
oldest_frame_ts = self.frames[-1][1] # FIX THIS
processed = 0
total_frames = len(self.frames)
while self.frames:
camera_id, ts, l, t, r, b, filename, frame_num = self.frames.pop(
0)
self.tracker.add_track(l, t, r, b, ts, filename, frame_num,
camera_id)
processed += 1
log.info('Tracker processed {} out of {} total frames'.format(
processed, total_frames))
self.executor.execute_query(queries,
self._update_frames_status,
oldest=oldest_frame_ts,
commit=True)
log.info('Tracker frames table updated')
for track_id in self.preload_ids:
track = self.tracker.get_track(track_id)
l1, t1, r1, b1, ts1, filename1, frame1 = track['last']
length = track['length']
self.executor.execute_query(queries,
self._update_tracks,
track_id=str(track_id),
l1=l1,
t1=t1,
r1=r1,
b1=b1,
ts1=ts1,
filename1=filename1,
frame1=frame1,
len=length,
commit=True)
new_ids = self.tracker.get_all_track_ids() - self.preload_ids
for track_id in new_ids:
track = self.tracker.get_track(track_id)
l0, t0, r0, b0, ts0, filename0, frame0 = track['first']
l1, t1, r1, b1, ts1, filename1, frame1 = track['last']
length = track['length']
camera_id = track['camera_id']
self.executor.execute_query(queries,
self._insert_into_tracks,
track_id=str(track_id),
l0=l0,
t0=t0,
r0=r0,
b0=b0,
ts0=ts0,
filename0=filename0,
frame0=frame0,
l1=l1,
t1=t1,
r1=r1,
b1=b1,
ts1=ts1,
filename1=filename1,
frame1=frame1,
len=length,
camera_id=str(camera_id),
commit=True)
log.info('Tracker inserted {} tracks into table'.format(
len(new_ids)))
self.tracker.empty_storage()
self.frames = []
log.info('Tracker full cycle finished')
time.sleep(1)