slvehicle 0.1.0__tar.gz

slvehicle-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+recursive-include slvehicle/models *.onnx *.pt

slvehicle-0.1.0/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: slvehicle
+Version: 0.1.0
+Summary: Sri Lanka Vehicle Detection & Segmentation (slvy)
+Author: SriLankaVehicleAI
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.23
+Requires-Dist: opencv-python>=4.7
+Requires-Dist: onnxruntime>=1.16
+Provides-Extra: gpu
+Requires-Dist: onnxruntime-gpu>=1.16; extra == "gpu"
+Provides-Extra: torch
+Requires-Dist: torch>=2.0; extra == "torch"
+Requires-Dist: ultralytics>=8.1; extra == "torch"
+Dynamic: author
+Dynamic: requires-python
+
+# slvehicle (slvy) — Sri Lanka Vehicle AI
+
+Vehicle detection & instance segmentation library for Sri Lankan traffic.
+
+**Classes:** bike, bus, car, lorry, tuktuk, van
+
+## Install
+
+```bash
+pip install slvehicle           # CPU
+pip install slvehicle[gpu]      # GPU (CUDA)
+```
+
+## Usage
+
+```python
+from slvehicle import VehicleDetector
+
+det = VehicleDetector()                              # auto device
+result = det.detect('image.jpg')
+det.detect_and_save('input_folder/', 'output_folder/')
+```
+
+## Performance
+
+- mAP50: 97.3%
+- Model size: 5.6 MB (FP16 ONNX)
+- Speed: ~15 ms (GPU), ~80 ms (CPU)

slvehicle-0.1.0/README.md

@@ -0,0 +1,28 @@
+# slvehicle (slvy) — Sri Lanka Vehicle AI
+
+Vehicle detection & instance segmentation library for Sri Lankan traffic.
+
+**Classes:** bike, bus, car, lorry, tuktuk, van
+
+## Install
+
+```bash
+pip install slvehicle           # CPU
+pip install slvehicle[gpu]      # GPU (CUDA)
+```
+
+## Usage
+
+```python
+from slvehicle import VehicleDetector
+
+det = VehicleDetector()                              # auto device
+result = det.detect('image.jpg')
+det.detect_and_save('input_folder/', 'output_folder/')
+```
+
+## Performance
+
+- mAP50: 97.3%
+- Model size: 5.6 MB (FP16 ONNX)
+- Speed: ~15 ms (GPU), ~80 ms (CPU)

slvehicle-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "slvehicle"
+version = "0.1.0"
+description = "Sri Lanka Vehicle Detection & Segmentation (slvy)"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "numpy>=1.23",
+    "opencv-python>=4.7",
+    "onnxruntime>=1.16",
+]
+
+[project.optional-dependencies]
+gpu = ["onnxruntime-gpu>=1.16"]
+torch = ["torch>=2.0", "ultralytics>=8.1"]

slvehicle-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

slvehicle-0.1.0/setup.py

@@ -0,0 +1,21 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="slvehicle",
+    version="0.1.0",
+    description="Sri Lanka Vehicle Detection & Segmentation (slvy)",
+    author="SriLankaVehicleAI",
+    packages=find_packages(),
+    include_package_data=True,
+    package_data={"slvehicle": ["models/*.onnx", "models/*.pt"]},
+    install_requires=[
+        "numpy>=1.23",
+        "opencv-python>=4.7",
+        "onnxruntime>=1.16",
+    ],
+    extras_require={
+        "gpu":   ["onnxruntime-gpu>=1.16"],
+        "torch": ["torch>=2.0", "ultralytics>=8.1"],
+    },
+    python_requires=">=3.8",
+)

slvehicle-0.1.0/slvehicle/__init__.py

@@ -0,0 +1,18 @@
+"""
+slvehicle — Sri Lanka Vehicle Detection Library
+================================================
+Quick start:
+
+    from slvehicle import VehicleDetector
+
+    det = VehicleDetector()
+    results = det.detect("car.jpg")
+    det.detect_and_save("input_folder", "output_folder")
+"""
+
+__version__ = "0.1.0"
+
+from .detector import VehicleDetector
+from .visualizer import Visualizer
+
+__all__ = ["VehicleDetector", "Visualizer", "__version__"]

slvehicle-0.1.0/slvehicle/config.py

@@ -0,0 +1,28 @@
+"""Global configuration constants for slvehicle."""
+
+from pathlib import Path
+
+PACKAGE_DIR = Path(__file__).resolve().parent
+MODEL_DIR   = PACKAGE_DIR / "models"
+
+DEFAULT_ONNX = MODEL_DIR / "yolo11n_seg_fp16.onnx"
+DEFAULT_PT   = MODEL_DIR / "yolo11n_seg.pt"
+
+CLASS_NAMES = ["bike", "bus", "car", "lorry", "tuktuk", "van"]
+NUM_CLASSES = len(CLASS_NAMES)
+
+INPUT_SIZE  = 640
+CONF_THRES  = 0.25
+IOU_THRES   = 0.45
+MAX_DET     = 300
+
+CLASS_COLORS = {
+    "bike":   (255, 56,  56),
+    "bus":    (56,  255, 56),
+    "car":    (56,  56,  255),
+    "lorry":  (255, 157, 56),
+    "tuktuk": (255, 56,  255),
+    "van":    (56,  255, 255),
+}
+
+IMG_EXTS = (".jpg", ".jpeg", ".png", ".bmp", ".tif", ".tiff", ".webp")

slvehicle-0.1.0/slvehicle/detector.py

@@ -0,0 +1,95 @@
+"""Main user-facing API."""
+
+import os
+import cv2
+import time
+from pathlib import Path
+
+from .config import DEFAULT_ONNX, CLASS_NAMES, IMG_EXTS, CONF_THRES, IOU_THRES
+from .engine import get_engine
+from .preprocessor import preprocess
+from .postprocessor import postprocess
+from .visualizer import Visualizer
+
+
+class VehicleDetector:
+    def __init__(self, model_path=None, device="auto",
+                 conf=CONF_THRES, iou=IOU_THRES):
+        self.model_path = Path(model_path) if model_path else DEFAULT_ONNX
+        if not self.model_path.exists():
+            raise FileNotFoundError(f"Model not found: {self.model_path}")
+        self.engine = get_engine(self.model_path, device=device)
+        self.conf = conf
+        self.iou = iou
+        self.visualizer = Visualizer()
+        print(f"[slvy] VehicleDetector ready on '{self.engine.device}'.")
+
+    def detect(self, image):
+        if isinstance(image, (str, Path)):
+            img = cv2.imread(str(image))
+            if img is None:
+                raise ValueError(f"Cannot read image: {image}")
+        else:
+            img = image
+        tensor, meta = preprocess(img)
+        outputs = self.engine.infer(tensor)
+        return postprocess(outputs, meta, self.conf, self.iou)
+
+    def detect_and_show(self, image, window="slvy"):
+        if isinstance(image, (str, Path)):
+            img = cv2.imread(str(image))
+        else:
+            img = image
+        result = self.detect(img)
+        vis = self.visualizer.draw(img, result)
+        cv2.imshow(window, vis)
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()
+        return result
+
+    def detect_folder(self, input_dir):
+        input_dir = Path(input_dir)
+        results = {}
+        files = [p for p in input_dir.iterdir()
+                 if p.suffix.lower() in IMG_EXTS]
+        print(f"[slvy] Processing {len(files)} images from {input_dir}")
+        for p in files:
+            try:
+                results[p.name] = self.detect(p)
+            except Exception as e:
+                print(f"  [WARN] {p.name}: {e}")
+        return results
+
+    def detect_and_save(self, input_dir, output_dir, save_viz=True):
+        input_dir = Path(input_dir)
+        output_dir = Path(output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        files = [p for p in input_dir.iterdir()
+                 if p.suffix.lower() in IMG_EXTS]
+        print(f"[slvy] Processing {len(files)} images -> {output_dir}")
+
+        summary = []
+        t0 = time.time()
+        for p in files:
+            img = cv2.imread(str(p))
+            if img is None:
+                continue
+            result = self.detect(img)
+            if save_viz:
+                vis = self.visualizer.draw(img, result)
+                cv2.imwrite(str(output_dir / p.name), vis)
+            # txt label file
+            txt = output_dir / (p.stem + ".txt")
+            with open(txt, "w") as f:
+                for i in range(len(result["boxes"])):
+                    x1, y1, x2, y2 = result["boxes"][i]
+                    cid = int(result["classes"][i])
+                    sc = float(result["scores"][i])
+                    f.write(f"{CLASS_NAMES[cid]} {sc:.4f} "
+                            f"{x1:.1f} {y1:.1f} {x2:.1f} {y2:.1f}\n")
+            summary.append((p.name, len(result["boxes"])))
+
+        dt = time.time() - t0
+        print(f"[slvy] Done in {dt:.2f}s ({dt/max(len(files),1)*1000:.1f} ms/img)")
+        return summary

slvehicle-0.1.0/slvehicle/engine/__init__.py

@@ -0,0 +1,7 @@
+"""Inference engines."""
+
+from .auto_engine import get_engine
+from .cpu_engine import CPUEngine
+from .gpu_engine import GPUEngine
+
+__all__ = ["get_engine", "CPUEngine", "GPUEngine"]

slvehicle-0.1.0/slvehicle/engine/auto_engine.py

@@ -0,0 +1,20 @@
+"""Auto engine selection."""
+
+import onnxruntime as ort
+from .cpu_engine import CPUEngine
+from .gpu_engine import GPUEngine
+
+
+def get_engine(model_path, device="auto"):
+    device = device.lower()
+    if device == "cpu":
+        return CPUEngine(model_path)
+    if device == "gpu" or device == "cuda":
+        return GPUEngine(model_path)
+    # auto
+    if "CUDAExecutionProvider" in ort.get_available_providers():
+        try:
+            return GPUEngine(model_path)
+        except Exception as e:
+            print(f"[slvy] GPU failed ({e}); falling back to CPU.")
+    return CPUEngine(model_path)

slvehicle-0.1.0/slvehicle/engine/base.py

@@ -0,0 +1,15 @@
+"""Base engine interface."""
+
+from abc import ABC, abstractmethod
+
+
+class BaseEngine(ABC):
+    @abstractmethod
+    def infer(self, input_tensor):
+        """Run inference; return list of numpy arrays."""
+        pass
+
+    @property
+    @abstractmethod
+    def device(self):
+        pass

slvehicle-0.1.0/slvehicle/engine/cpu_engine.py

@@ -0,0 +1,25 @@
+"""ONNX Runtime CPU engine."""
+
+import onnxruntime as ort
+from .base import BaseEngine
+
+
+class CPUEngine(BaseEngine):
+    def __init__(self, model_path):
+        self.model_path = str(model_path)
+        so = ort.SessionOptions()
+        so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        self.session = ort.InferenceSession(
+            self.model_path,
+            sess_options=so,
+            providers=["CPUExecutionProvider"],
+        )
+        self.input_name = self.session.get_inputs()[0].name
+        print(f"[slvy] CPUEngine loaded: {self.model_path}")
+
+    def infer(self, input_tensor):
+        return self.session.run(None, {self.input_name: input_tensor})
+
+    @property
+    def device(self):
+        return "cpu"

slvehicle-0.1.0/slvehicle/engine/gpu_engine.py

@@ -0,0 +1,23 @@
+"""ONNX Runtime GPU engine (CUDA)."""
+
+import onnxruntime as ort
+from .base import BaseEngine
+
+
+class GPUEngine(BaseEngine):
+    def __init__(self, model_path):
+        self.model_path = str(model_path)
+        providers = ["CUDAExecutionProvider", "CPUExecutionProvider"]
+        self.session = ort.InferenceSession(self.model_path, providers=providers)
+        active = self.session.get_providers()
+        if "CUDAExecutionProvider" not in active:
+            raise RuntimeError("CUDAExecutionProvider not available.")
+        self.input_name = self.session.get_inputs()[0].name
+        print(f"[slvy] GPUEngine loaded: {self.model_path}")
+
+    def infer(self, input_tensor):
+        return self.session.run(None, {self.input_name: input_tensor})
+
+    @property
+    def device(self):
+        return "cuda"

slvehicle-0.1.0/slvehicle/models/__init__.py

@@ -0,0 +1 @@
+"""Bundled models."""

slvehicle-0.1.0/slvehicle/postprocessor.py

@@ -0,0 +1,142 @@
+"""Postprocessing for YOLO11-seg ONNX outputs."""
+
+import cv2
+import numpy as np
+from .config import CONF_THRES, IOU_THRES, MAX_DET, NUM_CLASSES, INPUT_SIZE
+
+
+def xywh2xyxy(x):
+    y = np.copy(x)
+    y[..., 0] = x[..., 0] - x[..., 2] / 2
+    y[..., 1] = x[..., 1] - x[..., 3] / 2
+    y[..., 2] = x[..., 0] + x[..., 2] / 2
+    y[..., 3] = x[..., 1] + x[..., 3] / 2
+    return y
+
+
+def nms_numpy(boxes, scores, iou_thres=IOU_THRES):
+    if len(boxes) == 0:
+        return []
+    x1, y1, x2, y2 = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
+    areas = (x2 - x1) * (y2 - y1)
+    order = scores.argsort()[::-1]
+    keep = []
+    while order.size > 0:
+        i = order[0]
+        keep.append(i)
+        if order.size == 1:
+            break
+        xx1 = np.maximum(x1[i], x1[order[1:]])
+        yy1 = np.maximum(y1[i], y1[order[1:]])
+        xx2 = np.minimum(x2[i], x2[order[1:]])
+        yy2 = np.minimum(y2[i], y2[order[1:]])
+        w = np.maximum(0.0, xx2 - xx1)
+        h = np.maximum(0.0, yy2 - yy1)
+        inter = w * h
+        iou = inter / (areas[i] + areas[order[1:]] - inter + 1e-9)
+        inds = np.where(iou <= iou_thres)[0]
+        order = order[inds + 1]
+    return keep
+
+
+def sigmoid(x):
+    return 1.0 / (1.0 + np.exp(-x))
+
+
+def process_mask(protos, masks_in, bboxes, shape):
+    """Combine mask coeffs with prototypes -> binary masks at input size."""
+    c, mh, mw = protos.shape
+    masks = sigmoid(masks_in @ protos.reshape(c, -1)).reshape(-1, mh, mw)
+    # Upsample to input size
+    masks = np.stack([cv2.resize(m, (shape[1], shape[0]),
+                                 interpolation=cv2.INTER_LINEAR)
+                      for m in masks])
+    # Crop to bboxes
+    out = []
+    for i, b in enumerate(bboxes):
+        x1, y1, x2, y2 = b.astype(int)
+        crop = np.zeros_like(masks[i], dtype=np.uint8)
+        x1 = max(0, x1); y1 = max(0, y1)
+        x2 = min(shape[1], x2); y2 = min(shape[0], y2)
+        if x2 > x1 and y2 > y1:
+            crop[y1:y2, x1:x2] = (masks[i][y1:y2, x1:x2] > 0.5).astype(np.uint8)
+        out.append(crop)
+    return np.array(out) if out else np.zeros((0, shape[0], shape[1]), dtype=np.uint8)
+
+
+def scale_to_original(boxes_xyxy, masks, meta):
+    """Undo letterbox -> map boxes/masks to original image."""
+    ratio = meta["ratio"]
+    dx, dy = meta["pad"]
+    oh, ow = meta["orig_shape"]
+
+    boxes_xyxy[:, [0, 2]] -= dx
+    boxes_xyxy[:, [1, 3]] -= dy
+    boxes_xyxy /= ratio
+    boxes_xyxy[:, [0, 2]] = boxes_xyxy[:, [0, 2]].clip(0, ow)
+    boxes_xyxy[:, [1, 3]] = boxes_xyxy[:, [1, 3]].clip(0, oh)
+
+    out_masks = []
+    for m in masks:
+        # Crop padding then resize back
+        m_crop = m[int(dy):m.shape[0]-int(dy) or None,
+                   int(dx):m.shape[1]-int(dx) or None]
+        if m_crop.size == 0:
+            out_masks.append(np.zeros((oh, ow), dtype=np.uint8))
+            continue
+        m_resized = cv2.resize(m_crop, (ow, oh), interpolation=cv2.INTER_NEAREST)
+        out_masks.append(m_resized.astype(np.uint8))
+    return boxes_xyxy, np.array(out_masks) if out_masks else np.zeros((0, oh, ow), dtype=np.uint8)
+
+
+def postprocess(outputs, meta, conf_thres=CONF_THRES, iou_thres=IOU_THRES):
+    """
+    YOLO11-seg ONNX outputs:
+        outputs[0]: (1, 4+nc+32, N) detections
+        outputs[1]: (1, 32, mh, mw) mask prototypes
+    """
+    preds = outputs[0]
+    protos = outputs[1][0]
+
+    preds = np.squeeze(preds, 0).T  # (N, 4+nc+32)
+    nc = NUM_CLASSES
+    boxes_xywh = preds[:, :4]
+    cls_scores = preds[:, 4:4 + nc]
+    mask_coeffs = preds[:, 4 + nc:]
+
+    cls_ids = cls_scores.argmax(axis=1)
+    confs = cls_scores.max(axis=1)
+
+    keep_mask = confs > conf_thres
+    boxes_xywh = boxes_xywh[keep_mask]
+    confs = confs[keep_mask]
+    cls_ids = cls_ids[keep_mask]
+    mask_coeffs = mask_coeffs[keep_mask]
+
+    if len(boxes_xywh) == 0:
+        return {
+            "boxes":   np.zeros((0, 4)),
+            "scores":  np.zeros((0,)),
+            "classes": np.zeros((0,), dtype=int),
+            "masks":   np.zeros((0, meta["orig_shape"][0], meta["orig_shape"][1]),
+                                dtype=np.uint8),
+        }
+
+    boxes_xyxy = xywh2xyxy(boxes_xywh)
+    keep = nms_numpy(boxes_xyxy, confs, iou_thres)[:MAX_DET]
+
+    boxes_xyxy = boxes_xyxy[keep]
+    confs = confs[keep]
+    cls_ids = cls_ids[keep]
+    mask_coeffs = mask_coeffs[keep]
+
+    masks = process_mask(protos, mask_coeffs, boxes_xyxy.copy(),
+                         (INPUT_SIZE, INPUT_SIZE))
+    boxes_xyxy, masks = scale_to_original(boxes_xyxy, masks, meta)
+
+    return {
+        "boxes":   boxes_xyxy,
+        "scores":  confs,
+        "classes": cls_ids,
+        "masks":   masks,
+    }

slvehicle-0.1.0/slvehicle/preprocessor.py

@@ -0,0 +1,39 @@
+"""Image preprocessing: letterbox resize + normalize."""
+
+import cv2
+import numpy as np
+from .config import INPUT_SIZE
+
+
+def letterbox(img, new_size=INPUT_SIZE, color=(114, 114, 114)):
+    """Resize image with unchanged aspect ratio using padding."""
+    h, w = img.shape[:2]
+    r = min(new_size / h, new_size / w)
+    new_unpad = (int(round(w * r)), int(round(h * r)))
+    dw = new_size - new_unpad[0]
+    dh = new_size - new_unpad[1]
+    dw, dh = dw / 2, dh / 2
+
+    if (w, h) != new_unpad:
+        img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)
+
+    top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
+    left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
+    img = cv2.copyMakeBorder(img, top, bottom, left, right,
+                             cv2.BORDER_CONSTANT, value=color)
+    return img, r, (left, top)
+
+
+def preprocess(img_bgr, size=INPUT_SIZE):
+    """BGR image -> normalized CHW float32 tensor + meta."""
+    img, ratio, (dx, dy) = letterbox(img_bgr, size)
+    img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    img_norm = img_rgb.astype(np.float32) / 255.0
+    img_chw = np.transpose(img_norm, (2, 0, 1))
+    img_batch = np.expand_dims(img_chw, 0)
+    meta = {
+        "ratio": ratio,
+        "pad":   (dx, dy),
+        "orig_shape": img_bgr.shape[:2],
+    }
+    return img_batch, meta

slvehicle-0.1.0/slvehicle/visualizer.py

@@ -0,0 +1,38 @@
+"""Drawing utilities for detection results."""
+
+import cv2
+import numpy as np
+from .config import CLASS_NAMES, CLASS_COLORS
+
+
+class Visualizer:
+    def __init__(self, alpha=0.5):
+        self.alpha = alpha
+
+    def draw(self, img_bgr, result):
+        out = img_bgr.copy()
+        boxes  = result["boxes"]
+        scores = result["scores"]
+        cls    = result["classes"]
+        masks  = result["masks"]
+
+        # Masks
+        overlay = out.copy()
+        for i, m in enumerate(masks):
+            color = CLASS_COLORS[CLASS_NAMES[int(cls[i])]]
+            overlay[m > 0] = color
+        out = cv2.addWeighted(overlay, self.alpha, out, 1 - self.alpha, 0)
+
+        # Boxes + labels
+        for i, b in enumerate(boxes):
+            x1, y1, x2, y2 = map(int, b)
+            name = CLASS_NAMES[int(cls[i])]
+            color = CLASS_COLORS[name]
+            cv2.rectangle(out, (x1, y1), (x2, y2), color, 2)
+            label = f"{name} {scores[i]:.2f}"
+            (tw, th), _ = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)
+            cv2.rectangle(out, (x1, y1 - th - 6), (x1 + tw + 4, y1), color, -1)
+            cv2.putText(out, label, (x1 + 2, y1 - 4),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1,
+                        cv2.LINE_AA)
+        return out

slvehicle-0.1.0/slvehicle.egg-info/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: slvehicle
+Version: 0.1.0
+Summary: Sri Lanka Vehicle Detection & Segmentation (slvy)
+Author: SriLankaVehicleAI
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.23
+Requires-Dist: opencv-python>=4.7
+Requires-Dist: onnxruntime>=1.16
+Provides-Extra: gpu
+Requires-Dist: onnxruntime-gpu>=1.16; extra == "gpu"
+Provides-Extra: torch
+Requires-Dist: torch>=2.0; extra == "torch"
+Requires-Dist: ultralytics>=8.1; extra == "torch"
+Dynamic: author
+Dynamic: requires-python
+
+# slvehicle (slvy) — Sri Lanka Vehicle AI
+
+Vehicle detection & instance segmentation library for Sri Lankan traffic.
+
+**Classes:** bike, bus, car, lorry, tuktuk, van
+
+## Install
+
+```bash
+pip install slvehicle           # CPU
+pip install slvehicle[gpu]      # GPU (CUDA)
+```
+
+## Usage
+
+```python
+from slvehicle import VehicleDetector
+
+det = VehicleDetector()                              # auto device
+result = det.detect('image.jpg')
+det.detect_and_save('input_folder/', 'output_folder/')
+```
+
+## Performance
+
+- mAP50: 97.3%
+- Model size: 5.6 MB (FP16 ONNX)
+- Speed: ~15 ms (GPU), ~80 ms (CPU)

slvehicle-0.1.0/slvehicle.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+slvehicle/__init__.py
+slvehicle/config.py
+slvehicle/detector.py
+slvehicle/postprocessor.py
+slvehicle/preprocessor.py
+slvehicle/visualizer.py
+slvehicle.egg-info/PKG-INFO
+slvehicle.egg-info/SOURCES.txt
+slvehicle.egg-info/dependency_links.txt
+slvehicle.egg-info/requires.txt
+slvehicle.egg-info/top_level.txt
+slvehicle/engine/__init__.py
+slvehicle/engine/auto_engine.py
+slvehicle/engine/base.py
+slvehicle/engine/cpu_engine.py
+slvehicle/engine/gpu_engine.py
+slvehicle/models/__init__.py
+slvehicle/models/yolo11n_seg.pt
+slvehicle/models/yolo11n_seg_fp16.onnx
+tests/test_library.py

slvehicle-0.1.0/slvehicle.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

slvehicle-0.1.0/slvehicle.egg-info/requires.txt

@@ -0,0 +1,10 @@
+numpy>=1.23
+opencv-python>=4.7
+onnxruntime>=1.16
+
+[gpu]
+onnxruntime-gpu>=1.16
+
+[torch]
+torch>=2.0
+ultralytics>=8.1

slvehicle-0.1.0/slvehicle.egg-info/top_level.txt

@@ -0,0 +1 @@
+slvehicle

slvehicle-0.1.0/tests/test_library.py

@@ -0,0 +1,33 @@
+"""Quick smoke test for the slvehicle library."""
+
+import sys
+from pathlib import Path
+
+# Allow running before pip install
+ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(ROOT))
+
+from slvehicle import VehicleDetector
+
+
+def main():
+    print("=" * 60)
+    print("  slvy library test")
+    print("=" * 60)
+
+    det = VehicleDetector(device="auto")
+    print(f"  Device: {det.engine.device}")
+    print(f"  Model : {det.model_path}")
+    print("  [OK] Detector initialized.")
+
+    # If a sample image exists, run on it
+    sample = ROOT.parent / "data" / "samples"
+    if sample.exists():
+        results = det.detect_folder(sample)
+        print(f"  Processed {len(results)} samples.")
+    else:
+        print("  (no data/samples folder — skipping batch test)")
+
+
+if __name__ == "__main__":
+    main()