mapillary-tools 0.13.1__tar.gz → 0.13.2__tar.gz

{mapillary_tools-0.13.1/mapillary_tools.egg-info → mapillary_tools-0.13.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapillary_tools
-Version: 0.13.1
+Version: 0.13.2
 Summary: Mapillary Image/Video Import Pipeline
 Home-page: https://github.com/mapillary/mapillary_tools
 Author: Mapillary

mapillary_tools-0.13.2/mapillary_tools/__init__.py

@@ -0,0 +1 @@
+VERSION = "0.13.2"

{mapillary_tools-0.13.1 → mapillary_tools-0.13.2}/mapillary_tools/camm/camm_builder.py

@@ -1,7 +1,7 @@
 import io
 import typing as T
 
-from .. import geo, types
+from .. import geo, telemetry, types
 from ..mp4 import (
     construct_mp4_parser as cparser,
     mp4_sample_parser as sample_parser,
@@ -11,11 +11,62 @@ from ..mp4 import (
 from . import camm_parser
 
 
-def _build_camm_sample(measurement: camm_parser.TelemetryMeasurement) -> bytes:
-    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)
-    raise ValueError(f"Unsupported measurement type {type(measurement)}")
+TelemetryMeasurement = T.Union[
+    geo.Point,
+    telemetry.TelemetryMeasurement,
+]
+
+
+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)}")
 
 
 def _create_edit_list_from_points(
@@ -70,19 +121,16 @@ def _create_edit_list_from_points(
 
 def _multiplex(
     points: T.Sequence[geo.Point],
-    measurements: T.Optional[T.List[camm_parser.TelemetryMeasurement]] = None,
-) -> T.List[camm_parser.TelemetryMeasurement]:
-    mutiplexed: T.List[camm_parser.TelemetryMeasurement] = [
-        *points,
-        *(measurements or []),
-    ]
+    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[camm_parser.TelemetryMeasurement],
+    measurements: T.Sequence[TelemetryMeasurement],
     timescale: int,
 ) -> T.Generator[sample_parser.RawSample, None, None]:
     for idx, measurement in enumerate(measurements):
@@ -235,7 +283,7 @@ def create_camm_trak(
 
 def camm_sample_generator2(
     video_metadata: types.VideoMetadata,
-    telemetry_measurements: T.Optional[T.List[camm_parser.TelemetryMeasurement]] = None,
+    telemetry_measurements: T.Optional[T.List[telemetry.TelemetryMeasurement]] = None,
 ):
     def _f(
         fp: T.BinaryIO,

mapillary_tools-0.13.2/mapillary_tools/camm/camm_parser.py

@@ -0,0 +1,342 @@
+# pyre-ignore-all-errors[5, 11, 16, 21, 24, 58]
+
+import dataclasses
+import io
+import logging
+import pathlib
+import typing as T
+from enum import Enum
+
+import construct as C
+
+from .. import geo, telemetry
+from ..mp4 import simple_mp4_parser as sparser
+from ..mp4.mp4_sample_parser import MovieBoxParser, Sample, TrackBoxParser
+
+
+LOG = logging.getLogger(__name__)
+
+
+TelemetryMeasurement = T.Union[
+    geo.Point,
+    telemetry.AccelerationData,
+    telemetry.GyroscopeData,
+    telemetry.MagnetometerData,
+]
+
+
+# Camera Motion Metadata Spec https://developers.google.com/streetview/publish/camm-spec
+class CAMMType(Enum):
+    ANGLE_AXIS = 0
+    EXPOSURE_TIME = 1
+    GYRO = 2
+    ACCELERATION = 3
+    POSITION = 4
+    MIN_GPS = 5
+    GPS = 6
+    MAGNETIC_FIELD = 7
+
+
+# All fields are little-endian
+Float = C.Float32l
+Double = C.Float64l
+
+_SWITCH: T.Dict[int, C.Struct] = {
+    # angle_axis
+    CAMMType.ANGLE_AXIS.value: Float[3],
+    CAMMType.EXPOSURE_TIME.value: C.Struct(
+        "pixel_exposure_time" / C.Int32sl,
+        "rolling_shutter_skew_time" / C.Int32sl,
+    ),
+    # gyro
+    CAMMType.GYRO.value: Float[3],
+    # acceleration
+    CAMMType.ACCELERATION.value: Float[3],
+    # position
+    CAMMType.POSITION.value: Float[3],
+    # lat, lon, alt
+    CAMMType.MIN_GPS.value: Double[3],
+    CAMMType.GPS.value: C.Struct(
+        "time_gps_epoch" / Double,
+        "gps_fix_type" / C.Int32sl,
+        "latitude" / Double,
+        "longitude" / Double,
+        "altitude" / Float,
+        "horizontal_accuracy" / Float,
+        "vertical_accuracy" / Float,
+        "velocity_east" / Float,
+        "velocity_north" / Float,
+        "velocity_up" / Float,
+        "speed_accuracy" / Float,
+    ),
+    # magnetic_field
+    CAMMType.MAGNETIC_FIELD.value: Float[3],
+}
+
+CAMMSampleData = C.Struct(
+    C.Padding(2),
+    "type" / C.Int16ul,
+    "data"
+    / C.Switch(
+        C.this.type,
+        _SWITCH,
+    ),
+)
+
+
+def _parse_telemetry_from_sample(
+    fp: T.BinaryIO, sample: Sample
+) -> T.Optional[TelemetryMeasurement]:
+    fp.seek(sample.raw_sample.offset, io.SEEK_SET)
+    data = fp.read(sample.raw_sample.size)
+    box = CAMMSampleData.parse(data)
+    if box.type == CAMMType.MIN_GPS.value:
+        return geo.Point(
+            time=sample.exact_time,
+            lat=box.data[0],
+            lon=box.data[1],
+            alt=box.data[2],
+            angle=None,
+        )
+    elif box.type == CAMMType.GPS.value:
+        # Not using box.data.time_gps_epoch as the point timestamp
+        # because it is from another clock
+        return geo.Point(
+            time=sample.exact_time,
+            lat=box.data.latitude,
+            lon=box.data.longitude,
+            alt=box.data.altitude,
+            angle=None,
+        )
+    elif box.type == CAMMType.ACCELERATION.value:
+        return telemetry.AccelerationData(
+            time=sample.exact_time,
+            x=box.data[0],
+            y=box.data[1],
+            z=box.data[2],
+        )
+    elif box.type == CAMMType.GYRO.value:
+        return telemetry.GyroscopeData(
+            time=sample.exact_time,
+            x=box.data[0],
+            y=box.data[1],
+            z=box.data[2],
+        )
+    elif box.type == CAMMType.MAGNETIC_FIELD.value:
+        return telemetry.MagnetometerData(
+            time=sample.exact_time,
+            x=box.data[0],
+            y=box.data[1],
+            z=box.data[2],
+        )
+    return None
+
+
+def _filter_telemetry_by_elst_segments(
+    measurements: T.Iterable[TelemetryMeasurement],
+    elst: T.Sequence[T.Tuple[float, float]],
+) -> T.Generator[TelemetryMeasurement, None, None]:
+    empty_elst = [entry for entry in elst if entry[0] == -1]
+    if empty_elst:
+        offset = empty_elst[-1][1]
+    else:
+        offset = 0
+
+    elst = [entry for entry in elst if entry[0] != -1]
+
+    if not elst:
+        for m in measurements:
+            yield dataclasses.replace(m, time=m.time + offset)
+        return
+
+    elst.sort(key=lambda entry: entry[0])
+    elst_idx = 0
+    for m in measurements:
+        if len(elst) <= elst_idx:
+            break
+        media_time, duration = elst[elst_idx]
+        if m.time < media_time:
+            pass
+        elif m.time <= media_time + duration:
+            yield dataclasses.replace(m, time=m.time + offset)
+        else:
+            elst_idx += 1
+
+
+def elst_entry_to_seconds(
+    entry: T.Dict, movie_timescale: int, media_timescale: int
+) -> T.Tuple[float, float]:
+    assert movie_timescale > 0, "expected positive movie_timescale"
+    assert media_timescale > 0, "expected positive media_timescale"
+    media_time, duration = entry["media_time"], entry["segment_duration"]
+    if media_time != -1:
+        media_time = media_time / media_timescale
+    duration = duration / movie_timescale
+    return (media_time, duration)
+
+
+def _is_camm_description(description: T.Dict) -> bool:
+    return description["format"] == b"camm"
+
+
+def _contains_camm_description(track: TrackBoxParser) -> bool:
+    descriptions = track.extract_sample_descriptions()
+    return any(_is_camm_description(d) for d in descriptions)
+
+
+def _filter_telemetry_by_track_elst(
+    moov: MovieBoxParser,
+    track: TrackBoxParser,
+    measurements: T.Iterable[TelemetryMeasurement],
+) -> T.List[TelemetryMeasurement]:
+    elst_boxdata = track.extract_elst_boxdata()
+
+    if elst_boxdata is not None:
+        elst_entries = elst_boxdata["entries"]
+        if elst_entries:
+            # media_timescale
+            mdhd_boxdata = track.extract_mdhd_boxdata()
+            media_timescale = mdhd_boxdata["timescale"]
+
+            # movie_timescale
+            mvhd_boxdata = moov.extract_mvhd_boxdata()
+            movie_timescale = mvhd_boxdata["timescale"]
+
+            segments = [
+                elst_entry_to_seconds(
+                    entry,
+                    movie_timescale=movie_timescale,
+                    media_timescale=media_timescale,
+                )
+                for entry in elst_entries
+            ]
+
+            return list(_filter_telemetry_by_elst_segments(measurements, segments))
+
+    return list(measurements)
+
+
+def extract_points(fp: T.BinaryIO) -> T.Optional[T.List[geo.Point]]:
+    """
+    Return a list of points (could be empty) if it is a valid CAMM video,
+    otherwise None
+    """
+
+    moov = MovieBoxParser.parse_stream(fp)
+
+    for track in moov.extract_tracks():
+        if _contains_camm_description(track):
+            maybe_measurements = (
+                _parse_telemetry_from_sample(fp, sample)
+                for sample in track.extract_samples()
+                if _is_camm_description(sample.description)
+            )
+            points = [m for m in maybe_measurements if isinstance(m, geo.Point)]
+
+            return T.cast(
+                T.List[geo.Point], _filter_telemetry_by_track_elst(moov, track, points)
+            )
+
+    return None
+
+
+def extract_telemetry_data(fp: T.BinaryIO) -> T.Optional[T.List[TelemetryMeasurement]]:
+    moov = MovieBoxParser.parse_stream(fp)
+
+    for track in moov.extract_tracks():
+        if _contains_camm_description(track):
+            maybe_measurements = (
+                _parse_telemetry_from_sample(fp, sample)
+                for sample in track.extract_samples()
+                if _is_camm_description(sample.description)
+            )
+            measurements = [m for m in maybe_measurements if m is not None]
+
+            measurements = _filter_telemetry_by_track_elst(moov, track, measurements)
+
+            return measurements
+
+    return None
+
+
+def parse_gpx(path: pathlib.Path) -> T.List[geo.Point]:
+    with path.open("rb") as fp:
+        points = extract_points(fp)
+    if points is None:
+        return []
+    return points
+
+
+MakeOrModel = C.Struct(
+    "size" / C.Int16ub,
+    C.Padding(2),
+    "data" / C.FixedSized(C.this.size, C.GreedyBytes),
+)
+
+
+def _decode_quietly(data: bytes, h: sparser.Header) -> str:
+    try:
+        return data.decode("utf-8")
+    except UnicodeDecodeError:
+        LOG.warning("Failed to decode %s: %s", h, data[:512])
+        return ""
+
+
+def _parse_quietly(data: bytes, h: sparser.Header) -> bytes:
+    try:
+        parsed = MakeOrModel.parse(data)
+    except C.ConstructError:
+        LOG.warning("Failed to parse %s: %s", h, data[:512])
+        return b""
+    return parsed["data"]
+
+
+def extract_camera_make_and_model(fp: T.BinaryIO) -> T.Tuple[str, str]:
+    header_and_stream = sparser.parse_path(
+        fp,
+        [
+            b"moov",
+            b"udta",
+            [
+                # Insta360 Titan
+                b"\xa9mak",
+                b"\xa9mod",
+                # RICHO THETA V
+                b"@mod",
+                b"@mak",
+                # RICHO THETA V
+                b"manu",
+                b"modl",
+            ],
+        ],
+    )
+
+    make: T.Optional[str] = None
+    model: T.Optional[str] = None
+
+    try:
+        for h, s in header_and_stream:
+            data = s.read(h.maxsize)
+            if h.type == b"\xa9mak":
+                make_data = _parse_quietly(data, h)
+                make_data = make_data.rstrip(b"\x00")
+                make = _decode_quietly(make_data, h)
+            elif h.type == b"\xa9mod":
+                model_data = _parse_quietly(data, h)
+                model_data = model_data.rstrip(b"\x00")
+                model = _decode_quietly(model_data, h)
+            elif h.type in [b"@mak", b"manu"]:
+                make = _decode_quietly(data, h)
+            elif h.type in [b"@mod", b"modl"]:
+                model = _decode_quietly(data, h)
+            # quit when both found
+            if make and model:
+                break
+    except sparser.ParsingError:
+        pass
+
+    if make:
+        make = make.strip()
+    if model:
+        model = model.strip()
+    return make or "", model or ""

{mapillary_tools-0.13.1 → mapillary_tools-0.13.2}/mapillary_tools/telemetry.py

@@ -12,6 +12,14 @@ class GPSFix(Enum):
     FIX_3D = 3
 
 
+@dataclasses.dataclass
+class GPSPoint(Point):
+    epoch_time: T.Optional[float]
+    fix: T.Optional[GPSFix]
+    precision: T.Optional[float]
+    ground_speed: T.Optional[float]
+
+
 @dataclasses.dataclass(order=True)
 class TelemetryMeasurement:
     """Base class for all telemetry measurements.
@@ -24,26 +32,6 @@ class TelemetryMeasurement:
     time: float
 
 
-@dataclasses.dataclass
-class GPSPoint(TelemetryMeasurement, Point):
-    epoch_time: T.Optional[float]
-    fix: T.Optional[GPSFix]
-    precision: T.Optional[float]
-    ground_speed: T.Optional[float]
-
-
-@dataclasses.dataclass
-class CAMMGPSPoint(TelemetryMeasurement, Point):
-    time_gps_epoch: float
-    gps_fix_type: int
-    horizontal_accuracy: float
-    vertical_accuracy: float
-    velocity_east: float
-    velocity_north: float
-    velocity_up: float
-    speed_accuracy: float
-
-
 @dataclasses.dataclass(order=True)
 class GyroscopeData(TelemetryMeasurement):
     """Gyroscope signal in radians/seconds around XYZ axes of the camera."""

{mapillary_tools-0.13.1 → mapillary_tools-0.13.2}/mapillary_tools/upload.py

@@ -18,13 +18,14 @@ from . import (
     exceptions,
     history,
     ipc,
+    telemetry,
     types,
     upload_api_v4,
     uploader,
     utils,
     VERSION,
 )
-from .camm import camm_builder, camm_parser
+from .camm import camm_builder
 from .geotag import gpmf_parser
 from .mp4 import simple_mp4_builder
 from .types import FileType
@@ -615,7 +616,7 @@ def upload(
             assert isinstance(video_metadata.md5sum, str), "md5sum should be updated"
 
             # extract telemetry measurements from GoPro videos
-            telemetry_measurements: T.List[camm_parser.TelemetryMeasurement] = []
+            telemetry_measurements: T.List[telemetry.TelemetryMeasurement] = []
             if MAPILLARY__EXPERIMENTAL_ENABLE_IMU == "YES":
                 if video_metadata.filetype is FileType.GOPRO:
                     with video_metadata.filename.open("rb") as fp:

{mapillary_tools-0.13.1 → mapillary_tools-0.13.2/mapillary_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapillary_tools
-Version: 0.13.1
+Version: 0.13.2
 Summary: Mapillary Image/Video Import Pipeline
 Home-page: https://github.com/mapillary/mapillary_tools
 Author: Mapillary

mapillary_tools-0.13.1/mapillary_tools/__init__.py

@@ -1 +0,0 @@
-VERSION = "0.13.1"