supervisely 6.73.462__py3-none-any.whl → 6.73.464__py3-none-any.whl

supervisely/nn/inference/inference.py

@@ -11,6 +11,7 @@ import subprocess
 import tempfile
 import threading
 import time
+import uuid
 from collections import OrderedDict, defaultdict
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import asdict, dataclass
@@ -52,6 +53,7 @@ from supervisely.annotation.tag_meta import TagMeta, TagValueType
 from supervisely.api.api import Api, ApiField
 from supervisely.api.app_api import WorkflowMeta, WorkflowSettings
 from supervisely.api.image_api import ImageInfo
+from supervisely.api.video.video_api import VideoInfo
 from supervisely.app.content import get_data_dir
 from supervisely.app.fastapi.subapp import (
     Application,
@@ -102,6 +104,11 @@ from supervisely.video_annotation.video_figure import VideoFigure
 from supervisely.video_annotation.video_object import VideoObject
 from supervisely.video_annotation.video_object_collection import VideoObjectCollection
 from supervisely.video_annotation.video_tag_collection import VideoTagCollection
+from supervisely.video_annotation.key_id_map import KeyIdMap
+from supervisely.video_annotation.video_object_collection import (
+    VideoObject,
+    VideoObjectCollection,
+)
 
 try:
     from typing import Literal
@@ -2289,6 +2296,162 @@ class Inference:
         inference_request.final_result = {"video_ann": video_ann_json}
         return video_ann_json
 
+    def _tracking_by_detection(self, api: Api, state: dict, inference_request: InferenceRequest):
+        logger.debug("Inferring video_id...", extra={"state": state})
+        inference_settings = self._get_inference_settings(state)
+        logger.debug(f"Inference settings:", extra=inference_settings)
+        batch_size = self._get_batch_size_from_state(state)
+        video_id = get_value_for_keys(state, ["videoId", "video_id"], ignore_none=True)
+        if video_id is None:
+            raise ValueError("Video id is not provided")
+        video_info = api.video.get_info_by_id(video_id)
+        start_frame_index = get_value_for_keys(
+            state, ["startFrameIndex", "start_frame_index", "start_frame"], ignore_none=True
+        )
+        if start_frame_index is None:
+            start_frame_index = 0
+        step = get_value_for_keys(state, ["stride", "step"], ignore_none=True)
+        if step is None:
+            step = 1
+        end_frame_index = get_value_for_keys(
+            state, ["endFrameIndex", "end_frame_index", "end_frame"], ignore_none=True
+        )
+        duration = state.get("duration", None)
+        frames_count = get_value_for_keys(
+            state, ["framesCount", "frames_count", "num_frames"], ignore_none=True
+        )
+        tracking = state.get("tracker", None)
+        direction = state.get("direction", "forward")
+        direction = 1 if direction == "forward" else -1
+        track_id = get_value_for_keys(state, ["trackId", "track_id"], ignore_none=True)
+
+        if frames_count is not None:
+            n_frames = frames_count
+        elif end_frame_index is not None:
+            n_frames = end_frame_index - start_frame_index
+        elif duration is not None:
+            fps = video_info.frames_count / video_info.duration
+            n_frames = int(duration * fps)
+        else:
+            n_frames = video_info.frames_count
+
+        inference_request.tracker = self._tracker_init(state.get("tracker", None), state.get("tracker_settings", {}))
+
+        logger.debug(
+            f"Video info:",
+            extra=dict(
+                w=video_info.frame_width,
+                h=video_info.frame_height,
+                start_frame_index=start_frame_index,
+                n_frames=n_frames,
+            ),
+        )
+
+        # start downloading video in background
+        self.cache.run_cache_task_manually(api, None, video_id=video_id)
+
+        progress_total = (n_frames + step - 1) // step
+        inference_request.set_stage(InferenceRequest.Stage.INFERENCE, 0, progress_total)
+
+        _upload_f = partial(
+            self.upload_predictions_to_video,
+            api=api,
+            video_info=video_info,
+            track_id=track_id,
+            context=inference_request.context,
+            progress_cb=inference_request.done,
+            inference_request=inference_request,
+        )
+
+        _range = (start_frame_index, start_frame_index + direction * n_frames)
+        if _range[0] > _range[1]:
+            _range = (_range[1], _range[0])
+
+        def _notify_f(predictions: List[Prediction]):
+            logger.debug(
+                "Notifying tracking progress...",
+                extra={
+                    "track_id": track_id,
+                    "range": _range,
+                    "current": inference_request.progress.current,
+                    "total": inference_request.progress.total,
+                },
+            )
+            stopped = self.api.video.notify_progress(
+                track_id=track_id,
+                video_id=video_info.id,
+                frame_start=_range[0],
+                frame_end=_range[1],
+                current=inference_request.progress.current,
+                total=inference_request.progress.total,
+            )
+            if stopped:
+                inference_request.stop()
+                logger.info("Tracking has been stopped by user", extra={"track_id": track_id})
+
+        def _exception_handler(e: Exception):
+            self.api.video.notify_tracking_error(
+                track_id=track_id,
+                error=str(type(e)),
+                message=str(e),
+            )
+            raise e
+
+        with Uploader(
+            upload_f=_upload_f,
+            notify_f=_notify_f,
+            exception_handler=_exception_handler,
+            logger=logger,
+        ) as uploader:
+            for batch in batched(
+                range(
+                    start_frame_index, start_frame_index + direction * n_frames, direction * step
+                ),
+                batch_size,
+            ):
+                if inference_request.is_stopped():
+                    logger.debug(
+                        f"Cancelling inference video...",
+                        extra={"inference_request_uuid": inference_request.uuid},
+                    )
+                    break
+                logger.debug(
+                    f"Inferring frames {batch[0]}-{batch[-1]}:",
+                )
+                frames = self.cache.download_frames(
+                    api, video_info.id, batch, redownload_video=True
+                )
+                anns, slides_data = self._inference_auto(
+                    source=frames,
+                    settings=inference_settings,
+                )
+
+                if inference_request.tracker is not None:
+                    anns = self._apply_tracker_to_anns(frames, anns, inference_request.tracker)
+
+                predictions = [
+                    Prediction(
+                        ann,
+                        model_meta=self.model_meta,
+                        frame_index=frame_index,
+                        video_id=video_info.id,
+                        dataset_id=video_info.dataset_id,
+                        project_id=video_info.project_id,
+                    )
+                    for ann, frame_index in zip(anns, batch)
+                ]
+                for pred, this_slides_data in zip(predictions, slides_data):
+                    pred.extra_data["slides_data"] = this_slides_data
+                uploader.put(predictions)
+        video_ann_json = None
+        if inference_request.tracker is not None:
+            inference_request.set_stage("Postprocess...", 0, 1)
+            video_ann_json = inference_request.tracker.video_annotation.to_json()
+            inference_request.done()
+        inference_request.final_result = {"video_ann": video_ann_json}
+        return video_ann_json
+
+
     def _inference_project_id(self, api: Api, state: dict, inference_request: InferenceRequest):
         """Inference project images.
         If "output_project_id" in state, upload images and annotations to the output project.
@@ -2955,6 +3118,83 @@ class Inference:
         inference_request.add_results(results)
         inference_request.done(len(results))
 
+    def upload_predictions_to_video(
+        self,
+        predictions: List[Prediction],
+        api: Api,
+        video_info: VideoInfo,
+        track_id: str,
+        context: Dict,
+        progress_cb=None,
+        inference_request: InferenceRequest = None,
+    ):
+        key_id_map = KeyIdMap()
+        project_meta = context.get("project_meta", None)
+        if project_meta is None:
+            project_meta = ProjectMeta.from_json(api.project.get_meta(video_info.project_id))
+            context["project_meta"] = project_meta
+        meta_changed = False
+        for prediction in predictions:
+            project_meta, ann, meta_changed_ = update_meta_and_ann(
+                project_meta, prediction.annotation, None
+            )
+            prediction.annotation = ann
+            meta_changed = meta_changed or meta_changed_
+        if meta_changed:
+            project_meta = api.project.update_meta(video_info.project_id, project_meta)
+            context["project_meta"] = project_meta
+
+        figure_data_by_object_id = defaultdict(list)
+
+        tracks_to_object_ids = context.setdefault("tracks_to_object_ids", {})
+        new_tracks: Dict[int, VideoObject] = {}
+        for prediction in predictions:
+            annotation = prediction.annotation
+            tracks = annotation.custom_data
+            for track, label in zip(tracks, annotation.labels):
+                if track not in tracks_to_object_ids and track not in new_tracks:
+                    video_object = VideoObject(obj_class=label.obj_class)
+                    new_tracks[track] = video_object
+        if new_tracks:
+            tracks, video_objects = zip(*new_tracks.items())
+            added_object_ids = api.video.object.append_bulk(
+                video_info.id, VideoObjectCollection(video_objects), key_id_map=key_id_map
+            )
+            for track, object_id in zip(tracks, added_object_ids):
+                tracks_to_object_ids[track] = object_id
+        for prediction in predictions:
+            annotation = prediction.annotation
+            tracks = annotation.custom_data
+            for track, label in zip(tracks, annotation.labels):
+                object_id = tracks_to_object_ids[track]
+                figure_data_by_object_id[object_id].append(
+                    {
+                        ApiField.OBJECT_ID: object_id,
+                        ApiField.GEOMETRY_TYPE: label.geometry.geometry_name(),
+                        ApiField.GEOMETRY: label.geometry.to_json(),
+                        ApiField.META: {ApiField.FRAME: prediction.frame_index},
+                        ApiField.TRACK_ID: track_id,
+                    }
+                )
+
+        for object_id, figures_data in figure_data_by_object_id.items():
+            figures_keys = [uuid.uuid4() for _ in figures_data]
+            api.video.figure._append_bulk(
+                entity_id=video_info.id,
+                figures_json=figures_data,
+                figures_keys=figures_keys,
+                key_id_map=key_id_map,
+            )
+            logger.debug(f"Added {len(figures_data)} geometries to object #{object_id}")
+        if progress_cb:
+            progress_cb(len(predictions))
+        if inference_request is not None:
+            results = self._format_output(predictions)
+            for result in results:
+                result["annotation"] = None
+                result["data"] = None
+            inference_request.add_results(results)
+
     def serve(self):
         if not self._use_gui and not self._is_cli_deploy:
             Progress("Deploying model ...", 1)
@@ -3352,6 +3592,22 @@ class Inference:
                 "inference_request_uuid": inference_request.uuid,
             }
 
+        @server.post("/tracking_by_detection")
+        def tracking_by_detection(response: Response, request: Request):
+            state = request.state.state
+            context = request.state.context
+            state.update(context)
+            if state.get("tracker") is None:
+                state["tracker"] = "botsort"
+
+            logger.debug("Received a request to 'tracking_by_detection'", extra={"state": state})
+            self.validate_inference_state(state)
+            api = self.api_from_request(request)
+            inference_request, future = self.inference_requests_manager.schedule_task(
+                self._tracking_by_detection, api, state
+            )
+            return {"message": "Track task started."}
+
         @server.post("/inference_project_id_async")
         def inference_project_id_async(response: Response, request: Request):
             state = request.state.state

supervisely/video/sampling.py

@@ -225,28 +225,48 @@ def sample_video(
         progress.miniters = 1
         progress.refresh()
 
-    with VideoFrameReader(video_path, frame_indices) as reader:
-        for batch in batched_iter(zip(reader, frame_indices), 10):
-            frames, indices = zip(*batch)
-            if resize:
-                for frame in frames:
-                    cv2.resize(frame, [*resize, frame.shape[2]], interpolation=cv2.INTER_LINEAR)
-
-            image_ids = _upload_frames(
-                api=api,
-                frames=frames,
-                video_name=video_info.name,
-                video_frames_count=video_info.frames_count,
-                indices=indices,
-                dataset_id=dst_dataset_info.id,
-                sample_info=sample_info,
-                context=context,
-                copy_annotations=copy_annotations,
-                video_annotation=video_annotation,
-            )
+    batch_size = 50
+    try:
+        with VideoFrameReader(video_path, frame_indices) as reader:
+            for batch_indices in batched_iter(frame_indices, batch_size):
+                batch_indices_list = list(batch_indices)
+                frames = reader.read_batch(batch_indices_list)
+
+                if resize:
+                    resized_frames = []
+                    for frame in frames:
+                        resized_frame = cv2.resize(
+                            frame,
+                            (resize[1], resize[0]),  # (width, height)
+                            interpolation=cv2.INTER_LINEAR,
+                        )
+                        resized_frames.append(resized_frame)
+                    frames = resized_frames
+
+                image_ids = _upload_frames(
+                    api=api,
+                    frames=frames,
+                    video_name=video_info.name,
+                    video_frames_count=video_info.frames_count,
+                    indices=batch_indices_list,
+                    dataset_id=dst_dataset_info.id,
+                    sample_info=sample_info,
+                    context=context,
+                    copy_annotations=copy_annotations,
+                    video_annotation=video_annotation,
+                )
 
-            if progress is not None:
-                progress.update(len(image_ids))
+                if progress is not None:
+                    progress.update(len(image_ids))
+
+                # Free memory after each batch
+                del frames
+                if resize:
+                    del resized_frames
+    finally:
+        import os
+        if os.path.exists(video_path):
+            os.remove(video_path)
 
 
 def _get_or_create_dst_dataset(

supervisely/video/video.py

@@ -537,11 +537,9 @@ class VideoFrameReader:
             try:
                 import decord
 
-                self.vr = decord.VideoReader(str(self.video_path))
+                self.vr = decord.VideoReader(str(self.video_path), num_threads=1)
             except ImportError:
-                default_logger.debug(
-                    "Decord is not installed. Falling back to OpenCV for video reading."
-                )
+                default_logger.debug("Decord is not installed. Falling back to OpenCV for video reading.")
                 self.cap = cv2.VideoCapture(str(self.video_path))
 
     def close(self):
@@ -562,24 +560,30 @@ class VideoFrameReader:
     def __del__(self):
         self.close()
 
-    def iterate_frames(self, frame_indexes: List[int] = None) -> Generator[np.ndarray, None, None]:
+    def iterate_frames(self, frame_indexes: Optional[List[int]] = None) -> Generator[np.ndarray, None, None]:
         self._ensure_initialized()
         if frame_indexes is None:
             frame_indexes = self.frame_indexes
         if self.vr is not None:
+            # Decord
             if frame_indexes is None:
                 frame_indexes = range(len(self.vr))
-            for frame_index in frame_indexes:
-                frame = self.vr[frame_index]
-                yield frame.asnumpy()
+            for idx in frame_indexes:
+                arr = self.vr[idx].asnumpy()
+                yield arr
+                del arr
         else:
+            # OpenCV fallback
             if frame_indexes is None:
                 frame_count = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
                 frame_indexes = range(frame_count)
             for frame_index in frame_indexes:
-                if 1 > frame_index - self.prev_idx < 20:
+                if 1 < frame_index - self.prev_idx < 20:
                     while self.prev_idx < frame_index - 1:
-                        self.cap.read()
+                        ok, _ = self.cap.read()
+                        if not ok:
+                            break
+                        self.prev_idx += 1
                 if frame_index != self.prev_idx + 1:
                     self.cap.set(cv2.CAP_PROP_POS_FRAMES, frame_index)
                 ret, frame = self.cap.read()
@@ -588,6 +592,17 @@ class VideoFrameReader:
                 yield cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
                 self.prev_idx = frame_index
 
+    def read_batch(self, frame_indexes: List[int]) -> List[np.ndarray]:
+        self._ensure_initialized()
+        if self.vr is not None:
+            batch_nd = self.vr.get_batch(frame_indexes)
+            batch_np = batch_nd.asnumpy()
+            frames = [batch_np[i].copy() for i in range(batch_np.shape[0])]
+            del batch_np
+            return frames
+        else:
+            return list(self.iterate_frames(frame_indexes))
+
     def read_frames(self, frame_indexes: List[int] = None) -> List[np.ndarray]:
         return list(self.iterate_frames(frame_indexes))
 

{supervisely-6.73.462.dist-info → supervisely-6.73.464.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.462
+Version: 6.73.464
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely

{supervisely-6.73.462.dist-info → supervisely-6.73.464.dist-info}/RECORD

@@ -906,7 +906,7 @@ supervisely/nn/benchmark/visualization/widgets/table/__init__.py,sha256=47DEQpj8
 supervisely/nn/benchmark/visualization/widgets/table/table.py,sha256=atmDnF1Af6qLQBUjLhK18RMDKAYlxnsuVHMSEa5a-e8,4319
 supervisely/nn/inference/__init__.py,sha256=QFukX2ip-U7263aEPCF_UCFwj6EujbMnsgrXp5Bbt8I,1623
 supervisely/nn/inference/cache.py,sha256=Hkxvu70rrB-j7ztQ4TBOxQePAxiKS7Erdb2FmK7aetY,35795
-supervisely/nn/inference/inference.py,sha256=54SXkXYEyswQN1L9hbOn0luSLyWbFOoaSH1qzNfu7HQ,219687
+supervisely/nn/inference/inference.py,sha256=2Unz6m_AnzVWTKy1Jv9G6VYYLvzu1Mbdl17SKIPZkAA,230530
 supervisely/nn/inference/inference_request.py,sha256=yuqEL4BWjC-aKze_raGScEQyhHe8loYb_eNhGPsf2-4,14870
 supervisely/nn/inference/session.py,sha256=WRJKVnmh5GPXnwtuKJn7AO1C7Td39wZo774ZIVQJGYk,36228
 supervisely/nn/inference/uploader.py,sha256=Dn5MfMRq7tclEWpP0B9fJjTiQPBpwumfXxC8-lOYgnM,5659
@@ -1090,8 +1090,8 @@ supervisely/user/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 supervisely/user/user.py,sha256=4GSVIupPAxWjIxZmUtH3Dtms_vGV82-49kM_aaR2gBI,319
 supervisely/video/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/video/import_utils.py,sha256=b1Nl0gscNsV0iB9nWPeqt8GrkhOeuTZsN1p-d3gDUmE,544
-supervisely/video/sampling.py,sha256=PGZVP1V9pDzdMsGThwS7U8E4VS6h1ba0nvpjVshIPfg,20248
-supervisely/video/video.py,sha256=nG1TE4MEvoh-_pfTTOx44dzqRq2VqLljmUnQ8r1czUY,20799
+supervisely/video/sampling.py,sha256=SA1HeS1yK0-w7oHrojuCQJIAO5UAJuO6zrdOgeE1Twc,20979
+supervisely/video/video.py,sha256=ufwyec2d9ekV3_CLy4VhOj3Ni0gcXIerIBHtC1KGzTQ,21400
 supervisely/video_annotation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/video_annotation/constants.py,sha256=_gW9iMhVk1w_dUaFiaiyXn66mt13S6bkxC64xpjP-CU,529
 supervisely/video_annotation/frame.py,sha256=np21FqavJ3xW9VbLbohifDwZQtF5dWIsNSGVSjn-NnY,10574
@@ -1129,9 +1129,9 @@ supervisely/worker_proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 supervisely/worker_proto/worker_api_pb2.py,sha256=VQfi5JRBHs2pFCK1snec3JECgGnua3Xjqw_-b3aFxuM,59142
 supervisely/worker_proto/worker_api_pb2_grpc.py,sha256=3BwQXOaP9qpdi0Dt9EKG--Lm8KGN0C5AgmUfRv77_Jk,28940
 supervisely_lib/__init__.py,sha256=yRwzEQmVwSd6lUQoAUdBngKEOlnoQ6hA9ZcoZGJRNC4,331
-supervisely-6.73.462.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-supervisely-6.73.462.dist-info/METADATA,sha256=OzYjw5iRdUCofQdUCsd5xkjgEOSl600QFG7lHM7GAlU,35604
-supervisely-6.73.462.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-supervisely-6.73.462.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
-supervisely-6.73.462.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
-supervisely-6.73.462.dist-info/RECORD,,
+supervisely-6.73.464.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+supervisely-6.73.464.dist-info/METADATA,sha256=LetWCHVdHoghuOfeeVXPlpSzx46mBvxCsBpAf1P1uYs,35604
+supervisely-6.73.464.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+supervisely-6.73.464.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
+supervisely-6.73.464.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
+supervisely-6.73.464.dist-info/RECORD,,