supervisely 6.73.418__py3-none-any.whl → 6.73.419__py3-none-any.whl

supervisely/nn/tracker/utils/kalman_filter.py

@@ -1,492 +0,0 @@
-import numpy as np
-
-"""
-Table for the 0.95 quantile of the chi-square distribution with N degrees of
-freedom (contains values for N=1, ..., 9). Taken from MATLAB/Octave's chi2inv
-function and used as Mahalanobis gating threshold.
-"""
-chi2inv95 = {
-    1: 3.8415,
-    2: 5.9915,
-    3: 7.8147,
-    4: 9.4877,
-    5: 11.070,
-    6: 12.592,
-    7: 14.067,
-    8: 15.507,
-    9: 16.919,
-}
-
-
-class KalmanFilterXYWH(object):
-    """
-    A simple Kalman filter for tracking bounding boxes in image space.
-
-    The 8-dimensional state space
-
-        x, y, w, h, vx, vy, vw, vh
-
-    contains the bounding box center position (x, y), width w, height h,
-    and their respective velocities.
-
-    Object motion follows a constant velocity model. The bounding box location
-    (x, y, w, h) is taken as direct observation of the state space (linear
-    observation model).
-
-    """
-
-    def __init__(self):
-        ndim, dt = 4, 1.0
-
-        # Create Kalman filter model matrices.
-        self._motion_mat = np.eye(2 * ndim, 2 * ndim)
-        for i in range(ndim):
-            self._motion_mat[i, ndim + i] = dt
-        self._update_mat = np.eye(ndim, 2 * ndim)
-
-        # Motion and observation uncertainty are chosen relative to the current
-        # state estimate. These weights control the amount of uncertainty in
-        # the model. This is a bit hacky.
-        self._std_weight_position = 1.0 / 20
-        self._std_weight_velocity = 1.0 / 160
-
-    def initiate(self, measurement):
-        """Create track from unassociated measurement.
-
-        Parameters
-        ----------
-        measurement : ndarray
-            Bounding box coordinates (x, y, w, h) with center position (x, y),
-            width w, and height h.
-
-        Returns
-        -------
-        (ndarray, ndarray)
-            Returns the mean vector (8 dimensional) and covariance matrix (8x8
-            dimensional) of the new track. Unobserved velocities are initialized
-            to 0 mean.
-
-        """
-        mean_pos = measurement
-        mean_vel = np.zeros_like(mean_pos)
-        mean = np.r_[mean_pos, mean_vel]
-
-        std = [
-            2 * self._std_weight_position * measurement[2],
-            2 * self._std_weight_position * measurement[3],
-            2 * self._std_weight_position * measurement[2],
-            2 * self._std_weight_position * measurement[3],
-            10 * self._std_weight_velocity * measurement[2],
-            10 * self._std_weight_velocity * measurement[3],
-            10 * self._std_weight_velocity * measurement[2],
-            10 * self._std_weight_velocity * measurement[3],
-        ]
-        covariance = np.diag(np.square(std))
-        return mean, covariance
-
-    def predict(self, mean, covariance):
-        """Run Kalman filter prediction step.
-
-        Parameters
-        ----------
-        mean : ndarray
-            The 8 dimensional mean vector of the object state at the previous
-            time step.
-        covariance : ndarray
-            The 8x8 dimensional covariance matrix of the object state at the
-            previous time step.
-
-        Returns
-        -------
-        (ndarray, ndarray)
-            Returns the mean vector and covariance matrix of the predicted
-            state. Unobserved velocities are initialized to 0 mean.
-
-        """
-        std_pos = [
-            self._std_weight_position * mean[2],
-            self._std_weight_position * mean[3],
-            self._std_weight_position * mean[2],
-            self._std_weight_position * mean[3],
-        ]
-        std_vel = [
-            self._std_weight_velocity * mean[2],
-            self._std_weight_velocity * mean[3],
-            self._std_weight_velocity * mean[2],
-            self._std_weight_velocity * mean[3],
-        ]
-        motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))
-
-        mean = np.dot(mean, self._motion_mat.T)
-        covariance = (
-            np.linalg.multi_dot((self._motion_mat, covariance, self._motion_mat.T)) + motion_cov
-        )
-
-        return mean, covariance
-
-    def project(self, mean, covariance):
-        """Project state distribution to measurement space.
-
-        Parameters
-        ----------
-        mean : ndarray
-            The state's mean vector (8 dimensional array).
-        covariance : ndarray
-            The state's covariance matrix (8x8 dimensional).
-
-        Returns
-        -------
-        (ndarray, ndarray)
-            Returns the projected mean and covariance matrix of the given state
-            estimate.
-
-        """
-        std = [
-            self._std_weight_position * mean[2],
-            self._std_weight_position * mean[3],
-            self._std_weight_position * mean[2],
-            self._std_weight_position * mean[3],
-        ]
-        innovation_cov = np.diag(np.square(std))
-
-        mean = np.dot(self._update_mat, mean)
-        covariance = np.linalg.multi_dot((self._update_mat, covariance, self._update_mat.T))
-        return mean, covariance + innovation_cov
-
-    def multi_predict(self, mean, covariance):
-        """Run Kalman filter prediction step (Vectorized version).
-        Parameters
-        ----------
-        mean : ndarray
-            The Nx8 dimensional mean matrix of the object states at the previous
-            time step.
-        covariance : ndarray
-            The Nx8x8 dimensional covariance matrics of the object states at the
-            previous time step.
-        Returns
-        -------
-        (ndarray, ndarray)
-            Returns the mean vector and covariance matrix of the predicted
-            state. Unobserved velocities are initialized to 0 mean.
-        """
-        std_pos = [
-            self._std_weight_position * mean[:, 2],
-            self._std_weight_position * mean[:, 3],
-            self._std_weight_position * mean[:, 2],
-            self._std_weight_position * mean[:, 3],
-        ]
-        std_vel = [
-            self._std_weight_velocity * mean[:, 2],
-            self._std_weight_velocity * mean[:, 3],
-            self._std_weight_velocity * mean[:, 2],
-            self._std_weight_velocity * mean[:, 3],
-        ]
-        sqr = np.square(np.r_[std_pos, std_vel]).T
-
-        motion_cov = []
-        for i in range(len(mean)):
-            motion_cov.append(np.diag(sqr[i]))
-        motion_cov = np.asarray(motion_cov)
-
-        mean = np.dot(mean, self._motion_mat.T)
-        left = np.dot(self._motion_mat, covariance).transpose((1, 0, 2))
-        covariance = np.dot(left, self._motion_mat.T) + motion_cov
-
-        return mean, covariance
-
-    def update(self, mean, covariance, measurement):
-        """Run Kalman filter correction step.
-
-        Parameters
-        ----------
-        mean : ndarray
-            The predicted state's mean vector (8 dimensional).
-        covariance : ndarray
-            The state's covariance matrix (8x8 dimensional).
-        measurement : ndarray
-            The 4 dimensional measurement vector (x, y, w, h), where (x, y)
-            is the center position, w the width, and h the height of the
-            bounding box.
-
-        Returns
-        -------
-        (ndarray, ndarray)
-            Returns the measurement-corrected state distribution.
-
-        """
-        import scipy.linalg  # pylint: disable=import-error
-
-        projected_mean, projected_cov = self.project(mean, covariance)
-
-        chol_factor, lower = scipy.linalg.cho_factor(projected_cov, lower=True, check_finite=False)
-        kalman_gain = scipy.linalg.cho_solve(
-            (chol_factor, lower), np.dot(covariance, self._update_mat.T).T, check_finite=False
-        ).T
-        innovation = measurement - projected_mean
-
-        new_mean = mean + np.dot(innovation, kalman_gain.T)
-        new_covariance = covariance - np.linalg.multi_dot(
-            (kalman_gain, projected_cov, kalman_gain.T)
-        )
-        return new_mean, new_covariance
-
-    def gating_distance(self, mean, covariance, measurements, only_position=False, metric="maha"):
-        """Compute gating distance between state distribution and measurements.
-        A suitable distance threshold can be obtained from `chi2inv95`. If
-        `only_position` is False, the chi-square distribution has 4 degrees of
-        freedom, otherwise 2.
-        Parameters
-        ----------
-        mean : ndarray
-            Mean vector over the state distribution (8 dimensional).
-        covariance : ndarray
-            Covariance of the state distribution (8x8 dimensional).
-        measurements : ndarray
-            An Nx4 dimensional matrix of N measurements, each in
-            format (x, y, a, h) where (x, y) is the bounding box center
-            position, a the aspect ratio, and h the height.
-        only_position : Optional[bool]
-            If True, distance computation is done with respect to the bounding
-            box center position only.
-        Returns
-        -------
-        ndarray
-            Returns an array of length N, where the i-th element contains the
-            squared Mahalanobis distance between (mean, covariance) and
-            `measurements[i]`.
-        """
-        import scipy.linalg  # pylint: disable=import-error
-
-        mean, covariance = self.project(mean, covariance)
-        if only_position:
-            mean, covariance = mean[:2], covariance[:2, :2]
-            measurements = measurements[:, :2]
-
-        d = measurements - mean
-        if metric == "gaussian":
-            return np.sum(d * d, axis=1)
-        elif metric == "maha":
-            cholesky_factor = np.linalg.cholesky(covariance)
-            z = scipy.linalg.solve_triangular(
-                cholesky_factor, d.T, lower=True, check_finite=False, overwrite_b=True
-            )
-            squared_maha = np.sum(z * z, axis=0)
-            return squared_maha
-        else:
-            raise ValueError("invalid distance metric")
-
-
-class KalmanFilterXYAH(object):
-    """
-    A simple Kalman filter for tracking bounding boxes in image space.
-
-    The 8-dimensional state space
-
-        x, y, a, h, vx, vy, va, vh
-
-    contains the bounding box center position (x, y), aspect ratio a, height h,
-    and their respective velocities.
-
-    Object motion follows a constant velocity model. The bounding box location
-    (x, y, a, h) is taken as direct observation of the state space (linear
-    observation model).
-
-    """
-
-    def __init__(self):
-        ndim, dt = 4, 1.0
-
-        # Create Kalman filter model matrices.
-        self._motion_mat = np.eye(2 * ndim, 2 * ndim)
-        for i in range(ndim):
-            self._motion_mat[i, ndim + i] = dt
-        self._update_mat = np.eye(ndim, 2 * ndim)
-
-        # Motion and observation uncertainty are chosen relative to the current
-        # state estimate. These weights control the amount of uncertainty in
-        # the model. This is a bit hacky.
-        self._std_weight_position = 1.0 / 20
-        self._std_weight_velocity = 1.0 / 160
-
-    def initiate(self, measurement):
-        """Create track from unassociated measurement.
-
-        Parameters
-        ----------
-        measurement : ndarray
-            Bounding box coordinates (x, y, a, h) with center position (x, y),
-            aspect ratio a, and height h.
-
-        Returns
-        -------
-        (ndarray, ndarray)
-            Returns the mean vector (8 dimensional) and covariance matrix (8x8
-            dimensional) of the new track. Unobserved velocities are initialized
-            to 0 mean.
-
-        """
-        mean_pos = measurement
-        mean_vel = np.zeros_like(mean_pos)
-        mean = np.r_[mean_pos, mean_vel]
-
-        std = [
-            2 * self._std_weight_position * measurement[3],
-            2 * self._std_weight_position * measurement[3],
-            1e-2,
-            2 * self._std_weight_position * measurement[3],
-            10 * self._std_weight_velocity * measurement[3],
-            10 * self._std_weight_velocity * measurement[3],
-            1e-5,
-            10 * self._std_weight_velocity * measurement[3],
-        ]
-        covariance = np.diag(np.square(std))
-        return mean, covariance
-
-    def predict(self, mean, covariance):
-        """Run Kalman filter prediction step.
-
-        Parameters
-        ----------
-        mean : ndarray
-            The 8 dimensional mean vector of the object state at the previous
-            time step.
-        covariance : ndarray
-            The 8x8 dimensional covariance matrix of the object state at the
-            previous time step.
-
-        Returns
-        -------
-        (ndarray, ndarray)
-            Returns the mean vector and covariance matrix of the predicted
-            state. Unobserved velocities are initialized to 0 mean.
-
-        """
-        std_pos = [
-            self._std_weight_position * mean[3],
-            self._std_weight_position * mean[3],
-            1e-2,
-            self._std_weight_position * mean[3],
-        ]
-        std_vel = [
-            self._std_weight_velocity * mean[3],
-            self._std_weight_velocity * mean[3],
-            1e-5,
-            self._std_weight_velocity * mean[3],
-        ]
-        motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))
-
-        mean = np.dot(self._motion_mat, mean)
-        covariance = (
-            np.linalg.multi_dot((self._motion_mat, covariance, self._motion_mat.T)) + motion_cov
-        )
-
-        return mean, covariance
-
-    def project(self, mean, covariance):
-        """Project state distribution to measurement space.
-
-        Parameters
-        ----------
-        mean : ndarray
-            The state's mean vector (8 dimensional array).
-        covariance : ndarray
-            The state's covariance matrix (8x8 dimensional).
-
-        Returns
-        -------
-        (ndarray, ndarray)
-            Returns the projected mean and covariance matrix of the given state
-            estimate.
-
-        """
-        std = [
-            self._std_weight_position * mean[3],
-            self._std_weight_position * mean[3],
-            1e-1,
-            self._std_weight_position * mean[3],
-        ]
-        innovation_cov = np.diag(np.square(std))
-
-        mean = np.dot(self._update_mat, mean)
-        covariance = np.linalg.multi_dot((self._update_mat, covariance, self._update_mat.T))
-        return mean, covariance + innovation_cov
-
-    def update(self, mean, covariance, measurement):
-        """Run Kalman filter correction step.
-
-        Parameters
-        ----------
-        mean : ndarray
-            The predicted state's mean vector (8 dimensional).
-        covariance : ndarray
-            The state's covariance matrix (8x8 dimensional).
-        measurement : ndarray
-            The 4 dimensional measurement vector (x, y, a, h), where (x, y)
-            is the center position, a the aspect ratio, and h the height of the
-            bounding box.
-
-        Returns
-        -------
-        (ndarray, ndarray)
-            Returns the measurement-corrected state distribution.
-
-        """
-        import scipy.linalg  # pylint: disable=import-error
-
-        projected_mean, projected_cov = self.project(mean, covariance)
-
-        chol_factor, lower = scipy.linalg.cho_factor(projected_cov, lower=True, check_finite=False)
-        kalman_gain = scipy.linalg.cho_solve(
-            (chol_factor, lower), np.dot(covariance, self._update_mat.T).T, check_finite=False
-        ).T
-        innovation = measurement - projected_mean
-
-        new_mean = mean + np.dot(innovation, kalman_gain.T)
-        new_covariance = covariance - np.linalg.multi_dot(
-            (kalman_gain, projected_cov, kalman_gain.T)
-        )
-        return new_mean, new_covariance
-
-    def gating_distance(self, mean, covariance, measurements, only_position=False):
-        """Compute gating distance between state distribution and measurements.
-
-        A suitable distance threshold can be obtained from `chi2inv95`. If
-        `only_position` is False, the chi-square distribution has 4 degrees of
-        freedom, otherwise 2.
-
-        Parameters
-        ----------
-        mean : ndarray
-            Mean vector over the state distribution (8 dimensional).
-        covariance : ndarray
-            Covariance of the state distribution (8x8 dimensional).
-        measurements : ndarray
-            An Nx4 dimensional matrix of N measurements, each in
-            format (x, y, a, h) where (x, y) is the bounding box center
-            position, a the aspect ratio, and h the height.
-        only_position : Optional[bool]
-            If True, distance computation is done with respect to the bounding
-            box center position only.
-
-        Returns
-        -------
-        ndarray
-            Returns an array of length N, where the i-th element contains the
-            squared Mahalanobis distance between (mean, covariance) and
-            `measurements[i]`.
-
-        """
-        import scipy.linalg  # pylint: disable=import-error
-
-        mean, covariance = self.project(mean, covariance)
-        if only_position:
-            mean, covariance = mean[:2], covariance[:2, :2]
-            measurements = measurements[:, :2]
-
-        cholesky_factor = np.linalg.cholesky(covariance)
-        d = measurements - mean
-        z = scipy.linalg.solve_triangular(
-            cholesky_factor, d.T, lower=True, check_finite=False, overwrite_b=True
-        )
-        squared_maha = np.sum(z * z, axis=0)
-        return squared_maha

supervisely/nn/tracking/__init__.py

@@ -1 +0,0 @@
-from supervisely.nn.tracking.tracking import track

supervisely/nn/tracking/boxmot.py

@@ -1,114 +0,0 @@
-from typing import Iterable, List, Optional, Union
-
-import numpy as np
-
-from supervisely.annotation.annotation import Annotation
-from supervisely.geometry.rectangle import Rectangle
-from supervisely.nn.model.model_api import Prediction
-from supervisely.video_annotation.frame import Frame
-from supervisely.video_annotation.frame_collection import FrameCollection
-from supervisely.video_annotation.video_annotation import VideoAnnotation
-from supervisely.video_annotation.video_figure import VideoFigure
-from supervisely.video_annotation.video_object import VideoObject
-from supervisely.video_annotation.video_object_collection import VideoObjectCollection
-
-
-def _none_generator():
-    while True:
-        yield None
-
-
-def apply_boxmot(
-    tracker,
-    predictions: Union[List[Prediction], List[Annotation]],
-    class_names: List[str],
-    frames: Optional[Iterable[np.ndarray]] = None,
-) -> VideoAnnotation:
-    if frames is None:
-        frames = _none_generator()
-    results = []
-    annotations = []
-    frames_count = 0
-    for prediction, frame in zip(predictions, frames):
-        frames_count += 1
-        if isinstance(prediction, Prediction):
-            annotation = prediction.annotation
-            if frame is None:
-                frame = prediction.load_image()
-        else:
-            annotation = prediction
-        frame_shape = frame.shape[:2]
-        annotations.append(annotation)
-        detections = to_boxes(annotation, class_names)  # N x (x, y, x, y, conf, label)
-        tracks = tracker.update(
-            detections, frame
-        )  # M x (x, y, x, y, track_id, conf, label, det_id)
-        results.append(tracks)
-    return create_video_annotation(annotations, results, class_names, frame_shape, frames_count)
-
-
-def to_boxes(ann: Annotation, class_names: List[str]) -> np.ndarray:
-    """
-    Convert annotation to detections array in boxmot format.
-    :param ann: Supervisely Annotation object
-    :type ann: Annotation
-    :param class_names: model class names
-    :type class_names: List[str]
-    :return: detections array N x (x, y, x, y, conf, label)
-    :rtype: np.ndarray
-    """
-    # convert ann to N x (x, y, x, y, conf, cls) np.array
-    cls2label = {class_name: i for i, class_name in enumerate(class_names)}
-    detections = []
-    for label in ann.labels:
-        cat = cls2label[label.obj_class.name]
-        bbox = label.geometry.to_bbox()
-        conf = label.tags.get("confidence").value
-        detections.append([bbox.left, bbox.top, bbox.right, bbox.bottom, conf, cat])
-    detections = np.array(detections)
-    return detections
-
-
-def create_video_annotation(
-    annotations: List[Annotation],
-    tracking_results: list,
-    class_names: List[str],
-    frame_shape: tuple,
-    frames_count: int,
-) -> VideoAnnotation:
-    img_h, img_w = frame_shape
-    video_objects = {}  # track_id -> VideoObject
-    frames = []
-    cat2obj = {}
-    name2cat = {class_name: i for i, class_name in enumerate(class_names)}
-    obj_classes = {}
-    for annotation in annotations:
-        for label in annotation.labels:
-            obj_classes.setdefault(label.obj_class.name, label.obj_class)
-    for obj_name, cat in name2cat.items():
-        obj_class = obj_classes.get(obj_name)
-        if obj_class is None:
-            raise ValueError(f"Object class {obj_name} not found in annotations.")
-        cat2obj[cat] = obj_class
-    for i, tracks in enumerate(tracking_results):
-        frame_figures = []
-        for track in tracks:
-            # crop bbox to image size
-            dims = np.array([img_w, img_h, img_w, img_h]) - 1
-            track[:4] = np.clip(track[:4], 0, dims)
-            x1, y1, x2, y2, track_id, conf, cat = track[:7]
-            cat = int(cat)
-            track_id = int(track_id)
-            rect = Rectangle(y1, x1, y2, x2)
-            video_object = video_objects.setdefault(track_id, VideoObject(cat2obj[cat]))
-            frame_figures.append(VideoFigure(video_object, rect, i))
-        frames.append(Frame(i, frame_figures))
-
-    objects = list(video_objects.values())
-    video_annotation = VideoAnnotation(
-        img_size=frame_shape,
-        frames_count=frames_count,
-        objects=VideoObjectCollection(objects),
-        frames=FrameCollection(frames),
-    )
-    return video_annotation

supervisely/nn/tracking/tracking.py

@@ -1,24 +0,0 @@
-from typing import Any, Callable
-
-from supervisely.nn.model.model_api import ModelAPI
-from supervisely.nn.tracking.boxmot import apply_boxmot
-from supervisely.video_annotation.video_annotation import VideoAnnotation
-
-
-def _get_apply_fn(tracker: Any) -> Callable:
-    if tracker.__class__.__module__.startswith("boxmot"):
-        return apply_boxmot
-    else:
-        raise ValueError(
-            f"Tracker {tracker.__class__.__module__} is not supported. Please, use boxmot tracker."
-        )
-
-
-def track(video_id: int, tracker, detector: ModelAPI, **kwargs) -> VideoAnnotation:
-    apply_fn = _get_apply_fn(tracker)
-    if "classes" in kwargs:
-        classes = kwargs["classes"]
-    else:
-        classes = detector.get_classes()
-    predictions = detector.predict_detached(video_id=video_id, **kwargs)
-    return apply_fn(tracker, predictions, classes)