mapillary-tools 0.10.2a0__py3-none-any.whl → 0.10.3a1__py3-none-any.whl

mapillary_tools/exiftool_read_video.py

@@ -0,0 +1,360 @@
+import logging
+import typing as T
+import xml.etree.ElementTree as ET
+
+from . import exif_read, geo
+
+
+MAX_TRACK_ID = 10
+EXIFTOOL_NAMESPACES: T.Dict[str, str] = {
+    "Keys": "http://ns.exiftool.org/QuickTime/Keys/1.0/",
+    "IFD0": "http://ns.exiftool.org/EXIF/IFD0/1.0/",
+    "QuickTime": "http://ns.exiftool.org/QuickTime/QuickTime/1.0/",
+    "UserData": "http://ns.exiftool.org/QuickTime/UserData/1.0/",
+    "Insta360": "http://ns.exiftool.org/Trailer/Insta360/1.0/",
+    "GoPro": "http://ns.exiftool.org/QuickTime/GoPro/1.0/",
+    **{
+        f"Track{track_id}": f"http://ns.exiftool.org/QuickTime/Track{track_id}/1.0/"
+        for track_id in range(1, MAX_TRACK_ID + 1)
+    },
+}
+LOG = logging.getLogger(__name__)
+_FIELD_TYPE = T.TypeVar("_FIELD_TYPE", int, float, str, T.List[str])
+
+
+def _maybe_float(text: T.Optional[str]) -> T.Optional[float]:
+    if text is None:
+        return None
+    try:
+        return float(text)
+    except (ValueError, TypeError):
+        return None
+
+
+def _expand_tag(ns_tag: str) -> str:
+    try:
+        ns, tag = ns_tag.split(":", maxsplit=2)
+    except ValueError:
+        raise ValueError(f"Invalid tag {ns_tag}")
+    return "{" + EXIFTOOL_NAMESPACES[ns] + "}" + tag
+
+
+def _index_text_by_tag(elements: T.Iterable[ET.Element]) -> T.Dict[str, T.List[str]]:
+    texts_by_tag: T.Dict[str, T.List[str]] = {}
+    for element in elements:
+        tag = element.tag
+        if element.text is not None:
+            texts_by_tag.setdefault(tag, []).append(element.text)
+    return texts_by_tag
+
+
+def _extract_alternative_fields(
+    texts_by_tag: T.Dict[str, T.List[str]],
+    fields: T.Sequence[str],
+    field_type: T.Type[_FIELD_TYPE],
+) -> T.Optional[_FIELD_TYPE]:
+    for field in fields:
+        values = texts_by_tag.get(_expand_tag(field))
+        if values is None:
+            continue
+        if field_type is int:
+            value = values[0]
+            try:
+                return T.cast(_FIELD_TYPE, int(value))
+            except (ValueError, TypeError):
+                pass
+        elif field_type is float:
+            value = values[0]
+            try:
+                return T.cast(_FIELD_TYPE, float(value))
+            except (ValueError, TypeError):
+                pass
+        elif field_type is str:
+            value = values[0]
+            try:
+                return T.cast(_FIELD_TYPE, str(value))
+            except (ValueError, TypeError):
+                pass
+        elif field_type is list:
+            return T.cast(_FIELD_TYPE, values)
+        else:
+            raise ValueError(f"Invalid field type {field_type}")
+    return None
+
+
+def _aggregate_gps_track(
+    texts_by_tag: T.Dict[str, T.List[str]],
+    time_tag: T.Optional[str],
+    lon_tag: str,
+    lat_tag: str,
+    alt_tag: T.Optional[str] = None,
+    direction_tag: T.Optional[str] = None,
+    speed_tag: T.Optional[str] = None,
+) -> T.List[geo.Point]:
+    # aggregate coordinates (required)
+    lons = [
+        _maybe_float(lon)
+        for lon in _extract_alternative_fields(texts_by_tag, [lon_tag], list) or []
+    ]
+    lats = [
+        _maybe_float(lat)
+        for lat in _extract_alternative_fields(texts_by_tag, [lat_tag], list) or []
+    ]
+
+    if len(lons) != len(lats):
+        # no idea what to do if we have different number of lons and lats
+        LOG.warning(
+            "Found different number of longitudes %d and latitudes %d",
+            len(lons),
+            len(lats),
+        )
+        return []
+
+    expected_length = len(lats)
+
+    # aggregate timestamps (optional)
+    if time_tag is not None:
+        dts = [
+            exif_read.parse_gps_datetime(text)
+            for text in _extract_alternative_fields(texts_by_tag, [time_tag], list)
+            or []
+        ]
+        timestamps = [geo.as_unix_time(dt) if dt is not None else None for dt in dts]
+        if expected_length != len(timestamps):
+            # no idea what to do if we have different number of timestamps and coordinates
+            LOG.warning(
+                "Found different number of timestamps %d and coordinates %d",
+                len(timestamps),
+                expected_length,
+            )
+            return []
+    else:
+        timestamps = [0.0] * expected_length
+
+    assert len(timestamps) == expected_length
+
+    def _aggregate_float_values_same_length(
+        tag: T.Optional[str],
+    ) -> T.List[T.Optional[float]]:
+        if tag is not None:
+            vals = [
+                _maybe_float(val)
+                for val in _extract_alternative_fields(texts_by_tag, [tag], list) or []
+            ]
+        else:
+            vals = []
+        while len(vals) < expected_length:
+            vals.append(None)
+        return vals
+
+    # aggregate altitudes (optional)
+    alts = _aggregate_float_values_same_length(alt_tag)
+
+    # aggregate directions (optional)
+    directions = _aggregate_float_values_same_length(direction_tag)
+
+    # aggregate speeds (optional)
+    speeds = _aggregate_float_values_same_length(speed_tag)
+
+    # build track
+    track = []
+    for timestamp, lon, lat, alt, direction, _speed in zip(
+        timestamps,
+        lons,
+        lats,
+        alts,
+        directions,
+        speeds,
+    ):
+        if timestamp is None or lon is None or lat is None:
+            continue
+        track.append(
+            geo.Point(
+                time=timestamp,
+                lon=lon,
+                lat=lat,
+                alt=alt,
+                angle=direction,
+            )
+        )
+
+    track.sort(key=lambda point: point.time)
+
+    if track:
+        first_time = track[0].time
+        for point in track:
+            point.time = point.time - first_time
+
+    deduplicated_track = []
+    if track:
+        prev = None
+        for point in track:
+            cur = (point.time, point.lon, point.lat)
+            if prev is None or cur != prev:
+                deduplicated_track.append(point)
+            prev = cur
+
+    return deduplicated_track
+
+
+def _aggregate_samples(
+    elements: T.Iterable[ET.Element],
+    sample_time_tag: str,
+    sample_duration_tag: str,
+) -> T.Generator[T.Tuple[float, float, T.List[ET.Element]], None, None]:
+    expanded_sample_time_tag = _expand_tag(sample_time_tag)
+    expanded_sample_duration_tag = _expand_tag(sample_duration_tag)
+
+    accumulated_elements: T.List[ET.Element] = []
+    sample_time = None
+    sample_duration = None
+    for element in elements:
+        if element.tag == expanded_sample_time_tag:
+            if sample_time is not None and sample_duration is not None:
+                yield (sample_time, sample_duration, accumulated_elements)
+            accumulated_elements = []
+            sample_time = _maybe_float(element.text)
+        elif element.tag == expanded_sample_duration_tag:
+            sample_duration = _maybe_float(element.text)
+        else:
+            accumulated_elements.append(element)
+    if sample_time is not None and sample_duration is not None:
+        yield (sample_time, sample_duration, accumulated_elements)
+
+
+def _aggregate_gps_track_by_sample_time(
+    sample_iterator: T.Iterable[T.Tuple[float, float, T.List[ET.Element]]],
+    lon_tag: str,
+    lat_tag: str,
+    alt_tag: T.Optional[str] = None,
+    direction_tag: T.Optional[str] = None,
+    speed_tag: T.Optional[str] = None,
+) -> T.List[geo.Point]:
+    track: T.List[geo.Point] = []
+
+    for sample_time, sample_duration, elements in sample_iterator:
+        points = _aggregate_gps_track(
+            _index_text_by_tag(elements),
+            time_tag=None,
+            lon_tag=lon_tag,
+            lat_tag=lat_tag,
+            alt_tag=alt_tag,
+            direction_tag=direction_tag,
+            speed_tag=speed_tag,
+        )
+        if points:
+            avg_timedelta = sample_duration / len(points)
+            for idx, point in enumerate(points):
+                point.time = sample_time + idx * avg_timedelta
+            track.extend(points)
+
+    track.sort(key=lambda point: point.time)
+
+    return track
+
+
+class ExifToolReadVideo:
+    def __init__(
+        self,
+        etree: ET.ElementTree,
+    ) -> None:
+        self.etree = etree
+        self._texts_by_tag = _index_text_by_tag(self.etree.getroot())
+        self._all_tags = set(self._texts_by_tag.keys())
+
+    def extract_gps_track(self) -> T.List[geo.Point]:
+        track = self._extract_gps_track_from_quicktime()
+        if track:
+            return track
+
+        track = self._extract_gps_track_from_quicktime(namespace="Insta360")
+        if track:
+            return track
+
+        track = self._extract_gps_track_from_track()
+        if track:
+            return track
+
+        return []
+
+    def extract_make(self) -> T.Optional[str]:
+        make = self._extract_alternative_fields(
+            ["IFD0:Make", "Keys:Make", "UserData:Make", "Insta360:Make", "GoPro:Make"],
+            str,
+        )
+        if make is None:
+            return None
+        return make.strip()
+
+    def extract_model(self) -> T.Optional[str]:
+        model = self._extract_alternative_fields(
+            [
+                "IFD0:Model",
+                "Keys:Model",
+                "UserData:Model",
+                "Insta360:Model",
+                "GoPro:Model",
+            ],
+            str,
+        )
+        if model is None:
+            return None
+        return model.strip()
+
+    def _extract_gps_track_from_track(self) -> T.List[geo.Point]:
+        for track_id in range(1, MAX_TRACK_ID + 1):
+            track_ns = f"Track{track_id}"
+            if self._all_tags_exists(
+                {
+                    _expand_tag(f"{track_ns}:SampleTime"),
+                    _expand_tag(f"{track_ns}:SampleDuration"),
+                    _expand_tag(f"{track_ns}:GPSLongitude"),
+                    _expand_tag(f"{track_ns}:GPSLatitude"),
+                }
+            ):
+                sample_iterator = _aggregate_samples(
+                    self.etree.getroot(),
+                    f"{track_ns}:SampleTime",
+                    f"{track_ns}:SampleDuration",
+                )
+                track = _aggregate_gps_track_by_sample_time(
+                    sample_iterator,
+                    lon_tag=f"{track_ns}:GPSLongitude",
+                    lat_tag=f"{track_ns}:GPSLatitude",
+                    alt_tag=f"{track_ns}:GPSAltitude",
+                    direction_tag=f"{track_ns}:GPSTrack",
+                )
+                if track:
+                    return track
+        return []
+
+    def _extract_alternative_fields(
+        self,
+        fields: T.Sequence[str],
+        field_type: T.Type[_FIELD_TYPE],
+    ) -> T.Optional[_FIELD_TYPE]:
+        return _extract_alternative_fields(self._texts_by_tag, fields, field_type)
+
+    def _all_tags_exists(self, tags: T.Set[str]) -> bool:
+        return self._all_tags.issuperset(tags)
+
+    def _extract_gps_track_from_quicktime(
+        self, namespace: str = "QuickTime"
+    ) -> T.List[geo.Point]:
+        if not self._all_tags_exists(
+            {
+                _expand_tag(f"{namespace}:GPSDateTime"),
+                _expand_tag(f"{namespace}:GPSLongitude"),
+                _expand_tag(f"{namespace}:GPSLatitude"),
+            }
+        ):
+            return []
+
+        return _aggregate_gps_track(
+            self._texts_by_tag,
+            time_tag=f"{namespace}:GPSDateTime",
+            lon_tag=f"{namespace}:GPSLongitude",
+            lat_tag=f"{namespace}:GPSLatitude",
+            alt_tag=f"{namespace}:GPSAltitude",
+            direction_tag=f"{namespace}:GPSTrack",
+        )

mapillary_tools/geo.py

@@ -175,8 +175,16 @@ def as_unix_time(dt: T.Union[datetime.datetime, int, float]) -> float:
     if isinstance(dt, (int, float)):
         return dt
     else:
-        # if dt is naive, assume it's in local timezone
-        return dt.timestamp()
+        try:
+            # if dt is naive, assume it's in local timezone
+            return dt.timestamp()
+        except ValueError:
+            # Some datetimes can't be converted to timestamp
+            # e.g. 0001-01-01 00:00:00 will throw ValueError: year 0 is out of range
+            try:
+                return dt.replace(year=1970).timestamp()
+            except ValueError:
+                return 0.0
 
 
 def _interpolate_segment(start: Point, end: Point, t: float) -> Point:

mapillary_tools/geotag/geotag_from_generic.py

@@ -1,11 +1,22 @@
+import abc
 import typing as T
 
 from .. import types
 
 
-class GeotagFromGeneric:
+class GeotagImagesFromGeneric(abc.ABC):
     def __init__(self) -> None:
         pass
 
+    @abc.abstractmethod
     def to_description(self) -> T.List[types.ImageMetadataOrError]:
-        return []
+        raise NotImplementedError
+
+
+class GeotagVideosFromGeneric(abc.ABC):
+    def __init__(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def to_description(self) -> T.List[types.VideoMetadataOrError]:
+        raise NotImplementedError

mapillary_tools/geotag/{geotag_from_exif.py → geotag_images_from_exif.py}

@@ -4,96 +4,58 @@ import typing as T
 from multiprocessing import Pool
 from pathlib import Path
 
-import piexif
-
 from tqdm import tqdm
 
-from .. import exif_write, geo, types
-from ..exceptions import MapillaryGeoTaggingError
-from ..exif_read import ExifRead
-
-from .geotag_from_generic import GeotagFromGeneric
+from .. import exceptions, exif_write, geo, types
+from ..exif_read import ExifRead, ExifReadABC
+from .geotag_from_generic import GeotagImagesFromGeneric
 
 LOG = logging.getLogger(__name__)
 
 
 def verify_image_exif_write(
     metadata: types.ImageMetadata,
-    image_data: T.Optional[bytes] = None,
-) -> types.ImageMetadataOrError:
-    if image_data is None:
+    image_bytes: T.Optional[bytes] = None,
+) -> None:
+    if image_bytes is None:
         edit = exif_write.ExifEdit(metadata.filename)
     else:
-        edit = exif_write.ExifEdit(image_data)
+        edit = exif_write.ExifEdit(image_bytes)
 
     # The cast is to fix the type error in Python3.6:
     # Argument 1 to "add_image_description" of "ExifEdit" has incompatible type "ImageDescription"; expected "Dict[str, Any]"
     edit.add_image_description(
         T.cast(T.Dict, types.desc_file_to_exif(types.as_desc(metadata)))
     )
-    try:
-        edit.dump_image_bytes()
-    except piexif.InvalidImageDataError as exc:
-        return types.describe_error_metadata(
-            exc,
-            metadata.filename,
-            filetype=types.FileType.IMAGE,
-        )
-    except Exception as exc:
-        # possible error here: struct.error: 'H' format requires 0 <= number <= 65535
-        LOG.warning(
-            "Unknown error test writing image %s", metadata.filename, exc_info=True
-        )
-        return types.describe_error_metadata(
-            exc,
-            metadata.filename,
-            filetype=types.FileType.IMAGE,
-        )
-    return metadata
 
+    # Possible errors thrown here:
+    # - struct.error: 'H' format requires 0 <= number <= 65535
+    # - piexif.InvalidImageDataError
+    edit.dump_image_bytes()
 
-class GeotagFromEXIF(GeotagFromGeneric):
+
+class GeotagImagesFromEXIF(GeotagImagesFromGeneric):
     def __init__(self, image_paths: T.Sequence[Path]):
         self.image_paths = image_paths
         super().__init__()
 
     @staticmethod
-    def geotag_image(
-        image_path: Path, skip_lonlat_error: bool = False
-    ) -> types.ImageMetadataOrError:
-        with image_path.open("rb") as fp:
-            image_data = fp.read()
-        image_bytesio = io.BytesIO(image_data)
-
-        try:
-            exif = ExifRead(image_bytesio)
-        except Exception as ex:
-            LOG.warning(
-                "Unknown error reading EXIF from image %s",
-                image_path,
-                exc_info=True,
-            )
-            return types.describe_error_metadata(
-                ex, image_path, filetype=types.FileType.IMAGE
-            )
-
+    def build_image_metadata(
+        image_path: Path, exif: ExifReadABC, skip_lonlat_error: bool = False
+    ) -> types.ImageMetadata:
         lonlat = exif.extract_lon_lat()
         if lonlat is None:
             if not skip_lonlat_error:
-                exc = MapillaryGeoTaggingError(
+                raise exceptions.MapillaryGeoTaggingError(
                     "Unable to extract GPS Longitude or GPS Latitude from the image"
                 )
-                return types.describe_error_metadata(
-                    exc, image_path, filetype=types.FileType.IMAGE
-                )
             lonlat = (0.0, 0.0)
         lon, lat = lonlat
 
         capture_time = exif.extract_capture_time()
         if capture_time is None:
-            exc = MapillaryGeoTaggingError("Unable to extract timestamp from the image")
-            return types.describe_error_metadata(
-                exc, image_path, filetype=types.FileType.IMAGE
+            raise exceptions.MapillaryGeoTaggingError(
+                "Unable to extract timestamp from the image"
             )
 
         image_metadata = types.ImageMetadata(
@@ -111,26 +73,48 @@ class GeotagFromEXIF(GeotagFromGeneric):
             MAPDeviceModel=exif.extract_model(),
         )
 
-        image_bytesio.seek(0, io.SEEK_SET)
-        image_metadata.update_md5sum(image_bytesio)
+        return image_metadata
+
+    @staticmethod
+    def geotag_image(
+        image_path: Path, skip_lonlat_error: bool = False
+    ) -> types.ImageMetadataOrError:
+        try:
+            # 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)
+            exif = ExifRead(image_bytesio)
+
+            image_metadata = GeotagImagesFromEXIF.build_image_metadata(
+                image_path, exif, skip_lonlat_error=skip_lonlat_error
+            )
+
+            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_or_error = verify_image_exif_write(
-            image_metadata,
-            image_data=image_bytesio.read(),
-        )
+        image_metadata.update_md5sum(image_bytesio)
 
-        return image_metadata_or_error
+        return image_metadata
 
     def to_description(self) -> T.List[types.ImageMetadataOrError]:
         with Pool() as pool:
-            image_metadatas = pool.imap(
-                GeotagFromEXIF.geotag_image,
+            image_metadatas_iter = pool.imap(
+                GeotagImagesFromEXIF.geotag_image,
                 self.image_paths,
             )
             return list(
                 tqdm(
-                    image_metadatas,
+                    image_metadatas_iter,
                     desc="Extracting geotags from images",
                     unit="images",
                     disable=LOG.getEffectiveLevel() <= logging.DEBUG,

mapillary_tools/geotag/geotag_images_from_exiftool.py

@@ -0,0 +1,123 @@
+import io
+import logging
+import typing as T
+import xml.etree.ElementTree as ET
+from multiprocessing import Pool
+from pathlib import Path
+
+from tqdm import tqdm
+
+from .. import exceptions, types, utils
+from ..exiftool_read import EXIFTOOL_NAMESPACES, ExifToolRead
+from .geotag_from_generic import GeotagImagesFromGeneric
+from .geotag_images_from_exif import GeotagImagesFromEXIF, verify_image_exif_write
+
+LOG = logging.getLogger(__name__)
+_DESCRIPTION_TAG = "rdf:Description"
+
+
+def canonical_path(path: Path) -> str:
+    return str(path.resolve().as_posix())
+
+
+def find_rdf_description_path(element: ET.Element) -> T.Optional[Path]:
+    about = element.get("{" + EXIFTOOL_NAMESPACES["rdf"] + "}about")
+    if about is None:
+        return None
+    return Path(about)
+
+
+def index_rdf_description_by_path(
+    xml_paths: T.Sequence[Path],
+) -> T.Dict[str, ET.Element]:
+    rdf_description_by_path: T.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(f"Failed to parse {xml_path}", exc_info=verbose)
+            else:
+                LOG.warning(f"Failed to parse {xml_path}: {ex}", exc_info=verbose)
+            continue
+
+        elements = etree.iterfind(_DESCRIPTION_TAG, namespaces=EXIFTOOL_NAMESPACES)
+        for element in elements:
+            path = find_rdf_description_path(element)
+            if path is not None:
+                rdf_description_by_path[canonical_path(path)] = element
+
+    return rdf_description_by_path
+
+
+class GeotagImagesFromExifTool(GeotagImagesFromGeneric):
+    def __init__(self, image_paths: T.Sequence[Path], xml_path: Path):
+        self.image_paths = image_paths
+        self.xml_path = xml_path
+        super().__init__()
+
+    @staticmethod
+    def geotag_image(element: ET.Element) -> types.ImageMetadataOrError:
+        image_path = find_rdf_description_path(element)
+        assert image_path is not None, "must find the path from the element"
+
+        try:
+            exif = 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 = index_rdf_description_by_path([self.xml_path])
+
+        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(canonical_path(path))
+            if rdf_description is None:
+                exc = exceptions.MapillaryEXIFNotFoundError(
+                    f"The {_DESCRIPTION_TAG} XML element for the image not found"
+                )
+                error_metadatas.append(
+                    types.describe_error_metadata(
+                        exc, path, filetype=types.FileType.IMAGE
+                    )
+                )
+            else:
+                rdf_descriptions.append(rdf_description)
+
+        with Pool() as pool:
+            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),
+                )
+            )
+
+        return error_metadatas + image_metadata_or_errors