Spaces:
Paused
Paused
| """ | |
| ForensicAI Morphic Simulation Engine | |
| Gray-Scott reaction-diffusion parameterized by forensic case data. | |
| Palette: UV lab blue, evidence amber, biological green, digital cyan, crime red. | |
| """ | |
| from __future__ import annotations | |
| import io | |
| from typing import Optional | |
| import numpy as np | |
| from PIL import Image, ImageDraw, ImageFilter, ImageFont | |
| # ── Forensic color palette ──────────────────────────────────────────────────── | |
| _BLACK = np.array([5, 5, 10], dtype=np.float32) # near black | |
| _NAVY = np.array([10, 15, 40], dtype=np.float32) | |
| _BLUE = np.array([30, 80, 200], dtype=np.float32) | |
| _CYAN = np.array([0, 180, 220], dtype=np.float32) # UV cyan | |
| _GREEN = np.array([20, 200, 100], dtype=np.float32) # bio green | |
| _AMBER = np.array([245, 160, 10], dtype=np.float32) # evidence amber | |
| _RED = np.array([210, 40, 40], dtype=np.float32) # crime red | |
| _PURPLE = np.array([120, 40, 200], dtype=np.float32) # forensic purple | |
| _WHITE = np.array([230, 240, 255], dtype=np.float32) # cold white | |
| # Case type → color identity | |
| CASE_PALETTES: dict[str, tuple[np.ndarray, np.ndarray, np.ndarray]] = { | |
| "homicide": (_RED, _PURPLE, _WHITE), | |
| "sexual_assault": (_PURPLE, _CYAN, _WHITE), | |
| "digital_crime": (_CYAN, _BLUE, _WHITE), | |
| "drug_offense": (_AMBER, _GREEN, _WHITE), | |
| "arson": (_AMBER, _RED, _WHITE), | |
| "burglary": (_BLUE, _AMBER, _WHITE), | |
| "fraud": (_GREEN, _CYAN, _WHITE), | |
| "hit_and_run": (_AMBER, _RED, _CYAN), | |
| "default": (_CYAN, _BLUE, _WHITE), | |
| } | |
| # Case type → Gray-Scott parameters | |
| # Homicide/serious → complex labyrinthine (low f, mid k) | |
| # Digital → grid-like / spotted (mid f, high k) | |
| # Bio/sexual → worm-like tendrils (mid f, mid k) | |
| CASE_PARAMS: dict[str, tuple[float, float]] = { | |
| "homicide": (0.025, 0.055), | |
| "sexual_assault": (0.037, 0.061), | |
| "digital_crime": (0.029, 0.057), | |
| "drug_offense": (0.040, 0.060), | |
| "arson": (0.033, 0.058), | |
| "burglary": (0.038, 0.062), | |
| "fraud": (0.026, 0.053), | |
| "hit_and_run": (0.035, 0.059), | |
| "default": (0.037, 0.060), | |
| } | |
| # ── Color LUT builder ───────────────────────────────────────────────────────── | |
| def build_lut(c1: np.ndarray, c2: np.ndarray, c3: np.ndarray) -> np.ndarray: | |
| """Build 256×3 uint8 LUT: black → navy → c1 → c2 → c3 → cold white.""" | |
| stops = [ | |
| (0, _BLACK), | |
| (45, _NAVY), | |
| (90, c1 * 0.5), | |
| (130, c1), | |
| (170, c2), | |
| (210, c3 * 0.9), | |
| (245, c3), | |
| (255, _WHITE), | |
| ] | |
| lut = np.zeros((256, 3), dtype=np.float32) | |
| for i in range(len(stops) - 1): | |
| i0, a = stops[i] | |
| i1, b = stops[i + 1] | |
| span = i1 - i0 | |
| for j in range(i0, i1): | |
| t = (j - i0) / span | |
| lut[j] = a * (1 - t) + b * t | |
| lut[255] = _WHITE | |
| return np.clip(lut, 0, 255).astype(np.uint8) | |
| # ── Gray-Scott engine ───────────────────────────────────────────────────────── | |
| def _laplacian(z: np.ndarray) -> np.ndarray: | |
| return ( | |
| np.roll(z, 1, 0) + np.roll(z, -1, 0) + | |
| np.roll(z, 1, 1) + np.roll(z, -1, 1) - 4.0 * z | |
| ) | |
| def run_gray_scott( | |
| w: int, h: int, iters: int, | |
| feed: float, kill: float, | |
| seed: int, n_patches: int, | |
| ) -> np.ndarray: | |
| rng = np.random.default_rng(seed) | |
| u = np.ones((h, w), dtype=np.float32) | |
| v = np.zeros((h, w), dtype=np.float32) | |
| r = max(5, min(w, h) // 16) | |
| for _ in range(n_patches): | |
| cx = int(rng.integers(r, w - r)) | |
| cy = int(rng.integers(r, h - r)) | |
| noise = 0.05 * rng.random((2*r, 2*r)).astype(np.float32) | |
| u[cy-r:cy+r, cx-r:cx+r] = 0.50 + noise | |
| v[cy-r:cy+r, cx-r:cx+r] = 0.25 + noise | |
| Du, Dv = 0.16, 0.08 | |
| for _ in range(iters): | |
| uvv = u * v * v | |
| u += Du * _laplacian(u) - uvv + feed * (1.0 - u) | |
| v += Dv * _laplacian(v) + uvv - (feed + kill) * v | |
| np.clip(u, 0.0, 1.0, out=u) | |
| np.clip(v, 0.0, 1.0, out=v) | |
| return v | |
| # ── Renderer ────────────────────────────────────────────────────────────────── | |
| _FONT = None | |
| def _font(size=11): | |
| global _FONT | |
| if _FONT is None: | |
| try: | |
| _FONT = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf", size) | |
| except Exception: | |
| _FONT = ImageFont.load_default() | |
| return _FONT | |
| def _render(v: np.ndarray, lut: np.ndarray, size: int) -> Image.Image: | |
| vn = (v - v.min()) / (v.max() - v.min() + 1e-9) | |
| vs = np.clip(vn * 1.9 - 0.1, 0.0, 1.0) | |
| idx = (vs * 255).astype(np.uint8) | |
| rgb = lut[idx] | |
| img = Image.fromarray(rgb, "RGB").resize((size, size), Image.BILINEAR) | |
| glow = img.filter(ImageFilter.GaussianBlur(3)) | |
| return Image.blend(img, glow, 0.3) | |
| def _hud(img: Image.Image, case_type: str, generation: int, | |
| label: str, feed: float, kill: float) -> Image.Image: | |
| w, h = img.size | |
| draw = ImageDraw.Draw(img, "RGBA") | |
| font = _font(11) | |
| bracket = (0, 180, 220, 160) # UV cyan | |
| blen = 22 | |
| for bx, by in [(6, 6), (w-6, 6), (6, h-6), (w-6, h-6)]: | |
| sx = 1 if bx < w//2 else -1 | |
| sy = 1 if by < h//2 else -1 | |
| draw.line([(bx, by), (bx + sx*blen, by)], fill=bracket, width=2) | |
| draw.line([(bx, by), (bx, by + sy*blen)], fill=bracket, width=2) | |
| # Top bar | |
| draw.rectangle([(0, 0), (w, 26)], fill=(5, 5, 15, 210)) | |
| draw.text((10, 6), "FORENSICAI · 2ND BRAIN", fill=(0, 180, 220, 220), font=font) | |
| draw.text((w - 72, 6), f"GEN {generation:03d}", fill=(200, 100, 240, 200), font=font) | |
| # Bottom bar | |
| draw.rectangle([(0, h-26), (w, h)], fill=(5, 5, 15, 210)) | |
| draw.text((10, h-19), label, fill=(180, 200, 230, 200), font=font) | |
| draw.text((w-130, h-19), f"f={feed:.4f} k={kill:.4f}", fill=(80, 120, 180, 160), font=font) | |
| # Case type badge | |
| case_colors = { | |
| "homicide": (210, 40, 40), "digital_crime": (0, 180, 220), | |
| "drug_offense": (245, 160, 10), "sexual_assault": (160, 60, 220), | |
| "arson": (245, 100, 20), "default": (100, 140, 255), | |
| } | |
| cc = case_colors.get(case_type, (100, 140, 255)) | |
| draw.rectangle([(w-95, 28), (w-6, 48)], fill=(*cc, 180)) | |
| draw.text((w-90, 32), case_type[:12].upper(), fill=(255, 255, 255, 230), font=font) | |
| return img | |
| def generate_forensic_image( | |
| dominant_case: str = "default", | |
| evidence_confidence: float = 0.70, | |
| session_count: int = 1, | |
| pattern_generation: int = 1, | |
| case_complexity: float = 0.5, | |
| out_size: int = 512, | |
| grid: int = 220, | |
| iterations: int = 900, | |
| ) -> bytes: | |
| base_f, base_k = CASE_PARAMS.get(dominant_case, CASE_PARAMS["default"]) | |
| # Confidence shifts kill (higher confidence → more defined patterns) | |
| conf_norm = max(0.0, min(1.0, evidence_confidence)) | |
| cmplx_norm = max(0.0, min(1.0, case_complexity)) | |
| feed = round(base_f + cmplx_norm * 0.008, 5) | |
| kill = round(base_k + conf_norm * 0.006, 5) | |
| seed = (session_count * 17 + pattern_generation * 11 + 7) % (2**31) | |
| n_patches = min(2 + session_count // 6, 14) | |
| v = run_gray_scott(grid, grid, iterations, feed, kill, seed, n_patches) | |
| c1, c2, c3 = CASE_PALETTES.get(dominant_case, CASE_PALETTES["default"]) | |
| lut = build_lut(c1, c2, c3) | |
| img = _render(v, lut, out_size) | |
| label = f"{dominant_case} · conf {evidence_confidence:.2f} · complexity {case_complexity:.2f}" | |
| img = _hud(img, dominant_case, pattern_generation, label, feed, kill) | |
| buf = io.BytesIO() | |
| img.save(buf, "PNG", optimize=True) | |
| return buf.getvalue() | |
| def generate_case_heatmap( | |
| case_history: list[str], | |
| confidence_history: list[float], | |
| case_frequency: dict[str, int], | |
| out_size: int = 512, | |
| ) -> bytes: | |
| img = Image.new("RGB", (out_size, out_size), (5, 5, 15)) | |
| draw = ImageDraw.Draw(img) | |
| font = _font(11) | |
| w, h = out_size, out_size | |
| # Title | |
| draw.rectangle([(0, 0), (w, 30)], fill=(10, 20, 50)) | |
| draw.text((10, 8), "FORENSICAI 2ND BRAIN — CASE INTELLIGENCE MAP", fill=(0, 180, 220), font=font) | |
| # Confidence history strip (left half) | |
| pw = w // 2 - 10 | |
| strip_top, strip_bot = 50, h - 60 | |
| strip_h = strip_bot - strip_top | |
| draw.text((10, 36), "EVIDENCE CONFIDENCE HISTORY", fill=(80, 140, 220), font=font) | |
| hist = confidence_history[-pw:] if len(confidence_history) > pw else confidence_history | |
| for i, cf in enumerate(hist): | |
| t = max(0.0, min(1.0, cf)) | |
| r = int(30 + (210 - 30) * t) | |
| g = int(80 + (180 - 80) * t) | |
| b = int(200 + (220 - 200) * t) | |
| bh = int(strip_h * t) | |
| draw.line([(10+i, strip_bot), (10+i, strip_bot - bh)], fill=(r, g, b)) | |
| draw.rectangle([(8, strip_top), (10+pw, strip_bot)], outline=(30, 50, 100), width=1) | |
| # Case frequency bars (right half) | |
| rx = w // 2 + 5 | |
| draw.text((rx, 36), "CASE TYPE FREQUENCY", fill=(80, 140, 220), font=font) | |
| case_colors_map = { | |
| "homicide": (210, 40, 40), | |
| "digital_crime": (0, 180, 220), | |
| "drug_offense": (245, 160, 10), | |
| "sexual_assault": (160, 60, 220), | |
| "arson": (245, 100, 20), | |
| "burglary": (80, 140, 255), | |
| "fraud": (20, 200, 100), | |
| "hit_and_run": (245, 130, 50), | |
| } | |
| mx = max(case_frequency.values()) if case_frequency else 1 | |
| bw = (w - rx - 15) // max(len(case_frequency), 1) | |
| bx = rx + 5 | |
| for case, n in case_frequency.items(): | |
| ratio = n / max(mx, 1) | |
| bh = int((strip_h - 20) * ratio) | |
| col = case_colors_map.get(case, (100, 140, 220)) | |
| draw.rectangle([(bx, strip_bot-bh), (bx+bw-5, strip_bot)], fill=col) | |
| draw.text((bx, strip_bot+4), case[:6], fill=(160, 190, 230), font=font) | |
| draw.text((bx, strip_bot-bh-14), str(n), fill=(210, 220, 240), font=font) | |
| bx += bw | |
| # Confidence trend line (bottom) | |
| bt = h - 56 | |
| draw.text((10, bt-16), "CONFIDENCE TREND", fill=(80, 140, 220), font=font) | |
| scores = confidence_history[-(w-20):] if len(confidence_history) > w-20 else confidence_history | |
| if len(scores) > 1: | |
| pts = [(10 + int(i*(w-20)/len(scores)), bt + int((1-s)*40)) for i, s in enumerate(scores)] | |
| for i in range(len(pts)-1): | |
| draw.line([pts[i], pts[i+1]], fill=(0, 180, 220), width=2) | |
| draw.rectangle([(8, bt), (w-8, h-12)], outline=(30, 50, 100), width=1) | |
| buf = io.BytesIO() | |
| img.save(buf, "PNG", optimize=True) | |
| return buf.getvalue() | |