Modüler Çok-Sensörlü Anti-Drone (C-UAS) Tespit ve Sınıflandırma Sistemi Prototipi

def steering(theta_deg, n_el, d_lambda=0.5):
    """ULA yönlendirme vektörü (yarım-dalgaboyu aralık varsayılan)."""
    m = np.arange(n_el)
    return np.exp(-1j * 2 * np.pi * d_lambda * m * np.sin(np.deg2rad(theta_deg)))

def music_spectrum(x, n_src, scan=np.arange(-90, 90.1, 0.5)):
    """MUSIC sözde-spektrumu: gürültü alt-uzayına ortogonallikten AoA tepesi."""
    n_el = x.shape[0]
    R = (x @ x.conj().T) / x.shape[1]                   # örnek kovaryansı
    w, V = np.linalg.eigh(R)
    En = V[:, : n_el - n_src]                           # gürültü alt-uzayı
    ps = []
    for a in scan:
        sv = steering(a, n_el)
        ps.append(1.0 / (np.abs(sv.conj() @ En @ En.conj().T @ sv) + 1e-12))
    ps = 10 * np.log10(np.array(ps) / np.max(ps))
    return scan, ps

def detect_classical(img, min_area=60):
    """Gökyüzüne göre koyu nesneleri blob olarak bulur; şekilden sınıflandırır."""
    gray = img.mean(axis=2)
    bg = ndimage.uniform_filter(gray, size=61)          # yerel gökyüzü arka planı
    dark0 = (bg - gray) > 18                             # arka plandan koyu sapma (ham)
    darkd = ndimage.binary_dilation(dark0, iterations=3)  # gövde+rotorları birleştir (gruplama)
    lbl, n = ndimage.label(darkd)
    dets = []
    for i in range(1, n + 1):
        comp = lbl == i
        ys, xs = np.where(comp)
        if len(xs) < min_area:
            continue
        x0, x1, y0, y1 = xs.min(), xs.max(), ys.min(), ys.max()
        w, h = x1 - x0 + 1, y1 - y0 + 1
        aspect = w / h
        # Doluluk: GRUPLAMA değil, ham (dilatasyon-öncesi) piksellerden -> ince
        # strok yapılı kuş düşük doluluk, kompakt drone gövdesi yüksek doluluk verir.
        fill = int((dark0 & comp).sum()) / (w * h)
        # Şekil kuralları: drone kompakt & ~simetrik; kuş uzamış/seyrek
        if aspect > 2.2 or aspect < 0.45 or fill < 0.22:
            cls, conf = "kus", 0.6 + 0.3 * (1 - min(fill, 1))
        else:
            cls, conf = "drone", 0.65 + 0.3 * min(fill / 0.6, 1)
        dets.append({"cls": cls, "conf": round(float(min(conf, 0.99)), 2),
                     "bbox": [int(x0), int(y0), int(x1), int(y1)],
                     "aspect": round(float(aspect), 2), "fill": round(float(fill), 2)})
    return dets

def features(x):
    """Log-mel bant enerjileri + spektral merkez + harmonik oran + ZCR."""
    f = np.abs(np.fft.rfft(x * np.hanning(len(x)), n=_NFFT)) ** 2
    # kısa-zaman ortalama için birkaç çerçeve
    frames = [np.abs(np.fft.rfft(x[i:i + _NFFT] * np.hanning(_NFFT))) ** 2
              for i in range(0, len(x) - _NFFT, _NFFT // 2)]
    P = np.mean(frames, axis=0) if frames else f
    mel = np.log(_FB @ P + 1e-9)
    freqs = np.fft.rfftfreq(_NFFT, 1 / FS)
    centroid = (freqs * P).sum() / (P.sum() + 1e-9)
    low = P[(freqs < 300)].sum(); tot = P.sum() + 1e-9
    harm_ratio = low / tot                               # drone: alçak harmonik ağırlık
    zcr = np.mean(np.abs(np.diff(np.sign(x)))) / 2
    return np.concatenate([mel, [centroid / 1000, harm_ratio, zcr]])

def train_softmax(X, y, epochs=400, lr=0.3, l2=1e-3):
    mu, sd = X.mean(0), X.std(0) + 1e-9
    Xn = (X - mu) / sd
    n, d = Xn.shape
    K = len(CLASSES)
    W = np.zeros((d, K)); b = np.zeros(K)
    Y = np.eye(K)[y]
    for _ in range(epochs):
        p = _softmax(Xn @ W + b)
        gW = Xn.T @ (p - Y) / n + l2 * W
        gb = (p - Y).mean(0)
        W -= lr * gW; b -= lr * gb
    return {"W": W, "b": b, "mu": mu, "sd": sd}

def predict_update(self, z, dt):
        n = 2
        # 1) Karışım (interaction/mixing)
        cbar = self.PI.T @ self.mu
        w = (self.PI * self.mu[:, None]) / (cbar[None, :] + 1e-12)   # w[i,j]
        x0, P0 = [], []
        for j in range(n):
            xj = sum(w[i, j] * self.x[i] for i in range(n))
            Pj = sum(w[i, j] * (self.P[i] + np.outer(self.x[i] - xj, self.x[i] - xj))
                     for i in range(n))
            x0.append(xj); P0.append(Pj)
        # 2) Model-koşullu Kalman tahmin + güncelleme
        L = np.zeros(n)
        for j in range(n):
            F = _F(dt)
            xp = F @ x0[j]
            Pp = F @ P0[j] @ F.T + _Q(dt, self.q[j])
            S = H @ Pp @ H.T + self.R
            K = Pp @ H.T @ np.linalg.inv(S)
            y = z - H @ xp
            self.x[j] = xp + K @ y
            self.P[j] = (np.eye(4) - K @ H) @ Pp
            L[j] = np.exp(-0.5 * y @ np.linalg.inv(S) @ y) / np.sqrt(
                np.linalg.det(2 * np.pi * S))
        # 3) Model olasılığı güncelle
        self.mu = cbar * L
        self.mu /= self.mu.sum() + 1e-12
        # 4) Birleşik kestirim
        x = sum(self.mu[j] * self.x[j] for j in range(n))
        P = sum(self.mu[j] * (self.P[j] + np.outer(self.x[j] - x, self.x[j] - x))
                for j in range(n))
        return x, P

def fuse_group(group):
    """Bir demetteki sensör kararlarını log-olabilirlik toplayarak birleştirir."""
    logp = np.zeros(3)
    sensors = set()
    for d in group:
        w = RELIABILITY.get(d.sensor, 0.5)
        logp += w * np.log(_soft(d) + 1e-9)
        sensors.add(d.sensor)
    p = np.exp(logp - logp.max()); p /= p.sum()
    k = int(p.argmax())
    # Çok-sensör doğrulama katsayısı: tek kip -> güven cezası
    corroboration = min(len(sensors) / 3.0, 1.0)
    conf = float(p[k]) * (0.5 + 0.5 * corroboration)
    return {
        "cls": CLASSES[k].value,
        "conf": round(conf, 3),
        "prob": {CLASSES[i].value: round(float(p[i]), 3) for i in range(3)},
        "sensors": sorted(s.value for s in sensors),
        "n_sensor": len(sensors),
        "az": round(np.mean([d.azimuth_deg for d in group]), 1),
    }

def fuse(dets, promote_conf=0.6):
    groups = cluster_by_time_bearing(dets)
    out = []
    for g in groups:
        r = fuse_group(g)
        r["promoted"] = r["conf"] >= promote_conf and r["n_sensor"] >= 2
        out.append(r)
    return out