import numpy as np
import librosa
import soundfile as sf

# 데이터 로드 (예: 주식 가격)
data = np.array([100, 105, 103, 108, 112, 110, 115])

# 데이터 정규화 (0~1)
normalized = (data - data.min()) / (data.max() - data.min())

# 음높이 범위 설정 (C4~C6, MIDI 60~84)
midi_notes = 60 + (normalized * 24)

# 음표 생성
sample_rate = 22050
duration = 0.5  # 각 음표 0.5초

audio = []
for note in midi_notes:
    freq = librosa.midi_to_hz(note)
    t = np.linspace(0, duration, int(sample_rate * duration))
    # 사인파 생성
    tone = np.sin(2 * np.pi * freq * t)
    # ADSR 엔벨로프 적용
    envelope = np.exp(-3 * t)
    audio.extend(tone * envelope)

# 오디오 저장
sf.write('sonified_data.wav', audio, sample_rate)

[CSV 파일 읽기]
    ↓
[데이터 파싱]
    ↓
[온도] → [scale 0-40 → 200-800] → [Sine~ 오실레이터]
[습도] → [scale 0-100 → 0-1] → [Reverb wet/dry]
[풍속] → [scale 0-30 → 500-5000] → [Filter cutoff]
[기압] → [scale 980-1040 → 0.3-0.8] → [전체 gain~]
    ↓
[믹싱] → [출력]

# 선형 맵핑 (비추천)
frequency = 200 + (data_value * 10)

# 로그 맵핑 (추천)
import numpy as np
frequency = 200 * np.exp(data_value / 100)

# 멱함수 맵핑 (더 세밀한 제어)
frequency = 200 + (data_value ** 0.6) * 10

# 데이터를 펜타토닉 스케일로 양자화
def quantize_to_pentatonic(frequency):
    # C 펜타토닉: C, D, E, G, A
    pentatonic_ratios = [1.0, 9/8, 5/4, 3/2, 5/3]
    base_freq = 261.63  # C4
    
    # 가장 가까운 펜타토닉 음 찾기
    octave = int(np.log2(frequency / base_freq))
    normalized = frequency / (base_freq * (2 ** octave))
    
    closest_ratio = min(pentatonic_ratios, 
                       key=lambda x: abs(x - normalized))
    
    return base_freq * (2 ** octave) * closest_ratio

# Magenta (Google)를 활용한 예시
from magenta.models.music_vae import TrainedModel
import magenta.music as mm

# 사전 학습된 모델 로드
model = TrainedModel(
    'cat-mel_2bar_big',
    batch_size=4,
    checkpoint_dir_or_path='model_checkpoint'
)

# 데이터를 잠재 벡터로 인코딩
data_normalized = normalize_data(your_data)
latent_vector = data_to_latent(data_normalized)

# 음악 생성
generated_sequence = model.decode(
    length=32,
    z=latent_vector
)

# MIDI로 저장
mm.sequence_proto_to_midi_file(
    generated_sequence,
    'output.mid'
)

import numpy as np
from midiutil import MIDIFile

# 일주일 최고 기온 데이터 (예시)
temperatures = [15, 18, 22, 25, 23, 20, 17]
days = ['월', '화', '수', '목', '금', '토', '일']

print("이번 주 기온 데이터:")
for day, temp in zip(days, temperatures):
    print(f"{day}요일: {temp}°C")

# 온도를 MIDI 노트 번호로 맵핑
# 15도 = C4 (60), 25도 = C5 (72)
def temp_to_midi(temp):
    # 15~25도를 60~72 범위로 선형 맵핑
    midi_note = 60 + int((temp - 15) * 1.2)
    return midi_note

# C 메이저 스케일로 양자화
c_major_scale = [0, 2, 4, 5, 7, 9, 11]  # C, D, E, F, G, A, B

def quantize_to_scale(midi_note):
    octave = (midi_note // 12) * 12
    note_in_octave = midi_note % 12
    # 가장 가까운 스케일 음 찾기
    closest = min(c_major_scale, 
                  key=lambda x: abs(x - note_in_octave))
    return octave + closest

# 변환 실행
midi_notes = [quantize_to_scale(temp_to_midi(t)) 
              for t in temperatures]

print("\nMIDI 노트 번호:", midi_notes)

# MIDI 파일 생성
midi = MIDIFile(1)  # 1개 트랙
track = 0
channel = 0
time = 0
tempo = 120
volume = 100

midi.addTempo(track, time, tempo)

# 각 음표 추가
for i, note in enumerate(midi_notes):
    midi.addNote(track, channel, note, 
                 time + i, 1, volume)  # 1박자씩

# 파일 저장
with open("weather_melody.mid", "wb") as output_file:
    midi.writeFile(output_file)

print("\n✅ MIDI 파일 생성 완료: weather_melody.mid")
print("DAW나 MIDI 플레이어로 재생해보세요!")

from PIL import Image
import numpy as np

# 이미지 로드
img = Image.open('your_image.jpg')
img = img.resize((100, 100))  # 크기 조정
img_gray = img.convert('L')  # 흑백 변환

# 픽셀 데이터 추출
pixels = np.array(img_gray)

print(f"이미지 크기: {pixels.shape}")
print(f"밝기 범위: {pixels.min()} ~ {pixels.max()}")

# 각 행을 시간 단위로, 각 열을 주파수로
def image_to_frequencies(pixels, duration=10):
    height, width = pixels.shape
    
    # 밝기를 주파수로 (0-255 → 200-2000Hz)
    frequencies = 200 + (pixels / 255) * 1800
    
    # 시간 배열 생성
    time_per_row = duration / height
    
    return frequencies, time_per_row

freqs, time_step = image_to_frequencies(pixels)

import sounddevice as sd

sample_rate = 44100

def generate_audio(frequencies, time_step):
    audio = []
    
    for row in frequencies:
        # 각 행의 평균 주파수 계산
        avg_freq = np.mean(row)
        
        # 사인파 생성
        t = np.linspace(0, time_step, 
                       int(sample_rate * time_step))
        wave = np.sin(2 * np.pi * avg_freq * t)
        
        # 엔벨로프 적용
        envelope = np.exp(-3 * t / time_step)
        audio.extend(wave * envelope * 0.3)
    
    return np.array(audio)

# 오디오 생성 및 재생
audio = generate_audio(freqs, time_step)
sd.play(audio, sample_rate)
sd.wait()

print("✅ 이미지 소닉화 완료!")

from pyo import *
import requests
import threading
import time

# Pyo 서버 초기화
s = Server().boot()
s.start()

# 전역 변수
current_value = 0
value_lock = threading.Lock()

# 데이터 수집 스레드
def fetch_data():
    global current_value
    while True:
        try:
            # 예: 비트코인 가격 API
            response = requests.get(
                'https://api.coingecko.com/api/v3/simple/price',
                params={'ids': 'bitcoin', 'vs_currencies': 'usd'}
            )
            price = response.json()['bitcoin']['usd']
            
            with value_lock:
                current_value = price
            
            print(f"현재 BTC 가격: ${price:,.2f}")
            
        except Exception as e:
            print(f"데이터 수집 오류: {e}")
        
        time.sleep(10)  # 10초마다 업데이트

# 오디오 생성
class DataSonifier:
    def __init__(self):
        # 기본 오실레이터
        self.freq = Sig(440)
        self.osc = Sine(freq=self.freq, mul=0.3)
        
        # 필터
        self.filt = Biquad(self.osc, freq=1000, q=5, type=2)
        
        # 리버브
        self.rev = Freeverb(self.filt, size=0.8, damp=0.7, bal=0.3)
        
        # 출력
        self.out = self.rev.out()
        
        # 업데이트 타이머
        self.pattern = Pattern(self.update, time=0.1)
        self.pattern.play()
    
    def update(self):
        global current_value
        with value_lock:
            value = current_value
        
        # 가격을 주파수로 맵핑 (30000~50000 → 200~800Hz)
        if value > 0:
            freq = 200 + ((value - 30000) / 20000) * 600
            freq = max(200, min(800, freq))  # 범위 제한
            self.freq.value = freq

# 스레드 시작
data_thread = threading.Thread(target=fetch_data, daemon=True)
data_thread.start()

# 소니파이어 시작
sonifier = DataSonifier()

print("실시간 소닉화 시작!")
print("Ctrl+C로 종료")

# GUI 실행
s.gui(locals())