mapillary-tools 0.13.0__py3-none-any.whl → 0.13.1__py3-none-any.whl

mapillary_tools/__init__.py

@@ -1 +1 @@
-VERSION = "0.13.0"
+VERSION = "0.13.1"

mapillary_tools/camm/camm_builder.py

@@ -1,7 +1,7 @@
 import io
 import typing as T
 
-from .. import geo, telemetry, types
+from .. import geo, types
 from ..mp4 import (
     construct_mp4_parser as cparser,
     mp4_sample_parser as sample_parser,
@@ -11,62 +11,11 @@ from ..mp4 import (
 from . import camm_parser
 
 
-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 _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)}")
 
 
 def _create_edit_list_from_points(
@@ -121,16 +70,19 @@ 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 [])]
+    measurements: T.Optional[T.List[camm_parser.TelemetryMeasurement]] = None,
+) -> T.List[camm_parser.TelemetryMeasurement]:
+    mutiplexed: T.List[camm_parser.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):
@@ -283,7 +235,7 @@ def create_camm_trak(
 
 def camm_sample_generator2(
     video_metadata: types.VideoMetadata,
-    telemetry_measurements: T.Optional[T.List[telemetry.TelemetryMeasurement]] = None,
+    telemetry_measurements: T.Optional[T.List[camm_parser.TelemetryMeasurement]] = None,
 ):
     def _f(
         fp: T.BinaryIO,

mapillary_tools/camm/camm_parser.py

@@ -1,5 +1,6 @@
 # pyre-ignore-all-errors[5, 11, 16, 21, 24, 58]
 
+import abc
 import dataclasses
 import io
 import logging
@@ -19,9 +20,7 @@ LOG = logging.getLogger(__name__)
 
 TelemetryMeasurement = T.Union[
     geo.Point,
-    telemetry.AccelerationData,
-    telemetry.GyroscopeData,
-    telemetry.MagnetometerData,
+    telemetry.TelemetryMeasurement,
 ]
 
 
@@ -36,100 +35,320 @@ class CAMMType(Enum):
     GPS = 6
     MAGNETIC_FIELD = 7
 
+    # Mapillary extensions are offset by 1024
+    # GoPro GPS is not compatible with CAMMType.GPS,
+    # so we use a new type to represent it
+    MLY_GOPRO_GPS = 1024 + 6
+
 
 # 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,
-    ),
-)
+TTelemetry = T.TypeVar("TTelemetry", bound=TelemetryMeasurement)
 
 
-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:
+class CAMMSampleEntry(abc.ABC, T.Generic[TTelemetry]):
+    camm_type: CAMMType
+
+    construct: C.Struct
+
+    telemetry_cls: T.Type[TTelemetry]
+
+    @classmethod
+    def serializable(cls, data: T.Any, throw: bool = False) -> bool:
+        # Use "is" for exact type match, instead of isinstance
+        if type(data) is cls.telemetry_cls:
+            return True
+
+        if throw:
+            raise TypeError(
+                f"{cls} can not serialize {type(data)}: expect {cls.telemetry_cls}"
+            )
+        return False
+
+    @classmethod
+    @abc.abstractmethod
+    def serialize(cls, data: TTelemetry) -> bytes:
+        raise NotImplementedError
+
+    @classmethod
+    @abc.abstractmethod
+    def deserialize(cls, sample: Sample, data: T.Any) -> TTelemetry:
+        raise NotImplementedError
+
+
+class MinGPSSampleEntry(CAMMSampleEntry):
+    camm_type = CAMMType.MIN_GPS
+
+    construct = Double[3]  # type: ignore
+
+    telemetry_cls = geo.Point
+
+    @classmethod
+    def deserialize(cls, sample: Sample, data: T.Any) -> geo.Point:
         return geo.Point(
             time=sample.exact_time,
-            lat=box.data[0],
-            lon=box.data[1],
-            alt=box.data[2],
+            lat=data[0],
+            lon=data[1],
+            alt=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(
+
+    @classmethod
+    def serialize(cls, data: geo.Point) -> bytes:
+        cls.serializable(data, throw=True)
+
+        return CAMMSampleData.build(
+            {
+                "type": cls.camm_type.value,
+                "data": [
+                    data.lat,
+                    data.lon,
+                    -1.0 if data.alt is None else data.alt,
+                ],
+            }
+        )
+
+
+class GPSSampleEntry(CAMMSampleEntry):
+    camm_type: CAMMType = CAMMType.GPS
+
+    construct = C.Struct(
+        "time_gps_epoch" / Double,  # type: ignore
+        "gps_fix_type" / C.Int32sl,  # type: ignore
+        "latitude" / Double,  # type: ignore
+        "longitude" / Double,  # type: ignore
+        "altitude" / Float,  # type: ignore
+        "horizontal_accuracy" / Float,  # type: ignore
+        "vertical_accuracy" / Float,  # type: ignore
+        "velocity_east" / Float,  # type: ignore
+        "velocity_north" / Float,  # type: ignore
+        "velocity_up" / Float,  # type: ignore
+        "speed_accuracy" / Float,  # type: ignore
+    )
+
+    telemetry_cls = telemetry.CAMMGPSPoint
+
+    @classmethod
+    def deserialize(cls, sample: Sample, data: T.Any) -> telemetry.CAMMGPSPoint:
+        return telemetry.CAMMGPSPoint(
             time=sample.exact_time,
-            lat=box.data.latitude,
-            lon=box.data.longitude,
-            alt=box.data.altitude,
+            lat=data.latitude,
+            lon=data.longitude,
+            alt=data.altitude,
             angle=None,
+            time_gps_epoch=data.time_gps_epoch,
+            gps_fix_type=data.gps_fix_type,
+            horizontal_accuracy=data.horizontal_accuracy,
+            vertical_accuracy=data.vertical_accuracy,
+            velocity_east=data.velocity_east,
+            velocity_north=data.velocity_north,
+            velocity_up=data.velocity_up,
+            speed_accuracy=data.speed_accuracy,
+        )
+
+    @classmethod
+    def serialize(cls, data: telemetry.CAMMGPSPoint) -> bytes:
+        cls.serializable(data, throw=True)
+
+        return CAMMSampleData.build(
+            {
+                "type": cls.camm_type.value,
+                "data": {
+                    "time_gps_epoch": data.time_gps_epoch,
+                    "gps_fix_type": data.gps_fix_type,
+                    "latitude": data.lat,
+                    "longitude": data.lon,
+                    "altitude": -1.0 if data.alt is None else data.alt,
+                    "horizontal_accuracy": data.horizontal_accuracy,
+                    "vertical_accuracy": data.vertical_accuracy,
+                    "velocity_east": data.velocity_east,
+                    "velocity_north": data.velocity_north,
+                    "velocity_up": data.velocity_up,
+                    "speed_accuracy": data.speed_accuracy,
+                },
+            }
+        )
+
+
+class GoProGPSSampleEntry(CAMMSampleEntry):
+    camm_type: CAMMType = CAMMType.MLY_GOPRO_GPS
+
+    construct = C.Struct(
+        "latitude" / Double,  # type: ignore
+        "longitude" / Double,  # type: ignore
+        "altitude" / Float,  # type: ignore
+        "epoch_time" / Double,  # type: ignore
+        "fix" / C.Int32sl,  # type: ignore
+        "precision" / Float,  # type: ignore
+        "ground_speed" / Float,  # type: ignore
+    )
+
+    telemetry_cls = telemetry.GPSPoint
+
+    @classmethod
+    def deserialize(cls, sample: Sample, data: T.Any) -> telemetry.GPSPoint:
+        return telemetry.GPSPoint(
+            time=sample.exact_time,
+            lat=data.latitude,
+            lon=data.longitude,
+            alt=data.altitude,
+            angle=None,
+            epoch_time=data.epoch_time,
+            fix=telemetry.GPSFix(data.fix),
+            precision=data.precision,
+            ground_speed=data.ground_speed,
+        )
+
+    @classmethod
+    def serialize(cls, data: telemetry.GPSPoint) -> bytes:
+        cls.serializable(data, throw=True)
+
+        if data.fix is None:
+            gps_fix = telemetry.GPSFix.NO_FIX.value
+        else:
+            gps_fix = data.fix.value
+
+        return CAMMSampleData.build(
+            {
+                "type": cls.camm_type.value,
+                "data": {
+                    "latitude": data.lat,
+                    "longitude": data.lon,
+                    "altitude": -1.0 if data.alt is None else data.alt,
+                    "epoch_time": data.epoch_time,
+                    "fix": gps_fix,
+                    "precision": data.precision,
+                    "ground_speed": data.ground_speed,
+                },
+            }
         )
-    elif box.type == CAMMType.ACCELERATION.value:
+
+
+class AccelerationSampleEntry(CAMMSampleEntry):
+    camm_type: CAMMType = CAMMType.ACCELERATION
+
+    construct: C.Struct = Float[3]  # type: ignore
+
+    telemetry_cls = telemetry.AccelerationData
+
+    @classmethod
+    def deserialize(cls, sample: Sample, data: T.Any) -> telemetry.AccelerationData:
         return telemetry.AccelerationData(
             time=sample.exact_time,
-            x=box.data[0],
-            y=box.data[1],
-            z=box.data[2],
+            x=data[0],
+            y=data[1],
+            z=data[2],
         )
-    elif box.type == CAMMType.GYRO.value:
+
+    @classmethod
+    def serialize(cls, data: telemetry.AccelerationData) -> bytes:
+        cls.serializable(data, throw=True)
+
+        return CAMMSampleData.build(
+            {
+                "type": cls.camm_type.value,
+                "data": [data.x, data.y, data.z],
+            }
+        )
+
+
+class GyroscopeSampleEntry(CAMMSampleEntry):
+    camm_type: CAMMType = CAMMType.GYRO
+
+    construct: C.Struct = Float[3]  # type: ignore
+
+    telemetry_cls = telemetry.GyroscopeData
+
+    @classmethod
+    def deserialize(cls, sample: Sample, data: T.Any) -> telemetry.GyroscopeData:
         return telemetry.GyroscopeData(
             time=sample.exact_time,
-            x=box.data[0],
-            y=box.data[1],
-            z=box.data[2],
+            x=data[0],
+            y=data[1],
+            z=data[2],
         )
-    elif box.type == CAMMType.MAGNETIC_FIELD.value:
+
+    @classmethod
+    def serialize(cls, data: telemetry.GyroscopeData) -> bytes:
+        cls.serializable(data)
+
+        return CAMMSampleData.build(
+            {
+                "type": cls.camm_type.value,
+                "data": [data.x, data.y, data.z],
+            }
+        )
+
+
+class MagnetometerSampleEntry(CAMMSampleEntry):
+    camm_type: CAMMType = CAMMType.MAGNETIC_FIELD
+
+    construct: C.Struct = Float[3]  # type: ignore
+
+    telemetry_cls = telemetry.MagnetometerData
+
+    @classmethod
+    def deserialize(cls, sample: Sample, data: T.Any) -> telemetry.MagnetometerData:
         return telemetry.MagnetometerData(
             time=sample.exact_time,
-            x=box.data[0],
-            y=box.data[1],
-            z=box.data[2],
+            x=data[0],
+            y=data[1],
+            z=data[2],
         )
-    return None
+
+    @classmethod
+    def serialize(cls, data: telemetry.MagnetometerData) -> bytes:
+        cls.serializable(data)
+
+        return CAMMSampleData.build(
+            {
+                "type": cls.camm_type.value,
+                "data": [data.x, data.y, data.z],
+            }
+        )
+
+
+SAMPLE_ENTRY_CLS_BY_CAMM_TYPE = {
+    sample_entry_cls.camm_type: sample_entry_cls
+    for sample_entry_cls in CAMMSampleEntry.__subclasses__()
+}
+assert len(SAMPLE_ENTRY_CLS_BY_CAMM_TYPE) == 6, SAMPLE_ENTRY_CLS_BY_CAMM_TYPE.keys()
+
+
+_SWITCH: T.Dict[int, C.Struct] = {
+    # angle_axis
+    CAMMType.ANGLE_AXIS.value: Float[3],  # type: ignore
+    CAMMType.EXPOSURE_TIME.value: C.Struct(
+        "pixel_exposure_time" / C.Int32sl,  # type: ignore
+        "rolling_shutter_skew_time" / C.Int32sl,  # type: ignore
+    ),
+    # position
+    CAMMType.POSITION.value: Float[3],  # type: ignore
+    **{t.value: cls.construct for t, cls in SAMPLE_ENTRY_CLS_BY_CAMM_TYPE.items()},
+}
+
+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)
+
+    camm_type = CAMMType(box.type)  # type: ignore
+    SampleKlass = SAMPLE_ENTRY_CLS_BY_CAMM_TYPE.get(camm_type)
+    if SampleKlass is None:
+        return None
+    return SampleKlass.deserialize(sample, box.data)
 
 
 def _filter_telemetry_by_elst_segments(

mapillary_tools/geotag/geotag_images_from_gpx_file.py

@@ -25,7 +25,13 @@ class GeotagImagesFromGPXFile(GeotagImagesFromGeneric):
         num_processes: T.Optional[int] = None,
     ):
         super().__init__()
-        tracks = parse_gpx(source_path)
+        try:
+            tracks = parse_gpx(source_path)
+        except Exception as ex:
+            raise RuntimeError(
+                f"Error parsing GPX {source_path}: {ex.__class__.__name__}: {ex}"
+            )
+
         if 1 < len(tracks):
             LOG.warning(
                 "Found %s tracks in the GPX file %s. Will merge points in all the tracks as a single track for interpolation",

mapillary_tools/geotag/gpmf_parser.py

@@ -252,9 +252,24 @@ def _gps9_timestamp_to_epoch_time(
     return epoch_time
 
 
+def _get_gps_type(input) -> bytes:
+    final = b""
+    for val in input or []:
+        if isinstance(val, bytes):
+            final += val
+        elif isinstance(val, list):
+            final += _get_gps_type(val)
+        else:
+            raise ValueError(f"Unexpected type {type(val)} in {input}")
+
+    return final
+
+
 def gps9_from_stream(
     stream: T.Sequence[KLVDict],
 ) -> T.Generator[GPSPoint, None, None]:
+    NUM_VALUES = 9
+
     indexed: T.Dict[bytes, T.List[T.List[T.Any]]] = {
         klv["key"]: klv["data"] for klv in stream
     }
@@ -270,17 +285,25 @@ def gps9_from_stream(
     if any(s == 0 for s in scal_values):
         return
 
-    type = indexed.get(b"TYPE")
-    if type is None:
+    gps_value_types = _get_gps_type(indexed.get(b"TYPE"))
+    if not gps_value_types:
         return
-    gps_value_types = type[0]
+
+    if len(gps_value_types) != NUM_VALUES:
+        raise ValueError(
+            f"Error parsing the complex type {gps_value_types!r}: expect {NUM_VALUES} types but got {len(gps_value_types)}"
+        )
 
     try:
         sample_parser = C.Sequence(
-            *[_type_mapping[t.to_bytes()][0] for t in gps_value_types]
+            *[
+                # Changed in version 3.11: Added default argument values for length and byteorder
+                _type_mapping[t.to_bytes(length=1, byteorder="big")][0]
+                for t in gps_value_types
+            ]
         )
     except Exception as ex:
-        raise ValueError(f"Error parsing the complex type {gps_value_types}: {ex}")
+        raise ValueError(f"Error parsing the complex type {gps_value_types!r}: {ex}")
 
     for sample_data_bytes in gps9:
         sample_data = sample_parser.parse(sample_data_bytes)

mapillary_tools/telemetry.py

@@ -12,14 +12,6 @@ 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.
@@ -32,6 +24,26 @@ 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/upload.py

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

mapillary_tools/video_data_extraction/extractors/camm_parser.py

@@ -13,8 +13,12 @@ class CammParser(BaseParser):
     parser_label = "camm"
 
     @functools.cached_property
-    def __camera_info(self) -> T.Tuple[str, str]:
-        with self.videoPath.open("rb") as fp:
+    def _camera_info(self) -> T.Tuple[str, str]:
+        source_path = self.geotag_source_path
+        if not source_path:
+            return "", ""
+
+        with source_path.open("rb") as fp:
             return camm_parser.extract_camera_make_and_model(fp)
 
     def extract_points(self) -> T.Sequence[geo.Point]:
@@ -28,15 +32,7 @@ class CammParser(BaseParser):
                 return []
 
     def extract_make(self) -> T.Optional[str]:
-        source_path = self.geotag_source_path
-        if not source_path:
-            return None
-        with source_path.open("rb") as _fp:
-            return self.__camera_info[0] or None
+        return self._camera_info[0] or None
 
     def extract_model(self) -> T.Optional[str]:
-        source_path = self.geotag_source_path
-        if not source_path:
-            return None
-        with source_path.open("rb") as _fp:
-            return self.__camera_info[1] or None
+        return self._camera_info[1] or None

mapillary_tools/video_data_extraction/extractors/gpx_parser.py

@@ -20,7 +20,13 @@ class GpxParser(BaseParser):
         if not path:
             return []
 
-        gpx_tracks = geotag_images_from_gpx_file.parse_gpx(path)
+        try:
+            gpx_tracks = geotag_images_from_gpx_file.parse_gpx(path)
+        except Exception as ex:
+            raise RuntimeError(
+                f"Error parsing GPX {path}: {ex.__class__.__name__}: {ex}"
+            )
+
         if 1 < len(gpx_tracks):
             LOG.warning(
                 "Found %s tracks in the GPX file %s. Will merge points in all the tracks as a single track for interpolation",
@@ -32,40 +38,71 @@ class GpxParser(BaseParser):
         if not gpx_points:
             return gpx_points
 
+        offset = self._synx_gpx_by_first_gps_timestamp(gpx_points)
+
+        self._rebase_times(gpx_points, offset=offset)
+
+        return gpx_points
+
+    def _synx_gpx_by_first_gps_timestamp(
+        self, gpx_points: T.Sequence[geo.Point]
+    ) -> float:
+        offset: float = 0.0
+
+        if not gpx_points:
+            return offset
+
         first_gpx_dt = datetime.datetime.fromtimestamp(
             gpx_points[0].time, tz=datetime.timezone.utc
         )
         LOG.info("First GPX timestamp: %s", first_gpx_dt)
 
         # Extract first GPS timestamp (if found) for synchronization
-        offset: float = 0.0
-        parser = GenericVideoParser(self.videoPath, self.options, self.parserOptions)
+        # Use an empty dictionary to force video parsers to extract make/model from the video metadata itself
+        parser = GenericVideoParser(self.videoPath, self.options, {})
         gps_points = parser.extract_points()
-        if gps_points:
-            first_gps_point = gps_points[0]
-            if isinstance(first_gps_point, telemetry.GPSPoint):
-                if first_gps_point.epoch_time is not None:
-                    first_gps_dt = datetime.datetime.fromtimestamp(
-                        first_gps_point.epoch_time, tz=datetime.timezone.utc
-                    )
-                    LOG.info("First GPS timestamp: %s", first_gps_dt)
-                    offset = gpx_points[0].time - first_gps_point.epoch_time
-                    if offset:
-                        LOG.warning(
-                            "Found offset between GPX %s and video GPS timestamps %s: %s seconds",
-                            first_gpx_dt,
-                            first_gps_dt,
-                            offset,
-                        )
 
-        self._rebase_times(gpx_points, offset=offset)
+        if not gps_points:
+            LOG.warning(
+                "Skip GPX synchronization because no GPS found in video %s",
+                self.videoPath,
+            )
+            return offset
 
-        return gpx_points
+        first_gps_point = gps_points[0]
+        if isinstance(first_gps_point, telemetry.GPSPoint):
+            if first_gps_point.epoch_time is not None:
+                first_gps_dt = datetime.datetime.fromtimestamp(
+                    first_gps_point.epoch_time, tz=datetime.timezone.utc
+                )
+                LOG.info("First GPS timestamp: %s", first_gps_dt)
+                offset = gpx_points[0].time - first_gps_point.epoch_time
+                if offset:
+                    LOG.warning(
+                        "Found offset between GPX %s and video GPS timestamps %s: %s seconds",
+                        first_gpx_dt,
+                        first_gps_dt,
+                        offset,
+                    )
+                else:
+                    LOG.info(
+                        "GPX and GPS are perfectly synchronized (all starts from %s)",
+                        first_gpx_dt,
+                    )
+            else:
+                LOG.warning(
+                    "Skip GPX synchronization because no GPS epoch time found in video %s",
+                    self.videoPath,
+                )
+
+        return offset
 
     def extract_make(self) -> T.Optional[str]:
-        parser = GenericVideoParser(self.videoPath, self.options, self.parserOptions)
+        # Use an empty dictionary to force video parsers to extract make/model from the video metadata itself
+        parser = GenericVideoParser(self.videoPath, self.options, {})
         return parser.extract_make()
 
     def extract_model(self) -> T.Optional[str]:
-        parser = GenericVideoParser(self.videoPath, self.options, self.parserOptions)
+        # Use an empty dictionary to force video parsers to extract make/model from the video metadata itself
+        parser = GenericVideoParser(self.videoPath, self.options, {})
         return parser.extract_model()

{mapillary_tools-0.13.0.dist-info → mapillary_tools-0.13.1.dist-info}/METADATA

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

{mapillary_tools-0.13.0.dist-info → mapillary_tools-0.13.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-mapillary_tools/__init__.py,sha256=hZfMXyZ8nUrpqLa-dZCy9tXhu5fH1SZJKEGUd0caUDw,19
+mapillary_tools/__init__.py,sha256=XBFY-aPf1nqJ7U8CvnYiXTRu3uDJLRQjOxibBTi-54U,19
 mapillary_tools/api_v4.py,sha256=zhRtgx3EnzgqtjziRhvFq3ONvsPaB9hROsuKFcf_pFo,5197
 mapillary_tools/authenticate.py,sha256=LCFcs6LqZmXaYkTUEKgGfmqytWdh5v_L3KXB48ojOZ4,3090
 mapillary_tools/config.py,sha256=jCjaK4jJaTY4AV4qf_b_tcxn5LA_uPsEWlGIdm2zw6g,2103
@@ -15,14 +15,14 @@ mapillary_tools/ipc.py,sha256=DwWQb9hNshx0bg0Fo5NjY0mXjs-FkbR6tIQmjMgMtmg,1089
 mapillary_tools/process_geotag_properties.py,sha256=w4hhv_c4sRydCK9QCO50sT2yo2zeVlY7dSdXQ93InFc,23159
 mapillary_tools/process_sequence_properties.py,sha256=5oYEjz9crnLVQtCkxbwn57TkeuHFbBh_zQXQSA4ENWg,11561
 mapillary_tools/sample_video.py,sha256=dpdX7bUNEmcrz-3gh3Y3awnTDX66pChbTKuF8qGfeCI,14400
-mapillary_tools/telemetry.py,sha256=WpBGPF_GMPjM_EFqXIutFtpDFL9wj7yEzGNGnfQZUo8,1255
+mapillary_tools/telemetry.py,sha256=3a7MvTH4Rr_mXp2NInubPIS8JFOuBeQC7PC2prfXNfI,1559
 mapillary_tools/types.py,sha256=6kww2UdKM6YzabYbc862BYzEWtxL2hhxCRFfeDiUtF0,22074
-mapillary_tools/upload.py,sha256=8dQ3ZWsjau1_xZN3ssjGGkBnLKbKIhjC91-zWstYlD8,24439
+mapillary_tools/upload.py,sha256=ab1WEut6qv352njWKtNbUXmV8KShlApOjcwb1FpcC_Q,24439
 mapillary_tools/upload_api_v4.py,sha256=1WvoUis92KDXbqfoyvyyDmiCqwXezYkMJZhnYaVm3BA,8560
 mapillary_tools/uploader.py,sha256=VieDKi51wdXTIhN7x_mcuQeHESUyFlF5cgB-TAnF4g0,14093
 mapillary_tools/utils.py,sha256=VNtK1tAb3Hh8y3P5e5Y3iewREkIoLDa3C2myRYcF2lY,5970
-mapillary_tools/camm/camm_builder.py,sha256=TXZfhu3xGjtrLEWnB14D7aSOrHOoSJef24YSLApiIfY,10631
-mapillary_tools/camm/camm_parser.py,sha256=RaCWeLvS_AyHD6B6wDUu9DAsdfByVHMAPTqEqjtFibE,9734
+mapillary_tools/camm/camm_builder.py,sha256=x4WF-n6zOEUhK1Poo7du004-7DQhjnf598ZNfM3r7iA,9075
+mapillary_tools/camm/camm_parser.py,sha256=ARwImVcXY1FckCnPLPoyYAuODJb5iZI0hlQurAIeiWQ,16473
 mapillary_tools/commands/__init__.py,sha256=41CFrPLGlG3566uhxssEF3TGAtSpADFPPcDMHbViU0E,171
 mapillary_tools/commands/__main__.py,sha256=VdWkx1ekPH-88Ybe78IcO9FWpZ5cUhsbGRw7LuzQObU,4832
 mapillary_tools/commands/authenticate.py,sha256=4aVvAQal_mqtm2NEMBt5aKLahi0iRdO8b7WSBf6jokA,1136
@@ -40,13 +40,13 @@ mapillary_tools/geotag/geotag_images_from_exif.py,sha256=hCgBwZABk2tbBQC3cHQBV5p
 mapillary_tools/geotag/geotag_images_from_exiftool.py,sha256=a-c4H8VIyPdJkfUIvJho0phR0QU0zN8-lSyiCz0wc4s,3981
 mapillary_tools/geotag/geotag_images_from_exiftool_both_image_and_video.py,sha256=nRVAjgTJwx_eCaSBpPCgcIaZs3EYgGueYxSS9XhKv40,3350
 mapillary_tools/geotag/geotag_images_from_gpx.py,sha256=S9Pw6FvP5kRSpHUnKUYKXmw0CHa9V92UmrS_MJfbjS4,9053
-mapillary_tools/geotag/geotag_images_from_gpx_file.py,sha256=zEbC0kVf_iw9ioIyJLL-gYN_QvAOEdAoEczCBkizl38,5122
+mapillary_tools/geotag/geotag_images_from_gpx_file.py,sha256=-vTbZ1HufZzJCd8VvukdTjsJRcymtfld2W5t65VSG5E,5300
 mapillary_tools/geotag/geotag_images_from_nmea_file.py,sha256=dDdHnJInQ_WN3ZRf-w44NSBElDLPs7XYBiimvE2iCNo,1651
 mapillary_tools/geotag/geotag_images_from_video.py,sha256=XsaWOFChGItl-j1UbKM4hNjUqN29pVNbMpGT_BvI-o8,3306
 mapillary_tools/geotag/geotag_videos_from_exiftool_video.py,sha256=fkkWou1WFt3ft024399vis9No2cxrwot7Pg5HBw7o7s,5225
 mapillary_tools/geotag/geotag_videos_from_video.py,sha256=mqBZKUEkqT96nOzl5LJxzzTKuKsnAkMK5lH8k3oY3YE,7330
 mapillary_tools/geotag/gpmf_gps_filter.py,sha256=7cg8wEjC1DrujKY76FZguXsaPqTRkG9-t32OeuOJQIc,2755
-mapillary_tools/geotag/gpmf_parser.py,sha256=yAXzFAlj4VsbFju-kNDBxhT1K6kfmZL37lrM26Xkg0M,22514
+mapillary_tools/geotag/gpmf_parser.py,sha256=6Q38oeSd2kHTs44Fzpg9R555EbQqdd5QcIuIZdG4z_o,23233
 mapillary_tools/geotag/gps_filter.py,sha256=4CPL8glxdzPWIbfGPPgyqMLyiZFt-djce5vhiFPuZB8,3766
 mapillary_tools/geotag/utils.py,sha256=Orl35Df4ypxj4v6Lu1Mhk9d2XZxa8yNffz1s1C0JZsQ,651
 mapillary_tools/mp4/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -60,16 +60,16 @@ mapillary_tools/video_data_extraction/extract_video_data.py,sha256=_2BBdSYeYKR4B
 mapillary_tools/video_data_extraction/video_data_parser_factory.py,sha256=qaJHvLgwI5lukJncMd8ggxeSxXOiVzBSJO5GlGQYiXY,1134
 mapillary_tools/video_data_extraction/extractors/base_parser.py,sha256=s7Xuwg4I5JZ27oL4ebMSdo093plAXfZ-6uDQ_h97WHY,2134
 mapillary_tools/video_data_extraction/extractors/blackvue_parser.py,sha256=jAcGyF6PML2EdJ4zle8cR12QeTRZc5qxlz8_4gcTZPU,1089
-mapillary_tools/video_data_extraction/extractors/camm_parser.py,sha256=sr8oDbC9lGyHHp8qkpQBmWOf4U_umlokaJM0kPVKgzw,1314
+mapillary_tools/video_data_extraction/extractors/camm_parser.py,sha256=YMiViocXSVlfn8_qm1jcwSJhnnEaK8v5ADHwo2YXe10,1117
 mapillary_tools/video_data_extraction/extractors/exiftool_runtime_parser.py,sha256=PFNCRk9pGrPIfVwLMcnzmVNMITVjNHhbrOOMwxaSstg,2270
 mapillary_tools/video_data_extraction/extractors/exiftool_xml_parser.py,sha256=Tt0h4TiCKocERWMlRXzlpoaA_WJ_4b20MgMLGYNl4AM,1734
 mapillary_tools/video_data_extraction/extractors/generic_video_parser.py,sha256=34O6Km5kNDoJNJtIUOwtAzzMntuqkSZJfeli7caWSkA,1693
 mapillary_tools/video_data_extraction/extractors/gopro_parser.py,sha256=IVnTyquSraTUaG9rxbJfVWc1-drdY5PaHn5urh3IBk4,1325
-mapillary_tools/video_data_extraction/extractors/gpx_parser.py,sha256=FRysFhN2aa0MGnzLO7pcZkwo8790GUelIZg9pddZvic,2594
+mapillary_tools/video_data_extraction/extractors/gpx_parser.py,sha256=FNrdnXl48k8I1I5fGwYsClhfFEHVsooRLRboUYECv3I,3811
 mapillary_tools/video_data_extraction/extractors/nmea_parser.py,sha256=raSXavBvP-0LJCB_TwLL0mOv2uHSsB744igTsaKAaGc,658
-mapillary_tools-0.13.0.dist-info/LICENSE,sha256=l2D8cKfFmmJq_wcVq_JElPJrlvWQOzNWx7gMLINucxc,1292
-mapillary_tools-0.13.0.dist-info/METADATA,sha256=IjaJljFtCVqGSVhabQ2MptJlan76aUoGLulB1ecs9-E,19758
-mapillary_tools-0.13.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapillary_tools-0.13.0.dist-info/entry_points.txt,sha256=A3f3LP-BO_P-U8Y29QfpT4jx6Mjk3sXjTi2Yew4bvj8,75
-mapillary_tools-0.13.0.dist-info/top_level.txt,sha256=FbDkMgOrt1S70ho1WSBrOwzKOSkJFDwwqFOoY5-527s,16
-mapillary_tools-0.13.0.dist-info/RECORD,,
+mapillary_tools-0.13.1.dist-info/LICENSE,sha256=l2D8cKfFmmJq_wcVq_JElPJrlvWQOzNWx7gMLINucxc,1292
+mapillary_tools-0.13.1.dist-info/METADATA,sha256=K1pmlXXrkP_o1qFddzeG6RyXGt6HqVKhU8aLhIVUK_w,19758
+mapillary_tools-0.13.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapillary_tools-0.13.1.dist-info/entry_points.txt,sha256=A3f3LP-BO_P-U8Y29QfpT4jx6Mjk3sXjTi2Yew4bvj8,75
+mapillary_tools-0.13.1.dist-info/top_level.txt,sha256=FbDkMgOrt1S70ho1WSBrOwzKOSkJFDwwqFOoY5-527s,16
+mapillary_tools-0.13.1.dist-info/RECORD,,