Add external AI projects and fix build include

Author: kyrylon-spec

sunone_aimbot_cpp/China_ai/.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+*.pyo
+target/
+nul

sunone_aimbot_cpp/China_ai/ChillBitmap_16px.ttf

@@ -0,0 +1,180 @@
+import numpy as np
+from scipy.optimize import linear_sum_assignment
+from filterpy.kalman import KalmanFilter
+
+class KalmanBoxTracker(object):
+    count = 0
+
+    def __init__(self, bbox):
+        self.kf = KalmanFilter(dim_x=7, dim_z=4)
+        self.kf.F = np.array([[1, 0, 0, 0, 1, 0, 0], [0, 1, 0, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 1], [0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 0, 0, 1]])
+        self.kf.H = np.array([[1, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0]])
+        self.kf.R[2:, 2:] *= 10.0
+        self.kf.P[4:, 4:] *= 1000.0
+        self.kf.P *= 10.0
+        self.kf.Q[-1, -1] *= 0.01
+        self.kf.Q[4:, 4:] *= 0.01
+        self.kf.x[:4] = self.convert_bbox_to_z(bbox)
+        self.time_since_update = 0
+        self.id = KalmanBoxTracker.count
+        KalmanBoxTracker.count += 1
+        self.history = []
+        self.hits = 0
+        self.hit_streak = 0
+        self.age = 0
+
+    def update(self, bbox):
+        self.time_since_update = 0
+        self.history = []
+        self.hits += 1
+        self.hit_streak += 1
+        self.kf.update(self.convert_bbox_to_z(bbox))
+
+    def predict(self):
+        if self.kf.x[6] + self.kf.x[2] <= 0:
+            self.kf.x[6] *= 0.0
+        self.kf.predict()
+        self.age += 1
+        if self.time_since_update > 0:
+            self.hit_streak = 0
+        self.time_since_update += 1
+        self.history.append(self.convert_x_to_bbox(self.kf.x))
+        return self.history[-1]
+
+    def get_state(self):
+        return self.convert_x_to_bbox(self.kf.x)
+
+    @staticmethod
+    def convert_bbox_to_z(bbox):
+        w = bbox[2] - bbox[0]
+        h = bbox[3] - bbox[1]
+        x = bbox[0] + w / 2.0
+        y = bbox[1] + h / 2.0
+        s = w * h
+        r = w / float(h)
+        return np.array([x, y, s, r]).reshape((4, 1))
+
+    @staticmethod
+    def convert_x_to_bbox(x, score=None):
+        w = np.sqrt(x[2] * x[3])
+        h = x[2] / w
+        if score is None:
+            return np.array([x[0] - w / 2.0, x[1] - h / 2.0, x[0] + w / 2.0, x[1] + h / 2.0]).reshape((1, 4))
+        return np.array([x[0] - w / 2.0, x[1] - h / 2.0, x[0] + w / 2.0, x[1] + h / 2.0, score]).reshape((1, 5))
+
+class SimpleDeepSORT:
+
+    def __init__(self, max_age=30, min_hits=0, iou_threshold=0.3):
+        self.max_age = max_age
+        self.min_hits = min_hits
+        self.iou_threshold = iou_threshold
+        self.trackers = []
+        self.frame_count = 0
+
+    @staticmethod
+    def convert_bbox_xyxy_to_xywh(bbox):
+        """
+        Convert bounding boxes from format (x1, y1, x2, y2) to (center x, center y, width, height).
+
+        Args:
+            bbox (np.array): Bounding boxes in format (x1, y1, x2, y2), can be a single box or multiple boxes.
+
+        Returns:
+            np.array: Bounding boxes in format (x, y, w, h)
+        """
+        bbox = np.array(bbox)
+        if bbox.ndim == 1:
+            bbox = bbox[np.newaxis, :]
+        x1, y1, x2, y2 = (bbox[:, 0], bbox[:, 1], bbox[:, 2], bbox[:, 3])
+        x = (x1 + x2) / 2
+        y = (y1 + y2) / 2
+        w = x2 - x1
+        h = y2 - y1
+        return np.stack((x, y, w, h), axis=-1)
+
+    @staticmethod
+    def convert_bbox_xywh_to_xyxy(bbox):
+        """
+        Convert bounding boxes from format (center x, center y, width, height) to (x1, y1, x2, y2).
+
+        Args:
+            bbox (np.array): Bounding boxes in format (x, y, w, h), can be a single box or multiple boxes.
+
+        Returns:
+            np.array: Bounding boxes in format (x1, y1, x2, y2)
+        """
+        bbox = np.array(bbox)
+        if bbox.ndim == 1:
+            bbox = bbox[np.newaxis, :]
+        x, y, w, h = (bbox[:, 0], bbox[:, 1], bbox[:, 2], bbox[:, 3])
+        x1 = x - w / 2
+        y1 = y - h / 2
+        x2 = x + w / 2
+        y2 = y + h / 2
+        return np.stack((x1, y1, x2, y2), axis=-1)
+
+    def update(self, dets_xywh):
+        dets = self.convert_bbox_xywh_to_xyxy(dets_xywh)
+        self.frame_count += 1
+        trks = np.zeros((len(self.trackers), 5))
+        to_del = []
+        ret = []
+        for t, trk in enumerate(trks):
+            pos = self.trackers[t].predict()[0]
+            trk[:] = [pos[0], pos[1], pos[2], pos[3], 0]
+            if np.any(np.isnan(pos)):
+                to_del.append(t)
+        trks = np.ma.compress_rows(np.ma.masked_invalid(trks))
+        for t in reversed(to_del):
+            self.trackers.pop(t)
+        matched, unmatched_dets, unmatched_trks = self.associate_detections_to_trackers(dets, trks)
+        for m in matched:
+            self.trackers[m[1]].update(dets[m[0], :])
+        for i in unmatched_dets:
+            trk = KalmanBoxTracker(dets[i, :])
+            self.trackers.append(trk)
+        i = len(self.trackers)
+        for trk in reversed(self.trackers):
+            d = trk.history[-1] if len(trk.history) > 0 else trk.get_state()[0]
+            if trk.time_since_update < 1 and (trk.hit_streak >= self.min_hits or self.frame_count <= self.min_hits):
+                ret.append(np.concatenate((d, [trk.id + 1])).reshape(1, -1))
+            i -= 1
+            if trk.time_since_update > self.max_age:
+                self.trackers.pop(i)
+        if len(ret) > 0:
+            return (self.convert_bbox_xyxy_to_xywh(np.concatenate(ret)[:, :4]), np.concatenate(ret)[:, 4])
+        return (np.empty((0, 4)), np.empty(0, dtype=int))
+
+    def associate_detections_to_trackers(self, detections, trackers):
+        if len(trackers) == 0:
+            return (np.empty((0, 2), dtype=int), np.arange(len(detections)), np.empty((0, 5), dtype=int))
+        matched_indices = linear_sum_assignment(-np.ones((len(detections), len(trackers))))
+        matched_indices = np.asarray(matched_indices)
+        matched_indices = np.transpose(matched_indices)
+        unmatched_detections = []
+        for d, det in enumerate(detections):
+            if d not in matched_indices[:, 0]:
+                unmatched_detections.append(d)
+        unmatched_trackers = []
+        for t, trk in enumerate(trackers):
+            if t not in matched_indices[:, 1]:
+                unmatched_trackers.append(t)
+        matches = []
+        for m in matched_indices:
+            matches.append(m.reshape(1, 2))
+        if len(matches) == 0:
+            matches = np.empty((0, 2), dtype=int)
+        else:
+            matches = np.concatenate(matches, axis=0)
+        return (matches, np.array(unmatched_detections), np.array(unmatched_trackers))
+
+    def _iou(self, bb_test, bb_gt):
+        xx1 = np.maximum(bb_test[0], bb_gt[0])
+        yy1 = np.maximum(bb_test[1], bb_gt[1])
+        xx2 = np.minimum(bb_test[2], bb_gt[2])
+        yy2 = np.minimum(bb_test[3], bb_gt[3])
+        w = np.maximum(0.0, xx2 - xx1)
+        h = np.maximum(0.0, yy2 - yy1)
+        wh = w * h
+        o = wh / ((bb_test[2] - bb_test[0]) * (bb_test[3] - bb_test[1]) + (bb_gt[2] - bb_gt[0]) * (bb_gt[3] - bb_gt[1]) - wh)
+        return o