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

mapillary_tools/ffmpeg.py

@@ -1,4 +1,5 @@
 # pyre-ignore-all-errors[5, 24]
+from __future__ import annotations
 
 import datetime
 import json
@@ -33,7 +34,7 @@ class Stream(T.TypedDict):
 
 
 class ProbeOutput(T.TypedDict):
-    streams: T.List[Stream]
+    streams: list[Stream]
 
 
 class FFmpegNotFoundError(Exception):
@@ -77,7 +78,7 @@ class FFMPEG:
         self,
         ffmpeg_path: str = "ffmpeg",
         ffprobe_path: str = "ffprobe",
-        stderr: T.Optional[int] = None,
+        stderr: int | None = None,
     ) -> None:
         """
         ffmpeg_path: path to ffmpeg binary
@@ -88,8 +89,8 @@ class FFMPEG:
         self.ffprobe_path = ffprobe_path
         self.stderr = stderr
 
-    def _run_ffprobe_json(self, cmd: T.List[str]) -> T.Dict:
-        full_cmd: T.List[str] = [self.ffprobe_path, "-print_format", "json", *cmd]
+    def _run_ffprobe_json(self, cmd: list[str]) -> dict:
+        full_cmd: list[str] = [self.ffprobe_path, "-print_format", "json", *cmd]
         LOG.info(f"Extracting video information: {' '.join(full_cmd)}")
         try:
             completed = subprocess.run(
@@ -132,8 +133,8 @@ class FFMPEG:
 
         return output
 
-    def _run_ffmpeg(self, cmd: T.List[str]) -> None:
-        full_cmd: T.List[str] = [self.ffmpeg_path, *cmd]
+    def _run_ffmpeg(self, cmd: list[str]) -> None:
+        full_cmd: list[str] = [self.ffmpeg_path, *cmd]
         LOG.info(f"Extracting frames: {' '.join(full_cmd)}")
         try:
             subprocess.run(full_cmd, check=True, stderr=self.stderr)
@@ -145,7 +146,7 @@ class FFMPEG:
             raise FFmpegCalledProcessError(ex) from ex
 
     def probe_format_and_streams(self, video_path: Path) -> ProbeOutput:
-        cmd: T.List[str] = [
+        cmd: list[str] = [
             "-hide_banner",
             "-show_format",
             "-show_streams",
@@ -158,7 +159,7 @@ class FFMPEG:
         video_path: Path,
         sample_dir: Path,
         sample_interval: float,
-        stream_idx: T.Optional[int] = None,
+        stream_idx: int | None = None,
     ) -> None:
         """
         Extract frames by the sample interval from the specified video stream.
@@ -175,7 +176,7 @@ class FFMPEG:
             ouput_template = f"{sample_prefix}_{NA_STREAM_IDX}_%06d{FRAME_EXT}"
             stream_specifier = "v"
 
-        cmd: T.List[str] = [
+        cmd: list[str] = [
             # global options should be specified first
             *["-hide_banner", "-nostdin"],
             # input 0
@@ -195,7 +196,7 @@ class FFMPEG:
 
         self._run_ffmpeg(cmd)
 
-    def generate_binary_search(self, sorted_frame_indices: T.Sequence[int]) -> str:
+    def generate_binary_search(self, sorted_frame_indices: list[int]) -> str:
         length = len(sorted_frame_indices)
 
         if length == 0:
@@ -211,8 +212,8 @@ class FFMPEG:
         self,
         video_path: Path,
         sample_dir: Path,
-        frame_indices: T.Set[int],
-        stream_idx: T.Optional[int] = None,
+        frame_indices: set[int],
+        stream_idx: int | None = None,
     ) -> None:
         """
         Extract specified frames from the specified video stream.
@@ -253,7 +254,7 @@ class FFMPEG:
                 # If not close, error "The process cannot access the file because it is being used by another process"
                 if not delete:
                     select_file.close()
-                cmd: T.List[str] = [
+                cmd: list[str] = [
                     # global options should be specified first
                     *["-hide_banner", "-nostdin"],
                     # input 0
@@ -300,7 +301,7 @@ class Probe:
     def __init__(self, probe: ProbeOutput) -> None:
         self.probe = probe
 
-    def probe_video_start_time(self) -> T.Optional[datetime.datetime]:
+    def probe_video_start_time(self) -> datetime.datetime | None:
         """
         Find video start time of the given video.
         It searches video creation time and duration in video streams first and then the other streams.
@@ -327,11 +328,11 @@ class Probe:
 
         return None
 
-    def probe_video_streams(self) -> T.List[Stream]:
+    def probe_video_streams(self) -> list[Stream]:
         streams = self.probe.get("streams", [])
         return [stream for stream in streams if stream.get("codec_type") == "video"]
 
-    def probe_video_with_max_resolution(self) -> T.Optional[Stream]:
+    def probe_video_with_max_resolution(self) -> Stream | None:
         video_streams = self.probe_video_streams()
         video_streams.sort(
             key=lambda s: s.get("width", 0) * s.get("height", 0), reverse=True
@@ -341,7 +342,7 @@ class Probe:
         return video_streams[0]
 
 
-def extract_stream_start_time(stream: Stream) -> T.Optional[datetime.datetime]:
+def extract_stream_start_time(stream: Stream) -> datetime.datetime | None:
     """
     Find the start time of the given stream.
     Start time is the creation time of the stream minus the duration of the stream.
@@ -368,7 +369,7 @@ def extract_stream_start_time(stream: Stream) -> T.Optional[datetime.datetime]:
 def _extract_stream_frame_idx(
     sample_basename: str,
     sample_basename_pattern: T.Pattern[str],
-) -> T.Optional[T.Tuple[T.Optional[int], int]]:
+) -> tuple[int | None, int] | None:
     """
     extract stream id and frame index from sample basename
     e.g. basename GX010001_NA_000000.jpg will extract (None, 0)
@@ -408,7 +409,7 @@ def _extract_stream_frame_idx(
 
 def iterate_samples(
     sample_dir: Path, video_path: Path
-) -> T.Generator[T.Tuple[T.Optional[int], int, Path], None, None]:
+) -> T.Generator[tuple[int | None, int, Path], None, None]:
     """
     Search all samples in the sample_dir,
     and return a generator of the tuple: (stream ID, frame index, sample path).
@@ -428,17 +429,17 @@ def iterate_samples(
 
 
 def sort_selected_samples(
-    sample_dir: Path, video_path: Path, selected_stream_indices: T.List[T.Optional[int]]
-) -> T.List[T.Tuple[int, T.List[T.Optional[Path]]]]:
+    sample_dir: Path, video_path: Path, selected_stream_indices: list[int | None]
+) -> list[tuple[int, list[Path | None]]]:
     """
     Group frames by frame index, so that
     the Nth group contains all the frames from the selected streams at frame index N.
     """
-    stream_samples: T.Dict[int, T.List[T.Tuple[T.Optional[int], Path]]] = {}
+    stream_samples: dict[int, list[tuple[int | None, Path]]] = {}
     for stream_idx, frame_idx, sample_path in iterate_samples(sample_dir, video_path):
         stream_samples.setdefault(frame_idx, []).append((stream_idx, sample_path))
 
-    selected: T.List[T.Tuple[int, T.List[T.Optional[Path]]]] = []
+    selected: list[tuple[int, list[Path | None]]] = []
     for frame_idx in sorted(stream_samples.keys()):
         indexed = {
             stream_idx: sample_path

mapillary_tools/geo.py

@@ -1,10 +1,12 @@
 # pyre-ignore-all-errors[4]
+from __future__ import annotations
 
 import bisect
 import dataclasses
 import datetime
 import itertools
 import math
+import sys
 import typing as T
 
 WGS84_a = 6378137.0
@@ -27,34 +29,14 @@ class Point:
     time: float
     lat: float
     lon: float
-    alt: T.Optional[float]
-    angle: T.Optional[float]
+    alt: float | None
+    angle: float | None
 
 
-def _ecef_from_lla2(lat: float, lon: float) -> T.Tuple[float, float, float]:
-    """
-    Compute ECEF XYZ from latitude, longitude and altitude.
-
-    All using the WGS94 model.
-    Altitude is the distance to the WGS94 ellipsoid.
-    Check results here http://www.oc.nps.edu/oc2902w/coord/llhxyz.htm
-
-    """
-    lat = math.radians(lat)
-    lon = math.radians(lon)
-    cos_lat = math.cos(lat)
-    sin_lat = math.sin(lat)
-    L = 1.0 / math.sqrt(WGS84_a_SQ * cos_lat**2 + WGS84_b_SQ * sin_lat**2)
-    K = WGS84_a_SQ * L * cos_lat
-    x = K * math.cos(lon)
-    y = K * math.sin(lon)
-    z = WGS84_b_SQ * L * sin_lat
-    return x, y, z
+PointLike = T.TypeVar("PointLike", bound=Point)
 
 
-def gps_distance(
-    latlon_1: T.Tuple[float, float], latlon_2: T.Tuple[float, float]
-) -> float:
+def gps_distance(latlon_1: tuple[float, float], latlon_2: tuple[float, float]) -> float:
     """
     Distance between two (lat,lon) pairs.
 
@@ -69,19 +51,9 @@ def gps_distance(
     return math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2 + (z1 - z2) ** 2)
 
 
-def get_max_distance_from_start(latlons: T.List[T.Tuple[float, float]]) -> float:
-    """
-    Returns the radius of an entire GPS track. Used to calculate whether or not the entire sequence was just stationary video
-    Takes a sequence of points as input
-    """
-    if not latlons:
-        return 0
-    start = latlons[0]
-    return max(gps_distance(start, latlon) for latlon in latlons)
-
-
 def compute_bearing(
-    start_lat: float, start_lon: float, end_lat: float, end_lon: float
+    latlon_1: tuple[float, float],
+    latlon_2: tuple[float, float],
 ) -> float:
     """
     Get the compass bearing from start to end.
@@ -89,7 +61,10 @@ def compute_bearing(
     Formula from
     http://www.movable-type.co.uk/scripts/latlong.html
     """
-    # make sure everything is in radians
+    start_lat, start_lon = latlon_1
+    end_lat, end_lon = latlon_2
+
+    # Make sure everything is in radians
     start_lat = math.radians(start_lat)
     start_lon = math.radians(start_lon)
     end_lat = math.radians(end_lat)
@@ -125,14 +100,14 @@ _IT = T.TypeVar("_IT")
 
 
 # http://stackoverflow.com/a/5434936
-def pairwise(iterable: T.Iterable[_IT]) -> T.Iterable[T.Tuple[_IT, _IT]]:
+def pairwise(iterable: T.Iterable[_IT]) -> T.Iterable[tuple[_IT, _IT]]:
     """s -> (s0,s1), (s1,s2), (s2, s3), ..."""
     a, b = itertools.tee(iterable)
     next(b, None)
     return zip(a, b)
 
 
-def as_unix_time(dt: T.Union[datetime.datetime, int, float]) -> float:
+def as_unix_time(dt: datetime.datetime | int | float) -> float:
     if isinstance(dt, (int, float)):
         return dt
     else:
@@ -148,59 +123,37 @@ def as_unix_time(dt: T.Union[datetime.datetime, int, float]) -> float:
                 return 0.0
 
 
-def _interpolate_segment(start: Point, end: Point, t: float) -> Point:
-    if start.time == end.time:
-        weight = 0.0
-    else:
-        weight = (t - start.time) / (end.time - start.time)
+if sys.version_info < (3, 10):
 
-    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: T.Optional[float]
-    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_at_index(points: T.Sequence[Point], t: float, idx: int):
-    assert points, "expect non-empty points"
-
-    # find the segment (start point, end point)
-    if len(points) == 1:
-        start, end = points[0], points[0]
-    else:
-        if 0 < idx < len(points):
-            # interpolating within the range
-            start, end = points[idx - 1], points[idx]
-        elif idx <= 0:
-            # extrapolating behind the range
-            start, end = points[0], points[1]
-        else:
-            # extrapolating beyond the range
-            assert len(points) <= idx
-            start, end = points[-2], points[-1]
+    def interpolate(points: T.Sequence[Point], t: float, lo: int = 0) -> Point:
+        """
+        Interpolate or extrapolate the point at time t along the sequence of points (sorted by time).
+        """
+        if not points:
+            raise ValueError("Expect non-empty points")
 
-    return _interpolate_segment(start, end, t)
+        # Make sure that points are sorted (disabled because the check costs O(N)):
+        # 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)
+        return _interpolate_at_segment_idx(points, t, idx)
+else:
 
-def interpolate(points: T.Sequence[Point], t: float, lo: int = 0) -> Point:
-    """
-    Interpolate or extrapolate the point at time t along the sequence of points (sorted by time).
-    """
-    if not points:
-        raise ValueError("Expect non-empty points")
+    def interpolate(points: T.Sequence[Point], t: float, lo: int = 0) -> Point:
+        """
+        Interpolate or extrapolate the point at time t along the sequence of points (sorted by time).
+        """
+        if not points:
+            raise ValueError("Expect non-empty points")
 
-    # Make sure that points are sorted (disabled because the check costs O(N)):
-    # for cur, nex in pairwise(points):
-    #     assert cur.time <= nex.time, "Points not sorted"
+        # Make sure that points are sorted (disabled because the check costs O(N)):
+        # 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)
-    return _interpolate_at_index(points, t, idx)
+        idx = bisect.bisect_left(points, t, lo=lo, key=lambda x: x.time)
+        return _interpolate_at_segment_idx(points, t, idx)
 
 
 class Interpolator:
@@ -212,12 +165,22 @@ class Interpolator:
     track_idx: int
     # interpolation starts from the lower bound point index in the current track
     lo: int
-    prev_time: T.Optional[float]
+    prev_time: float | None
 
     def __init__(self, tracks: T.Sequence[T.Sequence[Point]]):
+        # Remove empty tracks
         self.tracks = [track for track in tracks if track]
+
         if not self.tracks:
-            raise ValueError("Expect non-empty tracks")
+            raise ValueError("Expect at least one non-empty track")
+
+        for track in self.tracks:
+            for left, right in pairwise(track):
+                if not (left.time <= right.time):
+                    raise ValueError(
+                        "Expect points to be sorted by time, but got {left.time} then {right.time}"
+                    )
+
         self.tracks.sort(key=lambda track: track[0].time)
         self.track_idx = 0
         self.lo = 0
@@ -225,7 +188,7 @@ class Interpolator:
 
     @staticmethod
     def _lsearch_left(
-        track: T.Sequence[Point], t: float, lo: int = 0, hi: T.Optional[int] = None
+        track: T.Sequence[Point], t: float, lo: int = 0, hi: int | None = None
     ) -> int:
         """
         similar to bisect.bisect_left, but faster in the incremental search case
@@ -244,39 +207,52 @@ class Interpolator:
 
     def interpolate(self, t: float) -> Point:
         if self.prev_time is not None:
-            assert self.prev_time <= t, "requires time to be monotonically increasing"
+            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
 
         while self.track_idx < len(self.tracks):
             track = self.tracks[self.track_idx]
+            assert track, "expect non-empty track"
+
             if t < track[0].time:
-                return _interpolate_at_index(track, t, 0)
+                interpolated = _interpolate_at_segment_idx(track, t, 0)
+                break
+
             elif track[0].time <= t <= track[-1].time:
-                # similar to bisect.bisect_left(points, p, lo=lo) but faster in this case
+                # Similar to bisect.bisect_left(points, p, lo=lo) but faster in this case
                 idx = Interpolator._lsearch_left(track, t, lo=self.lo)
-                # t must sit between (track[idx - 1], track[idx]]
-                # set the lower bound to idx - 1
-                # because the next t can still be interpolated anywhere between (track[idx - 1], track[idx]]
+                # Time t must be between (track[idx - 1], track[idx]], so set the lower bound to idx - 1
+                # Because the next t can still be interpolated anywhere between (track[idx - 1], track[idx]]
                 self.lo = max(idx - 1, 0)
-                return _interpolate_at_index(track, t, idx)
+                interpolated = _interpolate_at_segment_idx(track, t, idx)
+                break
+
             self.track_idx += 1
             self.lo = 0
 
-        interpolated = _interpolate_at_index(self.tracks[-1], t, len(self.tracks[-1]))
+        if interpolated is None:
+            interpolated = _interpolate_at_segment_idx(
+                self.tracks[-1], t, len(self.tracks[-1])
+            )
 
         self.prev_time = t
 
         return interpolated
 
 
-_PointAbstract = T.TypeVar("_PointAbstract")
+_T = T.TypeVar("_T")
 
 
 def sample_points_by_distance(
-    samples: T.Iterable[_PointAbstract],
+    samples: T.Iterable[_T],
     min_distance: float,
-    point_func: T.Callable[[_PointAbstract], Point],
-) -> T.Generator[_PointAbstract, None, None]:
-    prevp: T.Optional[Point] = None
+    point_func: T.Callable[[_T], Point],
+) -> T.Generator[_T, None, None]:
+    prevp: Point | None = None
     for sample in samples:
         if prevp is None:
             yield sample
@@ -288,34 +264,82 @@ def sample_points_by_distance(
                 prevp = p
 
 
-def interpolate_directions_if_none(sequence: T.Sequence[Point]) -> None:
+def interpolate_directions_if_none(sequence: T.Sequence[PointLike]) -> None:
     for cur, nex in pairwise(sequence):
         if cur.angle is None:
-            cur.angle = compute_bearing(cur.lat, cur.lon, nex.lat, nex.lon)
+            cur.angle = compute_bearing((cur.lat, cur.lon), (nex.lat, nex.lon))
 
     if len(sequence) == 1:
         if sequence[-1].angle is None:
             sequence[-1].angle = 0
     elif 2 <= len(sequence):
         if sequence[-1].angle is None:
-            sequence[-1].angle = sequence[-2].angle
+            prev_angle = sequence[-2].angle
+            assert prev_angle is not None, (
+                "expect the last second point to have an interpolated angle"
+            )
+            sequence[-1].angle = prev_angle
+
+
+def _ecef_from_lla2(lat: float, lon: float) -> tuple[float, float, float]:
+    """
+    Compute ECEF XYZ from latitude and longitude.
+
+    All using the WGS94 model.
+    Altitude is the distance to the WGS94 ellipsoid.
+    Check results here http://www.oc.nps.edu/oc2902w/coord/llhxyz.htm
+
+    """
+    lat = math.radians(lat)
+    lon = math.radians(lon)
+    cos_lat = math.cos(lat)
+    sin_lat = math.sin(lat)
+    L = 1.0 / math.sqrt(WGS84_a_SQ * cos_lat**2 + WGS84_b_SQ * sin_lat**2)
+    K = WGS84_a_SQ * L * cos_lat
+    x = K * math.cos(lon)
+    y = K * math.sin(lon)
+    z = WGS84_b_SQ * L * sin_lat
+    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
 
-_PointLike = T.TypeVar("_PointLike", bound=Point)
+    return Point(time=t, lat=lat, lon=lon, alt=alt, angle=angle)
 
 
-def extend_deduplicate_points(
-    sequence: T.Iterable[_PointLike],
-    to_extend: T.Optional[T.List[_PointLike]] = None,
-) -> T.List[_PointLike]:
-    if to_extend is None:
-        to_extend = []
-    for point in sequence:
-        if to_extend:
-            prev = to_extend[-1].lon, to_extend[-1].lat
-            cur = (point.lon, point.lat)
-            if cur != prev:
-                to_extend.append(point)
+def _interpolate_at_segment_idx(points: T.Sequence[Point], t: float, idx: int) -> Point:
+    """
+    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).
+    """
+
+    if len(points) == 1:
+        start, end = points[0], points[0]
+    elif 2 <= len(points):
+        if 0 < idx < len(points):
+            # Normal interpolation within the range
+            start, end = points[idx - 1], points[idx]
+        elif idx <= 0:
+            # Extrapolating before the first point
+            start, end = points[0], points[1]
         else:
-            to_extend.append(point)
-    return to_extend
+            # Extrapolating after the last point
+            assert len(points) <= idx
+            start, end = points[-2], points[-1]
+    else:
+        assert False, "expect non-empty points"
+
+    return _interpolate_segment(start, end, t)