init

app.py

@@ -0,0 +1,96 @@
+import gradio as gr
+
+from utils.presets import EMOTION_PRESETS
+from utils.drama import apply_drama
+from utils.color_model import infer_color, scale_rgb, render_color
+from utils.visualization import generate_scatter
+
+
+def process_emotion(emotion, drama):
+    preset = EMOTION_PRESETS[emotion]
+
+    raw = preset["raw"]
+    target = preset["target"]
+
+    cinematic = apply_drama(raw, target, drama)
+
+    rgb = infer_color(cinematic)
+    scaled = scale_rgb(rgb)
+    color_block = render_color(scaled)
+
+    scatter_fig = generate_scatter(raw, cinematic, emotion, drama)
+
+    return (
+        preset["text"],
+        raw,
+        cinematic,
+        scaled,
+        color_block,
+        scatter_fig
+    )
+
+
+with gr.Blocks(title="VIBE-Eyes 👁️") as demo:
+
+    gr.Markdown("# VIBE-Eyes 👁️")
+    gr.Markdown("**Emotion becomes cinema.**")
+
+    with gr.Row():
+
+        with gr.Column(scale=1):
+
+            emotion = gr.Radio(
+                choices=list(EMOTION_PRESETS.keys()),
+                label="Select Emotion",
+                value="Anger (Red)"
+            )
+
+            drama = gr.Slider(
+                minimum=0,
+                maximum=1.5,
+                value=0,
+                step=0.05,
+                label="Drama (Cinematic Amplification)"
+            )
+
+        with gr.Column(scale=2):
+
+            text_output = gr.Textbox(label="Preset Text")
+
+            with gr.Row():
+                raw_output = gr.JSON(label="Raw VAD+CC")
+                cine_output = gr.JSON(label="Cinematic VAD+CC")
+
+            rgb_output = gr.JSON(label="RGB + E + I")
+            color_display = gr.HTML(label="Rendered Color")
+
+            scatter_output = gr.Plot(label="Valence–Arousal Space")
+
+    emotion.change(
+        fn=process_emotion,
+        inputs=[emotion, drama],
+        outputs=[
+            text_output,
+            raw_output,
+            cine_output,
+            rgb_output,
+            color_display,
+            scatter_output
+        ]
+    )
+
+    drama.change(
+        fn=process_emotion,
+        inputs=[emotion, drama],
+        outputs=[
+            text_output,
+            raw_output,
+            cine_output,
+            rgb_output,
+            color_display,
+            scatter_output
+        ]
+    )
+
+demo.launch()
+

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+torch
+transformers
+matplotlib
+numpy
+

utils/cinematic.py

@@ -0,0 +1,44 @@
+import numpy as np
+from datasets import load_dataset
+from sklearn.metrics.pairwise import cosine_similarity
+
+palette_dataset = load_dataset("danielritchie/cinematic-mood-palette")["train"]
+
+palette_vectors = []
+palette_names = []
+
+for row in palette_dataset:
+    palette_vectors.append([row["V"], row["A"], row["D"], row["Cx"], row["Co"]])
+    palette_names.append(row.get("name", "unknown"))
+
+palette_vectors = np.array(palette_vectors)
+
+
+def nearest_palette_vector(raw_vad):
+    raw_vec = np.array([[raw_vad[k] for k in ["V","A","D","Cx","Co"]]])
+    sims = cosine_similarity(raw_vec, palette_vectors)[0]
+    idx = np.argmax(sims)
+    anchor = palette_vectors[idx]
+
+    return {
+        "vector": {
+            "V": anchor[0],
+            "A": anchor[1],
+            "D": anchor[2],
+            "Cx": anchor[3],
+            "Co": anchor[4],
+        },
+        "name": palette_names[idx]
+    }
+
+
+def amplify_with_palette(raw, drama):
+    anchor_data = nearest_palette_vector(raw)
+    anchor = anchor_data["vector"]
+
+    amplified = {
+        k: float(raw[k] + drama * (anchor[k] - raw[k]))
+        for k in raw
+    }
+
+    return amplified, anchor_data["name"]

utils/color_model.py

@@ -0,0 +1,52 @@
+import torch
+from transformers import AutoModel
+
+model = AutoModel.from_pretrained("danielritchie/vibe-color-model")
+model.eval()
+
+
+def infer_color(vad):
+    input_tensor = torch.tensor([[
+        vad["V"],
+        vad["A"],
+        vad["D"],
+        vad["Cx"],
+        vad["Co"]
+    ]], dtype=torch.float32)
+
+    with torch.no_grad():
+        output = model(input_tensor)
+
+    r, g, b, e, i = output[0].tolist()
+
+    return {
+        "R": r,
+        "G": g,
+        "B": b,
+        "E": e,
+        "I": i
+    }
+
+
+def scale_rgb(rgb):
+    return {
+        "R": int(max(0, min(255, rgb["R"] * 255))),
+        "G": int(max(0, min(255, rgb["G"] * 255))),
+        "B": int(max(0, min(255, rgb["B"] * 255))),
+        "E": rgb["E"],
+        "I": rgb["I"]
+    }
+
+
+def render_color(rgb):
+    return f"""
+    <div style="
+        width:100%;
+        height:240px;
+        border-radius:18px;
+        background: rgb({rgb['R']},{rgb['G']},{rgb['B']});
+        box-shadow: 0px 6px 32px rgba(0,0,0,0.25);
+        transition: all 0.3s ease-in-out;
+    "></div>
+    """
+

utils/drama.py

@@ -0,0 +1,6 @@
+def apply_drama(raw, target, drama):
+    return {
+        k: raw[k] + drama * (target[k] - raw[k])
+        for k in raw
+    }
+

utils/presets.py

@@ -0,0 +1,33 @@
+EMOTION_PRESETS = {
+
+    "Anger (Red)": {
+        "text": "Stop. I can't tolerate this anymore.",
+        "raw":     {"V":0.15,"A":0.80,"D":0.75,"Cx":0.70,"Co":0.80},
+        "target":  {"V":0.05,"A":0.95,"D":0.90,"Cx":0.90,"Co":0.95},
+    },
+
+    "Love (Pink)": {
+        "text": "I feel close to you. There is warmth between us.",
+        "raw":     {"V":0.85,"A":0.65,"D":0.80,"Cx":0.60,"Co":0.75},
+        "target":  {"V":0.95,"A":0.75,"D":0.95,"Cx":0.70,"Co":0.70},
+    },
+
+    "Sadness (Blue)": {
+        "text": "Everything feels heavy and distant.",
+        "raw":     {"V":0.30,"A":0.35,"D":0.15,"Cx":0.45,"Co":0.35},
+        "target":  {"V":0.20,"A":0.30,"D":0.00,"Cx":0.40,"Co":0.20},
+    },
+
+    "Anxiety (Off Green)": {
+        "text": "Something feels wrong. I can't settle.",
+        "raw":     {"V":0.35,"A":0.85,"D":0.35,"Cx":0.80,"Co":0.85},
+        "target":  {"V":0.30,"A":1.00,"D":0.20,"Cx":1.00,"Co":1.00},
+    },
+
+    "Neutral Calm (Gray)": {
+        "text": "Everything is stable. Nothing is pushing or pulling.",
+        "raw":     {"V":0.55,"A":0.45,"D":0.55,"Cx":0.55,"Co":0.60},
+        "target":  {"V":0.50,"A":0.50,"D":0.50,"Cx":0.60,"Co":0.65},
+    }
+}
+

utils/visualization.py

@@ -0,0 +1,39 @@
+import matplotlib.pyplot as plt
+from utils.presets import EMOTION_PRESETS
+
+
+def generate_scatter(raw, cinematic, emotion, drama):
+    fig, ax = plt.subplots(figsize=(6, 6))
+
+    # Plot target anchors faintly
+    for name, preset in EMOTION_PRESETS.items():
+        t = preset["target"]
+        ax.scatter(t["V"], t["A"], alpha=0.2, s=100, color="gray")
+
+    # Raw point
+    ax.scatter(raw["V"], raw["A"], s=200, color="blue", label="Raw")
+
+    # Cinematic point
+    ax.scatter(cinematic["V"], cinematic["A"], s=200, color="red", label="Cinematic")
+
+    # Arrow scaled by drama
+    ax.arrow(
+        raw["V"],
+        raw["A"],
+        cinematic["V"] - raw["V"],
+        cinematic["A"] - raw["A"],
+        head_width=0.02,
+        length_includes_head=True,
+        color="black"
+    )
+
+    ax.set_xlim(0, 1)
+    ax.set_ylim(0, 1)
+    ax.set_xlabel("Valence")
+    ax.set_ylabel("Arousal")
+    ax.set_title(f"{emotion} | Drama: {round(drama,2)}")
+    ax.legend()
+
+    plt.tight_layout()
+    return fig
+