mapillary-tools 0.14.0a1__py3-none-any.whl → 0.14.0b1__py3-none-any.whl

mapillary_tools/geotag/geotag_videos_from_gpx.py

@@ -1,140 +1,52 @@
 from __future__ import annotations
 
-import dataclasses
-import datetime
 import logging
-
+import sys
 import typing as T
 from pathlib import Path
 
-from .. import geo, telemetry, types
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+
+from .. import exceptions, 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
+from .base import GeotagVideosFromGeneric
+from .video_extractors.gpx import GPXVideoExtractor
 
 
 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,
+        source_path: 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
-        ]
+        super().__init__(num_processes=num_processes)
+        if source_path is None:
+            source_path = options.SourcePathOption(pattern="%g.gpx")
+        self.source_path = source_path
+
+    @override
+    def _generate_video_extractors(
+        self, video_paths: T.Sequence[Path]
+    ) -> T.Sequence[GPXVideoExtractor | types.ErrorMetadata]:
+        results: list[GPXVideoExtractor | types.ErrorMetadata] = []
+        for video_path in video_paths:
+            source_path = self.source_path.resolve(video_path)
+            if source_path.is_file():
+                results.append(GPXVideoExtractor(video_path, source_path))
+            else:
+                results.append(
+                    types.describe_error_metadata(
+                        exceptions.MapillaryVideoGPSNotFoundError(
+                            "GPX file not found for video"
+                        ),
+                        filename=video_path,
+                        filetype=types.FileType.VIDEO,
+                    )
+                )
+        return results

mapillary_tools/geotag/geotag_videos_from_video.py

@@ -1,165 +1,32 @@
 from __future__ import annotations
 
+import sys
 import typing as T
 from pathlib import Path
 
-from .. import blackvue_parser, exceptions, geo, telemetry, types, utils
-from ..camm import camm_parser
-from ..gpmf import gpmf_gps_filter, gpmf_parser
-from ..types import FileType
-from .geotag_from_generic import GenericVideoExtractor, GeotagVideosFromGeneric
-
-
-class GoProVideoExtractor(GenericVideoExtractor):
-    def extract(self) -> types.VideoMetadataOrError:
-        with self.video_path.open("rb") as fp:
-            gopro_info = gpmf_parser.extract_gopro_info(fp)
-
-        if gopro_info is None:
-            raise exceptions.MapillaryVideoGPSNotFoundError(
-                "No GPS data found from the video"
-            )
-
-        gps_points = gopro_info.gps
-        assert gps_points is not None, "must have GPS data extracted"
-        if not gps_points:
-            # Instead of raising an exception, return error metadata to tell the file type
-            ex: exceptions.MapillaryDescriptionError = (
-                exceptions.MapillaryGPXEmptyError("Empty GPS data found")
-            )
-            return types.describe_error_metadata(
-                ex, self.video_path, filetype=FileType.GOPRO
-            )
-
-        gps_points = T.cast(
-            T.List[telemetry.GPSPoint], gpmf_gps_filter.remove_noisy_points(gps_points)
-        )
-        if not gps_points:
-            # Instead of raising an exception, return error metadata to tell the file type
-            ex = exceptions.MapillaryGPSNoiseError("GPS is too noisy")
-            return types.describe_error_metadata(
-                ex, self.video_path, filetype=FileType.GOPRO
-            )
-
-        video_metadata = types.VideoMetadata(
-            filename=self.video_path,
-            filesize=utils.get_file_size(self.video_path),
-            filetype=FileType.GOPRO,
-            points=T.cast(T.List[geo.Point], gps_points),
-            make=gopro_info.make,
-            model=gopro_info.model,
-        )
-
-        return video_metadata
-
-
-class CAMMVideoExtractor(GenericVideoExtractor):
-    def extract(self) -> types.VideoMetadataOrError:
-        with self.video_path.open("rb") as fp:
-            camm_info = camm_parser.extract_camm_info(fp)
-
-        if camm_info is None:
-            raise exceptions.MapillaryVideoGPSNotFoundError(
-                "No GPS data found from the video"
-            )
-
-        if not camm_info.gps and not camm_info.mini_gps:
-            # Instead of raising an exception, return error metadata to tell the file type
-            ex: exceptions.MapillaryDescriptionError = (
-                exceptions.MapillaryGPXEmptyError("Empty GPS data found")
-            )
-            return types.describe_error_metadata(
-                ex, self.video_path, filetype=FileType.CAMM
-            )
-
-        return types.VideoMetadata(
-            filename=self.video_path,
-            filesize=utils.get_file_size(self.video_path),
-            filetype=FileType.CAMM,
-            points=T.cast(T.List[geo.Point], camm_info.gps or camm_info.mini_gps),
-            make=camm_info.make,
-            model=camm_info.model,
-        )
-
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
 
-class BlackVueVideoExtractor(GenericVideoExtractor):
-    def extract(self) -> types.VideoMetadataOrError:
-        with self.video_path.open("rb") as fp:
-            blackvue_info = blackvue_parser.extract_blackvue_info(fp)
-
-        if blackvue_info is None:
-            raise exceptions.MapillaryVideoGPSNotFoundError(
-                "No GPS data found from the video"
-            )
-
-        if not blackvue_info.gps:
-            # Instead of raising an exception, return error metadata to tell the file type
-            ex: exceptions.MapillaryDescriptionError = (
-                exceptions.MapillaryGPXEmptyError("Empty GPS data found")
-            )
-            return types.describe_error_metadata(
-                ex, self.video_path, filetype=FileType.BLACKVUE
-            )
-
-        video_metadata = types.VideoMetadata(
-            filename=self.video_path,
-            filesize=utils.get_file_size(self.video_path),
-            filetype=FileType.BLACKVUE,
-            points=blackvue_info.gps or [],
-            make=blackvue_info.make,
-            model=blackvue_info.model,
-        )
-
-        return video_metadata
-
-
-class NativeVideoExtractor(GenericVideoExtractor):
-    def __init__(self, video_path: Path, filetypes: set[FileType] | None = None):
-        super().__init__(video_path)
-        self.filetypes = filetypes
-
-    def extract(self) -> types.VideoMetadataOrError:
-        ft = self.filetypes
-        extractor: GenericVideoExtractor
-
-        if ft is None or FileType.VIDEO in ft or FileType.GOPRO in ft:
-            extractor = GoProVideoExtractor(self.video_path)
-            try:
-                return extractor.extract()
-            except exceptions.MapillaryVideoGPSNotFoundError:
-                pass
-
-        if ft is None or FileType.VIDEO in ft or FileType.CAMM in ft:
-            extractor = CAMMVideoExtractor(self.video_path)
-            try:
-                return extractor.extract()
-            except exceptions.MapillaryVideoGPSNotFoundError:
-                pass
-
-        if ft is None or FileType.VIDEO in ft or FileType.BLACKVUE in ft:
-            extractor = BlackVueVideoExtractor(self.video_path)
-            try:
-                return extractor.extract()
-            except exceptions.MapillaryVideoGPSNotFoundError:
-                pass
-
-        raise exceptions.MapillaryVideoGPSNotFoundError(
-            "No GPS data found from the video"
-        )
+from ..types import FileType
+from .base import GeotagVideosFromGeneric
+from .video_extractors.native import NativeVideoExtractor
 
 
 class GeotagVideosFromVideo(GeotagVideosFromGeneric):
     def __init__(
         self,
-        video_paths: T.Sequence[Path],
         filetypes: set[FileType] | None = None,
         num_processes: int | None = None,
     ):
-        super().__init__(video_paths, num_processes=num_processes)
+        super().__init__(num_processes=num_processes)
         self.filetypes = filetypes
 
-    def _generate_video_extractors(self) -> T.Sequence[GenericVideoExtractor]:
+    @override
+    def _generate_video_extractors(
+        self, video_paths: T.Sequence[Path]
+    ) -> T.Sequence[NativeVideoExtractor]:
         return [
-            NativeVideoExtractor(path, filetypes=self.filetypes)
-            for path in self.video_paths
+            NativeVideoExtractor(path, filetypes=self.filetypes) for path in video_paths
         ]

mapillary_tools/geotag/image_extractors/base.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import abc
+from pathlib import Path
+
+from ... import types
+
+
+class BaseImageExtractor(abc.ABC):
+    """
+    Extracts metadata from an image file.
+    """
+
+    def __init__(self, image_path: Path):
+        self.image_path = image_path
+
+    def extract(self) -> types.ImageMetadataOrError:
+        raise NotImplementedError

mapillary_tools/geotag/image_extractors/exif.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import contextlib
+import sys
+import typing as T
+from pathlib import Path
+
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+
+from ... import exceptions, exif_read, geo, types, utils
+from .base import BaseImageExtractor
+
+
+class ImageEXIFExtractor(BaseImageExtractor):
+    def __init__(self, image_path: Path, skip_lonlat_error: bool = False):
+        super().__init__(image_path)
+        self.skip_lonlat_error = skip_lonlat_error
+
+    @contextlib.contextmanager
+    def _exif_context(self) -> T.Generator[exif_read.ExifReadABC, None, None]:
+        with self.image_path.open("rb") as fp:
+            yield exif_read.ExifRead(fp)
+
+    @override
+    def extract(self) -> types.ImageMetadata:
+        with self._exif_context() as exif:
+            lonlat = exif.extract_lon_lat()
+            if lonlat is None:
+                if not self.skip_lonlat_error:
+                    raise exceptions.MapillaryGeoTaggingError(
+                        "Unable to extract GPS Longitude or GPS Latitude from the image"
+                    )
+                lonlat = (0.0, 0.0)
+            lon, lat = lonlat
+
+            capture_time = exif.extract_capture_time()
+            if capture_time is None:
+                raise exceptions.MapillaryGeoTaggingError(
+                    "Unable to extract timestamp from the image"
+                )
+
+            image_metadata = types.ImageMetadata(
+                filename=self.image_path,
+                filesize=utils.get_file_size(self.image_path),
+                time=geo.as_unix_time(capture_time),
+                lat=lat,
+                lon=lon,
+                alt=exif.extract_altitude(),
+                angle=exif.extract_direction(),
+                width=exif.extract_width(),
+                height=exif.extract_height(),
+                MAPOrientation=exif.extract_orientation(),
+                MAPDeviceMake=exif.extract_make(),
+                MAPDeviceModel=exif.extract_model(),
+            )
+
+        return image_metadata

mapillary_tools/geotag/image_extractors/exiftool.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import contextlib
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+from ... import exiftool_read
+from .exif import ImageEXIFExtractor
+
+
+class ImageExifToolExtractor(ImageEXIFExtractor):
+    def __init__(self, image_path: Path, element: ET.Element):
+        super().__init__(image_path)
+        self.element = element
+
+    @contextlib.contextmanager
+    def _exif_context(self):
+        yield exiftool_read.ExifToolRead(ET.ElementTree(self.element))

mapillary_tools/geotag/options.py

@@ -28,6 +28,7 @@ class SourceType(enum.Enum):
 SOURCE_TYPE_ALIAS: dict[str, SourceType] = {
     "blackvue_videos": SourceType.BLACKVUE,
     "gopro_videos": SourceType.GOPRO,
+    "exiftool": SourceType.EXIFTOOL_RUNTIME,
 }
 
 
@@ -59,9 +60,13 @@ class SourceOption:
             elif k == "filetypes":
                 kwargs[k] = {types.FileType(t) for t in v}
             elif k == "source_path":
-                kwargs.setdefault("source_path", SourcePathOption()).source_path = v
+                kwargs.setdefault(
+                    "source_path", SourcePathOption(source_path=Path(v))
+                ).sourthe_path = Path(v)
             elif k == "pattern":
-                kwargs.setdefault("source_path", SourcePathOption()).pattern = v
+                kwargs.setdefault(
+                    "source_path", SourcePathOption(pattern=v)
+                ).pattern = v
             elif k == "interpolation_offset_time":
                 kwargs.setdefault(
                     "interpolation", InterpolationOption()
@@ -84,6 +89,24 @@ class SourcePathOption:
             raise ValueError("Either pattern or source_path must be provided")
 
     def resolve(self, path: Path) -> Path:
+        """
+        Resolve the source path or pattern against the given path.
+
+        Examples:
+            >>> from pathlib import Path
+            >>> opt = SourcePathOption(source_path=Path("/foo/bar.mp4"))
+            >>> opt.resolve(Path("/baz/qux.mp4"))
+            PosixPath('/foo/bar.mp4')
+
+            >>> opt = SourcePathOption(pattern="videos/%g_sub%e")
+            >>> opt.resolve(Path("/data/video1.mp4"))
+            PosixPath('/data/videos/video1_sub.mp4')
+
+            >>> opt = SourcePathOption(pattern="/abs/path/%f")
+            >>> opt.resolve(Path("/tmp/abc.mov"))
+            PosixPath('/abs/path/abc.mov')
+        """
+
         if self.source_path is not None:
             return self.source_path
 
@@ -139,7 +162,7 @@ SourceOptionSchema = {
             "type": "integer",
         },
         "interpolation_offset_time": {
-            "type": "float",
+            "type": "number",
         },
         "interpolation_use_gpx_start_time": {
             "type": "boolean",

mapillary_tools/geotag/utils.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+import logging
+import typing as T
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+import gpxpy
+
+from .. import exiftool_read, geo, utils
+
+Track = T.List[geo.Point]
+LOG = logging.getLogger(__name__)
+
+
+def parse_gpx(gpx_file: Path) -> list[Track]:
+    with gpx_file.open("r") as f:
+        gpx = gpxpy.parse(f)
+
+    tracks: list[Track] = []
+
+    for track in gpx.tracks:
+        for segment in track.segments:
+            tracks.append([])
+            for point in segment.points:
+                if point.time is not None:
+                    tracks[-1].append(
+                        geo.Point(
+                            time=geo.as_unix_time(point.time),
+                            lat=point.latitude,
+                            lon=point.longitude,
+                            alt=point.elevation,
+                            angle=None,
+                        )
+                    )
+
+    return tracks
+
+
+def index_rdf_description_by_path(
+    xml_paths: T.Sequence[Path],
+) -> dict[str, ET.Element]:
+    rdf_description_by_path: dict[str, ET.Element] = {}
+
+    for xml_path in utils.find_xml_files(xml_paths):
+        try:
+            etree = ET.parse(xml_path)
+        except ET.ParseError as ex:
+            verbose = LOG.getEffectiveLevel() <= logging.DEBUG
+            if verbose:
+                LOG.warning("Failed to parse %s", xml_path, exc_info=True)
+            else:
+                LOG.warning("Failed to parse %s: %s", xml_path, ex)
+            continue
+
+        rdf_description_by_path.update(
+            exiftool_read.index_rdf_description_by_path_from_xml_element(
+                etree.getroot()
+            )
+        )
+
+    return rdf_description_by_path

mapillary_tools/geotag/video_extractors/base.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import abc
+from pathlib import Path
+
+from ... import types
+
+
+class BaseVideoExtractor(abc.ABC):
+    """
+    Extracts metadata from a video file.
+    """
+
+    def __init__(self, video_path: Path):
+        self.video_path = video_path
+
+    def extract(self) -> types.VideoMetadata:
+        raise NotImplementedError

mapillary_tools/geotag/video_extractors/exiftool.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import sys
+import typing as T
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+
+from ... import exceptions, exiftool_read_video, geo, telemetry, types, utils
+from ...gpmf import gpmf_gps_filter
+from .base import BaseVideoExtractor
+
+
+class VideoExifToolExtractor(BaseVideoExtractor):
+    def __init__(self, video_path: Path, element: ET.Element):
+        super().__init__(video_path)
+        self.element = element
+
+    @override
+    def extract(self) -> types.VideoMetadata:
+        exif = exiftool_read_video.ExifToolReadVideo(ET.ElementTree(self.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()
+
+        # ExifTool has no idea if GPS is not found or found but empty
+        if is_gopro:
+            if not points:
+                raise exceptions.MapillaryGPXEmptyError("Empty GPS data found")
+
+            # 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, telemetry.GPSPoint) and p.ground_speed is not None:
+                    p.ground_speed = p.ground_speed / 3.6
+
+            if isinstance(points[0], telemetry.GPSPoint):
+                points = T.cast(
+                    T.List[geo.Point],
+                    gpmf_gps_filter.remove_noisy_points(
+                        T.cast(T.List[telemetry.GPSPoint], points)
+                    ),
+                )
+                if not points:
+                    raise exceptions.MapillaryGPSNoiseError("GPS is too noisy")
+
+        if not points:
+            raise exceptions.MapillaryVideoGPSNotFoundError(
+                "No GPS data found from the video"
+            )
+
+        filetype = types.FileType.GOPRO if is_gopro else types.FileType.VIDEO
+
+        video_metadata = types.VideoMetadata(
+            self.video_path,
+            filesize=utils.get_file_size(self.video_path),
+            filetype=filetype,
+            points=points,
+            make=make,
+            model=model,
+        )
+
+        return video_metadata