Create lygo_profile.py

lygo_profile.py

@@ -0,0 +1,286 @@
+#!/usr/bin/env python3
+"""
+LYGO Profile Generator v0.3
+Image → Musical DNA + Lyrical Framework
+
+Extracts visual mathematics from an image and translates it into
+structured creative direction for music production and AI-assisted lyric writing.
+"""
+
+import cv2
+import numpy as np
+import json
+import math
+import argparse
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Any, Optional
+
+__version__ = "0.3.0"
+
+
+class LYGOProfileGenerator:
+    def __init__(self, verbose: bool = True):
+        self.verbose = verbose
+
+    def _log(self, msg: str):
+        if self.verbose:
+            print(msg)
+
+    def analyze_image(self, image_path: str) -> Dict[str, Any]:
+        """Extract rich mathematical features from the image."""
+        img = cv2.imread(str(image_path))
+        if img is None:
+            raise FileNotFoundError(f"Image not found: {image_path}")
+
+        if len(img.shape) == 2:
+            img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+
+        h, w, _ = img.shape
+        total_pixels = h * w
+
+        # === Color Analysis (HSV) ===
+        hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
+        avg_hue = float(np.mean(hsv[:, :, 0]) * 2)          # 0-360
+        avg_sat = float(np.mean(hsv[:, :, 1]) / 255.0)
+        avg_val = float(np.mean(hsv[:, :, 2]) / 255.0)
+        sat_std = float(np.std(hsv[:, :, 1]) / 255.0)       # colorfulness
+
+        # === Luminance & Contrast ===
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        brightness = float(np.mean(gray) / 255.0)
+        contrast = float(np.std(gray) / 255.0)
+
+        # === Structural Analysis ===
+        edges = cv2.Canny(gray, 50, 150)
+        edge_density = float(np.count_nonzero(edges) / total_pixels)
+
+        # Contours for structural complexity
+        contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        structure_index = min(len(contours) / 80.0, 1.0)
+
+        # Micro-chaos (FAST corners)
+        fast = cv2.FastFeatureDetector_create(threshold=38)
+        keypoints = fast.detect(gray, None)
+        chaos_index = len(keypoints)
+
+        features = {
+            "source_image": str(Path(image_path).name),
+            "dimensions": {"width": w, "height": h},
+            "color": {
+                "average_hue": round(avg_hue, 2),
+                "average_saturation": round(avg_sat, 4),
+                "average_brightness": round(brightness, 4),
+                "colorfulness": round(sat_std, 4),
+            },
+            "structure": {
+                "edge_density": round(edge_density, 4),
+                "contrast": round(contrast, 4),
+                "structure_index": round(structure_index, 4),
+                "chaos_keypoints": chaos_index,
+            },
+        }
+        return features
+
+    def _get_musical_key(self, hue: float, brightness: float) -> str:
+        keys = ["C", "G", "D", "A", "E", "B", "F#", "Db", "Ab", "Eb", "Bb", "F"]
+        key_index = int(hue / 30) % 12
+        mode = "Minor" if brightness < 0.48 else "Major"
+        return f"{keys[key_index]} {mode}"
+
+    def _calculate_bpm(self, edge_density: float, chaos: int, brightness: float) -> int:
+        base = 82 + (edge_density * 920)
+        chaos_mod = min(chaos / 1800, 0.6)
+        brightness_mod = (brightness - 0.5) * 12
+        bpm = int(base + (chaos_mod * 25) + brightness_mod)
+        return max(78, min(178, bpm))
+
+    def _generate_genre_texture(self, features: Dict) -> Dict[str, str]:
+        e = features["structure"]["edge_density"]
+        c = features["structure"]["chaos_keypoints"]
+        b = features["color"]["average_brightness"]
+        contrast = features["structure"]["contrast"]
+
+        if c > 650 and b < 0.38:
+            genre = "Industrial Dubstep / Dark Phonk"
+            texture = "Heavy distortion, aggressive stutters, deep sub-bass, metallic textures"
+            energy = "High-aggression"
+        elif e > 0.065 and contrast > 0.18:
+            genre = "Emo Rap / Modern Trap"
+            texture = "Crisp hi-hats, melancholic melodies, heavy 808s, emotional vocal layers"
+            energy = "Mid-High emotional"
+        elif c > 420 and b > 0.55:
+            genre = "Experimental / Glitch Hop"
+            texture = "Glitchy percussion, chopped vocals, atmospheric synths, rhythmic complexity"
+            energy = "High chaotic"
+        elif e < 0.035 and b > 0.6:
+            genre = "West Coast G-Funk / Smooth Instrumental"
+            texture = "Laid-back grooves, warm analog bass, melodic leads, nostalgic atmosphere"
+            energy = "Mid relaxed"
+        else:
+            genre = "Dark Alternative / Cinematic Rap"
+            texture = "Atmospheric pads, punchy drums, moody synths, introspective energy"
+            energy = "Mid cinematic"
+
+        return {"genre": genre, "texture": texture, "energy": energy}
+
+    def translate_to_lygo(self, features: Dict[str, Any]) -> Dict[str, Any]:
+        """Convert visual features into musical and lyrical creative direction."""
+        hue = features["color"]["average_hue"]
+        brightness = features["color"]["average_brightness"]
+        edge_density = features["structure"]["edge_density"]
+        chaos = features["structure"]["chaos_keypoints"]
+        contrast = features["structure"]["contrast"]
+
+        musical_key = self._get_musical_key(hue, brightness)
+        bpm = self._calculate_bpm(edge_density, chaos, brightness)
+        genre_data = self._generate_genre_texture(features)
+
+        # === Lyrical Theme Engine ===
+        if brightness < 0.42 and edge_density > 0.055:
+            core_theme = "Survival, betrayal, lone wolf resilience, moving in silence"
+            lyric_prompt = (
+                "Write raw, introspective lyrics about being the last one standing after betrayal. "
+                "Focus on trust issues, a very small circle of ride-or-die people, and the cold satisfaction of outlasting everyone who counted you out."
+            )
+            vocal_style = "Raspy melodic rap or gritty sung-rap hybrid"
+        elif chaos > 550:
+            core_theme = "Breaking chains, system resistance, unchained personal power"
+            lyric_prompt = (
+                "Write aggressive yet intelligent lyrics about breaking free from systems that tried to define you. "
+                "Emphasize resilience, moving in silence, and turning pain into unstoppable momentum."
+            )
+            vocal_style = "Assertive rap with melodic moments or distorted vocal processing"
+        else:
+            core_theme = "Observation, loyalty, navigating a cold modern world with quiet edge"
+            lyric_prompt = (
+                "Write clever, slightly dark observational lyrics with dry humor about modern life, loyalty, "
+                "and staying true to your own code while everything around you feels artificial."
+            )
+            vocal_style = "Deadpan to melodic rap delivery, slightly introspective"
+
+        # === Final Structured Output ===
+        lygo_profile = {
+            "LYGO_PROFILE": {
+                "version": __version__,
+                "generated_at": datetime.now().isoformat(),
+                "source": features["source_image"],
+                "mathematics": features,
+                "musical_dna": {
+                    "root_key": musical_key,
+                    "bpm": bpm,
+                    "energy_level": genre_data["energy"],
+                    "suggested_genre": genre_data["genre"],
+                    "texture_description": genre_data["texture"],
+                    "vocal_style": vocal_style,
+                },
+                "lyrical_framework": {
+                    "core_theme": core_theme,
+                    "ai_lyric_prompt": lyric_prompt,
+                },
+                "ai_music_prompt": (
+                    f"Create a {genre_data['genre']} track at {bpm} BPM in the key of {musical_key}. "
+                    f"The overall energy should feel {genre_data['energy'].lower()}. "
+                    f"Sound design and texture: {genre_data['texture']}. "
+                    f"Lyrical themes should center around {core_theme}."
+                ),
+                "production_notes": (
+                    f"High contrast and structural complexity suggest strong dynamic range. "
+                    f"Consider heavy low-end support and atmospheric layers to match the visual weight."
+                ),
+            }
+        }
+        return lygo_profile
+
+    def generate(self, image_path: str, output_json: str = "lygo_profile.json", create_brief: bool = False):
+        self._log(f"\n╔════════════════════════════════════════════╗")
+        self._log(f"║           LYGO Profile Generator v{__version__}      ║")
+        self._log(f"║     Image → Musical DNA + Lyrical Framework║")
+        self._log(f"╚════════════════════════════════════════════╝\n")
+
+        features = self.analyze_image(image_path)
+        profile = self.translate_to_lygo(features)
+
+        # Save JSON
+        with open(output_json, "w") as f:
+            json.dump(profile, f, indent=2)
+
+        self._log(json.dumps(profile, indent=2))
+        self._log(f"\n[+] LYGO Profile saved → {output_json}")
+
+        if create_brief:
+            brief_path = Path(output_json).with_suffix(".brief.txt")
+            self._create_creative_brief(profile, brief_path)
+            self._log(f"[+] Creative Brief saved → {brief_path}")
+
+    def _create_creative_brief(self, profile: Dict, path: Path):
+        data = profile["LYGO_PROFILE"]
+        brief = f"""LYGO CREATIVE BRIEF
+Generated: {data['generated_at']}
+Source Image: {data['source']}
+
+══════════════════════════════════════════════
+MUSICAL DNA
+══════════════════════════════════════════════
+Key: {data['musical_dna']['root_key']}
+BPM: {data['musical_dna']['bpm']}
+Energy: {data['musical_dna']['energy_level']}
+Genre Direction: {data['musical_dna']['suggested_genre']}
+
+Texture & Vibe:
+{data['musical_dna']['texture_description']}
+
+Vocal Approach: {data['musical_dna']['vocal_style']}
+
+══════════════════════════════════════════════
+LYRICAL DIRECTION
+══════════════════════════════════════════════
+Core Theme: {data['lyrical_framework']['core_theme']}
+
+AI Prompt:
+{data['lyrical_framework']['ai_lyric_prompt']}
+
+══════════════════════════════════════════════
+FULL AI MUSIC PROMPT (Copy-Paste Ready)
+══════════════════════════════════════════════
+{data['ai_music_prompt']}
+
+Production Notes:
+{data['production_notes']}
+"""
+        path.write_text(brief, encoding='utf-8')
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="LYGO Profile Generator — Turn any image into structured musical + lyrical creative direction"
+    )
+    parser.add_argument("image", help="Path to input image")
+    parser.add_argument("-o", "--output", default="lygo_profile.json", help="Output JSON file")
+    parser.add_argument("--brief", action="store_true", help="Also generate a human-readable .brief.txt file")
+    parser.add_argument("--batch", action="store_true", help="Process all images in a folder")
+    parser.add_argument("--quiet", action="store_true", help="Suppress console output")
+    args = parser.parse_args()
+
+    generator = LYGOProfileGenerator(verbose=not args.quiet)
+
+    if args.batch:
+        folder = Path(args.image)
+        if not folder.is_dir():
+            print("Error: --batch requires a folder path")
+            return
+        images = sorted(folder.glob("*.jpg")) + sorted(folder.glob("*.png")) + sorted(folder.glob("*.jpeg"))
+        if not images:
+            print("No images found in folder")
+            return
+        for img in images:
+            print(f"\nProcessing: {img.name}")
+            out_json = f"lygo_profile_{img.stem}.json"
+            generator.generate(str(img), out_json, create_brief=args.brief)
+        return
+
+    generator.generate(args.image, args.output, create_brief=args.brief)
+
+
+if __name__ == "__main__":
+    main()