app.py

# app.py — Affection 👁️ (Hugging Face Space)

import os
import gradio as gr
import matplotlib.pyplot as plt

os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"
os.environ["SPACES_DISABLE_RELOAD"] = "1"

from utils.presets import EMOTION_PRESETS
from utils.drama import apply_drama
from utils.color_model import infer_color, render_color


# ------------------------------------------------------------
# Passion (Radial Amplification)
# ------------------------------------------------------------
def apply_passion(raw: dict, passion: float) -> dict:
    passion = max(0.0, min(3.5, float(passion)))
    out = {}

    for k, v in raw.items():
        v = float(v)
        if k in ("V", "A", "D"):
            delta = v - 0.5
            magnitude = abs(delta)
            gain = 1.0 + passion * magnitude
            out[k] = max(0.0, min(1.0, 0.5 + delta * gain))
        else:
            out[k] = max(0.0, min(1.0, v))

    return out


# ------------------------------------------------------------
# Valence–Arousal Visualization (2D Projection)
# ------------------------------------------------------------
def generate_scatter(raw, amplified, cinematic, label, passion, drama):

    fig, ax = plt.subplots(figsize=(6, 6))

    base_color = "#2C3E50"  # neutral deep tone

    # Plot cinematic anchors faintly
    for _, preset in EMOTION_PRESETS.items():
        t = preset["target"]
        ax.scatter(t["V"], t["A"], alpha=0.1, s=90, color="#BBBBBB")

    # Natural
    ax.scatter(
        raw["V"], raw["A"],
        s=180,
        facecolor=base_color,
        alpha=0.5,
        label="Natural (Extraction)"
    )

    # After Passion
    ax.scatter(
        amplified["V"], amplified["A"],
        s=180,
        facecolors="none",
        edgecolors=base_color,
        linewidth=2,
        label="After Passion (Radial Gain)"
    )

    # After Drama
    ax.scatter(
        cinematic["V"], cinematic["A"],
        s=220,
        facecolor=base_color,
        edgecolor="black",
        linewidth=1.5,
        alpha=0.9,
        label="After Drama (Cinematic Alignment)"
    )

    # Arrow 1 — Raw → Amplified
    ax.arrow(
        raw["V"],
        raw["A"],
        amplified["V"] - raw["V"],
        amplified["A"] - raw["A"],
        head_width=0.02,
        length_includes_head=True,
        color=base_color,
        linestyle="--",
        linewidth=2,
        alpha=0.6
    )

    # Arrow 2 — Amplified → Cinematic
    ax.arrow(
        amplified["V"],
        amplified["A"],
        cinematic["V"] - amplified["V"],
        cinematic["A"] - amplified["A"],
        head_width=0.02,
        length_includes_head=True,
        color=base_color,
        linestyle="-",
        linewidth=2,
        alpha=0.9
    )

    # ----------------------------------
    # Dynamic Zoom (Centered + 20% Padding)
    # ----------------------------------
    xs = [raw["V"], amplified["V"], cinematic["V"]]
    ys = [raw["A"], amplified["A"], cinematic["A"]]

    min_x, max_x = min(xs), max(xs)
    min_y, max_y = min(ys), max(ys)

    span_x = max_x - min_x
    span_y = max_y - min_y

    # Use the larger span to keep square framing
    span = max(span_x, span_y)

    # Avoid zero-span collapse
    span = max(span, 0.05)

    padding = span * 0.20  # 20% larger

    center_x = (min_x + max_x) / 2
    center_y = (min_y + max_y) / 2

    half_range = (span / 2) + padding

    ax.set_xlim(center_x - half_range, center_x + half_range)
    ax.set_ylim(center_y - half_range, center_y + half_range)

    ax.set_aspect('equal', adjustable='box')
    
    ax.set_xlabel("Valence")
    ax.set_ylabel("Arousal")
    ax.set_title(f"{label}\nPassion={round(passion,2)} | Drama={round(drama,2)}")

    ax.legend(loc="lower right")
    ax.grid(alpha=0.15)

    plt.tight_layout()
    return fig


# ------------------------------------------------------------
# Fast-Loop Simulation
# ------------------------------------------------------------
def run_pipeline(preset_name, passion, drama):

    preset = EMOTION_PRESETS[preset_name]

    text = preset["text"]
    natural = preset["raw"]
    target = preset["target"]

    amplified = apply_passion(natural, passion)
    cinematic = apply_drama(amplified, target, drama)

    color_params = infer_color(cinematic)
    color_block = render_color(color_params)

    fig = generate_scatter(natural, amplified, cinematic, preset_name, passion, drama)

    return (
        text,
        natural,
        amplified,
        cinematic,
        color_params,
        color_block,
        fig
    )


# ------------------------------------------------------------
# UI
# ------------------------------------------------------------
with gr.Blocks(title="Affection 👁️ — Edge Emotional Intelligence") as demo:

    gr.Markdown("# Affection 👁️")
    gr.Markdown("## Simulation Layer for an Edge AI Emotional Robotics System")

    # ---------------------------
    # Robot Speech
    # ---------------------------
    gr.Markdown("### 🗣 Robot Speech")

    preset_selector = gr.Radio(
        choices=list(EMOTION_PRESETS.keys()),
        label="Select Transcript Sample",
        value=list(EMOTION_PRESETS.keys())[0],
    )

    transcript_output = gr.Textbox(label="Input Transcript", interactive=False)

    gr.Markdown("---")

    # ---------------------------
    # Edge Affect Processing
    # ---------------------------
    gr.Markdown("### ⚡ Edge Affect Processing — NVIDIA Jetson Orin Nano")

    gr.Markdown(
        """
This section provides a simplified visualization of a more complex on-device architecture.

In hardware deployment, the NVIDIA Jetson Orin Nano performs all of the following:  

• Robot hardware daemon service  
• Interactive conversational application  
• Real-time transcript ingestion   
• VAD extraction (NRC-VAD lexicon)   
• Structural language metrics (Complexity + Coherence)   
• Radial emotional amplification (Passion)  
• Cinematic nearest-exemplar alignment (Drama)  
• Dual-timescale blending (fast burst + slow baseline via Nemotron/Ollama)  
• Continuous emotional state streaming for display on an expression module  

This demo isolates a single loop transformation for clarity.

Our NVIDIA edge device is capable of running this loop 200x per second.
        """
    )

    with gr.Row():
        passion = gr.Slider(
            minimum=0.0,
            maximum=3.0,
            value=2.25,
            step=0.1,
            label="Passion (Radial Emotional Amplification)"
        )

        drama = gr.Slider(
            minimum=0.0,
            maximum=1.5,
            value=0.65,
            step=0.05,
            label="Drama (Cinematic Alignment)"
        )

    with gr.Row():
        natural_output = gr.JSON(label="Natural VAD+CC")
        amplified_output = gr.JSON(label="After Passion")
        cinematic_output = gr.JSON(label="After Drama")

    scatter_output = gr.Plot(label="Valence–Arousal Projection")

    gr.Markdown(
        """
**Note:**  
This plot shows a 2D Valence–Arousal projection for visualization only, but results are from the actual model.  
Actual transformation and color inference are more complex and operate on the full 5D VAD+CC vector.
        """
    )

    gr.Markdown("---")

    # ---------------------------
    # Emotional Expression
    # ---------------------------
    gr.Markdown("### 💡 Emotional Expression")

    gr.Markdown(
        """
The finalized VAD+CC vector is transmitted to an expressive display module. In this example, we are converting to colors to be used for eyes.

The module does not compute emotion.  
It receives the 5D emotional state and runs a trained neural model to convert it into expressive color.

Model used here (same as deployment):  
https://huggingface.co/danielritchie/vibe-color-model

VAD+CC (Affect Engine) → Embedded Model → Color Rendering (Expression)
        """
    )

    rgb_output = gr.JSON(label="Model Output (RGB + Expressive Parameters)")
    color_display = gr.HTML(label="Rendered Expression")

    outputs = [
        transcript_output,
        natural_output,
        amplified_output,
        cinematic_output,
        rgb_output,
        color_display,
        scatter_output
    ]

    preset_selector.change(fn=run_pipeline, inputs=[preset_selector, passion, drama], outputs=outputs)
    passion.change(fn=run_pipeline, inputs=[preset_selector, passion, drama], outputs=outputs)
    drama.change(fn=run_pipeline, inputs=[preset_selector, passion, drama], outputs=outputs)

    demo.load(fn=run_pipeline, inputs=[preset_selector, passion, drama], outputs=outputs)

demo.launch(server_name="0.0.0.0", server_port=7860)