audito/sampler.py

from enum import Enum
import os
import numpy as np
import librosa
import math
from scipy.interpolate import interp1d
import matplotlib.pyplot as plt


import random
import shutil
import subprocess
import tempfile
import textwrap

import click
import tensorflow as tf
from PIL import Image, ImageEnhance

from noisemaker.composer import EFFECT_PRESETS, GENERATOR_PRESETS, reload_presets
from noisemaker.constants import ColorSpace, ValueDistribution
from noisemaker.presets import PRESETS

import noisemaker.ai as ai
import noisemaker.dreamer as dreamer
import noisemaker.cli as cli
import noisemaker.generators as generators
import noisemaker.effects as effects
import noisemaker.util as util
import noisemaker.value as value

MAX_SEED_VALUE = 2 ** 32 - 1


os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'


reload_presets(PRESETS)

@click.group(context_settings=cli.CLICK_CONTEXT_SETTINGS)
def main():
    pass


def anlyzeSound():
    # Assuming that into "generated" directoruy U've already create "project_name" subfolder
    #audio_input_file = '/home/lalo/data/studio_grafica/deforum/stars_clip_r2.wav'
    audio_input_file = '/home/lalo/data/studio_suono/ardourprojects/space/export/star_r1_sessione_20240310_msub07.wav'
    #audio_input_file = '/home/lalo/data/studio_suono/spx/231104_001_m01.wav'
    #audio_input_file = '/home/lalo/data/studio_grafica/deforum/eucrasy_r1_sample.wav'
    #audio_input_file = '/home/lalo/data/studio_grafica/deforum/eucrasy_r1.wav'
    #audio_input_file = '/home/lalo/data/studio_grafica/deforum/eucrasy_short_r1.wav'
    #audio_input_file = '/home/lalo/data/studio_suono/231014_002_mastered_r2_clip.WAV'
    #audio_input_file = 'C:/Users/LucaConte/Music/lc_music/wilson_r1_mm.wav'
    #    Store the sampling rate as `sr`


    fps = 24

    flength = 22050//fps
    #audio frame size is 22050/30=735



    wave, sr = librosa.load(audio_input_file)
    rms = librosa.feature.rms(y=wave, frame_length=flength, hop_length=flength)

    #rms = librosa.feature.rms(y=wave, frame_length=735, hop_length=735)
    cent = librosa.feature.spectral_centroid(y=wave, sr=sr,n_fft=flength, hop_length=flength)
    duration = int(math.ceil(librosa.get_duration(y=wave, sr=sr)))

    frames = duration * fps 


    #:w
    # sr.len /22050 = duration
    # rms.len * 30 = duration
    # rms[i] mi da la potenza media del frame iesimo
    trms= rms[0]



    seed = 123456 
    seed = random.randint(1, MAX_SEED_VALUE)
    #generateSoundVariations("bubble-machine", 3793866858, rms,5000,7500)
    #generateSoundVariations("sands-of-time", 2226183906, rms,-1,2500)
    #generateSoundVariations("sands-of-time", 2226183906, rms,2500,5000)
    #generateSoundVariations("sands-of-time", 2226183906, rms,5000,7500)
    #generateSoundVariations("sands-of-time", 2226183906, rms,7500,10000)
    #generateSoundVariations("sands-of-time", 2226183906, rms,10000,10333)
    #generateSamples()
    #postprocessBrightness("/tmp/",cent, 8316,10000)
    return rms, cent

def width_option(default=1024, **attrs):
    attrs.setdefault("help", "Output width, in pixels")

    return int_option("--width", default=default, **attrs)
#gli estremi frame start e frame stop sono esclusi


@main.command()
@click.option('--width', required=True, type=int, default=1024)
@click.option('--height', required=True, type=int, default=1024)
@click.option('--seed', required=False, type=int, default=None)
@click.option('--framestart', required=False, type=int, default=1)
@click.option('--framestop', required=False, type=int, default=-1)
@click.option('--preset', type=click.Choice(["random"] + sorted(GENERATOR_PRESETS)))
@click.pass_context
def genframes(ctx,width, height,preset, seed,  framestart, framestop):
    rms, centroids = anlyzeSound()
    
    if not seed:
        seed = random.randint(1, MAX_SEED_VALUE)

    print(f"(total frames: {len(rms[0])}) (framestart: {framestart}) (framestop: {framestop})")
    time_dividend =10000
    s = interp1d([min(rms[0]), max(rms[0])], [0, 0.9])
    trms=rms[0]
    if framestop<0:
        framestop = len(rms[0])
    for frame in range(framestart, framestop):
        try:
            speed=float(format(trms[frame],'.3f'))
            #print(f"(speed: {speed}) (trms: {trms[frame]})  )")
            time = (float)((frame % time_dividend)/time_dividend)
            filename = "/tmp/"+ preset + "_" + str(seed)+ "_" + str(frame).zfill(10)   +".png"
            print(f"(speed: {speed}) (time: {time})  (filename: {filename})")
            generate(1080,1080,time,speed,seed,filename,False,False,False,False,False,False,"",False,False,preset)
            #generate(1024,1024,ftime,1,seed,"/tmp/" + str(frame).zfill(10)  +".png",False,False,False,False,False,False,"",False,False,preset_name)
            #generate(1024,1024,0.0,ftime,seed,"/tmp/" + str(frame).zfill(10)  +"_" + preset_name + ".png",False,False,False,False,False,False,"",False,False,preset_name)
        except Exception as e:
            print(f"Exception {e} on Preset: {preset}")
            continue
    

def testPillow():
    image = Image.open('/tmp/alt/sands-of-time_2226183906_0000005401.png')
    brightness_factor = 3.5  # Increase brightness by 50%
    enhancer = ImageEnhance.Brightness(image)
    brightened_image = enhancer.enhance(brightness_factor)
    contrast_factor = 2.2  # Increase contrast by 20%
    enhancer = ImageEnhance.Contrast(image)
    contrasted_image = enhancer.enhance(contrast_factor)
    brightened_image.save("/tmp/alt/brightened_image.png")
    contrasted_image.save("/tmp/alt/contrasted_image.png")

def postprocessBrightness(srcdir,centroids,framemin=0,framemax=9999999999):

    c = interp1d([centroids.min(), centroids.max()], [1, 4.5])
    items = os.listdir(srcdir)
    sorted_items = sorted(items)
    for f in sorted_items:
        if f.endswith(".png"):
            frame = int(f.split("_")[-1].split(".")[0])
            if frame >= framemin and frame < framemax: 
                image = Image.open(srcdir+f)
                enhancer = ImageEnhance.Brightness(image)
                brightened_image = enhancer.enhance(c(centroids[0][frame]))
                print(f'File: {f}')
                brightened_image.save(srcdir+"b_"+f)


def testCombinedVariations(preset_name):
    seed = random.randint(1, MAX_SEED_VALUE)
    times = 0
    for speed in range(0,999,1):
        try:
            if(times == 0):
                times = random.randint(1, 30)
                time = round(random.uniform(0, 1), 1)
            fspeed = (float)(speed/100)
            filename = "/tmp/"+ preset_name + "_" + str(seed)+ "_" + str(speed).zfill(10)   +".png"
            print(f"(speed: {speed}) (time: {time}) (times: {times}) (filename: {filename})")
            times -= 1
            #generate(600,600,time,fspeed,seed,filename,False,False,False,False,False,False,"",False,False,preset_name)
        except Exception as e:
            print(f"Exception on Preset: {preset_name}")
            continue


def generateSpeedVariations(preset_name):
    seed = random.randint(1, MAX_SEED_VALUE)
    for speed in range(0,999,1):
        try:
            generate(600,600,0.1,speed,seed,"/tmp/"+ preset_name + "_" + str(seed)+ "_" + str(speed).zfill(10)   +".png",False,False,False,False,False,False,"",False,False,preset_name)
        except Exception as e:
            print(f"Exception on Preset: {preset_name}")
            continue

def generateVariations(preset_name):
    seed = random.randint(1, MAX_SEED_VALUE)
    for time in range(0,999,1):
        try:
            ftime = (float)(time/1000)
            print(str(ftime))
            generate(600,600,ftime,1,seed,"/tmp/"+ preset_name + "_" + str(seed)+ "_" + str(time)   +".png",False,False,False,False,False,False,"",False,False,preset_name)
        except Exception as e:
            print(f"Exception on Preset: {preset_name}")
            continue
 
def generate(width, height, time, speed, seed, filename, with_alpha, with_supersample, with_fxaa, with_ai, with_upscale,
             with_alt_text, stability_model, debug_print, debug_out, preset_name):
    if not seed:
        seed = random.randint(1, MAX_SEED_VALUE)

    value.set_seed(seed)
    reload_presets(PRESETS)

    if preset_name == "random":
        preset_name = list(GENERATOR_PRESETS)[random.randint(0, len(GENERATOR_PRESETS) - 1)]

    preset = GENERATOR_PRESETS[preset_name]

    if debug_print or debug_out:
        debug_text = _debug_print(seed, preset, with_alpha, with_supersample, with_fxaa, with_ai, with_upscale, stability_model)

        if debug_print:
            for line in debug_text:
                print(line)

        if debug_out is not None:
            with open(debug_out, 'w') as fh:
                for line in debug_text:
                    fh.write(line + "\n")

    try:
        preset.render(seed, shape=[height, width, None], time=time, speed=speed, filename=filename,
                      with_alpha=with_alpha, with_supersample=with_supersample, with_fxaa=with_fxaa,
                      with_ai=with_ai, with_upscale=with_upscale, stability_model=stability_model)

    except Exception as e:
        util.logger.error(f"preset.render() failed: {e}\nSeed: {seed}\nArgs: {preset.__dict__}")
        raise

    if preset.ai_success:
        print(f"{preset_name} vs. {preset.ai_settings['model']} (seed: {seed})")

    else:
        print(f"{preset_name} (seed: {seed})")

    if with_alt_text:
        print(ai.describe(preset.name.replace('-', ' '), preset.ai_settings.get("prompt"), filename))


def _debug_print(seed, preset, with_alpha, with_supersample, with_fxaa, with_ai, with_upscale, stability_model):
    first_column = ["Layers:"]

    if preset.flattened_layers:
        first_column.append("  - Lineage (by newest):")

        if not preset.flattened_layers:
            first_column.append("    - None")

        for parent in reversed(preset.flattened_layers):
            first_column.append(f"    - {parent}")

    first_column.append("")
    first_column.append("  - Effects (by newest):")

    if not preset.final_effects and not with_ai and not preset.post_effects:
        first_column.append("    - None")
        first_column.append("")

    if preset.final_effects:
        first_column.append("    - Final Pass:")

        for effect in reversed(preset.final_effects):
            if callable(effect):
                first_column.append(f"      - {effect.func.__name__.replace('_', ' ')}")
            else:
                first_column.append(f"      - {effect.name.replace('_', ' ').replace('-', ' ')}")

        first_column.append("")

    if with_ai:
        first_column.append(f"    - AI Settings:")

        for (k, v) in sorted(preset.ai_settings.items()):
            if stability_model and k == 'model':
                v = stability_model

            for i, line in enumerate(textwrap.wrap(f"{k.replace('_', ' ')}: {v}", 42)):
                if i == 0:
                    first_column.append(f"      - {line}")
                else:
                    first_column.append(f"        {line}")

        first_column.append("")

    if preset.post_effects or with_ai:
        first_column.append("    - Post Pass:")

        if with_ai:
            first_column.append("      - stable diffusion")

        for effect in reversed(preset.post_effects):
            if callable(effect):
                first_column.append(f"      - {effect.func.__name__.replace('_', ' ')}")
            else:
                first_column.append(f"      - {effect.name.replace('_', ' ').replace('-', ' ')}")

        first_column.append("")

    if preset.octave_effects:
        first_column.append("    - Per-Octave Pass:")

        for effect in reversed(preset.octave_effects):
            if callable(effect):
                first_column.append(f"      - {effect.func.__name__.replace('_', ' ')}")
            else:
                first_column.append(f"      - {effect.name.replace('_', ' ').replace('-', ' ')}")

        first_column.append("")

    first_column.append("Canvas:")
    first_column.append(f"  - seed: {seed}")
    first_column.append(f"  - with alpha: {with_alpha}")
    first_column.append(f"  - with supersample: {with_supersample}")
    first_column.append(f"  - with fxaa: {with_fxaa}")
    first_column.append(f"  - with upscale: {with_upscale}")
    first_column.append("")

    second_column = ["Settings:"]
    for (k, v) in sorted(preset.settings.items()):
        if isinstance(v, Enum):
            second_column.append(f"  - {k.replace('_', ' ')}: {v.name.replace('_', ' ')}")
        elif isinstance(v, float):
            second_column.append(f"  - {k.replace('_', ' ')}: {round(v, 3)}")
        else:
            second_column.append(f"  - {k.replace('_', ' ')}: {v}")

    second_column.append("")

    out = []

    for i in range(max(len(first_column), len(second_column))):
        if i < len(first_column):
            first = first_column[i]
        else:
            first = ""

        if i < len(second_column):
            second = second_column[i]
        else:
            second = ""

        out.append(f"{first:50} {second}")

    return out




def apply(ctx, seed, filename, no_resize, with_fxaa, time, speed, preset_name, input_filename):
    if not seed:
        seed = random.randint(1, MAX_SEED_VALUE)

    value.set_seed(seed)
    reload_presets(PRESETS)

    input_shape = util.shape_from_file(input_filename)

    input_shape[2] = min(input_shape[2], 3)

    tensor = tf.image.convert_image_dtype(util.load(input_filename, channels=input_shape[2]), dtype=tf.float32)

    if preset_name == "random":
        preset_name = list(EFFECT_PRESETS)[random.randint(0, len(EFFECT_PRESETS) - 1)]

    print(f"{preset_name} (seed: {seed})")

    preset = EFFECT_PRESETS[preset_name]

    if no_resize:
        shape = input_shape

    else:
        shape = [1024, 1024, input_shape[2]]

        tensor = effects.square_crop_and_resize(tensor, input_shape, shape[0])

    try:
        preset.render(seed=seed, tensor=tensor, shape=shape, with_fxaa=with_fxaa, time=time, speed=speed, filename=filename)

    except Exception as e:
        util.logger.error(f"preset.render() failed: {e}\nSeed: {seed}\nArgs: {preset.__dict__}")
        raise


def animate(ctx, width, height,  seed, effect_preset, filename, save_frames, frame_count, watermark, preview_filename, with_alt_text, with_supersample, with_fxaa, preset_name):
    if seed is None:
        seed = random.randint(1, MAX_SEED_VALUE)

    value.set_seed(seed)
    reload_presets(PRESETS)

    if preset_name == 'random':
        preset_name = list(GENERATOR_PRESETS)[random.randint(0, len(GENERATOR_PRESETS) - 1)]

    if effect_preset == 'random':
        effect_preset = list(EFFECT_PRESETS)[random.randint(0, len(EFFECT_PRESETS) - 1)]

    if effect_preset:
        print(f"{preset_name} vs. {effect_preset} (seed: {seed})")
    else:
        print(f"{preset_name} (seed: {seed})")

    preset = GENERATOR_PRESETS[preset_name]

    caption = None

    with tempfile.TemporaryDirectory() as tmp:
        for i in range(frame_count):
            frame_filename = f'{tmp}/{i:04d}.png'

            common_params = ['--seed', str(seed),
                             '--time', f'{i/frame_count:0.4f}',
                             '--filename', frame_filename]

            extra_params = []
            if with_alt_text and i == 0:
                extra_params = ['--with-alt-text']

            if with_supersample:
                extra_params += ['--with-supersample']

            if with_fxaa:
                extra_params += ['--with-fxaa']

            output = subprocess.check_output(['noisemaker', 'generate', preset_name,
                                              '--speed', str(_use_reasonable_speed(preset, frame_count)),
                                              '--height', str(height),
                                              '--width', str(width)] + common_params + extra_params,
                                              universal_newlines=True).strip().split("\n")

            if with_alt_text and i == 0:
                if len(output) == 6:  # Useless extra crap that Tensorflow on Apple Silicon spews to stdout
                    print(output[2])
                else:
                    print(output[1])

            if effect_preset:
                extra_params = []

                if with_fxaa:
                    extra_params += ['--with-fxaa']

                util.check_call(['noisemaker', 'apply', effect_preset, frame_filename,
                                 '--no-resize',
                                 '--speed', str(_use_reasonable_speed(EFFECT_PRESETS[effect_preset], frame_count))]
                                + common_params + extra_params)

            if save_frames:
                shutil.copy(frame_filename, save_frames)

            if watermark:
                util.watermark(watermark, frame_filename)

            if preview_filename and i == 0:
                shutil.copy(frame_filename, preview_filename)

        if filename.endswith(".mp4"):
            util.check_call(["ffmpeg",
                             "-framerate", "30",
                             "-i", f"{tmp}/%04d.png",
                             "-s", "1024x1024",
                             "-c:v", "libx264",
                             "-preset", "veryslow",
                             "-crf", "15",
                             "-pix_fmt", "yuv420p",
                             "-b:v", "8000k",
                             "-bufsize", "16000k",
                             filename])

        else:
            util.magick(f'{tmp}/*png', filename)


def mashup(ctx, input_dir, filename, control_filename, time, speed, seed):
    filenames = []

    for root, _, files in os.walk(input_dir):
        for f in files:
            if f.endswith(('.png', '.jpg')):
                filenames.append(os.path.join(root, f))

    collage_count = min(random.randint(4, 6), len(filenames))
    collage_images = []

    for i in range(collage_count + 1):
        index = random.randint(0, len(filenames) - 1)

        input_filename = os.path.join(input_dir, filenames[index])

        collage_input = tf.image.convert_image_dtype(util.load(input_filename, channels=3), dtype=tf.float32)

        collage_images.append(collage_input)

    if control_filename:
        control_shape = util.shape_from_file(control_filename)
        control = tf.image.convert_image_dtype(util.load(control_filename, channels=control_shape[2]), dtype=tf.float32)

    else:
        control = collage_images.pop()

    shape = tf.shape(control)  # All images need to be the same size!

    control = value.value_map(control, shape, keepdims=True)

    value.set_seed(seed)

    base = generators.basic(freq=random.randint(2, 5), shape=shape, lattice_drift=random.randint(0, 1), hue_range=random.random(),
                            time=time, speed=speed)

    value_shape = value.value_shape(shape)

    control = value.convolve(kernel=effects.ValueMask.conv2d_blur, tensor=control, shape=value_shape)

    tensor = effects.blend_layers(control, shape, random.random() * .5, *collage_images)

    tensor = value.blend(tensor, base, .125 + random.random() * .125)

    tensor = effects.bloom(tensor, shape, alpha=.25 + random.random() * .125)
    tensor = effects.shadow(tensor, shape, alpha=.25 + random.random() * .125, reference=control)

    tensor = tf.image.adjust_brightness(tensor, .1)
    tensor = tf.image.adjust_contrast(tensor, 1.5)

    util.save(tensor, filename)

    print('mashup')


def _use_reasonable_speed(preset, frame_count):
    """Return a reasonable speed parameter for the given animation length."""

    return preset.settings.get("speed", 0.25) * (frame_count / 50.0)


def dream(width, height, filename):
    name, prompt, description = dreamer.dream(width, height, filename=filename)

    print(name)
    print(prompt)
    print(description)


main = click.CommandCollection(sources=[genframes])
if __name__ == "__main__":
    main()
    #testPillow()
    #postprocessBrightness('/tmp/')