supervisely 6.73.463__py3-none-any.whl → 6.73.465__py3-none-any.whl

supervisely/app/widgets/select_dataset_tree/select_dataset_tree.py

@@ -329,6 +329,7 @@ class SelectDatasetTree(Widget):
         """
         if not self._multiselect:
             raise ValueError("This method can only be called when multiselect is enabled.")
+        self._select_all_datasets_checkbox.uncheck()
         self._select_dataset.set_selected_by_id(dataset_ids)
 
     def team_changed(self, func: Callable) -> Callable:

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/nn/inference/predict_app/gui/input_selector.py

@@ -2,6 +2,9 @@ import threading
 from typing import Any, Dict, List
 
 from supervisely.api.api import Api
+from supervisely.api.dataset_api import DatasetInfo
+from supervisely.api.project_api import ProjectInfo
+from supervisely.api.video.video_api import VideoInfo
 from supervisely.app.widgets import (
     Button,
     Card,
@@ -202,6 +205,53 @@ class InputSelector:
 
             self.select_video.add_rows(rows)
 
+    def select_project(self, project_id: int, project_info: ProjectInfo = None):
+        if project_info is None:
+            project_info = self.api.project.get_info_by_id(project_id)
+        if project_info.type == ProjectType.IMAGES.value:
+            self.select_dataset_for_images.set_project_id(project_id)
+            self.select_dataset_for_images.select_all()
+            self.radio.set_value(ProjectType.IMAGES.value)
+        elif project_info.type == ProjectType.VIDEOS.value:
+            self.select_dataset_for_video.set_project_id(project_id)
+            self.select_dataset_for_video.select_all()
+            self._refresh_video_table()
+            self.select_video.select_rows(list(range(len(self.select_video._rows_total))))
+            self.radio.set_value(ProjectType.VIDEOS.value)
+        else:
+            raise ValueError(f"Project of type {project_info.type} is not supported.")
+
+    def select_datasets(self, dataset_ids: List[int], dataset_infos: List[DatasetInfo] = None):
+        if dataset_infos is None:
+            dataset_infos = [self.api.dataset.get_info_by_id(ds_id) for ds_id in dataset_ids]
+        project_ids = set(ds.project_id for ds in dataset_infos)
+        if len(project_ids) > 1:
+            raise ValueError("Cannot select datasets from different projects")
+        project_id = project_ids.pop()
+        project_info = self.api.project.get_info_by_id(project_id)
+        if project_info.type == ProjectType.IMAGES.value:
+            self.select_dataset_for_images.set_project_id(project_id)
+            self.select_dataset_for_images.set_dataset_ids(dataset_ids)
+            self.radio.set_value(ProjectType.IMAGES.value)
+        elif project_info.type == ProjectType.VIDEOS.value:
+            self.select_dataset_for_video.set_project_id(project_id)
+            self.select_dataset_for_video.set_dataset_ids(dataset_ids)
+            self._refresh_video_table()
+            self.select_video.select_rows(list(range(self.select_video._rows_total)))
+            self.radio.set_value(ProjectType.VIDEOS.value)
+        else:
+            raise ValueError(f"Project of type {project_info.type} is not supported.")
+
+    def select_videos(self, video_ids: List[int], video_infos: List[VideoInfo] = None):
+        if video_infos is None:
+            video_infos = self.api.video.get_info_by_id_batch(video_ids)
+        project_id = video_infos[0].project_id
+        self.select_dataset_for_video.set_project_id(project_id)
+        self.select_dataset_for_video.select_all()
+        self._refresh_video_table()
+        self.select_video.select_row_by_value("id", video_ids)
+        self.radio.set_value(ProjectType.VIDEOS.value)
+
     def disable(self):
         for widget in self.widgets_to_disable:
             widget.disable()
@@ -249,37 +299,13 @@ class InputSelector:
             video_infos = self.api.video.get_info_by_id_batch(video_ids)
             if not video_infos:
                 raise ValueError(f"Videos with video ids {video_ids} are not found")
-            project_id = video_infos[0].project_id
-            self.select_dataset_for_video.set_project_id(project_id)
-            self.select_dataset_for_video.select_all()
-            self.select_video.select_row_by_value("id", data["video_ids"])
-            self.radio.set_value(ProjectType.VIDEOS.value)
+            self.select_videos(video_ids, video_infos)
         elif "dataset_ids" in data:
             dataset_ids = data["dataset_ids"]
-            if len(dataset_ids) == 0:
-                raise ValueError("Dataset ids cannot be empty")
-            dataset_id = dataset_ids[0]
-            dataset_info = self.api.dataset.get_info_by_id(dataset_id)
-            project_info = self.api.project.get_info_by_id(dataset_info.project_id)
-            if project_info.type == ProjectType.VIDEOS:
-                self.select_dataset_for_video.set_project_id(project_info.id)
-                self.select_dataset_for_video.set_dataset_ids(dataset_ids)
-                self.radio.set_value(ProjectType.VIDEOS.value)
-            else:
-                self.select_dataset_for_images.set_project_id(project_info.id)
-                self.select_dataset_for_images.set_dataset_ids(dataset_ids)
-                self.radio.set_value(ProjectType.IMAGES.value)
+            self.select_datasets(dataset_ids)
         elif "project_id" in data:
             project_id = data["project_id"]
-            project_info = self.api.project.get_info_by_id(project_id)
-            if project_info.type == ProjectType.VIDEOS:
-                self.select_dataset_for_video.set_project_id(project_id)
-                self.select_dataset_for_video.select_all()
-                self.radio.set_value(ProjectType.VIDEOS.value)
-            else:
-                self.select_dataset_for_images.set_project_id(project_id)
-                self.select_dataset_for_images.select_all()
-                self.radio.set_value(ProjectType.IMAGES.value)
+            self.select_project(project_id)
 
     def get_project_id(self) -> int:
         if self.radio.get_value() == ProjectType.IMAGES.value:

{supervisely-6.73.463.dist-info → supervisely-6.73.465.dist-info}/METADATA

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

{supervisely-6.73.463.dist-info → supervisely-6.73.465.dist-info}/RECORD

@@ -461,7 +461,7 @@ supervisely/app/widgets/select_dataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JC
 supervisely/app/widgets/select_dataset/select_dataset.py,sha256=S7zl83lUhquJ1U8GugiViEiGId6a5nVDfyIRRxh_LT4,10295
 supervisely/app/widgets/select_dataset/template.html,sha256=7O_ZgmRs0vOL8tng6QvYbI_0o6A4yMAPB2MlfzWHeHQ,984
 supervisely/app/widgets/select_dataset_tree/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-supervisely/app/widgets/select_dataset_tree/select_dataset_tree.py,sha256=HQwKXzz5yhmdcS79qfP_AGDUpGgQESNmLcASZx2rv78,25802
+supervisely/app/widgets/select_dataset_tree/select_dataset_tree.py,sha256=zFb7a70Zb7iWAtoM7zESCWcobQ2YEROJIJoj0CKpQ3k,25855
 supervisely/app/widgets/select_dataset_tree/template.html,sha256=_uvKCMP0nkpSl3FiTUxqy10JZw3q8-9hXCv22W3BDF0,38
 supervisely/app/widgets/select_item/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/app/widgets/select_item/select_item.py,sha256=dcB0UN46rn3nFQybgrGpLRfwB6xnPo-GGrv9rsMeCbA,3833
@@ -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
@@ -937,7 +937,7 @@ supervisely/nn/inference/predict_app/predict_app.py,sha256=jgpNLfbi5sQCiOYITHego
 supervisely/nn/inference/predict_app/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 supervisely/nn/inference/predict_app/gui/classes_selector.py,sha256=qjc0-bpV2L2vIUr-LoNSLKXhNNrNfliJpl44ybAgSyw,6369
 supervisely/nn/inference/predict_app/gui/gui.py,sha256=Zkp3M2aKZEKX6kZQbYiaSPiTEFM_Ul_xtuNozQ7dkMs,39526
-supervisely/nn/inference/predict_app/gui/input_selector.py,sha256=vEGsS-XMjV052UbJIpg-aFfGxIfyz5inHqr8dIg6N_E,12461
+supervisely/nn/inference/predict_app/gui/input_selector.py,sha256=jZ3H9TP9flu1LrulS936I6jenHnC_a3a6iixjTL4srY,13781
 supervisely/nn/inference/predict_app/gui/model_selector.py,sha256=UvUErutEI8COCWA1WU5MMvMrju0k7W_65Sgp7URa9Qc,2369
 supervisely/nn/inference/predict_app/gui/output_selector.py,sha256=IEwR3CJUAh26eztfdPqfIyzjfyAHbV-fRTwmuwJE09g,6535
 supervisely/nn/inference/predict_app/gui/preview.py,sha256=UpOrXmjV32qDRdRKPO15BbRVIzhIEh906BkUtjjGaio,2871
@@ -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.463.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-supervisely-6.73.463.dist-info/METADATA,sha256=xOtl8l6e5EUS_V-ZuFKjRPc5yb6IwKpjCfqkOvplIcE,35604
-supervisely-6.73.463.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-supervisely-6.73.463.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
-supervisely-6.73.463.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
-supervisely-6.73.463.dist-info/RECORD,,
+supervisely-6.73.465.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+supervisely-6.73.465.dist-info/METADATA,sha256=FORh3_bNVnnyV7o_g3BQu0gQGdc_8uIrvGR0Tvkl9Eo,35604
+supervisely-6.73.465.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+supervisely-6.73.465.dist-info/entry_points.txt,sha256=U96-5Hxrp2ApRjnCoUiUhWMqijqh8zLR03sEhWtAcms,102
+supervisely-6.73.465.dist-info/top_level.txt,sha256=kcFVwb7SXtfqZifrZaSE3owHExX4gcNYe7Q2uoby084,28
+supervisely-6.73.465.dist-info/RECORD,,