mapillary-tools 0.14.4__py3-none-any.whl → 0.14.6__py3-none-any.whl

mapillary_tools/exif_write.py

@@ -1,3 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
 # pyre-ignore-all-errors[5, 21, 24]
 from __future__ import annotations
 
@@ -6,6 +11,7 @@ import io
 import json
 import logging
 import math
+from fractions import Fraction
 from pathlib import Path
 
 import piexif
@@ -29,16 +35,19 @@ class ExifEdit:
 
     @staticmethod
     def decimal_to_dms(
-        value: float, precision: int
-    ) -> tuple[tuple[float, int], tuple[float, int], tuple[float, int]]:
-        """
-        Convert decimal position to degrees, minutes, seconds in a fromat supported by EXIF
-        """
-        deg = math.floor(value)
-        min = math.floor((value - deg) * 60)
-        sec = math.floor((value - deg - min / 60) * 3600 * precision)
+        value: float,
+    ) -> tuple[tuple[int, int], tuple[int, int], tuple[int, int]]:
+        """Convert decimal position to Exif degrees, minutes, and seconds rationals"""
+
+        deg: int = int(value)
+        min: int = int(value := (value - deg) * 60)
+        sec: float = (value - min) * 60
 
-        return (deg, 1), (min, 1), (sec, precision)
+        return (
+            (deg, 1),
+            (min, 1),
+            (Fraction.from_float(sec).limit_denominator().as_integer_ratio()),
+        )
 
     def add_image_description(self, data: dict) -> None:
         """Add a dict to image description."""
@@ -83,41 +92,69 @@ class ExifEdit:
         self._ef["GPS"][piexif.GPSIFD.GPSTimeStamp] = (
             (dt.hour, 1),
             (dt.minute, 1),
-            # num / den = (dt.second * 1e6 + dt.microsecond) / 1e6
-            (int(dt.second * 1e6 + dt.microsecond), int(1e6)),
+            (
+                Fraction.from_float(dt.second + dt.microsecond / 1e6)
+                .limit_denominator()
+                .as_integer_ratio()
+            ),
         )
+        if LOG.isEnabledFor(logging.DEBUG):
+            LOG.debug(
+                'GPSDateStamp: "%s"\tGPSTimeStamp: %s',
+                self._ef["GPS"][piexif.GPSIFD.GPSDateStamp],
+                self._ef["GPS"][piexif.GPSIFD.GPSTimeStamp],
+            )
 
-    def add_lat_lon(self, lat: float, lon: float, precision: float = 1e7) -> None:
+    def add_lat_lon(self, lat: float, lon: float) -> None:
         """Add lat, lon to gps (lat, lon in float)."""
+
         self._ef["GPS"][piexif.GPSIFD.GPSLatitudeRef] = "N" if lat > 0 else "S"
+        self._ef["GPS"][piexif.GPSIFD.GPSLatitude] = ExifEdit.decimal_to_dms(
+            math.fabs(lat)
+        )
         self._ef["GPS"][piexif.GPSIFD.GPSLongitudeRef] = "E" if lon > 0 else "W"
         self._ef["GPS"][piexif.GPSIFD.GPSLongitude] = ExifEdit.decimal_to_dms(
-            abs(lon), int(precision)
-        )
-        self._ef["GPS"][piexif.GPSIFD.GPSLatitude] = ExifEdit.decimal_to_dms(
-            abs(lat), int(precision)
+            math.fabs(lon)
         )
+        if LOG.isEnabledFor(logging.DEBUG):
+            LOG.debug(
+                "GPSLatitude: %s\tGPSLongitude: %s",
+                self._ef["GPS"][piexif.GPSIFD.GPSLatitude],
+                self._ef["GPS"][piexif.GPSIFD.GPSLongitude],
+            )
+
+    def add_altitude(self, altitude: float) -> None:
+        """Add altitude."""
 
-    def add_altitude(self, altitude: float, precision: int = 100) -> None:
-        """Add altitude (pre is the precision)."""
         ref = 0 if altitude > 0 else 1
         self._ef["GPS"][piexif.GPSIFD.GPSAltitude] = (
-            int(abs(altitude) * precision),
-            precision,
+            Fraction.from_float(math.fabs(altitude))
+            .limit_denominator()
+            .as_integer_ratio()
         )
         self._ef["GPS"][piexif.GPSIFD.GPSAltitudeRef] = ref
+        if LOG.isEnabledFor(logging.DEBUG):
+            LOG.debug(
+                'GPSAltitudeRef: "%s"\tGPSAltitude: %s',
+                self._ef["GPS"][piexif.GPSIFD.GPSAltitudeRef],
+                self._ef["GPS"][piexif.GPSIFD.GPSAltitude],
+            )
 
-    def add_direction(
-        self, direction: float, ref: str = "T", precision: int = 100
-    ) -> None:
+    def add_direction(self, direction: float, ref: str = "T") -> None:
         """Add image direction."""
+
         # normalize direction
-        direction = direction % 360.0
+        direction = math.fmod(direction, 360.0)
         self._ef["GPS"][piexif.GPSIFD.GPSImgDirection] = (
-            int(abs(direction) * precision),
-            precision,
+            Fraction.from_float(direction).limit_denominator().as_integer_ratio()
         )
         self._ef["GPS"][piexif.GPSIFD.GPSImgDirectionRef] = ref
+        if LOG.isEnabledFor(logging.DEBUG):
+            LOG.debug(
+                'GPSImgDirectionRef: "%s"\tGPSImgDirection: %s',
+                self._ef["GPS"][piexif.GPSIFD.GPSImgDirectionRef],
+                self._ef["GPS"][piexif.GPSIFD.GPSImgDirection],
+            )
 
     def add_make(self, make: str) -> None:
         if not make:
@@ -182,6 +219,18 @@ class ExifEdit:
                     else:
                         del self._ef[ifd][tag]
                         # retry later
+                elif "thumbnail is too large" in message.lower():
+                    # Handle oversized thumbnails (max 64kB per EXIF spec)
+                    if thumbnail_removed:
+                        raise exc
+                    LOG.debug(
+                        "Thumbnail too large (max 64kB) -- removing thumbnail and 1st: %s",
+                        exc,
+                    )
+                    del self._ef["thumbnail"]
+                    del self._ef["1st"]
+                    thumbnail_removed = True
+                    # retry later
                 else:
                     raise exc
             except Exception as exc:

mapillary_tools/exiftool_read.py

@@ -1,3 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
 from __future__ import annotations
 
 import datetime
@@ -7,15 +12,19 @@ import xml.etree.ElementTree as ET
 from pathlib import Path
 
 from . import exif_read
+from .utils import sanitize_serial
 
 
 EXIFTOOL_NAMESPACES: dict[str, str] = {
     "Adobe": "http://ns.exiftool.org/APP14/Adobe/1.0/",
     "Apple": "http://ns.exiftool.org/MakerNotes/Apple/1.0/",
+    "Canon": "http://ns.exiftool.org/MakerNotes/Canon/1.0/",
     "Composite": "http://ns.exiftool.org/Composite/1.0/",
     "ExifIFD": "http://ns.exiftool.org/EXIF/ExifIFD/1.0/",
     "ExifTool": "http://ns.exiftool.org/ExifTool/1.0/",
     "File": "http://ns.exiftool.org/File/1.0/",
+    "FLIR": "http://ns.exiftool.org/APP1/FLIR/1.0/",
+    "FujiFilm": "http://ns.exiftool.org/MakerNotes/FujiFilm/1.0/",
     "GPS": "http://ns.exiftool.org/EXIF/GPS/1.0/",
     "GoPro": "http://ns.exiftool.org/APP6/GoPro/1.0/",
     "ICC-chrm": "http://ns.exiftool.org/ICC_Profile/ICC-chrm/1.0/",
@@ -28,11 +37,20 @@ EXIFTOOL_NAMESPACES: dict[str, str] = {
     "IPTC": "http://ns.exiftool.org/IPTC/IPTC/1.0/",
     "InteropIFD": "http://ns.exiftool.org/EXIF/InteropIFD/1.0/",
     "JFIF": "http://ns.exiftool.org/JFIF/JFIF/1.0/",
+    "Kodak": "http://ns.exiftool.org/MakerNotes/Kodak/1.0/",
+    "Leica": "http://ns.exiftool.org/MakerNotes/Leica/1.0/",
     "MPF0": "http://ns.exiftool.org/MPF/MPF0/1.0/",
     "MPImage1": "http://ns.exiftool.org/MPF/MPImage1/1.0/",
     "MPImage2": "http://ns.exiftool.org/MPF/MPImage2/1.0/",
+    "Nikon": "http://ns.exiftool.org/MakerNotes/Nikon/1.0/",
+    "Olympus": "http://ns.exiftool.org/MakerNotes/Olympus/1.0/",
+    "Panasonic": "http://ns.exiftool.org/MakerNotes/Panasonic/1.0/",
+    "Pentax": "http://ns.exiftool.org/MakerNotes/Pentax/1.0/",
     "Photoshop": "http://ns.exiftool.org/Photoshop/Photoshop/1.0/",
+    "Ricoh": "http://ns.exiftool.org/MakerNotes/Ricoh/1.0/",
     "Samsung": "http://ns.exiftool.org/MakerNotes/Samsung/1.0/",
+    "Sigma": "http://ns.exiftool.org/MakerNotes/Sigma/1.0/",
+    "Sony": "http://ns.exiftool.org/MakerNotes/Sony/1.0/",
     "System": "http://ns.exiftool.org/File/System/1.0/",
     "XMP-GAudio": "http://ns.exiftool.org/XMP/XMP-GAudio/1.0/",
     "XMP-GImage": "http://ns.exiftool.org/XMP/XMP-GImage/1.0/",
@@ -48,6 +66,8 @@ EXIFTOOL_NAMESPACES: dict[str, str] = {
     "XMP-xmp": "http://ns.exiftool.org/XMP/XMP-xmp/1.0/",
     "XMP-xmpMM": "http://ns.exiftool.org/XMP/XMP-xmpMM/1.0/",
     "XMP-xmpNote": "http://ns.exiftool.org/XMP/XMP-xmpNote/1.0/",
+    "XMP-drone-dji": "http://ns.exiftool.org/XMP/XMP-drone-dji/1.0/",
+    "DJI": "http://ns.exiftool.org/MakerNotes/DJI/1.0/",
     "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
 }
 
@@ -421,6 +441,75 @@ class ExifToolRead(exif_read.ExifReadABC):
             return 1
         return orientation
 
+    def extract_camera_uuid(self) -> str | None:
+        """
+        Extract camera UUID from serial numbers.
+        Returns a composite ID from body serial and lens serial if available.
+        """
+        # Try body serial number from various sources
+        body_serial = self._extract_alternative_fields(
+            [
+                # Standard EXIF tags (BodySerialNumber has priority over generic SerialNumber)
+                "ExifIFD:BodySerialNumber",
+                "ExifIFD:SerialNumber",
+                "IFD0:CameraSerialNumber",
+                "IFD0:SerialNumber",
+                # MakerNotes - camera specific
+                "Canon:SerialNumber",
+                "Canon:InternalSerialNumber",
+                "DJI:SerialNumber",
+                "XMP-drone-dji:CameraSerialNumber",
+                "XMP-drone-dji:DroneSerialNumber",
+                "FLIR:CameraSerialNumber",
+                "FujiFilm:InternalSerialNumber",
+                "GoPro:CameraSerialNumber",
+                "Kodak:SerialNumber",
+                "Leica:SerialNumber",
+                "Leica:InternalSerialNumber",
+                "Nikon:SerialNumber",
+                "Olympus:SerialNumber",
+                "Olympus:InternalSerialNumber",
+                "Panasonic:InternalSerialNumber",
+                "Pentax:SerialNumber",
+                "Pentax:InternalSerialNumber",
+                "Ricoh:SerialNumber",
+                "Ricoh:InternalSerialNumber",
+                "Ricoh:BodySerialNumber",
+                "Sigma:SerialNumber",
+                "Sony:InternalSerialNumber",
+                # XMP equivalents
+                "XMP-exif:SerialNumber",
+                "XMP-exif:BodySerialNumber",
+                "XMP-exifEX:SerialNumber",
+                "XMP-exif:CameraSerialNumber",
+                "XMP-exifEX:BodySerialNumber",
+                "XMP-aux:SerialNumber",
+            ],
+            str,
+        )
+
+        # Try lens serial number
+        lens_serial = self._extract_alternative_fields(
+            [
+                "ExifIFD:LensSerialNumber",
+                "FLIR:LensSerialNumber",
+                "Olympus:LensSerialNumber",
+                "Panasonic:LensSerialNumber",
+                "Ricoh:LensSerialNumber",
+                "XMP-exifEX:LensSerialNumber",
+                "XMP-aux:LensSerialNumber",
+            ],
+            str,
+        )
+
+        parts = [
+            s for s in [sanitize_serial(body_serial), sanitize_serial(lens_serial)] if s
+        ]
+
+        if parts:
+            return "_".join(parts)
+        return None
+
     def _extract_alternative_fields(
         self,
         fields: T.Sequence[str],

mapillary_tools/exiftool_read_video.py

@@ -1,3 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
 from __future__ import annotations
 
 import dataclasses
@@ -8,16 +13,23 @@ import xml.etree.ElementTree as ET
 
 from . import exif_read, exiftool_read, geo
 from .telemetry import GPSFix, GPSPoint
+from .utils import sanitize_serial
 
 
 MAX_TRACK_ID = 10
 EXIFTOOL_NAMESPACES: dict[str, str] = {
     "Keys": "http://ns.exiftool.org/QuickTime/Keys/1.0/",
     "IFD0": "http://ns.exiftool.org/EXIF/IFD0/1.0/",
+    "ExifIFD": "http://ns.exiftool.org/EXIF/ExifIFD/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/",
+    "Ricoh": "http://ns.exiftool.org/MakerNotes/Ricoh/1.0/",
+    "XMP-GSpherical": "http://ns.exiftool.org/XMP/XMP-GSpherical/1.0/",
+    "XMP-aux": "http://ns.exiftool.org/XMP/XMP-aux/1.0/",
+    "DJI": "http://ns.exiftool.org/MakerNotes/DJI/1.0/",
+    "XMP-drone-dji": "http://ns.exiftool.org/XMP/XMP-drone-dji/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)
@@ -403,6 +415,50 @@ class ExifToolReadVideo:
         _, model = self._extract_make_and_model()
         return model
 
+    def extract_camera_uuid(self) -> str | None:
+        """
+        Extract camera unique identifier from serial number tags in video metadata.
+        Builds a composite ID from body and lens serial numbers.
+        """
+        # Try camera-specific serial numbers first
+        body_serial = self._extract_alternative_fields(
+            [
+                # Camera-specific tags
+                "GoPro:SerialNumber",
+                "GoPro:CameraSerialNumber",
+                "Ricoh:SerialNumber",
+                "XMP-GSpherical:PiDeviceSN",  # Labpano cameras
+                "Insta360:SerialNumber",
+                "DJI:SerialNumber",
+                "XMP-drone-dji:CameraSerialNumber",
+                "XMP-drone-dji:DroneSerialNumber",
+                # Generic tags
+                "ExifIFD:BodySerialNumber",
+                "ExifIFD:SerialNumber",
+                "IFD0:SerialNumber",
+                "UserData:SerialNumber",
+                "XMP-aux:SerialNumber",
+                "UserData:SerialNumberHash",
+            ],
+            str,
+        )
+        lens_serial = self._extract_alternative_fields(
+            [
+                "UserData:LensSerialNumber",
+                "ExifIFD:LensSerialNumber",
+                "XMP-aux:LensSerialNumber",
+            ],
+            str,
+        )
+
+        parts = [
+            s for s in [sanitize_serial(body_serial), sanitize_serial(lens_serial)] if s
+        ]
+
+        if parts:
+            return "_".join(parts)
+        return None
+
     def _extract_gps_track_from_track(self) -> list[GPSPoint]:
         root = self.etree.getroot()
         if root is None:

mapillary_tools/exiftool_runner.py

@@ -1,3 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
 from __future__ import annotations
 
 import subprocess

mapillary_tools/ffmpeg.py

@@ -1,3 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
 # pyre-ignore-all-errors[5, 24]
 from __future__ import annotations
 

mapillary_tools/geo.py

@@ -1,3 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
 # pyre-ignore-all-errors[4]
 from __future__ import annotations
 
@@ -32,6 +37,47 @@ class Point:
     alt: float | None
     angle: float | None
 
+    def get_gps_epoch_time(self) -> float | None:
+        """
+        Return the GPS epoch time for this point.
+        Base Point class returns None, subclasses can override.
+        """
+        return None
+
+    def _calculate_weight_for_interpolation(self, other: "Point", t: float) -> float:
+        """
+        Calculate interpolation weight between self and other at time t.
+        Returns 0 if both points have the same time regardless of t.
+        """
+        if self.time == other.time:
+            return 0.0
+        return (t - self.time) / (other.time - self.time)
+
+    def interpolate_with(self, other: "Point", t: float) -> "Point":
+        """
+        Create a new interpolated point between self and other at time t.
+
+        Args:
+            other: The end point to interpolate towards
+            t: The target timestamp
+
+        Returns:
+            A new Point with interpolated values
+        """
+        weight = self._calculate_weight_for_interpolation(other, t)
+
+        lat = self.lat + (other.lat - self.lat) * weight
+        lon = self.lon + (other.lon - self.lon) * weight
+        angle = compute_bearing((self.lat, self.lon), (other.lat, other.lon))
+
+        alt: float | None
+        if self.alt is not None and other.alt is not None:
+            alt = self.alt + (other.alt - self.alt) * weight
+        else:
+            alt = None
+
+        return Point(time=t, lat=lat, lon=lon, alt=alt, angle=angle)
+
 
 PointLike = T.TypeVar("PointLike", bound=Point)
 
@@ -52,17 +98,36 @@ def gps_distance(latlon_1: tuple[float, float], latlon_2: tuple[float, float]) -
 
 
 def avg_speed(sequence: T.Sequence[PointLike]) -> float:
+    """
+    Calculate average speed over a sequence of points.
+    Uses GPS epoch time when available (via get_gps_epoch_time()),
+    otherwise falls back to the time field.
+    Returns 0.0 for empty or single-element sequences.
+    Returns NaN if time difference is zero (undefined speed).
+    """
+    # Need at least 2 points to calculate speed
+    if len(sequence) < 2:
+        return 0.0
+
     total_distance = 0.0
     for cur, nxt in pairwise(sequence):
         total_distance += gps_distance((cur.lat, cur.lon), (nxt.lat, nxt.lon))
 
-    if sequence:
-        time_diff = sequence[-1].time - sequence[0].time
+    first = sequence[0]
+    last = sequence[-1]
+
+    # Try to use GPS epoch time if available (via polymorphic method)
+    first_gps_time = first.get_gps_epoch_time()
+    last_gps_time = last.get_gps_epoch_time()
+
+    if first_gps_time is not None and last_gps_time is not None:
+        time_diff = last_gps_time - first_gps_time
     else:
-        time_diff = 0.0
+        # Fall back to time field if GPS epoch time not available
+        time_diff = last.time - first.time
 
     if time_diff == 0.0:
-        return float("inf")
+        return float("nan")
 
     return total_distance / time_diff
 
@@ -141,7 +206,7 @@ def as_unix_time(dt: datetime.datetime | int | float) -> float:
 
 if sys.version_info < (3, 10):
 
-    def interpolate(points: T.Sequence[Point], t: float, lo: int = 0) -> Point:
+    def interpolate(points: T.Sequence[PointLike], t: float, lo: int = 0) -> PointLike:
         """
         Interpolate or extrapolate the point at time t along the sequence of points (sorted by time).
         """
@@ -152,12 +217,14 @@ if sys.version_info < (3, 10):
         # for cur, nex in pairwise(points):
         #     assert cur.time <= nex.time, "Points not sorted"
 
-        p = Point(time=t, lat=float("-inf"), lon=float("-inf"), alt=None, angle=None)
-        idx = bisect.bisect_left(points, p, lo=lo)
+        times = [p.time for p in points]
+        # Use bisect_left on the times list
+        idx = bisect.bisect_left(times, t, lo=lo)
+
         return _interpolate_at_segment_idx(points, t, idx)
 else:
 
-    def interpolate(points: T.Sequence[Point], t: float, lo: int = 0) -> Point:
+    def interpolate(points: T.Sequence[PointLike], t: float, lo: int = 0) -> PointLike:
         """
         Interpolate or extrapolate the point at time t along the sequence of points (sorted by time).
         """
@@ -172,18 +239,19 @@ else:
         return _interpolate_at_segment_idx(points, t, idx)
 
 
-class Interpolator:
+class Interpolator(T.Generic[PointLike]):
     """
     Interpolator for interpolating a sequence of timestamps incrementally.
+    Preserves the type of input points (Point, GPSPoint, or CAMMGPSPoint).
     """
 
-    tracks: T.Sequence[T.Sequence[Point]]
+    tracks: T.Sequence[T.Sequence[PointLike]]
     track_idx: int
     # interpolation starts from the lower bound point index in the current track
     lo: int
     prev_time: float | None
 
-    def __init__(self, tracks: T.Sequence[T.Sequence[Point]]):
+    def __init__(self, tracks: T.Sequence[T.Sequence[PointLike]]):
         # Remove empty tracks
         self.tracks = [track for track in tracks if track]
 
@@ -204,7 +272,7 @@ class Interpolator:
 
     @staticmethod
     def _lsearch_left(
-        track: T.Sequence[Point], t: float, lo: int = 0, hi: int | None = None
+        track: T.Sequence[PointLike], t: float, lo: int = 0, hi: int | None = None
     ) -> int:
         """
         similar to bisect.bisect_left, but faster in the incremental search case
@@ -221,14 +289,14 @@ class Interpolator:
         # assert track[lo - 1].time < t <= track[lo].time
         return lo
 
-    def interpolate(self, t: float) -> Point:
+    def interpolate(self, t: float) -> PointLike:
         if self.prev_time is not None:
             if not (self.prev_time <= t):
                 raise ValueError(
                     f"Require times to be monotonically increasing, but got {self.prev_time} then {t}"
                 )
 
-        interpolated: Point | None = None
+        interpolated: PointLike | None = None
 
         while self.track_idx < len(self.tracks):
             track = self.tracks[self.track_idx]
@@ -318,25 +386,17 @@ def _ecef_from_lla2(lat: float, lon: float) -> tuple[float, float, float]:
     return x, y, z
 
 
-def _interpolate_segment(start: Point, end: Point, t: float) -> Point:
-    try:
-        weight = (t - start.time) / (end.time - start.time)
-    except ZeroDivisionError:
-        weight = 0.0
-
-    lat = start.lat + (end.lat - start.lat) * weight
-    lon = start.lon + (end.lon - start.lon) * weight
-    angle = compute_bearing((start.lat, start.lon), (end.lat, end.lon))
-    alt: float | None
-    if start.alt is not None and end.alt is not None:
-        alt = start.alt + (end.alt - start.alt) * weight
-    else:
-        alt = None
-
-    return Point(time=t, lat=lat, lon=lon, alt=alt, angle=angle)
+def _interpolate_segment(start: PointLike, end: PointLike, t: float) -> PointLike:
+    """
+    Interpolate between two points at time t, preserving the type of the input points.
+    Uses the polymorphic interpolate_with() method to support subclasses.
+    """
+    return T.cast(PointLike, start.interpolate_with(end, t))
 
 
-def _interpolate_at_segment_idx(points: T.Sequence[Point], t: float, idx: int) -> Point:
+def _interpolate_at_segment_idx(
+    points: T.Sequence[PointLike], t: float, idx: int
+) -> PointLike:
     """
     Interpolate time t along the segment between idx - 1 and idx.
     If idx is out of range, extrapolate it to the nearest segment (first or last).

mapillary_tools/geotag/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.

mapillary_tools/geotag/base.py

@@ -1,3 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
 from __future__ import annotations
 
 import abc

mapillary_tools/geotag/factory.py

@@ -1,3 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
 from __future__ import annotations
 
 import json

mapillary_tools/geotag/geotag_images_from_exif.py

@@ -1,3 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
 from __future__ import annotations
 
 import logging

mapillary_tools/geotag/geotag_images_from_exiftool.py

@@ -1,3 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
 from __future__ import annotations
 
 import logging

mapillary_tools/geotag/geotag_images_from_gpx.py

@@ -1,3 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
 from __future__ import annotations
 
 import dataclasses

mapillary_tools/geotag/geotag_images_from_gpx_file.py

@@ -1,3 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
 from __future__ import annotations
 
 import logging

mapillary_tools/geotag/geotag_images_from_nmea_file.py

@@ -1,3 +1,8 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
 from __future__ import annotations
 
 import datetime