ailia-tracker 1.1.1__tar.gz

ailia_tracker-1.1.1/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: ailia_tracker
+Version: 1.1.1
+Summary: ailia Tracker
+Home-page: https://ailia.jp/
+Author: ax Inc.
+Author-email: contact@axinc.jp
+License: https://ailia.ai/en/license/
+Requires-Python: >3.6
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-python
+Dynamic: summary
+
+# ailia Tracker Python API
+
+!! CAUTION !!
+“ailia” IS NOT OPEN SOURCE SOFTWARE (OSS).
+As long as user complies with the conditions stated in [License Document](https://ailia.ai/license/), user may use the Software for free of charge, but the Software is basically paid software.
+
+## About ailia Tracker
+
+ailia Tracker is a library for tracking the movement of objects based on object detection results. It provides a C API for native applications and a C# API for Unity. By using ailia Tracker, you can easily implement object tracking in your application.
+
+## Install from pip
+
+You can install the ailia SDK free evaluation package with the following command.
+
+```
+pip3 install ailia_tracker
+```
+
+## Install from package
+
+You can install the ailia SDK from Package with the following command.
+
+```
+python3 bootstrap.py
+pip3 install .
+```
+
+## Usage
+
+```python
+import ailia_tracker
+
+tracker = ailia_tracker.AiliaTracker()
+
+for frame in frames:
+    for detection in detections(frame):
+        tracker.add_target(detection.category, detection.prob, detection.x, detection.y, detection.w, detection.h)
+    tracker.compute()
+    for obj in tracker.get_objects():
+        print(obj.id, obj.category, obj.prob, obj.x, obj.y, obj.w, obj.h)
+```
+
+The coordinates of `add_target` and the tracking results are normalized to the image size (1 for the image width / height).
+
+## API specification
+
+https://github.com/ailia-ai/ailia-sdk

ailia_tracker-1.1.1/README.md

@@ -0,0 +1,47 @@
+# ailia Tracker Python API
+
+!! CAUTION !!
+“ailia” IS NOT OPEN SOURCE SOFTWARE (OSS).
+As long as user complies with the conditions stated in [License Document](https://ailia.ai/license/), user may use the Software for free of charge, but the Software is basically paid software.
+
+## About ailia Tracker
+
+ailia Tracker is a library for tracking the movement of objects based on object detection results. It provides a C API for native applications and a C# API for Unity. By using ailia Tracker, you can easily implement object tracking in your application.
+
+## Install from pip
+
+You can install the ailia SDK free evaluation package with the following command.
+
+```
+pip3 install ailia_tracker
+```
+
+## Install from package
+
+You can install the ailia SDK from Package with the following command.
+
+```
+python3 bootstrap.py
+pip3 install .
+```
+
+## Usage
+
+```python
+import ailia_tracker
+
+tracker = ailia_tracker.AiliaTracker()
+
+for frame in frames:
+    for detection in detections(frame):
+        tracker.add_target(detection.category, detection.prob, detection.x, detection.y, detection.w, detection.h)
+    tracker.compute()
+    for obj in tracker.get_objects():
+        print(obj.id, obj.category, obj.prob, obj.x, obj.y, obj.w, obj.h)
+```
+
+The coordinates of `add_target` and the tracking results are normalized to the image size (1 for the image width / height).
+
+## API specification
+
+https://github.com/ailia-ai/ailia-sdk

ailia_tracker-1.1.1/ailia_tracker/__init__.py

@@ -0,0 +1,363 @@
+#### python binding of ailia tracker ####
+
+import ctypes
+import os
+import sys
+
+import platform
+
+#### dependency check
+if sys.platform == "win32":
+    import ctypes
+    if platform.machine() != "ARM64":
+        try:
+            for library in ["vcruntime140.dll", "vcruntime140_1.dll", "msvcp140.dll"]:
+                ctypes.windll.LoadLibrary(library)
+        except:
+            print("  WARNING Please install MSVC 2015-2019 runtime from https://docs.microsoft.com/ja-jp/cpp/windows/latest-supported-vc-redist")
+
+
+#### loading DLL / DYLIB / SO  ####
+if sys.platform == "win32":
+    if platform.machine() == "ARM64":
+        dll_platform = "windows/arm64"
+    else:
+        dll_platform = "windows/x64"
+    dll_name = "ailia_tracker.dll"
+    load_fn = ctypes.WinDLL
+elif sys.platform == "darwin":
+    dll_platform = "mac"
+    dll_name = "libailia_tracker.dylib"
+    load_fn = ctypes.CDLL
+else:
+    is_arm = "arm" in platform.machine() or platform.machine() == "aarch64"
+    if is_arm:
+        if platform.architecture()[0] == "32bit":
+            dll_platform = "linux/armeabi-v7a"
+        else:
+            dll_platform = "linux/arm64-v8a"
+    else:
+        dll_platform = "linux/x64"
+    dll_name = "libailia_tracker.so"
+    load_fn = ctypes.CDLL
+
+dll_found = False
+candidate = ["", str(os.path.dirname(os.path.abspath(__file__))) + str(os.sep), str(os.path.dirname(os.path.abspath(__file__))) + str(os.sep) + dll_platform + str(os.sep)]
+for dir in candidate:
+    try:
+        dll = load_fn(dir + dll_name)
+        dll_found = True
+    except:
+        pass
+if not dll_found:
+    msg = "DLL load failed : \'" + dll_name + "\' is not found"
+    raise ImportError(msg)
+
+# ==============================================================================
+
+from ctypes import *
+
+#### constants definition ####
+
+AILIA_STATUS_SUCCESS = ( 0 )
+
+AILIA_TRACKER_ALGORITHM_BYTE_TRACK = ( 0 )
+
+AILIA_TRACKER_OBJECT_VERSION = ( 1 )
+AILIA_TRACKER_SETTINGS_VERSION = ( 1 )
+AILIA_DETECTOR_OBJECT_VERSION = ( 1 )
+
+AILIA_TRACKER_FLAG_NONE = ( 0 )
+AILIA_TRACKER_FLAG_ALLOW_WIDE_ASPECT_RATIO = ( 1 )
+
+#### data structure definition ####
+
+# AILIATrackerSettings
+class TrackerSettings(ctypes.Structure):
+    """ settings of the tracker (AILIATrackerSettings)
+
+    Attributes
+    ----------
+    score_threshold : float
+        Minimum confidence score to accept a detection result.
+    nms_threshold : float
+        Non-Maximum Suppression (NMS) threshold used to remove duplicate detections.
+    track_threshold : float
+        Confidence threshold for updating active tracks.
+    track_buffer : int
+        Maximum number of frames to keep lost tracks in memory.
+    match_threshold : float
+        IoU threshold used for matching objects between frames.
+    """
+    _fields_ = [
+        ("score_threshold", ctypes.c_float),
+        ("nms_threshold", ctypes.c_float),
+        ("track_threshold", ctypes.c_float),
+        ("track_buffer", ctypes.c_int),
+        ("match_threshold", ctypes.c_float)]
+    VERSION = ctypes.c_int(AILIA_TRACKER_SETTINGS_VERSION)
+
+# AILIATrackerObject
+class TrackerObject(ctypes.Structure):
+    """ tracking result (AILIATrackerObject)
+
+    Attributes
+    ----------
+    id : int
+        Object tracking id.
+    category : int
+        Object category number (0 to category_count-1).
+    prob : float
+        Estimated probability (0 to 1).
+    x : float
+        X position at the top left (1 for the image width).
+    y : float
+        Y position at the top left (1 for the image height).
+    w : float
+        Width (1 for the width of the image, negative numbers not allowed).
+    h : float
+        Height (1 for the height of the image, negative numbers not allowed).
+    """
+    _fields_ = [
+        ("id", ctypes.c_uint),
+        ("category", ctypes.c_uint),
+        ("prob", ctypes.c_float),
+        ("x", ctypes.c_float),
+        ("y", ctypes.c_float),
+        ("w", ctypes.c_float),
+        ("h", ctypes.c_float)]
+    VERSION = ctypes.c_uint(AILIA_TRACKER_OBJECT_VERSION)
+
+# AILIADetectorObject
+class DetectorObject(ctypes.Structure):
+    """ tracking target (AILIADetectorObject)
+
+    Attributes
+    ----------
+    category : int
+        Object category number (0 to category_count-1).
+    prob : float
+        Estimated probability (0 to 1).
+    x : float
+        X position at the top left (1 for the image width).
+    y : float
+        Y position at the top left (1 for the image height).
+    w : float
+        Width (1 for the width of the image, negative numbers not allowed).
+    h : float
+        Height (1 for the height of the image, negative numbers not allowed).
+    """
+    _fields_ = [
+        ("category", ctypes.c_uint),
+        ("prob", ctypes.c_float),
+        ("x", ctypes.c_float),
+        ("y", ctypes.c_float),
+        ("w", ctypes.c_float),
+        ("h", ctypes.c_float)]
+    VERSION = ctypes.c_int(AILIA_DETECTOR_OBJECT_VERSION)
+
+#### API prototypes ####
+
+dll.ailiaTrackerCreate.restype = ctypes.c_int
+dll.ailiaTrackerCreate.argtypes = (
+    ctypes.POINTER(ctypes.c_void_p),                # tracker
+    ctypes.c_int,                                   # algorithm
+    ctypes.POINTER(TrackerSettings),                # settings
+    ctypes.c_int,                                   # version
+    ctypes.c_int)                                   # flags
+
+dll.ailiaTrackerAddTarget.restype = ctypes.c_int
+dll.ailiaTrackerAddTarget.argtypes = (
+    ctypes.c_void_p,                                # tracker
+    ctypes.POINTER(DetectorObject),                 # detector_object
+    ctypes.c_int)                                   # version
+
+dll.ailiaTrackerCompute.restype = ctypes.c_int
+dll.ailiaTrackerCompute.argtypes = (
+    ctypes.c_void_p, )                              # tracker
+
+dll.ailiaTrackerGetObjectCount.restype = ctypes.c_int
+dll.ailiaTrackerGetObjectCount.argtypes = (
+    ctypes.c_void_p,                                # tracker
+    ctypes.POINTER(ctypes.c_uint))                  # obj_count
+
+dll.ailiaTrackerGetObject.restype = ctypes.c_int
+dll.ailiaTrackerGetObject.argtypes = (
+    ctypes.c_void_p,                                # tracker
+    ctypes.POINTER(TrackerObject),                  # obj
+    ctypes.c_uint,                                  # index
+    ctypes.c_uint)                                  # version
+
+dll.ailiaTrackerDestroy.restype = ctypes.c_int
+dll.ailiaTrackerDestroy.argtypes = (
+    ctypes.c_void_p, )                              # tracker
+
+dll.ailiaTrackerGetErrorDetail.restype = ctypes.c_char_p
+dll.ailiaTrackerGetErrorDetail.argtypes = (
+    ctypes.c_void_p, )                              # tracker
+
+#### exception ####
+
+class AiliaTrackerError(RuntimeError):
+    """ exception raised when an ailia tracker API call fails
+
+    Attributes
+    ----------
+    code : int
+        Error code (AILIA_STATUS_*) returned from the ailia tracker API.
+    """
+    def __init__(self, message, code):
+        super().__init__(message)
+        self.code = code
+
+#### API wrapper ####
+
+class AiliaTracker:
+    """ wrapper class for ailia tracker instance """
+
+    def __init__(self, algorithm=AILIA_TRACKER_ALGORITHM_BYTE_TRACK, score_threshold=0.1, nms_threshold=0.7, track_threshold=0.5, track_buffer=30, match_threshold=0.8, flags=AILIA_TRACKER_FLAG_NONE):
+        """ constructor of ailia tracker instance.
+
+        Parameters
+        ----------
+        algorithm : int, optional, default: AILIA_TRACKER_ALGORITHM_BYTE_TRACK(0)
+            tracking algorithm.
+        score_threshold : float, optional, default: 0.1
+            minimum confidence score to accept a detection result.
+        nms_threshold : float, optional, default: 0.7
+            Non-Maximum Suppression (NMS) threshold used to remove duplicate detections.
+        track_threshold : float, optional, default: 0.5
+            confidence threshold for updating active tracks.
+        track_buffer : int, optional, default: 30
+            maximum number of frames to keep lost tracks in memory.
+        match_threshold : float, optional, default: 0.8
+            IoU threshold used for matching objects between frames.
+        flags : int, optional, default: AILIA_TRACKER_FLAG_NONE(0)
+            logical OR of AILIA_TRACKER_FLAG_*.
+        """
+        self.__tracker = ctypes.c_void_p(None)
+        settings = TrackerSettings(
+            score_threshold=score_threshold,
+            nms_threshold=nms_threshold,
+            track_threshold=track_threshold,
+            track_buffer=track_buffer,
+            match_threshold=match_threshold)
+        code = dll.ailiaTrackerCreate(
+            ctypes.byref(self.__tracker),
+            ctypes.c_int(algorithm),
+            ctypes.byref(settings),
+            TrackerSettings.VERSION,
+            ctypes.c_int(flags))
+        self.__check(code, "ailiaTrackerCreate")
+
+    def __check(self, code, function_name):
+        if code != AILIA_STATUS_SUCCESS:
+            detail = "code : " + str(code)
+            if self.__tracker:
+                error_detail = dll.ailiaTrackerGetErrorDetail(self.__tracker)
+                if error_detail:
+                    detail = error_detail.decode("utf-8") + " (" + detail + ")"
+            raise AiliaTrackerError(function_name + " failed : " + detail, code)
+
+    def add_target(self, category, prob, x, y, w, h):
+        """ set a tracking target detected in the current frame.
+
+        Parameters
+        ----------
+        category : int
+            object category number.
+        prob : float
+            estimated probability (0 to 1).
+        x : float
+            x position at the top left (1 for the image width).
+        y : float
+            y position at the top left (1 for the image height).
+        w : float
+            width (1 for the width of the image).
+        h : float
+            height (1 for the height of the image).
+        """
+        obj = DetectorObject(
+            category=category,
+            prob=prob,
+            x=x,
+            y=y,
+            w=w,
+            h=h)
+        code = dll.ailiaTrackerAddTarget(
+            self.__tracker,
+            ctypes.byref(obj),
+            DetectorObject.VERSION)
+        self.__check(code, "ailiaTrackerAddTarget")
+
+    def compute(self):
+        """ run tracking with the targets given by add_target().
+
+        Get the tracking result with get_objects() or get_object().
+        """
+        code = dll.ailiaTrackerCompute(self.__tracker)
+        self.__check(code, "ailiaTrackerCompute")
+
+    def get_object_count(self):
+        """ get the number of tracked objects.
+
+        Returns
+        -------
+        int
+            number of tracked objects.
+        """
+        count = ctypes.c_uint(0)
+        code = dll.ailiaTrackerGetObjectCount(self.__tracker, ctypes.byref(count))
+        self.__check(code, "ailiaTrackerGetObjectCount")
+        return count.value
+
+    def get_object(self, index):
+        """ get a tracked object specified by index.
+
+        Parameters
+        ----------
+        index : int
+            object index.
+            valid values : range(0, get_object_count())
+
+        Returns
+        -------
+        TrackerObject
+            tracking result.
+        """
+        obj = TrackerObject()
+        code = dll.ailiaTrackerGetObject(
+            self.__tracker,
+            ctypes.byref(obj),
+            ctypes.c_uint(index),
+            TrackerObject.VERSION)
+        self.__check(code, "ailiaTrackerGetObject")
+        return obj
+
+    def get_objects(self):
+        """ get all tracked objects.
+
+        Returns
+        -------
+        list of TrackerObject
+            tracking results.
+        """
+        objects = []
+        for index in range(self.get_object_count()):
+            objects.append(self.get_object(index))
+        return objects
+
+    def release(self):
+        """ destroy the ailia tracker instance. """
+        if self.__tracker:
+            dll.ailiaTrackerDestroy(self.__tracker)
+            self.__tracker = ctypes.c_void_p(None)
+
+    def __del__(self):
+        self.release()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.release()

ailia_tracker-1.1.1/ailia_tracker.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: ailia_tracker
+Version: 1.1.1
+Summary: ailia Tracker
+Home-page: https://ailia.jp/
+Author: ax Inc.
+Author-email: contact@axinc.jp
+License: https://ailia.ai/en/license/
+Requires-Python: >3.6
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-python
+Dynamic: summary
+
+# ailia Tracker Python API
+
+!! CAUTION !!
+“ailia” IS NOT OPEN SOURCE SOFTWARE (OSS).
+As long as user complies with the conditions stated in [License Document](https://ailia.ai/license/), user may use the Software for free of charge, but the Software is basically paid software.
+
+## About ailia Tracker
+
+ailia Tracker is a library for tracking the movement of objects based on object detection results. It provides a C API for native applications and a C# API for Unity. By using ailia Tracker, you can easily implement object tracking in your application.
+
+## Install from pip
+
+You can install the ailia SDK free evaluation package with the following command.
+
+```
+pip3 install ailia_tracker
+```
+
+## Install from package
+
+You can install the ailia SDK from Package with the following command.
+
+```
+python3 bootstrap.py
+pip3 install .
+```
+
+## Usage
+
+```python
+import ailia_tracker
+
+tracker = ailia_tracker.AiliaTracker()
+
+for frame in frames:
+    for detection in detections(frame):
+        tracker.add_target(detection.category, detection.prob, detection.x, detection.y, detection.w, detection.h)
+    tracker.compute()
+    for obj in tracker.get_objects():
+        print(obj.id, obj.category, obj.prob, obj.x, obj.y, obj.w, obj.h)
+```
+
+The coordinates of `add_target` and the tracking results are normalized to the image size (1 for the image width / height).
+
+## API specification
+
+https://github.com/ailia-ai/ailia-sdk

ailia_tracker-1.1.1/ailia_tracker.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+setup.py
+ailia_tracker/__init__.py
+ailia_tracker.egg-info/PKG-INFO
+ailia_tracker.egg-info/SOURCES.txt
+ailia_tracker.egg-info/dependency_links.txt
+ailia_tracker.egg-info/top_level.txt
+ailia_tracker/linux/arm64-v8a/libailia_tracker.so
+ailia_tracker/linux/x64/libailia_tracker.so
+ailia_tracker/mac/libailia_tracker.dylib
+ailia_tracker/windows/arm64/ailia_tracker.dll
+ailia_tracker/windows/x64/ailia_tracker.dll

ailia_tracker-1.1.1/ailia_tracker.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ailia_tracker-1.1.1/ailia_tracker.egg-info/top_level.txt

@@ -0,0 +1 @@
+ailia_tracker

ailia_tracker-1.1.1/setup.cfg

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

ailia_tracker-1.1.1/setup.py

@@ -0,0 +1,57 @@
+import glob
+
+from setuptools import setup
+
+with open("README.md", encoding="utf-8") as f:
+    long_description = f.read()
+
+
+def find_libraries():
+    dll_names = []
+    platforms = ["win32", "win32_aarch64", "darwin", "linux_armv7l", "linux_aarch64", "linux_x86_64"]
+
+    for platform in platforms:
+        if platform == "win32":
+            dll_platform = "windows/x64"
+            dll_type = ".dll"
+        elif platform == "win32_aarch64":
+            dll_platform = "windows/arm64"
+            dll_type = ".dll"
+        elif platform == "darwin":
+            dll_platform = "mac"
+            dll_type = ".dylib"
+        else:
+            if platform == "linux_armv7l":
+                dll_platform = "linux/armeabi-v7a"
+            elif platform == "linux_aarch64":
+                dll_platform = "linux/arm64-v8a"
+            else:
+                dll_platform = "linux/x64"
+            dll_type = ".so"
+
+        dll_path = "./ailia_tracker/" + dll_platform + "/"
+
+        for f in glob.glob(dll_path + "*" + dll_type):
+            f = f.replace("\\", "/")
+            f = f.replace("./ailia_tracker/", "./")
+            dll_names.append(f)
+
+    return dll_names
+
+
+if __name__ == "__main__":
+    setup(
+        name="ailia_tracker",
+        version="1.1.1",
+        description="ailia Tracker",
+        long_description=long_description,
+        long_description_content_type="text/markdown",
+        author="ax Inc.",
+        author_email="contact@axinc.jp",
+        url="https://ailia.jp/",
+        license="https://ailia.ai/en/license/",
+        packages=["ailia_tracker"],
+        package_data={"ailia_tracker": find_libraries()},
+        include_package_data=True,
+        python_requires=">3.6",
+    )