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

mapillary_tools/geotag/geotag_videos_from_exiftool_video.py

@@ -1,52 +1,46 @@
+from __future__ import annotations
+
 import logging
 import typing as T
 import xml.etree.ElementTree as ET
-from multiprocessing import Pool
 from pathlib import Path
 
-from tqdm import tqdm
-
-from .. import exceptions, exiftool_read, geo, types, utils
+from .. import constants, exceptions, exiftool_read, geo, types, utils
 from ..exiftool_read_video import ExifToolReadVideo
+from ..exiftool_runner import ExiftoolRunner
+from ..gpmf import gpmf_gps_filter
 from ..telemetry import GPSPoint
-from . import gpmf_gps_filter, utils as video_utils
-from .geotag_from_generic import GeotagVideosFromGeneric
+from .geotag_from_generic import GenericVideoExtractor, GeotagVideosFromGeneric
 
 LOG = logging.getLogger(__name__)
-_DESCRIPTION_TAG = "rdf:Description"
 
 
-class GeotagVideosFromExifToolVideo(GeotagVideosFromGeneric):
-    def __init__(
-        self,
-        video_paths: T.Sequence[Path],
-        xml_path: Path,
-        num_processes: T.Optional[int] = None,
-    ):
-        self.video_paths = video_paths
-        self.xml_path = xml_path
-        self.num_processes = num_processes
-        super().__init__()
+class VideoExifToolExtractor(GenericVideoExtractor):
+    def __init__(self, video_path: Path, element: ET.Element):
+        super().__init__(video_path)
+        self.element = element
 
-    @staticmethod
-    def geotag_video(element: ET.Element) -> types.VideoMetadataOrError:
-        video_path = exiftool_read.find_rdf_description_path(element)
-        assert video_path is not None, "must find the path from the element"
+    def extract(self) -> types.VideoMetadataOrError:
+        exif = ExifToolReadVideo(ET.ElementTree(self.element))
 
-        try:
-            exif = ExifToolReadVideo(ET.ElementTree(element))
+        make = exif.extract_make()
+        model = exif.extract_model()
+
+        is_gopro = make is not None and make.upper() in ["GOPRO"]
 
-            points = exif.extract_gps_track()
+        points = exif.extract_gps_track()
 
+        # ExifTool has no idea if GPS is not found or found but empty
+        if is_gopro:
             if not points:
-                raise exceptions.MapillaryVideoGPSNotFoundError(
-                    "No GPS data found from the video"
-                )
+                raise exceptions.MapillaryGPXEmptyError("Empty GPS data found")
 
-            points = geo.extend_deduplicate_points(points)
-            assert points, "must have at least one point"
+            # ExifTool (since 13.04) converts GPSSpeed for GoPro to km/h, so here we convert it back to m/s
+            for p in points:
+                if isinstance(p, GPSPoint) and p.ground_speed is not None:
+                    p.ground_speed = p.ground_speed / 3.6
 
-            if all(isinstance(p, GPSPoint) for p in points):
+            if isinstance(points[0], GPSPoint):
                 points = T.cast(
                     T.List[geo.Point],
                     gpmf_gps_filter.remove_noisy_points(
@@ -56,90 +50,102 @@ class GeotagVideosFromExifToolVideo(GeotagVideosFromGeneric):
                 if not points:
                     raise exceptions.MapillaryGPSNoiseError("GPS is too noisy")
 
-            stationary = video_utils.is_video_stationary(
-                geo.get_max_distance_from_start([(p.lat, p.lon) for p in points])
+        if not points:
+            raise exceptions.MapillaryVideoGPSNotFoundError(
+                "No GPS data found from the video"
             )
 
-            if stationary:
-                raise exceptions.MapillaryStationaryVideoError("Stationary video")
-
-            video_metadata = types.VideoMetadata(
-                video_path,
-                md5sum=None,
-                filesize=utils.get_file_size(video_path),
-                filetype=types.FileType.VIDEO,
-                points=points,
-                make=exif.extract_make(),
-                model=exif.extract_model(),
-            )
+        filetype = types.FileType.GOPRO if is_gopro else types.FileType.VIDEO
 
-            LOG.debug("Calculating MD5 checksum for %s", str(video_metadata.filename))
+        video_metadata = types.VideoMetadata(
+            self.video_path,
+            filesize=utils.get_file_size(self.video_path),
+            filetype=filetype,
+            points=points,
+            make=make,
+            model=model,
+        )
 
-            video_metadata.update_md5sum()
+        return video_metadata
 
-        except Exception as ex:
-            if not isinstance(ex, exceptions.MapillaryDescriptionError):
-                LOG.warning(
-                    "Failed to geotag video %s: %s",
-                    video_path,
-                    str(ex),
-                    exc_info=LOG.getEffectiveLevel() <= logging.DEBUG,
-                )
-            return types.describe_error_metadata(
-                ex, video_path, filetype=types.FileType.VIDEO
-            )
 
-        return video_metadata
+class GeotagVideosFromExifToolVideo(GeotagVideosFromGeneric):
+    def __init__(
+        self,
+        video_paths: T.Sequence[Path],
+        xml_path: Path,
+        num_processes: int | None = None,
+    ):
+        super().__init__(video_paths, num_processes=num_processes)
+        self.xml_path = xml_path
 
-    def to_description(self) -> T.List[types.VideoMetadataOrError]:
+    def _generate_video_extractors(
+        self,
+    ) -> T.Sequence[GenericVideoExtractor | types.ErrorMetadata]:
         rdf_description_by_path = exiftool_read.index_rdf_description_by_path(
             [self.xml_path]
         )
 
-        error_metadatas: T.List[types.ErrorMetadata] = []
-        rdf_descriptions: T.List[ET.Element] = []
+        results: list[VideoExifToolExtractor | types.ErrorMetadata] = []
+
         for path in self.video_paths:
             rdf_description = rdf_description_by_path.get(
                 exiftool_read.canonical_path(path)
             )
             if rdf_description is None:
                 exc = exceptions.MapillaryEXIFNotFoundError(
-                    f"The {_DESCRIPTION_TAG} XML element for the video not found"
+                    f"The {exiftool_read._DESCRIPTION_TAG} XML element for the video not found"
                 )
-                error_metadatas.append(
+                results.append(
                     types.describe_error_metadata(
                         exc, path, filetype=types.FileType.VIDEO
                     )
                 )
             else:
-                rdf_descriptions.append(rdf_description)
-
-        if self.num_processes is None:
-            num_processes = self.num_processes
-            disable_multiprocessing = False
-        else:
-            num_processes = max(self.num_processes, 1)
-            disable_multiprocessing = self.num_processes <= 0
-
-        with Pool(processes=num_processes) as pool:
-            video_metadatas_iter: T.Iterator[types.VideoMetadataOrError]
-            if disable_multiprocessing:
-                video_metadatas_iter = map(
-                    GeotagVideosFromExifToolVideo.geotag_video, rdf_descriptions
-                )
-            else:
-                video_metadatas_iter = pool.imap(
-                    GeotagVideosFromExifToolVideo.geotag_video,
-                    rdf_descriptions,
+                results.append(VideoExifToolExtractor(path, rdf_description))
+
+        return results
+
+
+class GeotagVideosFromExifToolRunner(GeotagVideosFromGeneric):
+    def _generate_video_extractors(
+        self,
+    ) -> T.Sequence[GenericVideoExtractor | types.ErrorMetadata]:
+        runner = ExiftoolRunner(constants.EXIFTOOL_PATH)
+
+        LOG.debug(
+            "Extracting XML from %d videos with exiftool command: %s",
+            len(self.video_paths),
+            " ".join(runner._build_args_read_stdin()),
+        )
+
+        try:
+            xml = runner.extract_xml(self.video_paths)
+        except FileNotFoundError as ex:
+            raise exceptions.MapillaryExiftoolNotFoundError(ex) from ex
+
+        rdf_description_by_path = (
+            exiftool_read.index_rdf_description_by_path_from_xml_element(
+                ET.fromstring(xml)
+            )
+        )
+
+        results: list[VideoExifToolExtractor | types.ErrorMetadata] = []
+
+        for path in self.video_paths:
+            rdf_description = rdf_description_by_path.get(
+                exiftool_read.canonical_path(path)
+            )
+            if rdf_description is None:
+                exc = exceptions.MapillaryEXIFNotFoundError(
+                    f"The {exiftool_read._DESCRIPTION_TAG} XML element for the video not found"
                 )
-            video_metadata_or_errors = list(
-                tqdm(
-                    video_metadatas_iter,
-                    desc="Extracting GPS tracks from ExifTool XML",
-                    unit="videos",
-                    disable=LOG.getEffectiveLevel() <= logging.DEBUG,
-                    total=len(self.video_paths),
+                results.append(
+                    types.describe_error_metadata(
+                        exc, path, filetype=types.FileType.VIDEO
+                    )
                 )
-            )
+            else:
+                results.append(VideoExifToolExtractor(path, rdf_description))
 
-        return error_metadatas + video_metadata_or_errors
+        return results

mapillary_tools/geotag/geotag_videos_from_gpx.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import dataclasses
+import datetime
+import logging
+
+import typing as T
+from pathlib import Path
+
+from .. import geo, telemetry, types
+from . import options
+from .geotag_from_generic import GenericVideoExtractor, GeotagVideosFromGeneric
+from .geotag_images_from_gpx_file import parse_gpx
+from .geotag_videos_from_video import NativeVideoExtractor
+
+
+LOG = logging.getLogger(__name__)
+
+
+class GPXVideoExtractor(GenericVideoExtractor):
+    def __init__(self, video_path: Path, gpx_path: Path):
+        self.video_path = video_path
+        self.gpx_path = gpx_path
+
+    def extract(self) -> types.VideoMetadataOrError:
+        try:
+            gpx_tracks = parse_gpx(self.gpx_path)
+        except Exception as ex:
+            raise RuntimeError(
+                f"Error parsing GPX {self.gpx_path}: {ex.__class__.__name__}: {ex}"
+            )
+
+        if 1 < len(gpx_tracks):
+            LOG.warning(
+                "Found %s tracks in the GPX file %s. Will merge points in all the tracks as a single track for interpolation",
+                len(gpx_tracks),
+                self.gpx_path,
+            )
+
+        gpx_points: T.Sequence[geo.Point] = sum(gpx_tracks, [])
+
+        native_extractor = NativeVideoExtractor(self.video_path)
+
+        video_metadata_or_error = native_extractor.extract()
+
+        if isinstance(video_metadata_or_error, types.ErrorMetadata):
+            self._rebase_times(gpx_points)
+            return types.VideoMetadata(
+                filename=video_metadata_or_error.filename,
+                filetype=video_metadata_or_error.filetype or types.FileType.VIDEO,
+                points=gpx_points,
+            )
+
+        video_metadata = video_metadata_or_error
+
+        offset = self._synx_gpx_by_first_gps_timestamp(
+            gpx_points, video_metadata.points
+        )
+
+        self._rebase_times(gpx_points, offset=offset)
+
+        return dataclasses.replace(video_metadata_or_error, points=gpx_points)
+
+    @staticmethod
+    def _rebase_times(points: T.Sequence[geo.Point], offset: float = 0.0):
+        """
+        Make point times start from 0
+        """
+        if points:
+            first_timestamp = points[0].time
+            for p in points:
+                p.time = (p.time - first_timestamp) + offset
+        return points
+
+    def _synx_gpx_by_first_gps_timestamp(
+        self, gpx_points: T.Sequence[geo.Point], video_gps_points: T.Sequence[geo.Point]
+    ) -> float:
+        offset: float = 0.0
+
+        if not gpx_points:
+            return offset
+
+        first_gpx_dt = datetime.datetime.fromtimestamp(
+            gpx_points[0].time, tz=datetime.timezone.utc
+        )
+        LOG.info("First GPX timestamp: %s", first_gpx_dt)
+
+        if not video_gps_points:
+            LOG.warning(
+                "Skip GPX synchronization because no GPS found in video %s",
+                self.video_path,
+            )
+            return offset
+
+        first_gps_point = video_gps_points[0]
+        if isinstance(first_gps_point, telemetry.GPSPoint):
+            if first_gps_point.epoch_time is not None:
+                first_gps_dt = datetime.datetime.fromtimestamp(
+                    first_gps_point.epoch_time, tz=datetime.timezone.utc
+                )
+                LOG.info("First GPS timestamp: %s", first_gps_dt)
+                offset = gpx_points[0].time - first_gps_point.epoch_time
+                if offset:
+                    LOG.warning(
+                        "Found offset between GPX %s and video GPS timestamps %s: %s seconds",
+                        first_gpx_dt,
+                        first_gps_dt,
+                        offset,
+                    )
+                else:
+                    LOG.info(
+                        "GPX and GPS are perfectly synchronized (all starts from %s)",
+                        first_gpx_dt,
+                    )
+            else:
+                LOG.warning(
+                    "Skip GPX synchronization because no GPS epoch time found in video %s",
+                    self.video_path,
+                )
+
+        return offset
+
+
+class GeotagVideosFromGPX(GeotagVideosFromGeneric):
+    def __init__(
+        self,
+        video_paths: T.Sequence[Path],
+        option: options.SourcePathOption | None = None,
+        num_processes: int | None = None,
+    ):
+        super().__init__(video_paths, num_processes=num_processes)
+        if option is None:
+            option = options.SourcePathOption(pattern="%f.gpx")
+        self.option = option
+
+    def _generate_image_extractors(self) -> T.Sequence[GPXVideoExtractor]:
+        return [
+            GPXVideoExtractor(video_path, self.option.resolve(video_path))
+            for video_path in self.video_paths
+        ]