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

mapillary_tools/{geotag/blackvue_parser.py → blackvue_parser.py}

@@ -1,13 +1,16 @@
+from __future__ import annotations
+
+import dataclasses
+
 import json
 import logging
-import pathlib
 import re
 import typing as T
 
 import pynmea2
 
-from .. import geo
-from ..mp4 import simple_mp4_parser as sparser
+from . import geo
+from .mp4 import simple_mp4_parser as sparser
 
 
 LOG = logging.getLogger(__name__)
@@ -26,31 +29,45 @@ NMEA_LINE_REGEX = re.compile(
 )
 
 
-def _parse_gps_box(gps_data: bytes) -> T.Generator[geo.Point, None, None]:
-    for line_bytes in gps_data.splitlines():
-        match = NMEA_LINE_REGEX.match(line_bytes)
-        if match is None:
-            continue
-        nmea_line_bytes = match.group(2)
-        if nmea_line_bytes.startswith(b"$GPGGA"):
-            try:
-                nmea_line = nmea_line_bytes.decode("utf8")
-            except UnicodeDecodeError:
-                continue
-            try:
-                nmea = pynmea2.parse(nmea_line)
-            except pynmea2.nmea.ParseError:
-                continue
-            if not nmea.is_valid:
-                continue
-            epoch_ms = int(match.group(1))
-            yield geo.Point(
-                time=epoch_ms,
-                lat=nmea.latitude,
-                lon=nmea.longitude,
-                alt=nmea.altitude,
-                angle=None,
-            )
+@dataclasses.dataclass
+class BlackVueInfo:
+    # None and [] are equivalent here. Use None as default because:
+    # ValueError: mutable default <class 'list'> for field gps is not allowed: use default_factory
+    gps: list[geo.Point] | None = None
+    make: str = "BlackVue"
+    model: str = ""
+
+
+def extract_blackvue_info(fp: T.BinaryIO) -> BlackVueInfo | None:
+    try:
+        gps_data = sparser.parse_mp4_data_first(fp, [b"free", b"gps "])
+    except sparser.ParsingError:
+        gps_data = None
+
+    if gps_data is None:
+        return None
+
+    points = list(_parse_gps_box(gps_data))
+    points.sort(key=lambda p: p.time)
+
+    if points:
+        first_point_time = points[0].time
+        for p in points:
+            p.time = (p.time - first_point_time) / 1000
+
+    # Camera model
+    try:
+        cprt_bytes = sparser.parse_mp4_data_first(fp, [b"free", b"cprt"])
+    except sparser.ParsingError:
+        cprt_bytes = None
+        model = ""
+
+    if cprt_bytes is None:
+        model = ""
+    else:
+        model = _extract_camera_model_from_cprt(cprt_bytes)
+
+    return BlackVueInfo(model=model, gps=points)
 
 
 def extract_camera_model(fp: T.BinaryIO) -> str:
@@ -62,6 +79,10 @@ def extract_camera_model(fp: T.BinaryIO) -> str:
     if cprt_bytes is None:
         return ""
 
+    return _extract_camera_model_from_cprt(cprt_bytes)
+
+
+def _extract_camera_model_from_cprt(cprt_bytes: bytes) -> str:
     # examples: b' {"model":"DR900X Plus","ver":0.918,"lang":"English","direct":1,"psn":"","temp":34,"GPS":1}\x00'
     #           b' Pittasoft Co., Ltd.;DR900S-1CH;1.008;English;1;D90SS1HAE00661;T69;\x00'
     cprt_bytes = cprt_bytes.strip().strip(b"\x00")
@@ -90,29 +111,28 @@ def extract_camera_model(fp: T.BinaryIO) -> str:
         return ""
 
 
-def extract_points(fp: T.BinaryIO) -> T.Optional[T.List[geo.Point]]:
-    gps_data = sparser.parse_mp4_data_first(fp, [b"free", b"gps "])
-    if gps_data is None:
-        return None
-
-    points = list(_parse_gps_box(gps_data))
-    if not points:
-        return points
-
-    points.sort(key=lambda p: p.time)
-
-    first_point_time = points[0].time
-    for p in points:
-        p.time = (p.time - first_point_time) / 1000
-
-    return points
-
-
-def parse_gps_points(path: pathlib.Path) -> T.List[geo.Point]:
-    with path.open("rb") as fp:
-        points = extract_points(fp)
-
-    if points is None:
-        return []
-
-    return points
+def _parse_gps_box(gps_data: bytes) -> T.Generator[geo.Point, None, None]:
+    for line_bytes in gps_data.splitlines():
+        match = NMEA_LINE_REGEX.match(line_bytes)
+        if match is None:
+            continue
+        nmea_line_bytes = match.group(2)
+        if nmea_line_bytes.startswith(b"$GPGGA"):
+            try:
+                nmea_line = nmea_line_bytes.decode("utf8")
+            except UnicodeDecodeError:
+                continue
+            try:
+                nmea = pynmea2.parse(nmea_line)
+            except pynmea2.nmea.ParseError:
+                continue
+            if not nmea.is_valid:
+                continue
+            epoch_ms = int(match.group(1))
+            yield geo.Point(
+                time=epoch_ms,
+                lat=nmea.latitude,
+                lon=nmea.longitude,
+                alt=nmea.altitude,
+                angle=None,
+            )

mapillary_tools/camm/camm_builder.py

@@ -1,7 +1,9 @@
+from __future__ import annotations
+
 import io
 import typing as T
 
-from .. import geo, telemetry, types
+from .. import geo
 from ..mp4 import (
     construct_mp4_parser as cparser,
     mp4_sample_parser as sample_parser,
@@ -11,84 +13,35 @@ from ..mp4 import (
 from . import camm_parser
 
 
-TelemetryMeasurement = T.Union[
-    geo.Point,
-    telemetry.TelemetryMeasurement,
-]
+def _build_camm_sample(measurement: camm_parser.TelemetryMeasurement) -> bytes:
+    if camm_parser.GoProGPSSampleEntry.serializable(measurement):
+        return camm_parser.GoProGPSSampleEntry.serialize(measurement)
 
+    for sample_entry_cls in camm_parser.SAMPLE_ENTRY_CLS_BY_CAMM_TYPE.values():
+        if sample_entry_cls.serializable(measurement):
+            return sample_entry_cls.serialize(measurement)
 
-def _build_camm_sample(measurement: TelemetryMeasurement) -> bytes:
-    if isinstance(measurement, geo.Point):
-        return camm_parser.CAMMSampleData.build(
-            {
-                "type": camm_parser.CAMMType.MIN_GPS.value,
-                "data": [
-                    measurement.lat,
-                    measurement.lon,
-                    -1.0 if measurement.alt is None else measurement.alt,
-                ],
-            }
-        )
-    elif isinstance(measurement, telemetry.AccelerationData):
-        # Accelerometer reading in meters/second^2 along XYZ axes of the camera.
-        return camm_parser.CAMMSampleData.build(
-            {
-                "type": camm_parser.CAMMType.ACCELERATION.value,
-                "data": [
-                    measurement.x,
-                    measurement.y,
-                    measurement.z,
-                ],
-            }
-        )
-    elif isinstance(measurement, telemetry.GyroscopeData):
-        # Gyroscope signal in radians/seconds around XYZ axes of the camera. Rotation is positive in the counterclockwise direction.
-        return camm_parser.CAMMSampleData.build(
-            {
-                "type": camm_parser.CAMMType.GYRO.value,
-                "data": [
-                    measurement.x,
-                    measurement.y,
-                    measurement.z,
-                ],
-            }
-        )
-    elif isinstance(measurement, telemetry.MagnetometerData):
-        # Ambient magnetic field.
-        return camm_parser.CAMMSampleData.build(
-            {
-                "type": camm_parser.CAMMType.MAGNETIC_FIELD.value,
-                "data": [
-                    measurement.x,
-                    measurement.y,
-                    measurement.z,
-                ],
-            }
-        )
-    else:
-        raise ValueError(f"unexpected measurement type {type(measurement)}")
+    raise ValueError(f"Unsupported measurement type {type(measurement)}")
 
 
 def _create_edit_list_from_points(
-    point_segments: T.Sequence[T.Sequence[geo.Point]],
+    tracks: T.Sequence[T.Sequence[geo.Point]],
     movie_timescale: int,
     media_timescale: int,
 ) -> builder.BoxDict:
-    entries: T.List[T.Dict] = []
+    entries: list[dict] = []
 
-    non_empty_point_segments = [points for points in point_segments if points]
+    non_empty_tracks = [track for track in tracks if track]
 
-    for idx, points in enumerate(non_empty_point_segments):
-        assert 0 <= points[0].time, (
-            f"expect non-negative point time but got {points[0]}"
-        )
-        assert points[0].time <= points[-1].time, (
-            f"expect points to be sorted but got first point {points[0]} and last point {points[-1]}"
+    for idx, track in enumerate(non_empty_tracks):
+        assert 0 <= track[0].time, f"expect non-negative point time but got {track[0]}"
+        assert track[0].time <= track[-1].time, (
+            f"expect points to be sorted but got first point {track[0]} and last point {track[-1]}"
         )
 
         if idx == 0:
-            if 0 < points[0].time:
-                segment_duration = int(points[0].time * movie_timescale)
+            if 0 < track[0].time:
+                segment_duration = int(track[0].time * movie_timescale)
                 # put an empty edit list entry to skip the initial gap
                 entries.append(
                     {
@@ -100,8 +53,8 @@ def _create_edit_list_from_points(
                     }
                 )
         else:
-            media_time = int(points[0].time * media_timescale)
-            segment_duration = int((points[-1].time - points[0].time) * movie_timescale)
+            media_time = int(track[0].time * media_timescale)
+            segment_duration = int((track[-1].time - track[0].time) * movie_timescale)
             entries.append(
                 {
                     "media_time": media_time,
@@ -119,18 +72,8 @@ def _create_edit_list_from_points(
     }
 
 
-def _multiplex(
-    points: T.Sequence[geo.Point],
-    measurements: T.Optional[T.List[telemetry.TelemetryMeasurement]] = None,
-) -> T.List[TelemetryMeasurement]:
-    mutiplexed: T.List[TelemetryMeasurement] = [*points, *(measurements or [])]
-    mutiplexed.sort(key=lambda m: m.time)
-
-    return mutiplexed
-
-
 def convert_telemetry_to_raw_samples(
-    measurements: T.Sequence[TelemetryMeasurement],
+    measurements: T.Sequence[camm_parser.TelemetryMeasurement],
     timescale: int,
 ) -> T.Generator[sample_parser.RawSample, None, None]:
     for idx, measurement in enumerate(measurements):
@@ -281,29 +224,44 @@ def create_camm_trak(
     }
 
 
-def camm_sample_generator2(
-    video_metadata: types.VideoMetadata,
-    telemetry_measurements: T.Optional[T.List[telemetry.TelemetryMeasurement]] = None,
-):
+def camm_sample_generator2(camm_info: camm_parser.CAMMInfo):
     def _f(
         fp: T.BinaryIO,
-        moov_children: T.List[builder.BoxDict],
+        moov_children: list[builder.BoxDict],
     ) -> T.Generator[io.IOBase, None, None]:
         movie_timescale = builder.find_movie_timescale(moov_children)
-        # make sure the precision of timedeltas not lower than 0.001 (1ms)
+        # Make sure the precision of timedeltas not lower than 0.001 (1ms)
         media_timescale = max(1000, movie_timescale)
 
-        # points with negative time are skipped
-        # TODO: interpolate first point at time == 0
-        # TODO: measurements with negative times should be skipped too
-        points = [point for point in video_metadata.points if point.time >= 0]
-
-        measurements = _multiplex(points, telemetry_measurements)
+        # Multiplex points for creating elst
+        track: list[geo.Point] = [
+            *(camm_info.gps or []),
+            *(camm_info.mini_gps or []),
+        ]
+        track.sort(key=lambda p: p.time)
+        if track and track[0].time < 0:
+            track = [p for p in track if p.time >= 0]
+        elst = _create_edit_list_from_points([track], movie_timescale, media_timescale)
+
+        # Multiplex telemetry measurements
+        measurements: list[camm_parser.TelemetryMeasurement] = [
+            *(camm_info.gps or []),
+            *(camm_info.mini_gps or []),
+            *(camm_info.accl or []),
+            *(camm_info.gyro or []),
+            *(camm_info.magn or []),
+        ]
+        measurements.sort(key=lambda m: m.time)
+        if measurements and measurements[0].time < 0:
+            measurements = [m for m in measurements if m.time >= 0]
+
+        # Serialize the telemetry measurements into MP4 samples
         camm_samples = list(
             convert_telemetry_to_raw_samples(measurements, media_timescale)
         )
+
         camm_trak = create_camm_trak(camm_samples, media_timescale)
-        elst = _create_edit_list_from_points([points], movie_timescale, media_timescale)
+
         if T.cast(T.Dict, elst["data"])["entries"]:
             T.cast(T.List[builder.BoxDict], camm_trak["data"]).append(
                 {
@@ -313,19 +271,19 @@ def camm_sample_generator2(
             )
         moov_children.append(camm_trak)
 
-        udta_data: T.List[builder.BoxDict] = []
-        if video_metadata.make:
+        udta_data: list[builder.BoxDict] = []
+        if camm_info.make:
             udta_data.append(
                 {
                     "type": b"@mak",
-                    "data": video_metadata.make.encode("utf-8"),
+                    "data": camm_info.make.encode("utf-8"),
                 }
             )
-        if video_metadata.model:
+        if camm_info.model:
             udta_data.append(
                 {
                     "type": b"@mod",
-                    "data": video_metadata.model.encode("utf-8"),
+                    "data": camm_info.model.encode("utf-8"),
                 }
             )
         if udta_data: