flashdetect-cu124 1.0.0__py3-none-win_amd64.whl

flashdetect/__init__.py

@@ -0,0 +1,339 @@
+"""
+FlashDetect Python Wrapper — safe, Pythonic API on top of flashdetect.dll
+"""
+import ctypes
+import os
+import glob
+from typing import List, Optional, Tuple
+
+try:
+    import tensorrt_libs
+    os.add_dll_directory(tensorrt_libs.__path__[0])
+except ImportError:
+    pass
+_nvidia_base = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'nvidia')
+if os.path.isdir(_nvidia_base):
+    for _root, _dirs, _files in os.walk(_nvidia_base):
+        if any(f.endswith('.dll') for f in _files):
+            os.add_dll_directory(_root)
+
+
+class Detection:
+    """Single detection result."""
+    __slots__ = ("x1", "y1", "x2", "y2", "conf", "class_id")
+
+    def __init__(self, x1: float, y1: float, x2: float, y2: float,
+                 conf: float, class_id: int):
+        self.x1 = x1
+        self.y1 = y1
+        self.x2 = x2
+        self.y2 = y2
+        self.conf = conf
+        self.class_id = class_id
+
+    def __repr__(self):
+        return (f"Detection(x1={self.x1:.0f}, y1={self.y1:.0f}, "
+                f"x2={self.x2:.0f}, y2={self.y2:.0f}, "
+                f"cls={self.class_id}, conf={self.conf:.2f})")
+
+    @property
+    def xyxy(self) -> Tuple[float, float, float, float]:
+        return (self.x1, self.y1, self.x2, self.y2)
+
+
+class FlashDetect:
+    """
+    Low-latency YOLO26 inference engine.
+    """
+
+    def __init__(
+        self,
+        engine_path: str,
+        conf: float = 0.25,
+        device_id: int = 0,
+        target_classes: Optional[List[int]] = None,
+        max_dets: int = 0,
+        format: str = "BGR",
+        resize_mode: int = 0,       # 0=no resize (default), 1=GPU resize
+        src_w: int = 0,             # source width (resize_mode=1)
+        src_h: int = 0,             # source height (resize_mode=1)
+        sdk_dir: Optional[str] = None,
+    ):
+        if sdk_dir is None:
+            # Auto-detect: look for flashdetect.dll next to this file
+            sdk_dir = os.path.dirname(os.path.abspath(__file__))
+            # Also try parent directory's runtime folder
+            parent_runtime = os.path.join(os.path.dirname(sdk_dir), "runtime")
+            if os.path.isdir(parent_runtime):
+                os.add_dll_directory(parent_runtime)
+            os.add_dll_directory(sdk_dir)
+
+        # Find DLL
+        dll_path = os.path.join(sdk_dir, "flashdetect.dll")
+        if not os.path.exists(dll_path):
+            raise FileNotFoundError(f"flashdetect.dll not found in {sdk_dir}")
+
+        try:
+            self._dll = ctypes.CDLL(dll_path)
+        except OSError as e:
+            raise RuntimeError(
+                f"Cannot load flashdetect.dll — missing runtime DLLs.\n"
+                f"  {e}\n"
+                f"  Ensure CUDA 12.4 + TensorRT 11.0 are installed."
+            ) from e
+        self._setup_ctypes()
+
+        # Resolve engine path (support glob)
+        if not os.path.exists(engine_path):
+            candidates = glob.glob(engine_path)
+            if not candidates:
+                candidates = glob.glob(os.path.join(os.path.dirname(sdk_dir), "*.engine"))
+            if candidates:
+                engine_path = candidates[0]
+            else:
+                raise FileNotFoundError(f"Engine not found: {engine_path}")
+
+        # Prepare target classes
+        n_labels = len(target_classes) if target_classes else 0
+        c_labels = (ctypes.c_int * n_labels)(*target_classes) if target_classes else None
+
+        # Convert format string to DLL value
+        fmt_map = {"BGR": 0, "RGB": 1}
+        fmt_val = fmt_map.get(format.upper(), 0)
+
+        # Create context
+        self._ctx = self._dll.fd_create(
+            engine_path.encode("utf-8"),
+            ctypes.c_float(conf),
+            ctypes.c_int(device_id),
+            c_labels,
+            ctypes.c_int(n_labels),
+            ctypes.c_int(max_dets),
+            ctypes.c_int(fmt_val),
+            ctypes.c_int(resize_mode),
+            ctypes.c_int(src_w),
+            ctypes.c_int(src_h),
+        )
+        if not self._ctx:
+            # Try to get machine ID to guide the user
+            try:
+                mid = get_machine_id()
+            except Exception:
+                mid = "<unavailable>"
+            raise RuntimeError(
+                f"fd_create failed — likely missing or invalid license.key\n"
+                f"  Your machine ID: {mid}\n"
+                f"  Send this ID to the vendor to obtain a license.key file,\n"
+                f"  then place it beside flashdetect.dll.\n"
+                f"  Or run: python -c \"import flashdetect; print(flashdetect.get_machine_id())\""
+            )
+
+        # Get engine input size
+        h, w = ctypes.c_int(), ctypes.c_int()
+        self._dll.fd_get_size(self._ctx, ctypes.byref(h), ctypes.byref(w))
+        self.input_height = h.value
+        self.input_width = w.value
+        self.resize_mode = resize_mode
+        self._src_w = src_w if src_w > 0 else self.input_width
+        self._src_h = src_h if src_h > 0 else self.input_height
+
+    # ── ctypes setup ──────────────────────────────
+
+    def _setup_ctypes(self):
+        d = self._dll
+
+        class _Ctx(ctypes.Structure):
+            pass
+
+        class _Det(ctypes.Structure):
+            _fields_ = [
+                ("x1", ctypes.c_float), ("y1", ctypes.c_float),
+                ("x2", ctypes.c_float), ("y2", ctypes.c_float),
+                ("conf", ctypes.c_float), ("class_id", ctypes.c_int),
+            ]
+
+        d.fd_create.argtypes = [
+            ctypes.c_char_p, ctypes.c_float, ctypes.c_int,
+            ctypes.POINTER(ctypes.c_int), ctypes.c_int, ctypes.c_int, ctypes.c_int,
+            ctypes.c_int, ctypes.c_int, ctypes.c_int,
+        ]
+        d.fd_create.restype = ctypes.POINTER(_Ctx)
+
+        d.fd_process.argtypes = [
+            ctypes.POINTER(_Ctx), ctypes.POINTER(ctypes.c_uint8),
+            ctypes.POINTER(_Det), ctypes.c_int, ctypes.POINTER(ctypes.c_int),
+        ]
+        d.fd_process.restype = ctypes.c_int
+
+        d.fd_get_size.argtypes = [
+            ctypes.POINTER(_Ctx), ctypes.POINTER(ctypes.c_int),
+            ctypes.POINTER(ctypes.c_int),
+        ]
+        d.fd_get_size.restype = None
+
+        d.fd_release.argtypes = [ctypes.POINTER(_Ctx)]
+        d.fd_release.restype = None
+
+        d.fd_set_conf.argtypes = [ctypes.POINTER(_Ctx), ctypes.c_float]
+        d.fd_set_conf.restype = None
+
+        d.fd_set_classes.argtypes = [ctypes.POINTER(_Ctx), ctypes.POINTER(ctypes.c_int), ctypes.c_int]
+        d.fd_set_classes.restype = None
+
+        self._Det = _Det
+
+    # ── Public API ────────────────────────────────
+
+    def detect(self, image_rgb, conf: float = None, classes: List[int] = None) -> List[Detection]:
+        """
+        Run inference on a single image.
+
+        Args:
+            image_rgb: numpy array (H, W, 3) uint8 RGB.
+            conf:      Override confidence threshold for this frame (None = keep current).
+            classes:   Override target classes for this frame (None = keep current).
+
+        Returns:
+            List of Detection objects.
+        """
+        import numpy as np
+        if not isinstance(image_rgb, np.ndarray):
+            raise TypeError("image_rgb must be a numpy array")
+        if image_rgb.dtype != np.uint8:
+            image_rgb = image_rgb.astype(np.uint8)
+        if not image_rgb.flags["C_CONTIGUOUS"]:
+            image_rgb = np.ascontiguousarray(image_rgb)
+
+        if conf is not None:
+            self._dll.fd_set_conf(self._ctx, ctypes.c_float(conf))
+        if classes is not None:
+            n = len(classes)
+            c_cls = (ctypes.c_int * n)(*classes)
+            self._dll.fd_set_classes(self._ctx, c_cls, ctypes.c_int(n))
+
+        dets = (self._Det * 300)()
+        count = ctypes.c_int()
+        ptr = image_rgb.ctypes.data_as(ctypes.POINTER(ctypes.c_uint8))
+        ret = self._dll.fd_process(self._ctx, ptr, dets, 300, ctypes.byref(count))
+        if ret != 0:
+            raise RuntimeError(f"fd_process failed with code {ret}")
+
+        results = []
+        sx = self._src_w / self.input_width  if self.resize_mode else 1.0
+        sy = self._src_h / self.input_height if self.resize_mode else 1.0
+        for i in range(count.value):
+            d = dets[i]
+            b = Detection(d.x1*sx, d.y1*sy, d.x2*sx, d.y2*sy, d.conf, d.class_id)
+            results.append(b)
+        return results
+
+    def __call__(self, image) -> List[Detection]:
+        """Shortcut: engine(image) → detections"""
+        return self.detect(image)
+
+    def close(self):
+        """Release GPU resources."""
+        if self._ctx:
+            self._dll.fd_release(self._ctx)
+            self._ctx = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def __del__(self):
+        """Auto-release on garbage collection."""
+        try:
+            self.close()
+        except Exception:
+            pass
+
+    @property
+    def input_size(self) -> Tuple[int, int]:
+        return (self.input_height, self.input_width)
+
+
+# ── Module-level utilities ──────────────────────
+
+def get_machine_id(sdk_dir: str = None) -> str:
+    """
+    Get this machine's unique hardware ID for license generation.
+
+    Usage (first-time setup):
+        >>> import flashdetect
+        >>> print(flashdetect.get_machine_id())
+        A1B2C3D4E5F67890
+
+    Send this ID to the vendor to receive a license.key file,
+    then place it beside flashdetect.dll (in the same directory).
+
+    Args:
+        sdk_dir: Path to the directory containing flashdetect.dll.
+                 Defaults to the package install directory.
+    Returns:
+        16-character hex machine ID string.
+    """
+    if sdk_dir is None:
+        sdk_dir = os.path.dirname(os.path.abspath(__file__))
+        os.add_dll_directory(sdk_dir)
+
+    dll_path = os.path.join(sdk_dir, "flashdetect.dll")
+    if not os.path.exists(dll_path):
+        raise FileNotFoundError(f"flashdetect.dll not found in {sdk_dir}")
+
+    try:
+        dll = ctypes.CDLL(dll_path)
+    except OSError as e:
+        raise RuntimeError(
+            f"Cannot load flashdetect.dll — missing runtime DLLs.\n"
+            f"  {e}\n"
+            f"  Ensure CUDA 12.4 + TensorRT 11.0 are installed."
+        ) from e
+    dll.fd_get_machine_id.argtypes = [ctypes.c_char_p, ctypes.c_int]
+    dll.fd_get_machine_id.restype = ctypes.c_int
+
+    buf = ctypes.create_string_buffer(32)
+    if dll.fd_get_machine_id(buf, 32) != 0:
+        raise RuntimeError("Failed to get machine ID")
+    return buf.value.decode("utf-8")
+
+
+def install_license(source_path: str, sdk_dir: str = None) -> str:
+    """
+    Copy a license.key file into the flashdetect package directory.
+
+    Usage:
+        >>> import flashdetect
+        >>> flashdetect.install_license("C:/Users/me/Downloads/license.key")
+
+    This copies the file to the same directory as flashdetect.dll, where
+    the DLL looks for it at runtime.
+
+    Args:
+        source_path: Path to your license.key file.
+        sdk_dir:     Target directory (default: flashdetect package dir).
+    Returns:
+        The destination path where license.key was installed.
+    """
+    import shutil
+
+    if not os.path.exists(source_path):
+        raise FileNotFoundError(f"license.key not found at: {source_path}")
+
+    if sdk_dir is None:
+        sdk_dir = os.path.dirname(os.path.abspath(__file__))
+
+    dest_path = os.path.join(sdk_dir, "license.key")
+
+    if os.path.exists(dest_path):
+        print(f"[flashdetect] Replacing existing: {dest_path}")
+
+    shutil.copy2(source_path, dest_path)
+    print(f"[flashdetect] license.key installed → {dest_path}")
+
+    mid = get_machine_id(sdk_dir)
+    print(f"[flashdetect] Machine ID: {mid}")
+
+    return dest_path

flashdetect_cu124-1.0.0.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: flashdetect-cu124
+Version: 1.0.0
+Summary: Low-latency YOLO26 TensorRT inference for real-time video streams
+Home-page: https://github.com/toever/flashdetect
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Environment :: GPU :: NVIDIA CUDA
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.21
+Requires-Dist: tensorrt-cu12
+Requires-Dist: nvidia-cuda-runtime-cu12
+Requires-Dist: nvidia-cublas-cu12
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# FlashDetect
+
+**低延迟 YOLO26 目标检测推理引擎，专为实时视频流优化。仅支持 YOLO26 端到端导出（`[N,6]` 格式，无 NMS）。**
+
+基于 TensorRT + CUDA Graph，全 GPU 流水线。
+
+## 安装
+
+```bash
+pip install flashdetect-cu124
+```
+
+### 系统要求
+
+- Windows x64
+- NVIDIA GPU (Compute Capability ≥ 7.0)
+- Python ≥ 3.8
+
+运行时依赖自动安装（CUDA 12.4 + TensorRT 11.x）。
+
+## 激活授权
+
+本 SDK 需要硬件绑定授权，首次使用：
+
+```python
+import flashdetect
+
+# 1. 获取本机 ID，发送给供应商
+print(flashdetect.get_machine_id())
+
+# 2. 收到 license.key 后，一键安装
+flashdetect.install_license("C:/Users/me/Downloads/license.key")
+```
+
+激活后即可正常使用。
+
+## 快速开始
+
+```python
+from flashdetect import FlashDetect
+
+# 加载模型（支持 with 语句自动释放）
+with FlashDetect("yolo26n.engine", conf=0.25) as detector:
+    frame = camera.read()          # (H, W, 3) BGR uint8
+    dets = detector.detect(frame)
+
+    for d in dets:
+        print(f"  cls={d.class_id} conf={d.conf:.2f} "
+              f"({d.x1:.0f},{d.y1:.0f})-({d.x2:.0f},{d.y2:.0f})")
+```
+
+## API 参考
+
+### 模块级工具
+
+| 函数 | 说明 |
+|------|------|
+| `flashdetect.get_machine_id()` | 获取本机硬件 ID（用于申请授权） |
+| `flashdetect.install_license(path)` | 安装 license.key 到正确位置 |
+
+### `FlashDetect(engine_path, **kwargs)`
+
+| 参数 | 类型 | 默认值 | 说明 |
+|------|------|--------|------|
+| `engine_path` | `str` | 必填 | TensorRT .engine 文件路径 |
+| `conf` | `float` | `0.25` | 置信度阈值 |
+| `device_id` | `int` | `0` | GPU 设备编号 |
+| `target_classes` | `List[int]` | `None` | 只检测指定类别（None=全部） |
+| `max_dets` | `int` | `0` | 最大检测数（0=引擎默认） |
+| `format` | `str` | `"BGR"` | 输入颜色格式：`"BGR"` 或 `"RGB"` |
+| `resize_mode` | `int` | `0` | 0=不缩放，1=GPU 缩放至引擎尺寸 |
+| `src_w` | `int` | `0` | 源图像宽度（resize_mode=1 时必填） |
+| `src_h` | `int` | `0` | 源图像高度（resize_mode=1 时必填） |
+
+### `detect(image, conf=None, classes=None) -> List[Detection]`
+
+| 参数 | 类型 | 说明 |
+|------|------|------|
+| `image` | `np.ndarray` | (H, W, 3) uint8 图像 |
+| `conf` | `float` | 可选，覆盖当前帧的置信度阈值 |
+| `classes` | `List[int]` | 可选，覆盖当前帧的目标类别 |
+
+### `Detection`
+
+| 属性 | 类型 | 说明 |
+|------|------|------|
+| `x1, y1, x2, y2` | `float` | 边界框坐标 |
+| `conf` | `float` | 置信度 |
+| `class_id` | `int` | 类别 ID |
+| `xyxy` | `tuple` | `(x1, y1, x2, y2)` 快捷属性 |
+
+### 其他方法
+
+```python
+detector.input_width, detector.input_height   # 引擎输入尺寸
+detector.close()                               # 释放 GPU 资源
+# 或使用 with 语句自动释放：
+# with FlashDetect("model.engine") as detector:
+#     dets = detector.detect(frame)
+```
+
+## 性能
+
+待测试
+
+CUDA Graph 确保每次推理耗时稳定，无 CPU 端开销。
+
+## 适用场景
+
+- 游戏画面实时分析（DX 采集）
+- 工业相机检测
+- 视频流目标跟踪
+
+**不适用**：图片文件批量识别（无需 GPU Graph 优化）。
+
+## 许可 & 联系
+
+本 SDK 需硬件绑定授权，每台机器独立 `license.key`。
+无有效授权时，`FlashDetect()` 会抛出异常并显示本机 ID。
+
+获取授权请联系：
+
+- 📧 邮箱：`2169431623@qq.com` / `wut815318@gmail.com`

flashdetect_cu124-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+flashdetect/__init__.py,sha256=p7JADJvCDj5NTh67tdFUdEhoIxy69v7TmcWH4bNwIjo,12164
+flashdetect/flashdetect.dll,sha256=yFXtV5sTJLBT7avHYP3TVXDUfkVyR2QE-jTBZ51jdb4,78336
+flashdetect_cu124-1.0.0.dist-info/METADATA,sha256=O-arKuIHRSelAPZdehUNht2cImQNLQzKAbIRNFF4NMQ,4567
+flashdetect_cu124-1.0.0.dist-info/WHEEL,sha256=QR8DNjG6Lr6bNErJWJgF4dP2dJ2N7NpY-BWly1OvcTM,97
+flashdetect_cu124-1.0.0.dist-info/top_level.txt,sha256=FCzr5dABchxs3JZZRINKHH6sKMM5s1w-K5rHy3MLy5E,12
+flashdetect_cu124-1.0.0.dist-info/RECORD,,

flashdetect_cu124-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-win_amd64
+

flashdetect_cu124-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+flashdetect