mapillary-tools 0.12.1__py3-none-any.whl → 0.13.1a1__py3-none-any.whl

mapillary_tools/{geotag → camm}/camm_parser.py

@@ -9,17 +9,22 @@ from enum import Enum
 
 import construct as C
 
-from . import (
-    construct_mp4_parser as cparser,
-    geo,
-    mp4_sample_parser as sample_parser,
-    simple_mp4_parser as parser,
-)
+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
@@ -79,15 +84,15 @@ CAMMSampleData = C.Struct(
 )
 
 
-def _parse_point_from_sample(
-    fp: T.BinaryIO, sample: sample_parser.Sample
-) -> T.Optional[geo.Point]:
-    fp.seek(sample.offset, io.SEEK_SET)
-    data = fp.read(sample.size)
+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.time_offset,
+            time=sample.exact_time,
             lat=box.data[0],
             lon=box.data[1],
             alt=box.data[2],
@@ -97,18 +102,40 @@ def _parse_point_from_sample(
         # Not using box.data.time_gps_epoch as the point timestamp
         # because it is from another clock
         return geo.Point(
-            time=sample.time_offset,
+            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_points_by_elst(
-    points: T.Iterable[geo.Point], elst: T.Sequence[T.Tuple[float, float]]
-) -> T.Generator[geo.Point, None, 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]
@@ -118,20 +145,20 @@ def filter_points_by_elst(
     elst = [entry for entry in elst if entry[0] != -1]
 
     if not elst:
-        for p in points:
-            yield dataclasses.replace(p, time=p.time + offset)
+        for m in measurements:
+            yield dataclasses.replace(m, time=m.time + offset)
         return
 
     elst.sort(key=lambda entry: entry[0])
     elst_idx = 0
-    for p in points:
+    for m in measurements:
         if len(elst) <= elst_idx:
             break
         media_time, duration = elst[elst_idx]
-        if p.time < media_time:
+        if m.time < media_time:
             pass
-        elif p.time <= media_time + duration:
-            yield dataclasses.replace(p, time=p.time + offset)
+        elif m.time <= media_time + duration:
+            yield dataclasses.replace(m, time=m.time + offset)
         else:
             elst_idx += 1
 
@@ -148,15 +175,45 @@ def elst_entry_to_seconds(
     return (media_time, duration)
 
 
-def _extract_camm_samples(
-    s: T.BinaryIO,
-    maxsize: int = -1,
-) -> T.Generator[sample_parser.Sample, None, None]:
-    samples = sample_parser.parse_samples_from_trak(s, maxsize=maxsize)
-    camm_samples = (
-        sample for sample in samples if sample.description["format"] == b"camm"
-    )
-    yield from camm_samples
+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]]:
@@ -165,62 +222,41 @@ def extract_points(fp: T.BinaryIO) -> T.Optional[T.List[geo.Point]]:
     otherwise None
     """
 
-    points = None
-    movie_timescale = None
-    media_timescale = None
-    elst_entries = None
+    moov = MovieBoxParser.parse_stream(fp)
 
-    for h, s in parser.parse_path(fp, [b"moov", [b"mvhd", b"trak"]]):
-        if h.type == b"trak":
-            trak_start_offset = s.tell()
+    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)]
 
-            descriptions = sample_parser.parse_descriptions_from_trak(
-                s, maxsize=h.maxsize
+            return T.cast(
+                T.List[geo.Point], _filter_telemetry_by_track_elst(moov, track, points)
             )
-            camm_descriptions = [d for d in descriptions if d["format"] == b"camm"]
-            if camm_descriptions:
-                s.seek(trak_start_offset, io.SEEK_SET)
-                camm_samples = _extract_camm_samples(s, h.maxsize)
-
-                points_with_nones = (
-                    _parse_point_from_sample(fp, sample)
-                    for sample in camm_samples
-                    if sample.description["format"] == b"camm"
-                )
 
-                points = [p for p in points_with_nones if p is not None]
-                if points:
-                    s.seek(trak_start_offset)
-                    elst_data = parser.parse_box_data_first(
-                        s, [b"edts", b"elst"], maxsize=h.maxsize
-                    )
-                    if elst_data is not None:
-                        elst_entries = cparser.EditBox.parse(elst_data)["entries"]
-
-                    s.seek(trak_start_offset)
-                    mdhd_data = parser.parse_box_data_firstx(
-                        s, [b"mdia", b"mdhd"], maxsize=h.maxsize
-                    )
-                    mdhd = cparser.MediaHeaderBox.parse(mdhd_data)
-                    media_timescale = mdhd["timescale"]
-        else:
-            assert h.type == b"mvhd"
-            if not movie_timescale:
-                mvhd = cparser.MovieHeaderBox.parse(s.read(h.maxsize))
-                movie_timescale = mvhd["timescale"]
+    return None
 
-        # exit when both found
-        if movie_timescale is not None and points:
-            break
 
-    if points and movie_timescale and media_timescale and elst_entries:
-        segments = [
-            elst_entry_to_seconds(entry, movie_timescale, media_timescale)
-            for entry in elst_entries
-        ]
-        points = list(filter_points_by_elst(points, segments))
+def extract_telemetry_data(fp: T.BinaryIO) -> T.Optional[T.List[TelemetryMeasurement]]:
+    moov = MovieBoxParser.parse_stream(fp)
 
-    return points
+    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]:
@@ -238,7 +274,7 @@ MakeOrModel = C.Struct(
 )
 
 
-def _decode_quietly(data: bytes, h: parser.Header) -> str:
+def _decode_quietly(data: bytes, h: sparser.Header) -> str:
     try:
         return data.decode("utf-8")
     except UnicodeDecodeError:
@@ -246,7 +282,7 @@ def _decode_quietly(data: bytes, h: parser.Header) -> str:
         return ""
 
 
-def _parse_quietly(data: bytes, h: parser.Header) -> bytes:
+def _parse_quietly(data: bytes, h: sparser.Header) -> bytes:
     try:
         parsed = MakeOrModel.parse(data)
     except C.ConstructError:
@@ -256,7 +292,7 @@ def _parse_quietly(data: bytes, h: parser.Header) -> bytes:
 
 
 def extract_camera_make_and_model(fp: T.BinaryIO) -> T.Tuple[str, str]:
-    header_and_stream = parser.parse_path(
+    header_and_stream = sparser.parse_path(
         fp,
         [
             b"moov",
@@ -296,7 +332,7 @@ def extract_camera_make_and_model(fp: T.BinaryIO) -> T.Tuple[str, str]:
             # quit when both found
             if make and model:
                 break
-    except parser.ParsingError:
+    except sparser.ParsingError:
         pass
 
     if make:

mapillary_tools/commands/__init__.py

@@ -5,7 +5,6 @@ from . import (
     process_and_upload,
     sample_video,
     upload,
-    upload_camm,
     video_process,
     video_process_and_upload,
 )

mapillary_tools/commands/__main__.py

@@ -12,9 +12,6 @@ from . import (
     process_and_upload,
     sample_video,
     upload,
-    upload_blackvue,
-    upload_camm,
-    upload_zip,
     video_process,
     video_process_and_upload,
     zip,
@@ -23,9 +20,6 @@ from . import (
 mapillary_tools_commands = [
     process,
     upload,
-    upload_camm,
-    upload_blackvue,
-    upload_zip,
     sample_video,
     video_process,
     authenticate,

mapillary_tools/commands/process.py

@@ -10,7 +10,6 @@ from ..process_geotag_properties import (
     process_finalize,
     process_geotag_properties,
 )
-from ..process_import_meta_properties import process_import_meta_properties
 from ..process_sequence_properties import process_sequence_properties
 
 
@@ -107,44 +106,6 @@ class Command:
             default=None,
             required=False,
         )
-        group_metadata.add_argument(
-            "--add_file_name",
-            help="[DEPRECATED since v0.9.4] Add original file name to EXIF.",
-            action="store_true",
-            required=False,
-        )
-        group_metadata.add_argument(
-            "--add_import_date",
-            help="[DEPRECATED since v0.10.0] Add import date.",
-            action="store_true",
-            required=False,
-        )
-        group_metadata.add_argument(
-            "--orientation",
-            help="Specify the image orientation in degrees. Note this might result in image rotation. Note this input has precedence over the input read from the import source file.",
-            choices=[0, 90, 180, 270],
-            type=int,
-            default=None,
-            required=False,
-        )
-        group_metadata.add_argument(
-            "--GPS_accuracy",
-            help="GPS accuracy in meters. Note this input has precedence over the input read from the import source file.",
-            default=None,
-            required=False,
-        )
-        group_metadata.add_argument(
-            "--camera_uuid",
-            help="Custom string used to differentiate different captures taken with the same camera make and model.",
-            default=None,
-            required=False,
-        )
-        group_metadata.add_argument(
-            "--custom_meta_data",
-            help='[DEPRECATED since v0.10.0] Add custom meta data to all images. Required format of input is a string, consisting of the meta data name, type and value, separated by a comma for each entry, where entries are separated by semicolon. Supported types are long, double, string, boolean, date. Example for two meta data entries "random_name1,double,12.34;random_name2,long,1234".',
-            default=None,
-            required=False,
-        )
 
         group_geotagging = parser.add_argument_group(
             f"{constants.ANSI_BOLD}PROCESS GEOTAGGING OPTIONS{constants.ANSI_RESET_ALL}"
@@ -278,17 +239,6 @@ class Command:
             ),
         )
 
-        metadatas = process_import_meta_properties(
-            metadatas=metadatas,
-            **(
-                {
-                    k: v
-                    for k, v in vars_args.items()
-                    if k in inspect.getfullargspec(process_import_meta_properties).args
-                }
-            ),
-        )
-
         metadatas = process_sequence_properties(
             metadatas=metadatas,
             **(

mapillary_tools/commands/upload.py

@@ -1,8 +1,7 @@
 import inspect
-import typing as T
 
 from .. import constants
-from ..upload import DirectUploadFileType, FileType, upload
+from ..upload import upload
 
 
 class Command:
@@ -34,30 +33,6 @@ class Command:
         group = parser.add_argument_group(
             f"{constants.ANSI_BOLD}UPLOAD OPTIONS{constants.ANSI_RESET_ALL}"
         )
-        default_filetypes = ",".join(sorted(t.value for t in FileType))
-        supported_filetypes = ",".join(
-            sorted(
-                [t.value for t in DirectUploadFileType] + [t.value for t in FileType]
-            )
-        )
-
-        def _type(option: str) -> T.List[T.Union[FileType, DirectUploadFileType]]:
-            r: T.List[T.Union[FileType, DirectUploadFileType]] = []
-            for t in option.split(","):
-                if t in [x.value for x in FileType]:
-                    r.append(FileType(t))
-                else:
-                    r.append(DirectUploadFileType(t))
-            return r
-
-        group.add_argument(
-            "--filetypes",
-            "--file_types",
-            help=f"Upload files of the specified types only. Supported file types: {supported_filetypes} [default: %(default)s]",
-            type=_type,
-            default=default_filetypes,
-            required=False,
-        )
         group.add_argument(
             "--desc_path",
             help=f'Path to the description file generated by the process command. The hyphen "-" indicates STDIN. [default: {{IMPORT_PATH}}/{constants.IMAGE_DESCRIPTION_FILENAME}]',

mapillary_tools/constants.py

@@ -43,8 +43,8 @@ GOPRO_GPS_PRECISION = float(os.getenv(_ENV_PREFIX + "GOPRO_GPS_PRECISION", 15))
 
 # WARNING: Changing the following envvars might result in failed uploads
 # Max number of images per sequence
-MAX_SEQUENCE_LENGTH = int(os.getenv(_ENV_PREFIX + "MAX_SEQUENCE_LENGTH", 500))
+MAX_SEQUENCE_LENGTH = int(os.getenv(_ENV_PREFIX + "MAX_SEQUENCE_LENGTH", 1000))
 # Max file size per sequence (sum of image filesizes in the sequence)
-MAX_SEQUENCE_FILESIZE: str = os.getenv(_ENV_PREFIX + "MAX_SEQUENCE_FILESIZE", "2G")
+MAX_SEQUENCE_FILESIZE: str = os.getenv(_ENV_PREFIX + "MAX_SEQUENCE_FILESIZE", "10G")
 # Max number of pixels per sequence (sum of image pixels in the sequence)
 MAX_SEQUENCE_PIXELS: str = os.getenv(_ENV_PREFIX + "MAX_SEQUENCE_PIXELS", "6G")

mapillary_tools/exiftool_read_video.py

@@ -5,6 +5,7 @@ import typing as T
 import xml.etree.ElementTree as ET
 
 from . import exif_read, exiftool_read, geo
+from .telemetry import GPSFix, GPSPoint
 
 
 MAX_TRACK_ID = 10
@@ -87,7 +88,7 @@ def _aggregate_gps_track(
     alt_tag: T.Optional[str] = None,
     direction_tag: T.Optional[str] = None,
     ground_speed_tag: T.Optional[str] = None,
-) -> T.List[geo.PointWithFix]:
+) -> T.List[GPSPoint]:
     """
     Aggregate all GPS data by the tags.
     It requires lat, lon to be present, and their lengths must match.
@@ -173,15 +174,16 @@ def _aggregate_gps_track(
         if timestamp is None or lon is None or lat is None:
             continue
         track.append(
-            geo.PointWithFix(
+            GPSPoint(
                 time=timestamp,
                 lon=lon,
                 lat=lat,
                 alt=alt,
                 angle=direction,
-                gps_fix=None,
-                gps_precision=None,
-                gps_ground_speed=ground_speed,
+                epoch_time=None,
+                fix=None,
+                precision=None,
+                ground_speed=ground_speed,
             )
         )
 
@@ -230,8 +232,8 @@ def _aggregate_gps_track_by_sample_time(
     ground_speed_tag: T.Optional[str] = None,
     gps_fix_tag: T.Optional[str] = None,
     gps_precision_tag: T.Optional[str] = None,
-) -> T.List[geo.PointWithFix]:
-    track: T.List[geo.PointWithFix] = []
+) -> T.List[GPSPoint]:
+    track: T.List[GPSPoint] = []
 
     expanded_gps_fix_tag = None
     if gps_fix_tag is not None:
@@ -249,7 +251,7 @@ def _aggregate_gps_track_by_sample_time(
             gps_fix_texts = texts_by_tag.get(expanded_gps_fix_tag)
             if gps_fix_texts:
                 try:
-                    gps_fix = geo.GPSFix(int(gps_fix_texts[0]))
+                    gps_fix = GPSFix(int(gps_fix_texts[0]))
                 except ValueError:
                     gps_fix = None
 
@@ -280,7 +282,7 @@ def _aggregate_gps_track_by_sample_time(
             for idx, point in enumerate(points):
                 point.time = sample_time + idx * avg_timedelta
             track.extend(
-                dataclasses.replace(point, gps_fix=gps_fix, gps_precision=gps_precision)
+                dataclasses.replace(point, fix=gps_fix, precision=gps_precision)
                 for point in points
             )
 
@@ -355,7 +357,7 @@ class ExifToolReadVideo:
         _, model = self._extract_make_and_model()
         return model
 
-    def _extract_gps_track_from_track(self) -> T.List[geo.PointWithFix]:
+    def _extract_gps_track_from_track(self) -> T.List[GPSPoint]:
         for track_id in range(1, MAX_TRACK_ID + 1):
             track_ns = f"Track{track_id}"
             if self._all_tags_exists(
@@ -397,7 +399,7 @@ class ExifToolReadVideo:
 
     def _extract_gps_track_from_quicktime(
         self, namespace: str = "QuickTime"
-    ) -> T.List[geo.PointWithFix]:
+    ) -> T.List[GPSPoint]:
         if not self._all_tags_exists(
             {
                 expand_tag(f"{namespace}:GPSDateTime"),

mapillary_tools/ffmpeg.py

@@ -202,10 +202,10 @@ class FFMPEG:
             return "0"
 
         if length == 1:
-            return f"eq(n\\,{ sorted_frame_indices[0] })"
+            return f"eq(n\\,{sorted_frame_indices[0]})"
 
         middle = length // 2
-        return f"if(lt(n\\,{ sorted_frame_indices[middle] })\\,{ self.generate_binary_search(sorted_frame_indices[:middle]) }\\,{ self.generate_binary_search(sorted_frame_indices[middle:]) })"
+        return f"if(lt(n\\,{sorted_frame_indices[middle]})\\,{self.generate_binary_search(sorted_frame_indices[:middle])}\\,{self.generate_binary_search(sorted_frame_indices[middle:])})"
 
     def extract_specified_frames(
         self,

mapillary_tools/geo.py

@@ -6,7 +6,6 @@ import datetime
 import itertools
 import math
 import typing as T
-from enum import Enum, unique
 
 WGS84_a = 6378137.0
 WGS84_a_SQ = WGS84_a**2
@@ -32,45 +31,6 @@ class Point:
     angle: T.Optional[float]
 
 
-@unique
-class GPSFix(Enum):
-    NO_FIX = 0
-    FIX_2D = 2
-    FIX_3D = 3
-
-
-@dataclasses.dataclass
-class PointWithFix(Point):
-    gps_fix: T.Optional[GPSFix]
-    gps_precision: T.Optional[float]
-    gps_ground_speed: T.Optional[float]
-
-
-def _ecef_from_lla_DEPRECATED(
-    lat: float, lon: float, alt: float
-) -> T.Tuple[float, float, float]:
-    """
-    Deprecated because it is slow. Keep here for reference and comparison.
-    Use _ecef_from_lla2 instead.
-
-    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
-
-    """
-    a2 = WGS84_a**2
-    b2 = WGS84_b**2
-    lat = math.radians(lat)
-    lon = math.radians(lon)
-    L = 1.0 / math.sqrt(a2 * math.cos(lat) ** 2 + b2 * math.sin(lat) ** 2)
-    x = (a2 * L + alt) * math.cos(lat) * math.cos(lon)
-    y = (a2 * L + alt) * math.cos(lat) * math.sin(lon)
-    z = (b2 * L + alt) * math.sin(lat)
-    return x, y, z
-
-
 def _ecef_from_lla2(lat: float, lon: float) -> T.Tuple[float, float, float]:
     """
     Compute ECEF XYZ from latitude, longitude and altitude.
@@ -172,20 +132,6 @@ def pairwise(iterable: T.Iterable[_IT]) -> T.Iterable[T.Tuple[_IT, _IT]]:
     return zip(a, b)
 
 
-def group_every(
-    iterable: T.Iterable[_IT], n: int
-) -> T.Generator[T.Generator[_IT, None, None], None, None]:
-    """
-    Return a generator that divides the iterable into groups by N.
-    """
-
-    if not (0 < n):
-        raise ValueError("expect 0 < n but got {0}".format(n))
-
-    for _, group in itertools.groupby(enumerate(iterable), key=lambda t: t[0] // n):
-        yield (item for _, item in group)
-
-
 def as_unix_time(dt: T.Union[datetime.datetime, int, float]) -> float:
     if isinstance(dt, (int, float)):
         return dt

mapillary_tools/geotag/blackvue_parser.py

@@ -7,7 +7,7 @@ import typing as T
 import pynmea2
 
 from .. import geo
-from . import simple_mp4_parser
+from ..mp4 import simple_mp4_parser as sparser
 
 
 LOG = logging.getLogger(__name__)
@@ -55,8 +55,8 @@ def _parse_gps_box(gps_data: bytes) -> T.Generator[geo.Point, None, None]:
 
 def extract_camera_model(fp: T.BinaryIO) -> str:
     try:
-        cprt_bytes = simple_mp4_parser.parse_mp4_data_first(fp, [b"free", b"cprt"])
-    except simple_mp4_parser.ParsingError:
+        cprt_bytes = sparser.parse_mp4_data_first(fp, [b"free", b"cprt"])
+    except sparser.ParsingError:
         return ""
 
     if cprt_bytes is None:
@@ -91,7 +91,7 @@ def extract_camera_model(fp: T.BinaryIO) -> str:
 
 
 def extract_points(fp: T.BinaryIO) -> T.Optional[T.List[geo.Point]]:
-    gps_data = simple_mp4_parser.parse_mp4_data_first(fp, [b"free", b"gps "])
+    gps_data = sparser.parse_mp4_data_first(fp, [b"free", b"gps "])
     if gps_data is None:
         return None
 

mapillary_tools/geotag/geotag_images_from_exif.py

@@ -6,7 +6,7 @@ from pathlib import Path
 
 from tqdm import tqdm
 
-from .. import exceptions, exif_write, geo, types
+from .. import exceptions, exif_write, geo, types, utils
 from ..exif_read import ExifRead, ExifReadABC
 from .geotag_from_generic import GeotagImagesFromGeneric
 
@@ -64,6 +64,7 @@ class GeotagImagesFromEXIF(GeotagImagesFromGeneric):
         image_metadata = types.ImageMetadata(
             filename=image_path,
             md5sum=None,
+            filesize=utils.get_file_size(image_path),
             time=geo.as_unix_time(capture_time),
             lat=lat,
             lon=lon,

mapillary_tools/geotag/geotag_images_from_exiftool_both_image_and_video.py

@@ -48,7 +48,6 @@ class GeotagImagesFromExifToolBothImageAndVideo(GeotagImagesFromGeneric):
         video_paths = utils.find_videos(
             [Path(pathstr) for pathstr in rdf_description_by_path.keys()],
             skip_subfolders=True,
-            check_file_suffix=True,
         )
 
         # will try to geotag these error metadatas from video later