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

mapillary_tools/geotag/geotag_images_from_nmea_file.py

@@ -1,5 +1,6 @@
+from __future__ import annotations
+
 import datetime
-import typing as T
 from pathlib import Path
 
 import pynmea2
@@ -11,15 +12,13 @@ from .geotag_images_from_gpx import GeotagImagesFromGPX
 class GeotagImagesFromNMEAFile(GeotagImagesFromGPX):
     def __init__(
         self,
-        image_paths: T.Sequence[Path],
         source_path: Path,
         use_gpx_start_time: bool = False,
         offset_time: float = 0.0,
-        num_processes: T.Optional[int] = None,
+        num_processes: int | None = None,
     ):
         points = get_lat_lon_time_from_nmea(source_path)
         super().__init__(
-            image_paths,
             points,
             use_gpx_start_time=use_gpx_start_time,
             offset_time=offset_time,
@@ -27,7 +26,7 @@ class GeotagImagesFromNMEAFile(GeotagImagesFromGPX):
         )
 
 
-def get_lat_lon_time_from_nmea(nmea_file: Path) -> T.List[geo.Point]:
+def get_lat_lon_time_from_nmea(nmea_file: Path) -> list[geo.Point]:
     with nmea_file.open("r") as f:
         lines = f.readlines()
         lines = [line.rstrip("\n\r") for line in lines]

mapillary_tools/geotag/geotag_images_from_video.py

@@ -1,13 +1,19 @@
+from __future__ import annotations
+
 import logging
+import sys
 import typing as T
 from pathlib import Path
 
-from tqdm import tqdm
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
 
 from .. import types, utils
-
-from .geotag_from_generic import GeotagImagesFromGeneric
-from .geotag_images_from_gpx import GeotagImagesFromGPXWithProgress
+from .base import GeotagImagesFromGeneric
+from .geotag_images_from_gpx import GeotagImagesFromGPX
+from .geotag_videos_from_video import GeotagVideosFromVideo
 
 
 LOG = logging.getLogger(__name__)
@@ -16,75 +22,106 @@ LOG = logging.getLogger(__name__)
 class GeotagImagesFromVideo(GeotagImagesFromGeneric):
     def __init__(
         self,
-        image_paths: T.Sequence[Path],
         video_metadatas: T.Sequence[types.VideoMetadataOrError],
         offset_time: float = 0.0,
-        num_processes: T.Optional[int] = None,
+        num_processes: int | None = None,
     ):
-        self.image_paths = image_paths
+        super().__init__(num_processes=num_processes)
         self.video_metadatas = video_metadatas
         self.offset_time = offset_time
-        self.num_processes = num_processes
-        super().__init__()
 
-    def to_description(self) -> T.List[types.ImageMetadataOrError]:
-        # will return this list
-        final_image_metadatas: T.List[types.ImageMetadataOrError] = []
+    @override
+    def to_description(
+        self, image_paths: T.Sequence[Path]
+    ) -> list[types.ImageMetadataOrError]:
+        # Will return this list
+        final_image_metadatas: list[types.ImageMetadataOrError] = []
 
-        for video_metadata in self.video_metadatas:
-            video_path = video_metadata.filename
-            LOG.debug("Processing video: %s", video_path)
+        video_metadatas, video_error_metadatas = types.separate_errors(
+            self.video_metadatas
+        )
 
-            sample_image_paths = list(
-                utils.filter_video_samples(self.image_paths, video_path)
+        for video_error_metadata in video_error_metadatas:
+            video_path = video_error_metadata.filename
+            sample_paths = list(utils.filter_video_samples(image_paths, video_path))
+            LOG.debug(
+                "Found %d sample images from video %s with error: %s",
+                len(sample_paths),
+                video_path,
+                video_error_metadata.error,
             )
+            for sample_path in sample_paths:
+                image_error_metadata = types.describe_error_metadata(
+                    video_error_metadata.error,
+                    sample_path,
+                    filetype=types.FileType.IMAGE,
+                )
+                final_image_metadatas.append(image_error_metadata)
+
+        for video_metadata in video_metadatas:
+            video_path = video_metadata.filename
+
+            sample_paths = list(utils.filter_video_samples(image_paths, video_path))
             LOG.debug(
                 "Found %d sample images from video %s",
-                len(sample_image_paths),
+                len(sample_paths),
                 video_path,
             )
 
-            if isinstance(video_metadata, types.ErrorMetadata):
-                for sample_image_path in sample_image_paths:
-                    error_metadata = types.describe_error_metadata(
-                        video_metadata.error,
-                        sample_image_path,
-                        filetype=types.FileType.IMAGE,
-                    )
-                    final_image_metadatas.append(error_metadata)
-                continue
-
-            with tqdm(
-                total=len(sample_image_paths),
-                desc=f"Interpolating {video_path.name}",
-                unit="images",
-                disable=LOG.getEffectiveLevel() <= logging.DEBUG,
-            ) as pbar:
-                image_metadatas = GeotagImagesFromGPXWithProgress(
-                    sample_image_paths,
-                    video_metadata.points,
-                    use_gpx_start_time=False,
-                    use_image_start_time=True,
-                    offset_time=self.offset_time,
-                    num_processes=self.num_processes,
-                    progress_bar=pbar,
-                ).to_description()
-                final_image_metadatas.extend(image_metadatas)
-
-            # update make and model
-            LOG.debug(
-                'Found camera make "%s" and model "%s"',
-                video_metadata.make,
-                video_metadata.model,
+            geotag = GeotagImagesFromGPX(
+                video_metadata.points,
+                use_gpx_start_time=False,
+                use_image_start_time=True,
+                offset_time=self.offset_time,
+                num_processes=self.num_processes,
             )
+
+            image_metadatas = geotag.to_description(image_paths)
+
             for metadata in image_metadatas:
                 if isinstance(metadata, types.ImageMetadata):
                     metadata.MAPDeviceMake = video_metadata.make
                     metadata.MAPDeviceModel = video_metadata.model
 
+            final_image_metadatas.extend(image_metadatas)
+
         # NOTE: this method only geotags images that have a corresponding video,
         # so the number of image metadata objects returned might be less than
         # the number of the input image_paths
-        assert len(final_image_metadatas) <= len(self.image_paths)
+        assert len(final_image_metadatas) <= len(image_paths)
 
         return final_image_metadatas
+
+
+class GeotagImageSamplesFromVideo(GeotagImagesFromGeneric):
+    def __init__(
+        self,
+        source_path: Path,
+        filetypes: set[types.FileType] | None = None,
+        offset_time: float = 0.0,
+        num_processes: int | None = None,
+    ):
+        super().__init__(num_processes=num_processes)
+        self.source_path = source_path
+        self.filetypes = filetypes
+        self.offset_time = offset_time
+
+    @override
+    def to_description(
+        self, image_paths: T.Sequence[Path]
+    ) -> list[types.ImageMetadataOrError]:
+        video_paths = utils.find_videos([self.source_path])
+        image_samples_by_video_path = utils.find_all_image_samples(
+            image_paths, video_paths
+        )
+        video_paths_with_image_samples = list(image_samples_by_video_path.keys())
+        video_metadatas = GeotagVideosFromVideo(
+            filetypes=self.filetypes,
+            num_processes=self.num_processes,
+        ).to_description(video_paths_with_image_samples)
+        geotag = GeotagImagesFromVideo(
+            video_metadatas,
+            offset_time=self.offset_time,
+            num_processes=self.num_processes,
+        )
+        return geotag.to_description(image_paths)

mapillary_tools/geotag/geotag_videos_from_exiftool.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import logging
+import sys
+import typing as T
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+
+from .. import constants, exceptions, exiftool_read, types
+from ..exiftool_runner import ExiftoolRunner
+from . import options
+from .base import GeotagVideosFromGeneric
+from .utils import index_rdf_description_by_path
+from .video_extractors.exiftool import VideoExifToolExtractor
+
+LOG = logging.getLogger(__name__)
+
+
+class GeotagVideosFromExifToolXML(GeotagVideosFromGeneric):
+    def __init__(
+        self, source_path: options.SourcePathOption, num_processes: int | None = None
+    ):
+        super().__init__(num_processes=num_processes)
+        self.source_path = source_path
+
+    @classmethod
+    def build_video_extractors_from_etree(
+        cls, rdf_by_path: dict[str, ET.Element], video_paths: T.Iterable[Path]
+    ) -> list[VideoExifToolExtractor | types.ErrorMetadata]:
+        results: list[VideoExifToolExtractor | types.ErrorMetadata] = []
+
+        for path in video_paths:
+            rdf = rdf_by_path.get(exiftool_read.canonical_path(path))
+            if rdf is None:
+                ex = exceptions.MapillaryExifToolXMLNotFoundError(
+                    "Cannot find the video in the ExifTool XML"
+                )
+                results.append(
+                    types.describe_error_metadata(
+                        ex, path, filetype=types.FileType.VIDEO
+                    )
+                )
+            else:
+                results.append(VideoExifToolExtractor(path, rdf))
+
+        return results
+
+    @override
+    def _generate_video_extractors(
+        self, video_paths: T.Sequence[Path]
+    ) -> T.Sequence[VideoExifToolExtractor | types.ErrorMetadata]:
+        rdf_by_path = self.find_rdf_by_path(self.source_path, video_paths)
+        return self.build_video_extractors_from_etree(rdf_by_path, video_paths)
+
+    @classmethod
+    def find_rdf_by_path(
+        cls, option: options.SourcePathOption, paths: T.Iterable[Path]
+    ) -> dict[str, ET.Element]:
+        if option.source_path is not None:
+            return index_rdf_description_by_path([option.source_path])
+
+        elif option.pattern is not None:
+            rdf_by_path = {}
+            for path in paths:
+                source_path = option.resolve(path)
+                r = index_rdf_description_by_path([source_path])
+                rdfs = list(r.values())
+                if rdfs:
+                    rdf_by_path[exiftool_read.canonical_path(path)] = rdfs[0]
+            return rdf_by_path
+
+        else:
+            assert False, "Either source_path or pattern must be provided"
+
+
+class GeotagVideosFromExifToolRunner(GeotagVideosFromGeneric):
+    @override
+    def _generate_video_extractors(
+        self, video_paths: T.Sequence[Path]
+    ) -> T.Sequence[VideoExifToolExtractor | types.ErrorMetadata]:
+        if constants.EXIFTOOL_PATH is None:
+            runner = ExiftoolRunner()
+        else:
+            runner = ExiftoolRunner(constants.EXIFTOOL_PATH)
+
+        LOG.debug(
+            "Extracting XML from %d videos with ExifTool command: %s",
+            len(video_paths),
+            " ".join(runner._build_args_read_stdin()),
+        )
+        try:
+            xml = runner.extract_xml(video_paths)
+        except FileNotFoundError as ex:
+            exiftool_ex = exceptions.MapillaryExiftoolNotFoundError(ex)
+            return [
+                types.describe_error_metadata(
+                    exiftool_ex, video_path, filetype=types.FileType.VIDEO
+                )
+                for video_path in video_paths
+            ]
+
+        try:
+            xml_element = ET.fromstring(xml)
+        except ET.ParseError as ex:
+            LOG.warning(
+                "Failed to parse ExifTool XML: %s",
+                str(ex),
+                exc_info=LOG.getEffectiveLevel() <= logging.DEBUG,
+            )
+            rdf_by_path = {}
+        else:
+            rdf_by_path = exiftool_read.index_rdf_description_by_path_from_xml_element(
+                xml_element
+            )
+
+        return GeotagVideosFromExifToolXML.build_video_extractors_from_etree(
+            rdf_by_path, video_paths
+        )

mapillary_tools/geotag/geotag_videos_from_gpx.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import logging
+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, types
+from . import options
+from .base import GeotagVideosFromGeneric
+from .video_extractors.gpx import GPXVideoExtractor
+
+
+LOG = logging.getLogger(__name__)
+
+
+class GeotagVideosFromGPX(GeotagVideosFromGeneric):
+    def __init__(
+        self,
+        source_path: options.SourcePathOption | None = None,
+        num_processes: int | None = None,
+    ):
+        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,197 +1,32 @@
-import io
-import logging
+from __future__ import annotations
+
+import sys
 import typing as T
-from multiprocessing import Pool
 from pathlib import Path
 
-from tqdm import tqdm
-
-from .. import exceptions, geo, 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
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
 
-LOG = logging.getLogger(__name__)
+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: T.Optional[T.Set[types.FileType]] = None,
-        num_processes: T.Optional[int] = None,
+        filetypes: set[FileType] | None = None,
+        num_processes: int | None = None,
     ):
-        self.video_paths = video_paths
+        super().__init__(num_processes=num_processes)
         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),
-                )
-            )
-
-    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
-            )
-
-            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 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,
-            )
 
-        return video_metadata
+    @override
+    def _generate_video_extractors(
+        self, video_paths: T.Sequence[Path]
+    ) -> T.Sequence[NativeVideoExtractor]:
+        return [
+            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