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

mapillary_tools/geotag/geotag_images_from_exiftool.py

@@ -1,109 +1,160 @@
-import io
+from __future__ import annotations
+
 import logging
+import sys
 import typing as T
 import xml.etree.ElementTree as ET
-from multiprocessing import Pool
 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 exceptions, exiftool_read, types
-from .geotag_from_generic import GeotagImagesFromGeneric
-from .geotag_images_from_exif import GeotagImagesFromEXIF, verify_image_exif_write
+from .. import constants, exceptions, exiftool_read, types, utils
+from ..exiftool_runner import ExiftoolRunner
+from . import options
+from .base import GeotagImagesFromGeneric
+from .geotag_images_from_video import GeotagImagesFromVideo
+from .geotag_videos_from_exiftool import GeotagVideosFromExifToolXML
+from .image_extractors.exiftool import ImageExifToolExtractor
 
 LOG = logging.getLogger(__name__)
 
 
-class GeotagImagesFromExifTool(GeotagImagesFromGeneric):
+class GeotagImagesFromExifToolXML(GeotagImagesFromGeneric):
     def __init__(
-        self,
-        image_paths: T.Sequence[Path],
-        xml_path: Path,
-        num_processes: T.Optional[int] = None,
+        self, source_path: options.SourcePathOption, num_processes: int | None = None
     ):
-        self.image_paths = image_paths
-        self.xml_path = xml_path
-        self.num_processes = num_processes
-        super().__init__()
-
-    @staticmethod
-    def geotag_image(element: ET.Element) -> types.ImageMetadataOrError:
-        image_path = exiftool_read.find_rdf_description_path(element)
-        assert image_path is not None, "must find the path from the element"
+        self.source_path = source_path
+        super().__init__(num_processes=num_processes)
 
-        try:
-            exif = exiftool_read.ExifToolRead(ET.ElementTree(element))
-            image_metadata = GeotagImagesFromEXIF.build_image_metadata(
-                image_path, exif, skip_lonlat_error=False
-            )
-            # load the image bytes into memory to avoid reading it multiple times
-            with image_path.open("rb") as fp:
-                image_bytesio = io.BytesIO(fp.read())
-            image_bytesio.seek(0, io.SEEK_SET)
-            verify_image_exif_write(
-                image_metadata,
-                image_bytes=image_bytesio.read(),
-            )
-        except Exception as ex:
-            return types.describe_error_metadata(
-                ex, image_path, filetype=types.FileType.IMAGE
-            )
-
-        image_bytesio.seek(0, io.SEEK_SET)
-        image_metadata.update_md5sum(image_bytesio)
-
-        return image_metadata
-
-    def to_description(self) -> T.List[types.ImageMetadataOrError]:
-        rdf_description_by_path = exiftool_read.index_rdf_description_by_path(
-            [self.xml_path]
-        )
+    @classmethod
+    def build_image_extractors(
+        cls, rdf_by_path: dict[str, ET.Element], image_paths: T.Iterable[Path]
+    ) -> list[ImageExifToolExtractor | types.ErrorMetadata]:
+        results: list[ImageExifToolExtractor | types.ErrorMetadata] = []
 
-        error_metadatas: T.List[types.ErrorMetadata] = []
-        rdf_descriptions: T.List[ET.Element] = []
-        for path in self.image_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 image not found"
+        for path in image_paths:
+            rdf = rdf_by_path.get(exiftool_read.canonical_path(path))
+            if rdf is None:
+                ex = exceptions.MapillaryExifToolXMLNotFoundError(
+                    "Cannot find the image in the ExifTool XML"
                 )
-                error_metadatas.append(
+                results.append(
                     types.describe_error_metadata(
-                        exc, path, filetype=types.FileType.IMAGE
+                        ex, path, filetype=types.FileType.IMAGE
                     )
                 )
             else:
-                rdf_descriptions.append(rdf_description)
+                results.append(ImageExifToolExtractor(path, rdf))
+
+        return results
+
+    @override
+    def _generate_image_extractors(
+        self, image_paths: T.Sequence[Path]
+    ) -> T.Sequence[ImageExifToolExtractor | types.ErrorMetadata]:
+        rdf_by_path = GeotagVideosFromExifToolXML.find_rdf_by_path(
+            self.source_path, image_paths
+        )
+        return self.build_image_extractors(rdf_by_path, image_paths)
+
 
-        if self.num_processes is None:
-            num_processes = self.num_processes
-            disable_multiprocessing = False
+class GeotagImagesFromExifToolRunner(GeotagImagesFromGeneric):
+    @override
+    def _generate_image_extractors(
+        self, image_paths: T.Sequence[Path]
+    ) -> T.Sequence[ImageExifToolExtractor | types.ErrorMetadata]:
+        if constants.EXIFTOOL_PATH is None:
+            runner = ExiftoolRunner()
         else:
-            num_processes = max(self.num_processes, 1)
-            disable_multiprocessing = self.num_processes <= 0
-
-        with Pool(processes=num_processes) as pool:
-            image_metadatas_iter: T.Iterator[types.ImageMetadataOrError]
-            if disable_multiprocessing:
-                image_metadatas_iter = map(
-                    GeotagImagesFromExifTool.geotag_image,
-                    rdf_descriptions,
-                )
-            else:
-                image_metadatas_iter = pool.imap(
-                    GeotagImagesFromExifTool.geotag_image,
-                    rdf_descriptions,
-                )
-            image_metadata_or_errors = list(
-                tqdm(
-                    image_metadatas_iter,
-                    desc="Extracting geotags from ExifTool XML",
-                    unit="images",
-                    disable=LOG.getEffectiveLevel() <= logging.DEBUG,
-                    total=len(self.image_paths),
+            runner = ExiftoolRunner(constants.EXIFTOOL_PATH)
+
+        LOG.debug(
+            "Extracting XML from %d images with ExifTool command: %s",
+            len(image_paths),
+            " ".join(runner._build_args_read_stdin()),
+        )
+        try:
+            xml = runner.extract_xml(image_paths)
+        except FileNotFoundError as ex:
+            exiftool_ex = exceptions.MapillaryExiftoolNotFoundError(ex)
+            return [
+                types.describe_error_metadata(
+                    exiftool_ex, image_path, filetype=types.FileType.IMAGE
                 )
+                for image_path in image_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 GeotagImagesFromExifToolXML.build_image_extractors(
+            rdf_by_path, image_paths
+        )
+
+
+class GeotagImagesFromExifToolWithSamples(GeotagImagesFromGeneric):
+    def __init__(
+        self,
+        source_path: options.SourcePathOption,
+        offset_time: float = 0.0,
+        num_processes: int | None = None,
+    ):
+        super().__init__(num_processes=num_processes)
+        self.source_path = source_path
+        self.offset_time = offset_time
+
+    def geotag_samples(
+        self, image_paths: T.Sequence[Path]
+    ) -> list[types.ImageMetadataOrError]:
+        # Find all video paths in self.xml_path
+        rdf_by_path = GeotagVideosFromExifToolXML.find_rdf_by_path(
+            self.source_path, image_paths
+        )
+        video_paths = utils.find_videos(
+            [Path(canonical_path) for canonical_path in rdf_by_path.keys()],
+            skip_subfolders=True,
+        )
+        # Find all video paths that have sample images
+        samples_by_video = utils.find_all_image_samples(image_paths, video_paths)
+
+        video_metadata_or_errors = GeotagVideosFromExifToolXML(
+            self.source_path, num_processes=self.num_processes
+        ).to_description(list(samples_by_video.keys()))
+        sample_paths = sum(samples_by_video.values(), [])
+        sample_metadata_or_errors = GeotagImagesFromVideo(
+            video_metadata_or_errors,
+            offset_time=self.offset_time,
+            num_processes=self.num_processes,
+        ).to_description(sample_paths)
+
+        return sample_metadata_or_errors
+
+    @override
+    def to_description(
+        self, image_paths: T.Sequence[Path]
+    ) -> list[types.ImageMetadataOrError]:
+        sample_metadata_or_errors = self.geotag_samples(image_paths)
+
+        sample_paths = set(metadata.filename for metadata in sample_metadata_or_errors)
+
+        non_sample_paths = [path for path in image_paths if path not in sample_paths]
+
+        non_sample_metadata_or_errors = GeotagImagesFromExifToolXML(
+            self.source_path, num_processes=self.num_processes
+        ).to_description(non_sample_paths)
 
-        return error_metadatas + image_metadata_or_errors
+        return sample_metadata_or_errors + non_sample_metadata_or_errors

mapillary_tools/geotag/geotag_images_from_gpx.py

@@ -1,12 +1,20 @@
+from __future__ import annotations
+
 import dataclasses
 import logging
+import sys
 import typing as T
-from multiprocessing import Pool
 from pathlib import Path
 
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+
 from .. import exceptions, geo, types
-from .geotag_from_generic import GeotagImagesFromGeneric
-from .geotag_images_from_exif import GeotagImagesFromEXIF
+from ..serializer.description import build_capture_time
+from .base import GeotagImagesFromGeneric
+from .geotag_images_from_exif import ImageEXIFExtractor
 
 
 LOG = logging.getLogger(__name__)
@@ -15,79 +23,50 @@ LOG = logging.getLogger(__name__)
 class GeotagImagesFromGPX(GeotagImagesFromGeneric):
     def __init__(
         self,
-        image_paths: T.Sequence[Path],
         points: T.Sequence[geo.Point],
         use_gpx_start_time: bool = False,
         use_image_start_time: bool = False,
         offset_time: float = 0.0,
-        num_processes: T.Optional[int] = None,
+        num_processes: int | None = None,
     ):
-        super().__init__()
-        self.image_paths = image_paths
+        super().__init__(num_processes=num_processes)
         self.points = points
         self.use_gpx_start_time = use_gpx_start_time
         self.use_image_start_time = use_image_start_time
         self.offset_time = offset_time
-        self.num_processes = num_processes
-
-    @staticmethod
-    def geotag_image(image_path: Path) -> types.ImageMetadataOrError:
-        return GeotagImagesFromEXIF.geotag_image(image_path, skip_lonlat_error=True)
-
-    def geotag_multiple_images(
-        self, image_paths: T.Sequence[Path]
-    ) -> T.List[types.ImageMetadataOrError]:
-        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
-
-        if disable_multiprocessing:
-            return list(map(GeotagImagesFromGPX.geotag_image, image_paths))
-        else:
-            with Pool(processes=num_processes) as pool:
-                return pool.map(GeotagImagesFromGPX.geotag_image, image_paths)
 
     def _interpolate_image_metadata_along(
         self,
         image_metadata: types.ImageMetadata,
         sorted_points: T.Sequence[geo.Point],
-    ) -> types.ImageMetadataOrError:
+    ) -> types.ImageMetadata:
         assert sorted_points, "must have at least one point"
 
         if image_metadata.time < sorted_points[0].time:
             delta = sorted_points[0].time - image_metadata.time
-            gpx_start_time = types.datetime_to_map_capture_time(sorted_points[0].time)
-            gpx_end_time = types.datetime_to_map_capture_time(sorted_points[-1].time)
+            gpx_start_time = build_capture_time(sorted_points[0].time)
+            gpx_end_time = build_capture_time(sorted_points[-1].time)
             # with the tolerance of 1ms
             if 0.001 < delta:
-                exc = exceptions.MapillaryOutsideGPXTrackError(
+                raise exceptions.MapillaryOutsideGPXTrackError(
                     f"The image date time is {round(delta, 3)} seconds behind the GPX start point",
-                    image_time=types.datetime_to_map_capture_time(image_metadata.time),
+                    image_time=build_capture_time(image_metadata.time),
                     gpx_start_time=gpx_start_time,
                     gpx_end_time=gpx_end_time,
                 )
-                return types.describe_error_metadata(
-                    exc, image_metadata.filename, filetype=types.FileType.IMAGE
-                )
 
         if sorted_points[-1].time < image_metadata.time:
             delta = image_metadata.time - sorted_points[-1].time
-            gpx_start_time = types.datetime_to_map_capture_time(sorted_points[0].time)
-            gpx_end_time = types.datetime_to_map_capture_time(sorted_points[-1].time)
+            gpx_start_time = build_capture_time(sorted_points[0].time)
+            gpx_end_time = build_capture_time(sorted_points[-1].time)
             # with the tolerance of 1ms
             if 0.001 < delta:
-                exc = exceptions.MapillaryOutsideGPXTrackError(
+                raise exceptions.MapillaryOutsideGPXTrackError(
                     f"The image time is {round(delta, 3)} seconds beyond the GPX end point",
-                    image_time=types.datetime_to_map_capture_time(image_metadata.time),
+                    image_time=build_capture_time(image_metadata.time),
                     gpx_start_time=gpx_start_time,
                     gpx_end_time=gpx_end_time,
                 )
-                return types.describe_error_metadata(
-                    exc, image_metadata.filename, filetype=types.FileType.IMAGE
-                )
 
         interpolated = geo.interpolate(sorted_points, image_metadata.time)
 
@@ -100,34 +79,30 @@ class GeotagImagesFromGPX(GeotagImagesFromGeneric):
             time=interpolated.time,
         )
 
-    def to_description(self) -> T.List[types.ImageMetadataOrError]:
-        metadatas: T.List[types.ImageMetadataOrError] = []
-
-        if not self.points:
-            exc = exceptions.MapillaryGPXEmptyError(
-                "Empty GPS extracted from the geotag source"
-            )
-            for image_path in self.image_paths:
-                metadatas.append(
-                    types.describe_error_metadata(
-                        exc, image_path, filetype=types.FileType.IMAGE
-                    ),
-                )
-            assert len(self.image_paths) == len(metadatas)
-            return metadatas
+    @override
+    def _generate_image_extractors(
+        self, image_paths: T.Sequence[Path]
+    ) -> T.Sequence[ImageEXIFExtractor]:
+        return [
+            ImageEXIFExtractor(path, skip_lonlat_error=True) for path in image_paths
+        ]
+
+    @override
+    def to_description(
+        self, image_paths: T.Sequence[Path]
+    ) -> list[types.ImageMetadataOrError]:
+        final_metadatas: list[types.ImageMetadataOrError] = []
 
-        image_metadata_or_errors = self.geotag_multiple_images(self.image_paths)
+        image_metadata_or_errors = super().to_description(image_paths)
 
-        image_metadatas = []
-        for metadata_or_error in image_metadata_or_errors:
-            if isinstance(metadata_or_error, types.ErrorMetadata):
-                metadatas.append(metadata_or_error)
-            else:
-                image_metadatas.append(metadata_or_error)
+        image_metadatas, error_metadatas = types.separate_errors(
+            image_metadata_or_errors
+        )
+        final_metadatas.extend(error_metadatas)
 
         if not image_metadatas:
-            assert len(self.image_paths) == len(metadatas)
-            return metadatas
+            assert len(image_paths) == len(final_metadatas)
+            return final_metadatas
 
         # Do not use point itself for comparison because point.angle or point.alt could be None
         # when you compare nonnull value with None, it will throw
@@ -162,64 +137,25 @@ class GeotagImagesFromGPX(GeotagImagesFromGeneric):
                 LOG.debug("GPX start time delta: %s", time_delta)
                 image_time_offset += time_delta
 
-        LOG.debug("Final time offset for interpolation: %s", image_time_offset)
+        if image_time_offset:
+            LOG.debug("Final time offset for interpolation: %s", image_time_offset)
+            for image_metadata in sorted_image_metadatas:
+                # TODO: this time modification seems to affect final capture times
+                image_metadata.time += image_time_offset
 
         for image_metadata in sorted_image_metadatas:
-            image_metadata.time += image_time_offset
-            metadatas.append(
-                self._interpolate_image_metadata_along(image_metadata, sorted_points)
-            )
-
-        assert len(self.image_paths) == len(metadatas)
-        return metadatas
-
-
-class GeotagImagesFromGPXWithProgress(GeotagImagesFromGPX):
-    def __init__(
-        self,
-        image_paths: T.Sequence[Path],
-        points: T.Sequence[geo.Point],
-        use_gpx_start_time: bool = False,
-        use_image_start_time: bool = False,
-        offset_time: float = 0.0,
-        num_processes: T.Optional[int] = None,
-        progress_bar=None,
-    ) -> None:
-        super().__init__(
-            image_paths,
-            points,
-            use_gpx_start_time=use_gpx_start_time,
-            use_image_start_time=use_image_start_time,
-            offset_time=offset_time,
-            num_processes=num_processes,
-        )
-        self._progress_bar = progress_bar
-
-    def geotag_multiple_images(
-        self, image_paths: T.Sequence[Path]
-    ) -> T.List[types.ImageMetadataOrError]:
-        if self._progress_bar is None:
-            return super().geotag_multiple_images(image_paths)
-
-        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
-
-        output = []
-        with Pool(processes=num_processes) as pool:
-            image_metadatas_iter: T.Iterator[types.ImageMetadataOrError]
-            if disable_multiprocessing:
-                image_metadatas_iter = map(
-                    GeotagImagesFromGPX.geotag_image, image_paths
+            try:
+                final_metadatas.append(
+                    self._interpolate_image_metadata_along(
+                        image_metadata, sorted_points
+                    )
                 )
-            else:
-                image_metadatas_iter = pool.imap(
-                    GeotagImagesFromGPX.geotag_image, image_paths
+            except exceptions.MapillaryOutsideGPXTrackError as ex:
+                error_metadata = types.describe_error_metadata(
+                    ex, image_metadata.filename, filetype=types.FileType.IMAGE
                 )
-            for image_metadata_or_error in image_metadatas_iter:
-                self._progress_bar.update(1)
-                output.append(image_metadata_or_error)
-        return output
+                final_metadatas.append(error_metadata)
+
+        assert len(image_paths) == len(final_metadatas)
+
+        return final_metadatas

mapillary_tools/geotag/geotag_images_from_gpx_file.py

@@ -1,32 +1,25 @@
-import dataclasses
+from __future__ import annotations
+
 import logging
-import typing as T
-from multiprocessing import Pool
 from pathlib import Path
 
-import gpxpy
-from tqdm import tqdm
-
-from .. import exif_read, geo, types
-from .geotag_from_generic import GeotagImagesFromGeneric
-from .geotag_images_from_gpx import GeotagImagesFromGPXWithProgress
+from . import utils
+from .geotag_images_from_gpx import GeotagImagesFromGPX
 
 
 LOG = logging.getLogger(__name__)
 
 
-class GeotagImagesFromGPXFile(GeotagImagesFromGeneric):
+class GeotagImagesFromGPXFile(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,
     ):
-        super().__init__()
         try:
-            tracks = parse_gpx(source_path)
+            tracks = utils.parse_gpx(source_path)
         except Exception as ex:
             raise RuntimeError(
                 f"Error parsing GPX {source_path}: {ex.__class__.__name__}: {ex}"
@@ -38,116 +31,10 @@ class GeotagImagesFromGPXFile(GeotagImagesFromGeneric):
                 len(tracks),
                 source_path,
             )
-        self.points: T.List[geo.Point] = sum(tracks, [])
-        self.image_paths = image_paths
-        self.source_path = source_path
-        self.use_gpx_start_time = use_gpx_start_time
-        self.offset_time = offset_time
-        self.num_processes = num_processes
-
-    @staticmethod
-    def _extract_image_metadata(
-        image_metadata: types.ImageMetadata,
-    ) -> types.ImageMetadataOrError:
-        try:
-            exif = exif_read.ExifRead(image_metadata.filename)
-            orientation = exif.extract_orientation()
-            make = exif.extract_make()
-            model = exif.extract_model()
-        except Exception as ex:
-            return types.describe_error_metadata(
-                ex, image_metadata.filename, filetype=types.FileType.IMAGE
-            )
-
-        return dataclasses.replace(
-            image_metadata,
-            MAPOrientation=orientation,
-            MAPDeviceMake=make,
-            MAPDeviceModel=model,
-        )
-
-    def to_description(self) -> T.List[types.ImageMetadataOrError]:
-        with tqdm(
-            total=len(self.image_paths),
-            desc="Interpolating",
-            unit="images",
-            disable=LOG.getEffectiveLevel() <= logging.DEBUG,
-        ) as pbar:
-            geotag = GeotagImagesFromGPXWithProgress(
-                self.image_paths,
-                self.points,
-                use_gpx_start_time=self.use_gpx_start_time,
-                offset_time=self.offset_time,
-                progress_bar=pbar,
-            )
-            image_metadata_or_errors = geotag.to_description()
-
-        image_metadatas: T.List[types.ImageMetadata] = []
-        error_metadatas: T.List[types.ErrorMetadata] = []
-        for metadata in image_metadata_or_errors:
-            if isinstance(metadata, types.ErrorMetadata):
-                error_metadatas.append(metadata)
-            else:
-                image_metadatas.append(metadata)
-
-        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:
-            image_metadatas_iter: T.Iterator[types.ImageMetadataOrError]
-            if disable_multiprocessing:
-                image_metadatas_iter = map(
-                    GeotagImagesFromGPXFile._extract_image_metadata, image_metadatas
-                )
-            else:
-                # Do not pass error metadatas where the error object can not be pickled for multiprocessing to work
-                # Otherwise we get:
-                # TypeError: __init__() missing 3 required positional arguments: 'image_time', 'gpx_start_time', and 'gpx_end_time'
-                # See https://stackoverflow.com/a/61432070
-                image_metadatas_iter = pool.imap(
-                    GeotagImagesFromGPXFile._extract_image_metadata, image_metadatas
-                )
-            image_metadata_or_errors = list(
-                tqdm(
-                    image_metadatas_iter,
-                    desc="Processing",
-                    unit="images",
-                    disable=LOG.getEffectiveLevel() <= logging.DEBUG,
-                )
-            )
-
-        return (
-            T.cast(T.List[types.ImageMetadataOrError], error_metadatas)
-            + image_metadata_or_errors
+        points = sum(tracks, [])
+        super().__init__(
+            points,
+            use_gpx_start_time=use_gpx_start_time,
+            offset_time=offset_time,
+            num_processes=num_processes,
         )
-
-
-Track = T.List[geo.Point]
-
-
-def parse_gpx(gpx_file: Path) -> T.List[Track]:
-    with gpx_file.open("r") as f:
-        gpx = gpxpy.parse(f)
-
-    tracks: T.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