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

mapillary_tools/geotag/geotag_videos_from_video.py

@@ -1,197 +1,165 @@
-import io
-import logging
+from __future__ import annotations
+
 import typing as T
-from multiprocessing import Pool
 from pathlib import Path
 
-from tqdm import tqdm
-
-from .. import exceptions, geo, types, utils
+from .. import blackvue_parser, exceptions, geo, telemetry, types, utils
 from ..camm import camm_parser
-from ..mp4 import simple_mp4_parser as sparser
-from ..telemetry import GPSPoint
-from . import blackvue_parser, gpmf_gps_filter, gpmf_parser, utils as video_utils
-from .geotag_from_generic import GeotagVideosFromGeneric
+from ..gpmf import gpmf_gps_filter, gpmf_parser
+from ..types import FileType
+from .geotag_from_generic import GenericVideoExtractor, GeotagVideosFromGeneric
 
-LOG = logging.getLogger(__name__)
 
+class GoProVideoExtractor(GenericVideoExtractor):
+    def extract(self) -> types.VideoMetadataOrError:
+        with self.video_path.open("rb") as fp:
+            gopro_info = gpmf_parser.extract_gopro_info(fp)
 
-class GeotagVideosFromVideo(GeotagVideosFromGeneric):
-    def __init__(
-        self,
-        video_paths: T.Sequence[Path],
-        filetypes: T.Optional[T.Set[types.FileType]] = None,
-        num_processes: T.Optional[int] = None,
-    ):
-        self.video_paths = video_paths
-        self.filetypes = filetypes
-        self.num_processes = num_processes
-
-    def to_description(self) -> T.List[types.VideoMetadataOrError]:
-        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(self._geotag_video, self.video_paths)
-            else:
-                video_metadatas_iter = pool.imap(
-                    self._geotag_video,
-                    self.video_paths,
-                )
-            return list(
-                tqdm(
-                    video_metadatas_iter,
-                    desc="Extracting GPS tracks from videos",
-                    unit="videos",
-                    disable=LOG.getEffectiveLevel() <= logging.DEBUG,
-                    total=len(self.video_paths),
-                )
+        if gopro_info is None:
+            raise exceptions.MapillaryVideoGPSNotFoundError(
+                "No GPS data found from the video"
             )
 
-    def _geotag_video(
-        self,
-        video_path: Path,
-    ) -> types.VideoMetadataOrError:
-        return GeotagVideosFromVideo.geotag_video(video_path, self.filetypes)
-
-    @staticmethod
-    def _extract_video_metadata(
-        video_path: Path,
-        filetypes: T.Optional[T.Set[types.FileType]] = None,
-    ) -> T.Optional[types.VideoMetadata]:
-        if (
-            filetypes is None
-            or types.FileType.VIDEO in filetypes
-            or types.FileType.CAMM in filetypes
-        ):
-            with video_path.open("rb") as fp:
-                try:
-                    points = camm_parser.extract_points(fp)
-                except sparser.ParsingError:
-                    points = None
-
-                if points is not None:
-                    fp.seek(0, io.SEEK_SET)
-                    make, model = camm_parser.extract_camera_make_and_model(fp)
-                    return types.VideoMetadata(
-                        filename=video_path,
-                        md5sum=None,
-                        filesize=utils.get_file_size(video_path),
-                        filetype=types.FileType.CAMM,
-                        points=points,
-                        make=make,
-                        model=model,
-                    )
-
-        if (
-            filetypes is None
-            or types.FileType.VIDEO in filetypes
-            or types.FileType.GOPRO in filetypes
-        ):
-            with video_path.open("rb") as fp:
-                try:
-                    points_with_fix = gpmf_parser.extract_points(fp)
-                except sparser.ParsingError:
-                    points_with_fix = None
-
-                if points_with_fix is not None:
-                    fp.seek(0, io.SEEK_SET)
-                    make, model = "GoPro", gpmf_parser.extract_camera_model(fp)
-                    return types.VideoMetadata(
-                        filename=video_path,
-                        md5sum=None,
-                        filesize=utils.get_file_size(video_path),
-                        filetype=types.FileType.GOPRO,
-                        points=T.cast(T.List[geo.Point], points_with_fix),
-                        make=make,
-                        model=model,
-                    )
-
-        if (
-            filetypes is None
-            or types.FileType.VIDEO in filetypes
-            or types.FileType.BLACKVUE in filetypes
-        ):
-            with video_path.open("rb") as fp:
-                try:
-                    points = blackvue_parser.extract_points(fp)
-                except sparser.ParsingError:
-                    points = None
-
-                if points is not None:
-                    fp.seek(0, io.SEEK_SET)
-                    make, model = "BlackVue", blackvue_parser.extract_camera_model(fp)
-                    return types.VideoMetadata(
-                        filename=video_path,
-                        md5sum=None,
-                        filesize=utils.get_file_size(video_path),
-                        filetype=types.FileType.BLACKVUE,
-                        points=points,
-                        make=make,
-                        model=model,
-                    )
-
-        return None
-
-    @staticmethod
-    def geotag_video(
-        video_path: Path,
-        filetypes: T.Optional[T.Set[types.FileType]] = None,
-    ) -> types.VideoMetadataOrError:
-        video_metadata = None
-        try:
-            video_metadata = GeotagVideosFromVideo._extract_video_metadata(
-                video_path, filetypes
+        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,
+        )
+
+
+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 video_metadata is None:
-                raise exceptions.MapillaryVideoError("No GPS data found from the video")
-
-            if not video_metadata.points:
-                raise exceptions.MapillaryGPXEmptyError("Empty GPS data found")
-
-            video_metadata.points = geo.extend_deduplicate_points(video_metadata.points)
-            assert video_metadata.points, "must have at least one point"
-
-            if all(isinstance(p, GPSPoint) for p in video_metadata.points):
-                video_metadata.points = T.cast(
-                    T.List[geo.Point],
-                    gpmf_gps_filter.remove_noisy_points(
-                        T.cast(T.List[GPSPoint], video_metadata.points)
-                    ),
-                )
-                if not video_metadata.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 video_metadata.points]
-                )
+        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")
             )
-            if stationary:
-                raise exceptions.MapillaryStationaryVideoError("Stationary video")
-
-            LOG.debug("Calculating MD5 checksum for %s", str(video_metadata.filename))
-            video_metadata.update_md5sum()
-        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,
-                )
-            filetype = None if video_metadata is None else video_metadata.filetype
             return types.describe_error_metadata(
-                ex,
-                video_path,
-                filetype=filetype,
+                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"
+        )
+
+
+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)
+        self.filetypes = filetypes
+
+    def _generate_video_extractors(self) -> T.Sequence[GenericVideoExtractor]:
+        return [
+            NativeVideoExtractor(path, filetypes=self.filetypes)
+            for path in self.video_paths
+        ]

mapillary_tools/geotag/options.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import dataclasses
+import enum
+import json
+import typing as T
+from pathlib import Path
+
+import jsonschema
+
+from .. import types
+
+
+class SourceType(enum.Enum):
+    NATIVE = "native"
+    GPX = "gpx"
+    NMEA = "nmea"
+    EXIFTOOL_XML = "exiftool_xml"
+    EXIFTOOL_RUNTIME = "exiftool_runtime"
+
+    # Legacy source types for images
+    GOPRO = "gopro"
+    BLACKVUE = "blackvue"
+    CAMM = "camm"
+    EXIF = "exif"
+
+
+SOURCE_TYPE_ALIAS: dict[str, SourceType] = {
+    "blackvue_videos": SourceType.BLACKVUE,
+    "gopro_videos": SourceType.GOPRO,
+}
+
+
+@dataclasses.dataclass
+class SourceOption:
+    # Type of the source
+    source: SourceType
+
+    # Filter by these filetypes
+    filetypes: set[types.FileType] | None = None
+
+    num_processes: int | None = None
+
+    source_path: SourcePathOption | None = None
+
+    interpolation: InterpolationOption | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, T.Any]) -> SourceOption:
+        validate_option(data)
+
+        kwargs: dict[str, T.Any] = {}
+        for k, v in data.items():
+            # None values are considered as absent and should be ignored
+            if v is None:
+                continue
+            if k == "source":
+                kwargs[k] = SourceType(SOURCE_TYPE_ALIAS.get(v, v))
+            elif k == "filetypes":
+                kwargs[k] = {types.FileType(t) for t in v}
+            elif k == "source_path":
+                kwargs.setdefault("source_path", SourcePathOption()).source_path = v
+            elif k == "pattern":
+                kwargs.setdefault("source_path", SourcePathOption()).pattern = v
+            elif k == "interpolation_offset_time":
+                kwargs.setdefault(
+                    "interpolation", InterpolationOption()
+                ).offset_time = v
+            elif k == "interpolation_use_gpx_start_time":
+                kwargs.setdefault(
+                    "interpolation", InterpolationOption()
+                ).use_gpx_start_time = v
+
+        return cls(**kwargs)
+
+
+@dataclasses.dataclass
+class SourcePathOption:
+    pattern: str | None = None
+    source_path: Path | None = None
+
+    def __post_init__(self):
+        if self.source_path is None and self.pattern is None:
+            raise ValueError("Either pattern or source_path must be provided")
+
+    def resolve(self, path: Path) -> Path:
+        if self.source_path is not None:
+            return self.source_path
+
+        assert self.pattern is not None, (
+            "either pattern or source_path must be provided"
+        )
+
+        # %f: the full video filename (foo.mp4)
+        # %g: the video filename without extension (foo)
+        # %e: the video filename extension (.mp4)
+        replaced = Path(
+            self.pattern.replace("%f", path.name)
+            .replace("%g", path.stem)
+            .replace("%e", path.suffix)
+        )
+
+        abs_path = (
+            replaced
+            if replaced.is_absolute()
+            else Path.joinpath(path.parent.resolve(), replaced)
+        ).resolve()
+
+        return abs_path
+
+
+@dataclasses.dataclass
+class InterpolationOption:
+    offset_time: float = 0.0
+    use_gpx_start_time: bool = False
+
+
+SourceOptionSchema = {
+    "type": "object",
+    "properties": {
+        "source": {
+            "type": "string",
+            "enum": [s.value for s in SourceType] + list(SOURCE_TYPE_ALIAS.keys()),
+        },
+        "filetypes": {
+            "type": "array",
+            "items": {
+                "type": "string",
+                "enum": [t.value for t in types.FileType],
+            },
+        },
+        "source_path": {
+            "type": "string",
+        },
+        "pattern": {
+            "type": "string",
+        },
+        "num_processes": {
+            "type": "integer",
+        },
+        "interpolation_offset_time": {
+            "type": "float",
+        },
+        "interpolation_use_gpx_start_time": {
+            "type": "boolean",
+        },
+    },
+    "required": ["source"],
+    "additionalProperties": False,
+}
+
+
+def validate_option(instance):
+    jsonschema.validate(instance=instance, schema=SourceOptionSchema)
+
+
+if __name__ == "__main__":
+    # python -m mapillary_tools.geotag.options > schema/geotag_source_option.json
+    print(json.dumps(SourceOptionSchema, indent=4))