def __init__(self, module_name, settings, pipe):
"""Initialize video capture, logger, and processing plugins.
Args:
module_name -- TODO
settings -- dict of settings for this object.
pipe -- TODO
"""
self.module_name = module_name
self.master_settings = settings['sensor/vision/control']
self.settings = settings[module_name]
self.processor = FrameProcessor()
self._com = Communicator(module_name)
# Nagging messages from the parent come from here. The process must
# respond quickly enough or be killed by the parent.
self._pipe = pipe
self._fresh_frame_available = Event()
self._got_im, self._im = None, None
self._init_stream()
# Individual stream images will be processed by modules stored here.
self._plugins = []
# Load, instantiate, and store the modules defined in the settings file.
for plugin_name in self.settings['plugins']:
# Name of module and the class should be the same.
module_obj = getattr(
import_module('..' + plugin_name, package='plugins.subpkg'),
plugin_name)(self.processor, self.settings)
self._plugins += [module_obj]
# Configure the VideoCapture object.
self._vision_process()
def __init__(self, envName, is_atari:bool, no_op_steps=None, agent_history_length=4):
self.env = gym.make(envName)
self.process_frame = FrameProcessor()
self.state = None
self.last_lives = 0
self.is_atari = is_atari
self.no_op_steps = no_op_steps or (10 if is_atari else 0)
self.agent_history_length = agent_history_length
def main(args: typing.List[str]) -> int:
"""Analyse video file or camera for motion. If no file is entered, the first camera is used."""
video_file = None
config = read_config()
frame_processor = FrameProcessor(config)
if len(args) > 1:
video_file = args[1]
frame_processor.capture(video_file)
return 0
def main(args: typing.List[str]) -> int:
"""Analyse video file or camera for motion. If no file is entered, the first camera is used."""
video_file = None
config = read_config()
logger = setup_custom_logger("COLLECTOR")
logger.info("Application started")
parser = argparse.ArgumentParser()
parser.add_argument("-f",
"--file",
help="Process video file",
action='store_true')
parser.add_argument(
"-l",
"--list",
help="Process .txt file that contains a list of video files",
action='store_true')
parser.add_argument("filename", type=str, nargs='?', default="")
args = parser.parse_args()
if not args.list:
frame_processor = FrameProcessor(config, logger)
if args.file:
video_file = args.filename
frame_processor.capture(video_file)
return 0
else:
file = open(args.filename, "r")
while True:
next_video_file = file.readline()
if len(next_video_file) > 0:
next_video_file = next_video_file.rstrip('\n')
next_video_file = next_video_file.strip()
if len(next_video_file) > 0 and next_video_file[0] != '#':
frame_processor = FrameProcessor(config, logger)
frame_processor.capture(next_video_file)
else:
break
file.close
return 0
def __init__(self, image_size, frame_delay, in_size, out_size, border_blur,
back_blur, model):
self.processor = FrameProcessor(image_size=image_size,
frame_delay=frame_delay,
in_size=in_size,
out_size=out_size,
border_blur=border_blur,
back_blur=back_blur,
model=model)
self.capture = cv2.VideoCapture(0)
self.model = model.split('/')[-1]
def start_camera_analysis():
print("Starting Camera Analysis")
calibration = np.load('./calibration_1080.npz')
frame_processor = FrameProcessor(calibration, camera_index=cam_index, debug_mode=debug)
frame_processor.init_camera()
while server_running:
frame_processor.capture()
transforms = frame_processor.proccess()
if transforms:
try:
cloned_clients = clients[:]
except:
continue
send_transforms(cloned_clients, transforms)
if cv2.waitKey(1) & 0xFF == ord('q'):
continue
print("Stopping Camera Analysis")
def play_game(agent, env, game_play, mode, render):
action_list = ['stay', 'go up', 'go down']
reward_avg = 0
for i in range(game_play):
total_reward = 0
obs = env.reset()
if render:
env.render()
frame_processor = FrameProcessor(obs)
obs, reward, done, _ = env.step(
agent.random_action() + 1) # do random action at the first frame
total_reward += reward
# play one game
while not done:
if render:
env.render()
time.sleep(1 / 30)
input_frame = frame_processor.process(obs)
prob = agent.get_action_prob(input_frame)
if mode == 0:
action = np.random.choice(3, p=prob)
elif mode == 1:
action = np.argmax(prob)
if render:
print('the agent has {:.2f}% stay, {:.2f}% goes up, {:.2f}% goes down ==> it choose to {}' \
.format(prob[0] * 100, prob[1] * 100, prob[2] * 100, action_list[action]))
obs, reward, done, _ = env.step(action + 1)
total_reward += reward
reward_avg += (total_reward - reward_avg) / (
i + 1) # use moving average to get reward average
print(
'in {}th game: the total_reward is: {}, average total_reward is: {}'
.format(i, total_reward, reward_avg))
else:
detector = MovementDetector(args.min_contour_area,
args.rectangle_separation,
args.gray_threshold,
args.gray_sma_interval, min_rect_size)
if args.onvif_credentials is not None:
onvif_connector = ONVIFConnector(
urlparse(args.url).hostname, args.onvif_port,
args.onvif_credentials[0], args.onvif_credentials[1], logger)
else:
onvif_connector = None
processor = FrameProcessor(detector, recognizer, onvif_connector, logger,
class_colors, class_names, background_names,
background_boxes, args.min_class_conf,
args.background_overlap, args.screenshot_dir,
args.screenshot_quality,
args.raw_screenshot_dir, args.max_screen_size)
# insert credentials into URL if required
url = args.url.format(user=args.credentials[0], passwd=args.credentials[1]
) if args.credentials is not None else args.url
if args.mjpg:
watch_mjpg(url, args.credentials, args.retry_interval)
else:
watch(url, args.retry_interval)
logger.info('Stop watching')
def main():
# get options
args = build_argparser().parse_args()
# log setting
log.basicConfig(format="[ %(levelname)s ] %(asctime)-15s %(message)s",
level=log.INFO if not args.verbose else log.DEBUG,
stream=sys.stdout)
log.debug(str(args))
# Pre-process
visualizer = Visualizer(args)
frame_processor = FrameProcessor(args)
# display flag
display = not args.no_show
# frame number
frame_number = 0
# open input file
input_stream = visualizer.open_input_stream(args.input)
if input_stream is None or not input_stream.isOpened():
# error
log.error(f"Cannot open input stream '{args.input}'")
raise FileNotFoundError(f"Cannot open input stream '{args.input}'")
# output stream
output_stream = visualizer.open_output_stream(args.output)
# break or normal end
break_flag = False
# for initialize frame timer
visualizer.update_fps()
# main loop
while input_stream.isOpened():
# frame_start_time = time.time()
# input frame
has_frame, frame = input_stream.read()
if not has_frame:
# end of frame
break
# cropping
frame = visualizer.crop_frame(frame)
# Recognition process
rois, landmarks, headposes = frame_processor.process(frame)
"""
for idx, landmark in enumerate(landmarks) :
print(f'INDEX {idx} ======================================')
print(f'left_eye : {landmark.left_eye}')
print(f'right_eye : {landmark.right_eye}')
print(f'nose_tip : {landmark.nose_tip}')
print(f'left_lip_corner : {landmark.left_lip_corner}')
print(f'right_lip_corner : {landmark.right_lip_corner}')
print('####################################################')
"""
"""
for idx, headpose in enumerate(headposes) :
print(f'INDEX {idx} ======================================')
print(f'pitch : {headpose.pitch}')
print(f'yaw : {headpose.yaw}')
print(f'roll : {headpose.roll}')
print('####################################################')
"""
# Result output
visualizer.draw_detections(frame, rois, landmarks, headposes)
visualizer.update_fps()
visualizer.draw_status(frame, rois, frame_number)
if args.perf_stats:
log.info('Performance stats:')
# log.info(pprint.pformat(frame_processor.get_performance_stats()))
pprint.pprint(frame_processor.get_performance_stats())
if output_stream:
# output to file
output_stream.write(frame)
if display:
visualizer.display_interactive_window(frame)
break_flag = visualizer.should_stop_display()
if break_flag:
break
frame_number += 1
# frame_time = time.time()- frame_start_time
# print(f'frame_time : {frame_time}')
# Hold the window waiting for keystrokes at the last frame
if display: # display mode
if not break_flag: # not break loop
if frame_number > 0: # no input error
print("Press any key to exit")
visualizer.should_stop_display(True)
# Release resources
if output_stream:
output_stream.release()
if input_stream:
input_stream.release()
visualizer.terminete()
agent = PG(run_name=arg.run_name,
input_shape=[160,160],
n_action=3,
learning_rate=arg.learning_rate,
save_path=arg.save_path,
record_io=False,
record=True,
gpu_fraction=0.9)
for i in range(arg.games_num):
replay_buffer = ReplayBuffer(input_shape=[160, 160], start_size=32, max_size=10000000)
memory = []
total_reward = 0
obs = env.reset()
frame_processor = FrameProcessor(obs)
obs, reward, done, _ = env.step(agent.random_action() + 1) # do random action at the first frame
total_reward += reward
# play one game
while not done:
input_frame = frame_processor.process(obs)
prob = agent.get_action_prob(input_frame)
action = np.random.choice(3, p=prob)
obs, reward, done, _ = env.step(action + 1)
if reward == 0:
replay_buffer.store_transition(input_frame, action)
else:
total_reward += reward
if reward == 1:
def main():
args = parse_args()
FOLDER = args.output_folder
FRAME_LIMIT = args.frame_limit
VIDEO_FILE = args.video_file
DRAW_BOXES = args.draw_boxes
SCORES_FILE = args.scores_file
DETECTION = args.detection
GAZE_ESTIMATION = not args.no_gaze_estimation
OUTPUT_TYPE = args.output_type
NO_SCORES = args.no_scores
if GAZE_ESTIMATION:
processor = FrameProcessor()
else:
processor = None
if DETECTION == "cv2":
detector = CVFaceDetector()
elif DETECTION == "cnn":
detector = MTCNNFaceDetector()
else:
raise Exception(f"detection method {DETECTION} is invalid, expected one of [cv2, cnn]")
df_faces = []
if NO_SCORES:
print(f">> Reading frames from {VIDEO_FILE}")
frames = [
cv2.imread(os.path.join(VIDEO_FILE, frame_file))
for frame_file in os.listdir(VIDEO_FILE)
]
h, w, _ = frames[0].shape
df = pd.DataFrame([{
'track_id': i // 128,
'frame_id': i,
'abs_frame_id': i,
'box_id': 0,
'x': 0,
'y': 0,
'x2': w,
'y2': h,
} for i in range(len(frames))])
else:
print(f">> Reading video from {VIDEO_FILE}")
df = pd.read_csv(SCORES_FILE, header=None, index_col=None, names=[
"track_id", "frame_id", "box_id", "x", "y", "x2", "y2"] + list(range(80)))
df["abs_frame_id"] = df.frame_id + df.track_id - 128
frames = collect_frames(VIDEO_FILE, FRAME_LIMIT)
if os.path.isdir(FOLDER):
shutil.rmtree(FOLDER)
print(">> Matching frames")
for i, frame in tqdm(enumerate(frames), total=len(frames)):
new_frame = match_faces_bodies(
frame,
df[df.abs_frame_id == i],
processor=processor,
detector=detector,
draw_boxes=DRAW_BOXES
)
frames[i], new_df_faces = new_frame
df_faces += new_df_faces
if not os.path.isdir(FOLDER):
print(f">> Creating folder {FOLDER}")
os.makedirs(FOLDER)
if OUTPUT_TYPE == "frames":
os.makedirs(os.path.join(FOLDER, "frames"))
save_video_to_files(frames, os.path.join(FOLDER, "frames"))
df_faces = pd.DataFrame(df_faces)
print(">> Saving box files")
box_ids = df_faces.box_id.unique()
for box_id in tqdm(box_ids, total=len(box_ids)):
with open(os.path.join(FOLDER, f"person{box_id}.txt"), "w") as f:
for _, frame in df_faces[df_faces.box_id == box_id].iterrows():
bbox = str([frame.x, frame.y, frame.x2, frame.y2]).replace(" ", "").strip("[]")
f.write(f"frame_{frame.frame_id}.png,{bbox}\n")
else:
output_video_file(os.path.join(FOLDER, "video.mp4"), frames)
