evileye 0.0.4__py3-none-any.whl

evileye/__init__.py

@@ -0,0 +1,88 @@
+"""
+EvilEye - Intelligence video surveillance system
+
+A comprehensive video surveillance system with object detection, tracking,
+and multi-camera support.
+"""
+
+__version__ = "1.0.0"
+__author__ = "EvilEye Team"
+__email__ = "team@evileye.com"
+
+# Import core components
+from .core import PipelineProcessors, ProcessorBase, ProcessorSource, ProcessorFrame, ProcessorStep
+from .pipelines import PipelineSurveillance
+
+# Import registered classes
+from .capture import video_capture
+from .object_detector import object_detection_yolo
+from .object_tracker import object_tracking_botsort
+from .object_multi_camera_tracker import ObjectMultiCameraTracking
+
+# Import main modules
+from . import process
+from . import configure
+from . import controller
+
+# Define public API
+__all__ = [
+    # Core components
+    "Pipeline",
+    "ProcessorBase", 
+    "ProcessorSource",
+    "ProcessorFrame",
+    "ProcessorStep",
+    "PipelineSurveillance",
+    
+    # Registered classes
+    "video_capture",
+    "object_detection_yolo", 
+    "object_tracking_botsort",
+    "ObjectMultiCameraTracking",
+    
+    # Main modules
+    "process",
+    "configure", 
+    "controller",
+]
+
+# Auto-fix entry points on first import
+def _auto_fix_entry_points():
+    """Automatically fix entry points when package is imported"""
+    import os
+    import subprocess
+    from pathlib import Path
+    
+    # Only run once per session
+    if hasattr(_auto_fix_entry_points, '_run'):
+        return
+    _auto_fix_entry_points._run = True
+    
+    try:
+        # Get the project root directory
+        package_dir = Path(__file__).parent
+        project_root = package_dir.parent
+        fix_script = project_root / "fix_entry_points.sh"
+        
+        if fix_script.exists() and os.access(fix_script, os.X_OK):
+            # Run the fix script silently
+            result = subprocess.run(
+                [str(fix_script)],
+                cwd=project_root,
+                capture_output=True,
+                text=True,
+                timeout=30  # 30 second timeout
+            )
+            
+            if result.returncode == 0:
+                print("✅ EvilEye entry points automatically fixed")
+            else:
+                print(f"⚠️  Warning: Could not auto-fix entry points: {result.stderr}")
+                
+    except Exception as e:
+        # Don't fail the import if fixing fails
+        pass
+
+# Call auto-fix function (only if not imported as module)
+if __name__ != "__main__":
+    _auto_fix_entry_points()

evileye/capture/__init__.py

@@ -0,0 +1,4 @@
+from .video_capture_base import VideoCaptureBase
+from .video_capture import VideoCapture
+from .video_capture import CaptureImage
+from .video_capture import CaptureDeviceType

evileye/capture/video_capture.py

@@ -0,0 +1,229 @@
+import datetime
+
+import cv2
+from threading import Lock
+import time
+from timeit import default_timer as timer
+from .video_capture_base import VideoCaptureBase, CaptureImage, CaptureDeviceType
+from enum import IntEnum
+
+from ..core.base_class import EvilEyeBase
+
+
+@EvilEyeBase.register("VideoCapture")
+class VideoCapture(VideoCaptureBase):
+    class VideoCaptureAPIs(IntEnum):
+        CAP_ANY = 0
+        CAP_GSTREAMER = 1800
+        CAP_FFMPEG = 1900
+        CAP_IMAGES = 2000
+
+    def __init__(self):
+        super().__init__()
+
+        self.capture = cv2.VideoCapture()
+        self.mutex = Lock()
+
+    def is_opened(self):
+        return self.capture.isOpened()
+
+    def set_params_impl(self):
+        super().set_params_impl()
+
+    def init_impl(self):
+        api_pref = self.params.get('apiPreference','CAP_FFMPEG')
+        if self.source_type == CaptureDeviceType.IpCamera and api_pref == "CAP_GSTREAMER":  # Приведение rtsp ссылки к формату gstreamer
+            if '!' not in self.source_address:
+                str_h265 = (' ! rtph265depay ! h265parse ! avdec_h265 ! decodebin ! videoconvert ! '  # Указание кодеков и форматов
+                            'video/x-raw, format=(string)BGR ! appsink')
+                str_h264 = (' ! rtph264depay ! h264parse ! avdec_h264 ! decodebin ! videoconvert ! '
+                            'video/x-raw, format=(string)BGR ! appsink')
+
+                if self.source_address.find('tcp') == 0:  # Задание протокола
+                    str1 = 'rtspsrc protocols=' + 'tcp ' + 'location='
+                elif self.source_address.find('udp') == 0:
+                    str1 = 'rtspsrc protocols=' + 'udp ' + 'location='
+                else:
+                    str1 = 'rtspsrc protocols=' + 'tcp ' + 'location='
+
+                pos = self.source_address.find('rtsp')
+                source = str1 + self.source_address[pos:] + str_h265
+                self.capture.open(source, VideoCapture.VideoCaptureAPIs[api_pref])
+                if not self.is_opened():  # Если h265 не подойдет, используем h264
+                    source = str1 + self.source_address + str_h264
+                    self.capture.open(source, VideoCapture.VideoCaptureAPIs[api_pref])
+            else:
+                self.capture.open(self.source_address, VideoCapture.VideoCaptureAPIs[api_pref])
+        else:
+            self.capture.open(self.source_address, VideoCapture.VideoCaptureAPIs[api_pref])
+
+        self.source_fps = None
+        if self.capture.isOpened():
+            self.is_working = True
+            if self.source_type == CaptureDeviceType.VideoFile:
+                self.video_length = self.capture.get(cv2.CAP_PROP_FRAME_COUNT)
+                self.video_current_frame = 0
+                self.video_current_position = 0.0
+            self.finished = False
+            try:
+                self.source_fps = self.capture.get(cv2.CAP_PROP_FPS)
+                if self.source_fps == 0.0:
+                    self.source_fps = None
+                    self.video_duration = None
+                print(f'FPS: {self.source_fps}')
+
+                if self.source_fps is not None and self.source_type == CaptureDeviceType.VideoFile:
+                    self.video_duration = self.video_length * 1000.0 / self.source_fps
+            except cv2.error as e:
+                print(f"Failed to read source_fps: {e} for sources {self.source_names}")
+        else:
+            print(f"Could not connect to a sources: {self.source_names}")
+            self.video_duration = None
+            self.video_length = None
+            self.video_current_frame = None
+            self.video_current_position = None
+            return False
+
+        return True
+
+    def release_impl(self):
+        self.capture.release()
+
+    def reset_impl(self):
+        self.release()
+        self.init()
+        timestamp = datetime.datetime.now()
+        if self.get_init_flag() and self.is_opened():
+            print(f"Reconnected to a sources: {self.source_names}")
+            self.is_working = True
+            self.reconnects.append((self.params['camera'], timestamp, self.is_working))
+        else:
+            print(f"Could not connect to sources: {self.source_names}")
+        for sub in self.subscribers:
+            sub.update()
+
+    def _grab_frames(self):
+        while self.run_flag:
+            begin_it = timer()
+            if not self.is_inited or self.capture is None:
+                time.sleep(0.1)
+                if self.init():
+                    timestamp = datetime.datetime.now()
+                    print(f"Reconnected to a sources: {self.source_names}")
+                    self.reconnects.append((self.params['camera'], timestamp, self.is_working))
+                    for sub in self.subscribers:
+                        sub.update()
+                else:
+                    continue
+
+            if not self.is_opened():
+                time.sleep(0.1)
+                self.reset()
+
+            is_grabbed = False
+            with self.mutex:
+                is_grabbed = self.capture.grab()
+            if not is_grabbed:
+                if self.source_type != CaptureDeviceType.VideoFile or self.loop_play:
+                    self.is_working = False
+                    timestamp = datetime.datetime.now()
+                    self.disconnects.append((self.params['camera'], timestamp, self.is_working))
+                    for sub in self.subscribers:
+                        sub.update()
+                    self.reset()
+                else:
+                    self.finished = True
+
+            end_it = timer()
+            elapsed_seconds = end_it - begin_it
+            if self.source_fps:
+                fps_multiplier = 1.5 if self.source_type == CaptureDeviceType.IpCamera else 1.0
+                sleep_seconds = 1. / (fps_multiplier * self.source_fps) - elapsed_seconds
+                if sleep_seconds <= 0.0:
+                    sleep_seconds = 0.001
+            else:
+                sleep_seconds = 0.03
+            time.sleep(sleep_seconds)
+
+    def _retrieve_frames(self):
+        while self.run_flag:
+            begin_it = timer()
+            is_read, src_image = None, None
+            with self.mutex:
+                is_read, src_image = self.capture.retrieve()
+            if is_read:
+                if self.frames_queue.full():
+                    self.frames_queue.get()
+                if self.source_type == CaptureDeviceType.VideoFile:
+                    self.video_current_frame += 1
+                    if self.source_fps and self.source_fps > 0.0:
+                        self.video_current_position = (self.video_current_frame * 1000.0) / self.source_fps
+                if self.source_type == CaptureDeviceType.IpCamera:
+                    self.last_frame_time = datetime.datetime.now()
+                self.frames_queue.put([is_read, src_image, self.frame_id_counter, self.video_current_frame, self.video_current_position])
+                self.frame_id_counter += 1
+
+            end_it = timer()
+            elapsed_seconds = end_it - begin_it
+
+            retrieve_fps = self.desired_fps if self.desired_fps else self.source_fps if self.source_fps else 15
+            sleep_seconds = 1. / retrieve_fps - elapsed_seconds
+            if sleep_seconds <= 0.0:
+                sleep_seconds = 0.001
+
+            time.sleep(sleep_seconds)
+
+        if not self.run_flag:
+            print('Not run flag')
+            while not self.frames_queue.empty:
+                self.frames_queue.get()
+
+        if not self.run_flag:
+            print('Not run flag')
+            while not self.frames_queue.empty:
+                self.frames_queue.get()
+
+    def get_frames_impl(self) -> list[CaptureImage]:
+        captured_images: list[CaptureImage] = []
+        if self.frames_queue.empty():
+            return captured_images
+        ret, src_image, frame_id, current_video_frame, current_video_position = self.frames_queue.get()
+        if ret:
+            if self.split_stream:  # Если сплит, то возвращаем список с частями потока, иначе - исходное изображение
+                for stream_cnt in range(self.num_split):
+                    capture_image = CaptureImage()
+                    capture_image.source_id = self.source_ids[stream_cnt]
+                    capture_image.time_stamp = time.time()
+                    capture_image.frame_id = frame_id
+                    capture_image.current_video_frame = current_video_frame
+                    capture_image.current_video_position = current_video_position
+                    capture_image.image = src_image[self.src_coords[stream_cnt][1]:self.src_coords[stream_cnt][1] + int(self.src_coords[stream_cnt][3]),
+                                          self.src_coords[stream_cnt][0]:self.src_coords[stream_cnt][0] + int(self.src_coords[stream_cnt][2])].copy()
+                    captured_images.append(capture_image)
+            else:
+                capture_image = CaptureImage()
+                capture_image.source_id = self.source_ids[0]
+                capture_image.time_stamp = time.time()
+                capture_image.frame_id = frame_id
+                capture_image.current_video_frame = current_video_frame
+                capture_image.current_video_position = current_video_position
+                capture_image.image = src_image
+                captured_images.append(capture_image)
+        return captured_images
+
+    def default(self):
+        pass
+
+    def test_disconnect(self):
+        with self.conn_mutex:
+            timestamp = datetime.datetime.now()
+            print(f'Disconnect: {timestamp}')
+            is_working = False
+            self.disconnects.append((self.source_address, timestamp, is_working))
+
+    def test_reconnect(self):
+        with self.conn_mutex:
+            timestamp = datetime.datetime.now()
+            print(f'Reconnect: {timestamp}')
+            is_working = True
+            self.reconnects.append((self.source_address, timestamp, is_working))

evileye/capture/video_capture_base.py

@@ -0,0 +1,181 @@
+import copy
+import datetime
+from abc import ABC, abstractmethod
+import threading
+from queue import Queue
+from enum import Enum
+from urllib.parse import urlparse
+from threading import Lock
+from collections import deque
+from ..core.base_class import EvilEyeBase
+from ..core.frame import CaptureImage, Frame
+
+
+class CaptureDeviceType(Enum):
+    VideoFile = "VideoFile"
+    IpCamera = "IpCamera"
+    Device = "Device"
+    NotSet = "NotSet"
+
+class VideoCaptureBase(EvilEyeBase):
+    def __init__(self):
+        super().__init__()
+        self.source_address = None
+        self.username = None
+        self.password = None
+        self.pure_url = None
+        self.run_flag = False
+        self.frames_queue = Queue(maxsize=2)
+        self.frame_id_counter = 0
+        self.source_type = CaptureDeviceType.NotSet
+        self.source_fps = None
+        self.desired_fps = None
+        self.split_stream = False
+        self.num_split = 0
+        self.src_coords = None
+        self.source_ids = None
+        self.source_names = None
+        self.finished = False
+        self.loop_play = True
+        self.video_duration = None
+        self.video_length = None
+        self.video_current_frame = None
+        self.video_current_position = None
+        self.is_working = False
+        self.conn_mutex = Lock()
+        self.disconnects = []
+        self.reconnects = []
+        self.subscribers = []
+
+        self.capture_thread = None
+        self.grab_thread = None
+        self.retrieve_thread = None
+
+    def is_opened(self) -> bool:
+        return False
+
+    def is_working(self) -> bool:
+        return self.is_working
+
+    def is_finished(self) -> bool:
+        return self.finished
+
+    def is_running(self):
+        return self.run_flag
+
+    def get(self) -> list[CaptureImage]:
+        captured_images: list[CaptureImage] = []
+        if self.get_init_flag():
+            captured_images = self.get_frames_impl()
+        return captured_images
+
+    def start(self):
+        if not self.is_inited:
+            return
+        self.run_flag = True
+        # self.capture_thread = threading.Thread(target=self._capture_frames)
+        # self.capture_thread.start()
+        self.grab_thread = threading.Thread(target=self._grab_frames)
+        self.retrieve_thread = threading.Thread(target=self._retrieve_frames)
+        self.grab_thread.start()
+        self.retrieve_thread.start()
+
+    def stop(self):
+        self.run_flag = False
+        # if self.capture_thread:
+        #     self.capture_thread.join()
+        #     self.capture_thread = None
+        #     print('Capture stopped')
+        if self.grab_thread:
+            if self.grab_thread.is_alive():
+                self.grab_thread.join()
+            self.grab_thread = None
+        if self.retrieve_thread:
+            if self.retrieve_thread.is_alive():
+                self.retrieve_thread.join()
+            self.retrieve_thread = None
+
+    def set_params_impl(self):
+        self.release()
+        self.split_stream = self.params.get('split', False)
+        self.num_split = self.params.get('num_split', None)
+        self.src_coords = self.params.get('src_coords', None)
+        self.source_ids = self.params.get('source_ids', None)
+        self.desired_fps = self.params.get('desired_fps', None)
+        self.source_names = self.params.get('source_names', self.source_ids)
+        self.loop_play = self.params.get('loop_play', True)
+        source_param = self.params.get('source', "")
+        if source_param:
+            self.source_type = CaptureDeviceType[source_param]
+        else:
+            self.source_type = CaptureDeviceType.NotSet
+        self.source_address = self.params.get('camera', '')
+        if self.source_type == CaptureDeviceType.IpCamera:
+            parsed = urlparse(self.source_address)
+            self.username = parsed.username
+            self.password = parsed.password
+            replaced_url = parsed._replace(netloc=f"{parsed.hostname}")
+            self.pure_url = replaced_url.geturl()
+            self.username = self.params.get('username', self.username)
+            self.password = self.params.get('password', self.password)
+            self.source_address = self.reconstruct_url(replaced_url, self.username, self.password)
+        else:
+            self.username = None
+            self.password = None
+            self.pure_url = None
+
+    def get_params_impl(self):
+        params = dict()
+        params['split'] = self.split_stream
+        params['num_split'] = self.num_split
+        params['src_coords'] = self.src_coords
+        params['source_ids'] = self.source_ids
+        params['desired_fps'] = self.desired_fps
+        params['source_names'] = self.source_names
+        params['loop_play'] = self.loop_play
+        params['source'] = self.source_type.name
+        params['camera'] = self.source_address
+        return params
+
+    def get_disconnects_info(self) -> list[tuple[str, datetime.datetime, bool]]:
+        disconnects = copy.deepcopy(self.disconnects)
+        self.disconnects = []
+        return disconnects
+
+    def get_reconnects_info(self) -> list[tuple[str, datetime.datetime, bool]]:
+        reconnects = copy.deepcopy(self.reconnects)
+        self.reconnects = []
+        return reconnects
+
+    @staticmethod
+    def reconstruct_url(url_parsed_info, username, password):
+        processed_username = username if (username and username != "") else None
+        processed_password = password if (password and password != "") else None
+        if not processed_password and not processed_username:
+            return url_parsed_info.geturl()
+
+        if not processed_password:
+            reconstructed_url = url_parsed_info._replace(netloc=f"{processed_username}@{url_parsed_info.hostname}")
+            return reconstructed_url.geturl()
+
+        reconstructed_url = url_parsed_info._replace(netloc=f"{processed_username}:{processed_password}@{url_parsed_info.hostname}")
+        return reconstructed_url.geturl()
+
+    def subscribe(self, *subscribers):
+        self.subscribers = list(subscribers)
+
+    # @abstractmethod
+    # def _capture_frames(self):
+    #     pass
+
+    @abstractmethod
+    def get_frames_impl(self) -> list[CaptureImage]:
+        pass
+
+    @abstractmethod
+    def _grab_frames(self):
+        pass
+
+    @abstractmethod
+    def _retrieve_frames(self):
+        pass