supervisely 6.73.456__py3-none-any.whl → 6.73.458__py3-none-any.whl

supervisely/nn/tracker/visualize.py

@@ -1,21 +1,22 @@
-from typing import Union, Dict, List, Tuple, Iterator, Optional
-import numpy as np
-import cv2
-import ffmpeg
-from pathlib import Path
+import shutil
+import tempfile
 from collections import defaultdict
 from dataclasses import dataclass
-import tempfile
-import shutil
+from pathlib import Path
+from typing import Dict, Iterator, List, Optional, Tuple, Union
+
+import cv2
+import ffmpeg
+import numpy as np
 
 import supervisely as sly
-from supervisely import logger
+from supervisely import VideoAnnotation, logger
 from supervisely.nn.model.prediction import Prediction
-from supervisely import VideoAnnotation
 from supervisely.nn.tracker.utils import predictions_to_video_annotation
 
 
 class TrackingVisualizer:
+
     def __init__(
         self,
         show_labels: bool = True,
@@ -29,7 +30,7 @@ class TrackingVisualizer:
         codec: str = "mp4",
         output_fps: float = 30.0,
         colorize_tracks: bool = True,
-
+        trajectory_thickness: int = 2,
     ):
         """
         Initialize the visualizer with configuration.
@@ -58,6 +59,7 @@ class TrackingVisualizer:
         self.text_scale = text_scale
         self.text_thickness = text_thickness
         self.trajectory_length = trajectory_length
+        self.trajectory_thickness = trajectory_thickness
         self.colorize_tracks = colorize_tracks
 
         # Output settings
@@ -71,7 +73,7 @@ class TrackingVisualizer:
         self.track_colors = {}
         self.color_palette = self._generate_color_palette()
         self._temp_dir = None
-        
+
     def _generate_color_palette(self, num_colors: int = 100) -> List[Tuple[int, int, int]]:
         """
         Generate bright, distinct color palette for track visualization.
@@ -88,11 +90,11 @@ class TrackingVisualizer:
             bgr_color = cv2.cvtColor(hsv_color, cv2.COLOR_HSV2BGR)[0][0]
             colors.append(tuple(map(int, bgr_color)))
         return colors
-    
+
     def _get_track_color(self, track_id: int) -> Tuple[int, int, int]:
         """Get consistent color for track ID from palette."""
         return self.color_palette[track_id % len(self.color_palette)]
-    
+
     def _get_video_info(self, video_path: Path) -> Tuple[int, int, float, int]:
         """
         Get video metadata using ffmpeg.
@@ -104,13 +106,13 @@ class TrackingVisualizer:
             probe = ffmpeg.probe(str(video_path))
             video_stream = next((stream for stream in probe['streams'] 
                                if stream['codec_type'] == 'video'), None)
-            
+
             if video_stream is None:
                 raise ValueError(f"No video stream found in: {video_path}")
-            
+
             width = int(video_stream['width'])
             height = int(video_stream['height'])
-            
+
             # Extract FPS
             fps_str = video_stream.get('r_frame_rate', '30/1')
             if '/' in fps_str:
@@ -118,19 +120,19 @@ class TrackingVisualizer:
                 fps = num / den if den != 0 else 30.0
             else:
                 fps = float(fps_str)
-            
+
             # Get total frames
             total_frames = int(video_stream.get('nb_frames', 0))
             if total_frames == 0:
                 # Fallback: estimate from duration and fps
                 duration = float(video_stream.get('duration', 0))
                 total_frames = int(duration * fps) if duration > 0 else 0
-            
+
             return width, height, fps, total_frames
-            
+
         except Exception as e:
             raise ValueError(f"Could not read video metadata {video_path}: {str(e)}")
-    
+
     def _create_frame_iterator(self, source: Union[str, Path]) -> Iterator[Tuple[int, np.ndarray]]:
         """
         Create iterator that yields (frame_index, frame) tuples.
@@ -142,38 +144,38 @@ class TrackingVisualizer:
             Tuple of (frame_index, frame_array)
         """
         source = Path(source)
-        
+
         if source.is_file():
             yield from self._iterate_video_frames(source)
         elif source.is_dir():
             yield from self._iterate_directory_frames(source)
         else:
             raise ValueError(f"Source must be a video file or directory, got: {source}")
-    
+
     def _iterate_video_frames(self, video_path: Path) -> Iterator[Tuple[int, np.ndarray]]:
         """Iterate through video frames using ffmpeg."""
         width, height, fps, total_frames = self._get_video_info(video_path)
-        
+
         # Store video info for later use
         self.source_fps = fps
         self.frame_size = (width, height)
-        
+
         process = (
             ffmpeg
             .input(str(video_path))
             .output('pipe:', format='rawvideo', pix_fmt='bgr24', loglevel='quiet')
             .run_async(pipe_stdout=True, pipe_stderr=False)
         )
-        
+
         try:
             frame_size_bytes = width * height * 3
             frame_idx = 0
-            
+
             while True:
                 frame_data = process.stdout.read(frame_size_bytes)
                 if len(frame_data) != frame_size_bytes:
                     break
-                
+
                 frame = np.frombuffer(frame_data, np.uint8).reshape([height, width, 3])
                 yield frame_idx, frame
                 frame_idx += 1
@@ -186,26 +188,26 @@ class TrackingVisualizer:
             if process.stderr:
                 process.stderr.close()
             process.wait()
-    
+
     def _iterate_directory_frames(self, frames_dir: Path) -> Iterator[Tuple[int, np.ndarray]]:
         """Iterate through image frames in directory."""
         if not frames_dir.is_dir():
             raise ValueError(f"Directory does not exist: {frames_dir}")
-        
+
         # Support common image extensions
         extensions = ['.jpg', '.jpeg', '.png', '.bmp', '.tiff']
         image_files = []
         for ext in extensions:
             image_files.extend(frames_dir.glob(f'*{ext}'))
             image_files.extend(frames_dir.glob(f'*{ext.upper()}'))
-        
+
         image_files = sorted(image_files)
         if not image_files:
             raise ValueError(f"No image files found in directory: {frames_dir}")
-        
+
         # Set fps from config for image sequences
         self.source_fps = self.output_fps
-        
+
         for frame_idx, img_path in enumerate(image_files):
             frame = cv2.imread(str(img_path))
             if frame is not None:
@@ -215,7 +217,7 @@ class TrackingVisualizer:
                 yield frame_idx, frame
             else:
                 logger.warning(f"Could not read image: {img_path}")
-    
+
     def _extract_tracks_from_annotation(self) -> None:
         """
         Extract tracking data from Supervisely VideoAnnotation.
@@ -224,29 +226,29 @@ class TrackingVisualizer:
         """
         self.tracks_by_frame = defaultdict(list)
         self.track_colors = {}
-        
+
         # Map object keys to track info
         objects = {}
         for i, obj in enumerate(self.annotation.objects):
             objects[obj.key] = (i, obj.obj_class.name)
-        
+
         # Extract tracks from frames
         for frame in self.annotation.frames:
             frame_idx = frame.index
             for figure in frame.figures:
                 if figure.geometry.geometry_name() != 'rectangle':
                     continue
-                    
+
                 object_key = figure.parent_object.key
                 if object_key not in objects:
                     continue
-                    
+
                 track_id, class_name = objects[object_key]
-                
+
                 # Extract bbox coordinates
                 rect = figure.geometry
                 bbox = (rect.left, rect.top, rect.right, rect.bottom)
-                
+
                 if track_id not in self.track_colors:
                     if self.colorize_tracks:
                         # auto-color override everything
@@ -263,11 +265,10 @@ class TrackingVisualizer:
 
                     self.track_colors[track_id] = color
 
-                
                 self.tracks_by_frame[frame_idx].append((track_id, bbox, class_name))
-        
+
         logger.info(f"Extracted tracks from {len(self.tracks_by_frame)} frames")
-        
+
     def _draw_detection(self, img: np.ndarray, track_id: int, bbox: Tuple[int, int, int, int], 
                     class_name: str) -> Optional[Tuple[int, int]]:
         """
@@ -278,7 +279,7 @@ class TrackingVisualizer:
 
         if x2 <= x1 or y2 <= y1:
             return None
-        
+
         color = self.track_colors[track_id]
 
         # Draw bounding box
@@ -304,7 +305,6 @@ class TrackingVisualizer:
         # Return center point for trajectory
         return (x1 + x2) // 2, (y1 + y2) // 2
 
-
     def _draw_trajectories(self, img: np.ndarray) -> None:
         """Draw trajectory lines for all tracks, filtering out big jumps."""
         if not self.show_trajectories:
@@ -323,13 +323,12 @@ class TrackingVisualizer:
                 p1, p2 = points[i - 1], points[i]
                 if p1 is None or p2 is None:
                     continue
-              
+
                 if np.hypot(p2[0] - p1[0], p2[1] - p1[1]) > max_jump:
                     continue
-                cv2.line(img, p1, p2, color, 2)
+                cv2.line(img, p1, p2, color, self.trajectory_thickness)
                 cv2.circle(img, p1, 3, color, -1)
 
-        
     def _process_single_frame(self, frame: np.ndarray, frame_idx: int) -> np.ndarray:
         """
         Process single frame: add annotations and return processed frame.
@@ -351,23 +350,23 @@ class TrackingVisualizer:
                 if len(self.track_centers[track_id]) > self.trajectory_length:
                     self.track_centers[track_id].pop(0)
                 active_ids.add(track_id)
-        
+
         for tid in self.track_centers.keys():
             if tid not in active_ids:
                 self.track_centers[tid].append(None)
                 if len(self.track_centers[tid]) > self.trajectory_length:
                     self.track_centers[tid].pop(0)
-                
+
         # Draw trajectories
         self._draw_trajectories(img)
-        
+
         # Add frame number if requested
         if self.show_frame_number:
             cv2.putText(img, f"Frame: {frame_idx + 1}", (10, 30),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2, cv2.LINE_AA)
-        
+
         return img
-    
+
     def _save_processed_frame(self, frame: np.ndarray, frame_idx: int) -> str:
         """
         Save processed frame to temporary directory.
@@ -382,7 +381,7 @@ class TrackingVisualizer:
         frame_path = self._temp_dir / f"frame_{frame_idx:08d}.jpg"
         cv2.imwrite(str(frame_path), frame, [cv2.IMWRITE_JPEG_QUALITY, 95])
         return str(frame_path)
-    
+
     def _create_video_from_frames(self, output_path: Union[str, Path]) -> None:
         """
         Create final video from processed frames using ffmpeg.
@@ -392,10 +391,10 @@ class TrackingVisualizer:
         """
         output_path = Path(output_path)
         output_path.parent.mkdir(parents=True, exist_ok=True)
-        
+
         # Create video from frame sequence
         input_pattern = str(self._temp_dir / "frame_%08d.jpg")
-        
+
         try:
             (
                 ffmpeg
@@ -405,17 +404,17 @@ class TrackingVisualizer:
                 .run(capture_stdout=True, capture_stderr=True)
             )
             logger.info(f"Video saved to {output_path}")
-            
+
         except ffmpeg.Error as e:
             error_msg = e.stderr.decode() if e.stderr else "Unknown ffmpeg error"
             raise ValueError(f"Failed to create video: {error_msg}")
-    
+
     def _cleanup_temp_directory(self) -> None:
         """Clean up temporary directory and all its contents."""
         if self._temp_dir and self._temp_dir.exists():
             shutil.rmtree(self._temp_dir)
             self._temp_dir = None
-    
+
     def visualize_video_annotation(self, annotation: VideoAnnotation, 
                                   source: Union[str, Path], 
                                   output_path: Union[str, Path]) -> None:
@@ -433,43 +432,43 @@ class TrackingVisualizer:
         """
         if not isinstance(annotation, VideoAnnotation):
             raise TypeError(f"Annotation must be VideoAnnotation, got {type(annotation)}")
-        
+
         # Store annotation
         self.annotation = annotation
-        
+
         # Create temporary directory for processed frames
         self._temp_dir = Path(tempfile.mkdtemp(prefix="video_viz_"))
-        
+
         try:
             # Extract tracking data
             self._extract_tracks_from_annotation()
-            
+
             if not self.tracks_by_frame:
                 logger.warning("No tracking data found in annotation")
-            
+
             # Reset trajectory tracking
             self.track_centers = defaultdict(list)
-            
+
             # Process frames one by one
             frame_count = 0
             for frame_idx, frame in self._create_frame_iterator(source):
                 # Process frame
                 processed_frame = self._process_single_frame(frame, frame_idx)
-                
+
                 # Save processed frame
                 self._save_processed_frame(processed_frame, frame_idx)
-                
+
                 frame_count += 1
-                
+
                 # Progress logging
                 if frame_count % 100 == 0:
                     logger.info(f"Processed {frame_count} frames")
-            
+
             logger.info(f"Finished processing {frame_count} frames")
-            
+
             # Create final video from saved frames
             self._create_video_from_frames(output_path)
-            
+
         finally:
             # Always cleanup temporary files
             self._cleanup_temp_directory()
@@ -477,7 +476,7 @@ class TrackingVisualizer:
     def __del__(self):
         """Cleanup temporary directory on object destruction."""
         self._cleanup_temp_directory()
-        
+
 
 def visualize(
     predictions: Union[VideoAnnotation, List[Prediction]], 
@@ -519,4 +518,3 @@ def visualize(
         visualizer.visualize_video_annotation(predictions, source, output_path)
     else:
         raise TypeError(f"Predictions must be VideoAnnotation or list of Prediction, got {type(predictions)}")
-

supervisely/video/video.py

@@ -4,7 +4,7 @@
 from __future__ import annotations
 
 import os
-from typing import Dict, Generator, List, Optional, Tuple
+from typing import Dict, Generator, Iterable, List, Optional, Tuple
 
 import cv2
 import numpy as np
@@ -625,3 +625,17 @@ class VideoFrameReader:
             return self.vr.get_avg_fps()
         else:
             return int(self.cap.get(cv2.CAP_PROP_FPS))
+
+
+def create_from_frames(frames: Iterable[np.ndarray], output_path: str, fps: int = 30) -> None:
+    video_writer = None
+    for frame in frames:
+        if video_writer is None:
+            height, width, _ = frame.shape
+            fourcc = cv2.VideoWriter.fourcc(*"mp4v")
+            video_writer = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+        if frame.dtype != np.uint8:
+            frame = (frame * 255).astype(np.uint8) if frame.max() <= 1.0 else frame.astype(np.uint8)
+
+        video_writer.write(frame)
+    video_writer.release()

supervisely/worker_api/agent_rpc.py

@@ -1,10 +1,12 @@
 # coding: utf-8
+# isort: skip_file
 
 import cv2
 import numpy as np
 
 from .chunking import load_to_memory_chunked_image, load_to_memory_chunked
-from ..worker_proto import worker_api_pb2 as api_proto
+
+# from ..worker_proto import worker_api_pb2 as api_proto # Import moved to methods where needed
 
 
 class SimpleCache:
@@ -22,6 +24,13 @@ class SimpleCache:
 
 
 def download_image_from_remote(agent_api, image_hash, src_node_token, logger):
+    try:
+        from ..worker_proto import worker_api_pb2 as api_proto
+    except Exception as e:
+        from supervisely.app.v1.constants import PROTOBUF_REQUIRED_ERROR
+
+        raise ImportError(PROTOBUF_REQUIRED_ERROR) from e
+
     resp = agent_api.get_stream_with_data(
         'DownloadImages',
         api_proto.ChunkImage,
@@ -34,6 +43,13 @@ def download_image_from_remote(agent_api, image_hash, src_node_token, logger):
 
 
 def download_data_from_remote(agent_api, req_id, logger):
+    try:
+        from ..worker_proto import worker_api_pb2 as api_proto
+    except Exception as e:
+        from supervisely.app.v1.constants import PROTOBUF_REQUIRED_ERROR
+
+        raise ImportError(PROTOBUF_REQUIRED_ERROR) from e
+
     resp = agent_api.get_stream_with_data('GetGeneralEventData', api_proto.Chunk, api_proto.Empty(),
                                           addit_headers={'x-request-id': req_id})
     b_data = load_to_memory_chunked(resp)
@@ -47,6 +63,13 @@ def batched(seq, batch_size):
 
 
 def send_from_memory_generator(out_bytes, chunk_size):
+    try:
+        from ..worker_proto import worker_api_pb2 as api_proto
+    except Exception as e:
+        from supervisely.app.v1.constants import PROTOBUF_REQUIRED_ERROR
+
+        raise ImportError(PROTOBUF_REQUIRED_ERROR) from e
+
     for bytes_chunk in batched(out_bytes, chunk_size):
         yield api_proto.Chunk(buffer=bytes_chunk, total_size=len(out_bytes))
 

supervisely/worker_api/rpc_servicer.py

@@ -1,4 +1,5 @@
 # coding: utf-8
+# isort: skip_file
 
 import os
 import concurrent.futures
@@ -11,18 +12,27 @@ import threading
 from supervisely.annotation.annotation import Annotation
 from supervisely.function_wrapper import function_wrapper, function_wrapper_nofail
 from supervisely.imaging.image import drop_image_alpha_channel
-from supervisely.nn.legacy.hosted.inference_modes import InferenceModeFactory, InfModeFullImage, \
-    MODE, NAME, get_effective_inference_mode_config
+from supervisely.nn.legacy.hosted.inference_modes import (
+    InferenceModeFactory,
+    InfModeFullImage,
+    MODE,
+    NAME,
+    get_effective_inference_mode_config,
+)
 from supervisely.project.project_meta import ProjectMeta
 from supervisely.worker_api.agent_api import AgentAPI
-from supervisely.worker_api.agent_rpc import decode_image, download_image_from_remote, download_data_from_remote, \
-    send_from_memory_generator
+from supervisely.worker_api.agent_rpc import (
+    decode_image,
+    download_image_from_remote,
+    download_data_from_remote,
+    send_from_memory_generator,
+)
 from supervisely.worker_api.interfaces import SingleImageInferenceInterface
-from supervisely.worker_proto import worker_api_pb2 as api_proto
+
+# from supervisely.worker_proto import worker_api_pb2 as api_proto  # Import moved to methods where needed
 from supervisely.task.progress import report_agent_rpc_ready
 from supervisely.api.api import Api
 
-
 REQUEST_TYPE = 'request_type'
 GET_OUT_META = 'get_out_meta'
 INFERENCE = 'inference'
@@ -123,6 +133,13 @@ class AgentRPCServicerBase:
             self.thread_pool.submit(function_wrapper_nofail, self._send_data, res_msg, req_id)  # skip errors
 
     def _send_data(self, out_msg, req_id):
+        try:
+            from supervisely.worker_proto import worker_api_pb2 as api_proto
+        except Exception as e:
+            from supervisely.app.v1.constants import PROTOBUF_REQUIRED_ERROR
+
+            raise ImportError(PROTOBUF_REQUIRED_ERROR) from e
+
         self.logger.trace('Will send output data.', extra={REQUEST_ID: req_id})
         out_bytes = json.dumps(out_msg).encode('utf-8')
 
@@ -173,6 +190,13 @@ class AgentRPCServicerBase:
             self._load_data_if_required(event_obj)
 
     def run_inf_loop(self):
+        try:
+            from supervisely.worker_proto import worker_api_pb2 as api_proto
+        except Exception as e:
+            from supervisely.app.v1.constants import PROTOBUF_REQUIRED_ERROR
+
+            raise ImportError(PROTOBUF_REQUIRED_ERROR) from e
+
         def seq_inf_wrapped():
             function_wrapper(self._sequential_final_processing)  # exit if raised
 
@@ -252,4 +276,4 @@ class InactiveRPCServicer(AgentRPCServicer):
         self.logger.info('Created InactiveRPCServicer for internal usage', extra=conn_config)
 
     def run_inf_loop(self):
-        raise RuntimeError("Method is not accessible")
+        raise RuntimeError("Method is not accessible")

{supervisely-6.73.456.dist-info → supervisely-6.73.458.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: supervisely
-Version: 6.73.456
+Version: 6.73.458
 Summary: Supervisely Python SDK.
 Home-page: https://github.com/supervisely/supervisely
 Author: Supervisely
@@ -25,7 +25,6 @@ Requires-Dist: numpy<2.0.0,>=1.19
 Requires-Dist: opencv-python<5.0.0.0,>=4.6.0.66
 Requires-Dist: PTable<1.0.0,>=0.9.2
 Requires-Dist: pillow<=10.4.0,>=5.4.1
-Requires-Dist: protobuf<=3.20.3,>=3.19.5
 Requires-Dist: python-json-logger<3.0.0,>=0.1.11
 Requires-Dist: requests<3.0.0,>=2.27.1
 Requires-Dist: requests-toolbelt>=0.9.1
@@ -71,6 +70,8 @@ Requires-Dist: zstd
 Requires-Dist: aiofiles
 Requires-Dist: httpx[http2]==0.27.2
 Requires-Dist: debugpy
+Provides-Extra: agent
+Requires-Dist: protobuf<=3.20.3,>=3.19.5; extra == "agent"
 Provides-Extra: apps
 Requires-Dist: uvicorn[standard]<1.0.0,>=0.18.2; extra == "apps"
 Requires-Dist: fastapi<1.0.0,>=0.79.0; extra == "apps"