mapillary-tools 0.13.3a1__py3-none-any.whl → 0.14.0__py3-none-any.whl

mapillary_tools/sample_video.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import datetime
 import logging
 import os
@@ -11,14 +13,14 @@ from . import constants, exceptions, ffmpeg as ffmpeglib, geo, types, utils
 from .exif_write import ExifEdit
 from .geotag import geotag_videos_from_video
 from .mp4 import mp4_sample_parser
-from .process_geotag_properties import GeotagSource
+from .serializer.description import parse_capture_time
 
 LOG = logging.getLogger(__name__)
 
 
 def _normalize_path(
     video_import_path: Path, skip_subfolders: bool
-) -> T.Tuple[Path, T.List[Path]]:
+) -> tuple[Path, list[Path]]:
     if video_import_path.is_dir():
         video_list = utils.find_videos(
             [video_import_path], skip_subfolders=skip_subfolders
@@ -46,12 +48,11 @@ def sample_video(
     video_import_path: Path,
     import_path: Path,
     # None if called from the sample_video command
-    geotag_source: T.Optional[GeotagSource] = None,
     skip_subfolders=False,
     video_sample_distance=constants.VIDEO_SAMPLE_DISTANCE,
     video_sample_interval=constants.VIDEO_SAMPLE_INTERVAL,
     video_duration_ratio=constants.VIDEO_DURATION_RATIO,
-    video_start_time: T.Optional[str] = None,
+    video_start_time: str | None = None,
     skip_sample_errors: bool = False,
     rerun: bool = False,
 ) -> None:
@@ -62,10 +63,10 @@ def sample_video(
             f"Expect either non-negative video_sample_distance or positive video_sample_interval but got {video_sample_distance} and {video_sample_interval} respectively"
         )
 
-    video_start_time_dt: T.Optional[datetime.datetime] = None
+    video_start_time_dt: datetime.datetime | None = None
     if video_start_time is not None:
         try:
-            video_start_time_dt = types.map_capture_time_to_datetime(video_start_time)
+            video_start_time_dt = parse_capture_time(video_start_time)
         except ValueError as ex:
             raise exceptions.MapillaryBadParameterError(str(ex))
 
@@ -86,16 +87,6 @@ def sample_video(
             elif sample_dir.is_file():
                 os.remove(sample_dir)
 
-    if geotag_source is None:
-        geotag_source = "exif"
-
-    # If it is not exif, then we use the legacy interval-based sample and geotag them in "process" for backward compatibility
-    if geotag_source not in ["exif"]:
-        if 0 <= video_sample_distance:
-            raise exceptions.MapillaryBadParameterError(
-                f'Geotagging from "{geotag_source}" works with the legacy interval-based sampling only. To switch back, rerun the command with "--video_sample_distance -1 --video_sample_interval 2"'
-            )
-
     for video_path in video_list:
         # need to resolve video_path because video_dir might be absolute
         sample_dir = Path(import_path).joinpath(
@@ -189,7 +180,7 @@ def _sample_single_video_by_interval(
     sample_dir: Path,
     sample_interval: float,
     duration_ratio: float,
-    start_time: T.Optional[datetime.datetime] = None,
+    start_time: datetime.datetime | None = None,
 ) -> None:
     ffmpeg = ffmpeglib.FFMPEG(constants.FFMPEG_PATH, constants.FFPROBE_PATH)
 
@@ -203,8 +194,8 @@ def _sample_single_video_by_interval(
             )
 
     with wip_dir_context(wip_sample_dir(sample_dir), sample_dir) as wip_dir:
-        ffmpeg.extract_frames(video_path, wip_dir, sample_interval)
-        frame_samples = ffmpeglib.sort_selected_samples(wip_dir, video_path, [None])
+        ffmpeg.extract_frames_by_interval(video_path, wip_dir, sample_interval)
+        frame_samples = ffmpeglib.FFMPEG.sort_selected_samples(wip_dir, video_path)
         for frame_idx_1based, sample_paths in frame_samples:
             assert len(sample_paths) == 1
             if sample_paths[0] is None:
@@ -229,7 +220,7 @@ def _sample_video_stream_by_distance(
     points: T.Sequence[geo.Point],
     video_track_parser: mp4_sample_parser.TrackBoxParser,
     sample_distance: float,
-) -> T.Dict[int, T.Tuple[mp4_sample_parser.Sample, geo.Point]]:
+) -> dict[int, tuple[mp4_sample_parser.Sample, geo.Point]]:
     """
     Locate video frames along the track (points), then resample them by the minimal sample_distance, and return the sparse frames.
     """
@@ -285,7 +276,7 @@ def _sample_single_video_by_distance(
     video_path: Path,
     sample_dir: Path,
     sample_distance: float,
-    start_time: T.Optional[datetime.datetime] = None,
+    start_time: datetime.datetime | None = None,
 ) -> None:
     ffmpeg = ffmpeglib.FFMPEG(constants.FFMPEG_PATH, constants.FFPROBE_PATH)
 
@@ -299,9 +290,12 @@ def _sample_single_video_by_distance(
             )
 
     LOG.info("Extracting video metdata")
-    video_metadata = geotag_videos_from_video.GeotagVideosFromVideo.geotag_video(
-        video_path
+
+    video_metadatas = geotag_videos_from_video.GeotagVideosFromVideo().to_description(
+        [video_path]
     )
+    assert len(video_metadatas) == 1, "expect 1 video metadata"
+    video_metadata = video_metadatas[0]
     if isinstance(video_metadata, types.ErrorMetadata):
         LOG.warning(str(video_metadata.error))
         return
@@ -328,11 +322,11 @@ def _sample_single_video_by_distance(
             video_path,
             wip_dir,
             frame_indices=set(sorted_sample_indices),
-            stream_idx=video_stream_idx,
+            stream_specifier=str(video_stream_idx),
         )
 
-        frame_samples = ffmpeglib.sort_selected_samples(
-            wip_dir, video_path, [video_stream_idx]
+        frame_samples = ffmpeglib.FFMPEG.sort_selected_samples(
+            wip_dir, video_path, selected_stream_specifiers=[str(video_stream_idx)]
         )
         if len(frame_samples) != len(sorted_sample_indices):
             raise exceptions.MapillaryVideoError(