From 9958a965725764aee7150a67d9f63e241b4c345e Mon Sep 17 00:00:00 2001 From: Théo de la Hogue Date: Wed, 17 Apr 2024 14:16:40 +0200 Subject: Improving aruco marker pipeline documentation. --- src/argaze/utils/aruco_marker_group_export.py | 234 ++++++++++++++++++++++++++ 1 file changed, 234 insertions(+) create mode 100644 src/argaze/utils/aruco_marker_group_export.py (limited to 'src') diff --git a/src/argaze/utils/aruco_marker_group_export.py b/src/argaze/utils/aruco_marker_group_export.py new file mode 100644 index 0000000..961d12b --- /dev/null +++ b/src/argaze/utils/aruco_marker_group_export.py @@ -0,0 +1,234 @@ +#!/usr/bin/env python + +""" + +This program is free software: you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free Software +Foundation, either version 3 of the License, or (at your option) any later +version. +This program is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. +You should have received a copy of the GNU General Public License along with +this program. If not, see . +""" + +__author__ = "Théo de la Hogue" +__credits__ = [] +__copyright__ = "Copyright 2023, Ecole Nationale de l'Aviation Civile (ENAC)" +__license__ = "GPLv3" + +import argparse +import contextlib + +import cv2 + +from argaze import DataFeatures +from argaze.ArUcoMarker import ArUcoDetector, ArUcoOpticCalibrator, ArUcoMarkerGroup +from argaze.utils import UtilsFeatures + + +def main(): + """ + Detect DICTIONARY and SIZE ArUco markers inside a MOVIE frame then, export detected ArUco markers group as .obj file into an OUTPUT folder. + """ + + # Manage arguments + parser = argparse.ArgumentParser(description=main.__doc__.split('-')[0]) + parser.add_argument('movie', metavar='MOVIE', type=str, default=None, help='movie path') + parser.add_argument('dictionary', metavar='DICTIONARY', type=str, default=None, + help='expected ArUco markers dictionary') + parser.add_argument('size', metavar='SIZE', type=float, default=None, help='expected ArUco markers size (in cm)') + + parser.add_argument('-p', '--parameters', metavar='PARAMETERS', type=str, default=None, + help='ArUco detector parameters file') + parser.add_argument('-op', '--optic_parameters', metavar='OPTIC_PARAMETERS', type=str, default=None, + help='ArUco detector optic parameters file') + + parser.add_argument('-s', '--start', metavar='START', type=float, default=0., help='start time in second') + parser.add_argument('-o', '--output', metavar='OUTPUT', type=str, default='.', help='export folder path') + parser.add_argument('-v', '--verbose', action='store_true', default=False, + help='enable verbose mode to print information in console') + + args = parser.parse_args() + + # Load movie + video_capture = cv2.VideoCapture(args.movie) + + video_fps = video_capture.get(cv2.CAP_PROP_FPS) + image_width = int(video_capture.get(cv2.CAP_PROP_FRAME_WIDTH)) + image_height = int(video_capture.get(cv2.CAP_PROP_FRAME_HEIGHT)) + + # Edit ArUco detector configuration + configuration = { + "dictionary": args.dictionary + } + + if args.parameters: + configuration["parameters"] = args.parameters + + if args.optic_parameters: + configuration["optic_parameters"] = args.optic_parameters + + # Load ArUco detector configuration + aruco_detector = DataFeatures.from_dict(ArUcoDetector.ArUcoDetector, configuration) + + if args.verbose: + print(aruco_detector) + + # Create empty ArUco scene + aruco_markers_group = None + + # Edit draw parameters + draw_parameters = { + "color": [255, 255, 255], + "draw_axes": { + "thickness": 4 + } + } + + # Create a window + cv2.namedWindow("Export detected ArUco markers", cv2.WINDOW_AUTOSIZE) + + # Init image selection + current_image_index = -1 + _, current_image = video_capture.read() + next_image_index = int(args.start * video_fps) + refresh = False + + # Waiting for 'ctrl+C' interruption + with contextlib.suppress(KeyboardInterrupt): + + while True: + + # Select a new image and detect markers once + if next_image_index != current_image_index or refresh: + + video_capture.set(cv2.CAP_PROP_POS_FRAMES, next_image_index) + + success, video_image = video_capture.read() + + video_height, video_width, _ = video_image.shape + + # Create default optic parameters adapted to frame size + if aruco_detector.optic_parameters is None: + # Note: The choice of 1000 for default focal length should be discussed... + aruco_detector.optic_parameters = ArUcoOpticCalibrator.OpticParameters(rms=-1, dimensions=( + video_width, video_height), K=ArUcoOpticCalibrator.K0(focal_length=(1000., 1000.), + width=video_width, height=video_height)) + + if success: + + # Refresh once + refresh = False + + current_image_index = video_capture.get(cv2.CAP_PROP_POS_FRAMES) - 1 + current_image_time = video_capture.get(cv2.CAP_PROP_POS_MSEC) + + try: + + # Detect and project AR features + aruco_detector.detect_markers(video_image) + + # Estimate all detected markers pose + aruco_detector.estimate_markers_pose(args.size) + + # Build aruco scene from detected markers + aruco_markers_group = ArUcoMarkerGroup.ArUcoMarkerGroup(aruco_detector.dictionary, + aruco_detector.detected_markers()) + + # Detection succeeded + exception = None + + # Write errors + except Exception as e: + + aruco_markers_group = None + + exception = e + + # Draw detected markers + aruco_detector.draw_detected_markers(video_image, draw_parameters) + + # Write detected markers + cv2.putText(video_image, f'Detecting markers {list(aruco_detector.detected_markers().keys())}', + (20, video_height - 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 1, cv2.LINE_AA) + + # Write timing + cv2.putText(video_image, f'Frame at {int(current_image_time)}ms', (20, 40), + cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 255, 255), 1, cv2.LINE_AA) + + # Write exception + if exception is not None: + cv2.putText(video_image, f'error: {exception}', (20, 80), cv2.FONT_HERSHEY_SIMPLEX, 1, + (0, 255, 255), 1, cv2.LINE_AA) + + # Write documentation + cv2.putText(video_image, f'<- previous image', (video_width - 500, video_height - 160), + cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 255), 1, cv2.LINE_AA) + cv2.putText(video_image, f'-> next image', (video_width - 500, video_height - 120), + cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 255), 1, cv2.LINE_AA) + cv2.putText(video_image, f'r: reload config', (video_width - 500, video_height - 80), + cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 255), 1, cv2.LINE_AA) + cv2.putText(video_image, f'Ctrl+s: export ArUco markers', (video_width - 500, video_height - 40), + cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 255), 1, cv2.LINE_AA) + + # Copy image + current_image = video_image.copy() + + # Keep last image + else: + + video_image = current_image.copy() + + key_pressed = cv2.waitKey(10) + + #if key_pressed != -1: + # print(key_pressed) + + # Select previous image with left arrow + if key_pressed == 2: + next_image_index -= 1 + + # Select next image with right arrow + if key_pressed == 3: + next_image_index += 1 + + # Clip image index + if next_image_index < 0: + next_image_index = 0 + + # r: reload configuration + if key_pressed == 114: + aruco_detector = DataFeatures.from_dict(ArUcoDetector.ArUcoDetector, configuration) + refresh = True + print('Configuration reloaded') + + # Save selected marker edition using 'Ctrl + s' + if key_pressed == 19: + + if aruco_markers_group: + + aruco_markers_group.to_obj(f'{args.output}/{int(current_image_time)}-aruco_markers_group.obj') + print(f'ArUco markers saved into {args.output}') + + else: + + print(f'No ArUco markers to export') + + # Close window using 'Esc' key + if key_pressed == 27: + break + + # Display video + cv2.imshow(aruco_detector.name, video_image) + + # Close movie capture + video_capture.release() + + # Stop image display + cv2.destroyAllWindows() + + +if __name__ == '__main__': + main() -- cgit v1.1