Update app.py

app.py

@@ -1,3 +1,5 @@
+
+# Part 1/4 - Imports and Initial Setup
 import gradio as gr
 import numpy as np
 import librosa
@@ -8,7 +10,7 @@ import requests
 import json
 import time
 
-# 데이터 저장을 위한 간단한 파일 기반 DB
+# 데이터 저장을 위한 DB 클래스
 class SimpleDB:
     def __init__(self, file_path="wishes.json"):
         self.file_path = file_path
@@ -27,15 +29,12 @@ class SimpleDB:
     def save_wish(self, name, wish, timestamp=None):
         if timestamp is None:
             timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        
         wish_data = {
             "name": name,
             "wish": wish,
             "timestamp": timestamp
         }
-        
         self.wishes.append(wish_data)
-        
         try:
             with open(self.file_path, 'w', encoding='utf-8') as f:
                 json.dump(self.wishes, f, ensure_ascii=False, indent=2)
@@ -44,12 +43,11 @@ class SimpleDB:
             print(f"Error saving wish: {e}")
             return False
 
-# 환경변수 설정
+# 환경변수 및 API 설정
 HF_API_TOKEN = os.getenv("roots")
 if not HF_API_TOKEN:
     raise ValueError("roots token not found in environment variables")
 
-# API 설정
 API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
 headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
 
@@ -64,7 +62,7 @@ text_analyzer = pipeline(
 )
 
 # 상수 정의
-IMAGE_DISPLAY_TIME = 30  # 이미지 표시 시간 (초)
+IMAGE_DISPLAY_TIME = 30
 WELCOME_MESSAGE = """
 # 디지털 굿판에 오신 것을 환영합니다
 
@@ -85,7 +83,159 @@ WORLDVIEW_MESSAGE = """
 """
 
 
-# Part 2/3 - Core Functions and Image Generation
+# Part 2/4 - Analysis Functions
+def calculate_baseline_features(audio_path):
+    """기준점 음성 특성 분석"""
+    try:
+        y, sr = librosa.load(audio_path, sr=16000)
+        features = {
+            "energy": float(np.mean(librosa.feature.rms(y=y))),
+            "tempo": float(librosa.beat.tempo(y)[0]),
+            "pitch": float(np.mean(librosa.feature.zero_crossing_rate(y))),
+            "volume": float(np.mean(np.abs(y))),
+            "mfcc": librosa.feature.mfcc(y=y, sr=sr, n_mfcc=13).mean(axis=1).tolist()
+        }
+        return features
+    except Exception as e:
+        print(f"Error calculating baseline: {str(e)}")
+        return None
+
+def map_acoustic_to_emotion(features, baseline_features=None):
+    """음향학적 특성을 감정으로 매핑"""
+    energy_norm = min(features["energy"] * 100, 100)
+    tempo_norm = min(features["tempo"] / 200, 1)
+    pitch_norm = min(features["pitch"] * 2, 1)
+
+    if baseline_features:
+        energy_norm = (features["energy"] / baseline_features["energy"]) * 50
+        tempo_norm = (features["tempo"] / baseline_features["tempo"])
+        pitch_norm = (features["pitch"] / baseline_features["pitch"])
+
+    emotions = {
+        "primary": "",
+        "intensity": energy_norm,
+        "confidence": 0.0,
+        "secondary": "",
+        "characteristics": []
+    }
+
+    if energy_norm > 70:
+        if tempo_norm > 0.6:
+            emotions["primary"] = "기쁨/열정"
+            emotions["characteristics"].append("빠르고 활기찬 말하기 패턴")
+        else:
+            emotions["primary"] = "분노/강조"
+            emotions["characteristics"].append("강한 음성 강도")
+        emotions["confidence"] = energy_norm / 100
+    elif pitch_norm > 0.6:
+        if energy_norm > 50:
+            emotions["primary"] = "놀람/흥분"
+            emotions["characteristics"].append("높은 음고와 강한 강세")
+        else:
+            emotions["primary"] = "관심/호기심"
+            emotions["characteristics"].append("음고 변화가 큼")
+        emotions["confidence"] = pitch_norm
+    elif energy_norm < 30:
+        if tempo_norm < 0.4:
+            emotions["primary"] = "슬픔/우울"
+            emotions["characteristics"].append("느리고 약한 음성")
+        else:
+            emotions["primary"] = "피로/무기력"
+            emotions["characteristics"].append("낮은 에너지 레벨")
+        emotions["confidence"] = (30 - energy_norm) / 30
+    else:
+        if tempo_norm > 0.5:
+            emotions["primary"] = "평온/안정"
+            emotions["characteristics"].append("균형잡힌 말하기 패턴")
+        else:
+            emotions["primary"] = "차분/진지"
+            emotions["characteristics"].append("안정적인 음성 특성")
+        emotions["confidence"] = 0.5
+
+    emotions["details"] = {
+        "energy_level": f"{energy_norm:.1f}%",
+        "speech_rate": f"{'빠름' if tempo_norm > 0.6 else '보통' if tempo_norm > 0.4 else '느림'}",
+        "pitch_variation": f"{'높음' if pitch_norm > 0.6 else '보통' if pitch_norm > 0.3 else '낮음'}",
+        "voice_volume": f"{'큼' if features['volume'] > 0.7 else '보통' if features['volume'] > 0.3 else '작음'}"
+    }
+
+    return emotions
+
+def analyze_voice(audio_path, state):
+    """통합 음성 분석"""
+    if audio_path is None:
+        return state, "음성을 먼저 녹음해주세요.", "", "", ""
+    
+    try:
+        y, sr = librosa.load(audio_path, sr=16000)
+        
+        # 음향학적 특성 분석
+        acoustic_features = {
+            "energy": float(np.mean(librosa.feature.rms(y=y))),
+            "tempo": float(librosa.beat.tempo(y)[0]),
+            "pitch": float(np.mean(librosa.feature.zero_crossing_rate(y))),
+            "volume": float(np.mean(np.abs(y)))
+        }
+
+        # 음성 감정 분석
+        voice_emotion = map_acoustic_to_emotion(acoustic_features, state.get("baseline_features"))
+        
+        # 음성 인식
+        transcription = speech_recognizer(y)
+        text = transcription["text"]
+        
+        # 텍스트 감정 분석
+        text_sentiment = text_analyzer(text)[0]
+        
+        # 결과 포맷팅
+        voice_result = (
+            f"음성 감정: {voice_emotion['primary']} "
+            f"(강도: {voice_emotion['intensity']:.1f}%, 신뢰도: {voice_emotion['confidence']:.2f})\n"
+            f"특징: {', '.join(voice_emotion['characteristics'])}\n"
+            f"상세 분석:\n"
+            f"- 에너지 레벨: {voice_emotion['details']['energy_level']}\n"
+            f"- 말하기 속도: {voice_emotion['details']['speech_rate']}\n"
+            f"- 음높이 변화: {voice_emotion['details']['pitch_variation']}\n"
+            f"- 음성 크기: {voice_emotion['details']['voice_volume']}"
+        )
+        
+        text_result = f"텍스트 감정 분석 (1-5): {text_sentiment['score']}"
+        
+        # 프롬프트 생성
+        prompt = generate_detailed_prompt(text, voice_emotion, text_sentiment)
+        
+        return state, text, voice_result, text_result, prompt
+    except Exception as e:
+        return state, f"오류 발생: {str(e)}", "", "", ""
+
+
+# Part 3/4 - Generation and Processing Functions
+def generate_detailed_prompt(text, emotions, text_sentiment):
+    """감정 기반 상세 프롬프트 생성"""
+    emotion_colors = {
+        "기쁨/열정": "밝은 노랑과 따뜻한 주황색",
+        "분노/강조": "강렬한 빨강과 짙은 검정",
+        "놀람/흥분": "선명한 파랑과 밝은 보라",
+        "관심/호기심": "연한 하늘색과 민트색",
+        "슬픔/우울": "어두운 파랑과 회색",
+        "피로/무기력": "탁한 갈색과 짙은 회색",
+        "평온/안정": "부드러운 초록과 베이지",
+        "차분/진지": "차분한 남색과 깊은 보라"
+    }
+
+    if emotions["intensity"] > 70:
+        visual_style = "역동적인 붓질과 강한 대비"
+    elif emotions["intensity"] > 40:
+        visual_style = "균형잡힌 구도와 중간 톤의 조화"
+    else:
+        visual_style = "부드러운 그라데이션과 차분한 톤"
+
+    prompt = f"한국 전통 민화 스타일의 추상화, {emotion_colors.get(emotions['primary'], '자연스러운 색상')} 기반. "
+    prompt += f"{visual_style}로 표현된 {emotions['primary']}의 감정. "
+    prompt += f"음성의 특징({', '.join(emotions['characteristics'])})을 화면의 동적 요소로 표현. "
+    prompt += f"발화 내용 '{text}'에서 느껴지는 감정(강도: {text_sentiment['score']}/5)을 은유적 이미지로 담아내기."
+    
+    return prompt
 
 def generate_image_from_prompt(prompt):
     """이미지 생성 함수"""
@@ -110,7 +260,7 @@ def generate_image_from_prompt(prompt):
         
         if response.status_code == 200:
             print("Image generated successfully")
-            # 이미지 저장 로직 추가
+            # 이미지 저장
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
             image_path = f"generated_images/{timestamp}.png"
             os.makedirs("generated_images", exist_ok=True)
@@ -125,64 +275,6 @@ def generate_image_from_prompt(prompt):
         print(f"Error generating image: {str(e)}")
         return None, None
 
-def analyze_voice_with_retry(audio_path, state, max_retries=3):
-    """음성 분석 함수 (재시도 로직 포함)"""
-    for attempt in range(max_retries):
-        try:
-            y, sr = librosa.load(audio_path, sr=16000)
-            
-            acoustic_features = {
-                "energy": float(np.mean(librosa.feature.rms(y=y))),
-                "tempo": float(librosa.beat.tempo(y)[0]),
-                "pitch": float(np.mean(librosa.feature.zero_crossing_rate(y))),
-                "volume": float(np.mean(np.abs(y)))
-            }
-            
-            transcription = speech_recognizer(y)
-            text = transcription["text"]
-            
-            emotions = map_acoustic_to_emotion(acoustic_features, state.get("baseline_features"))
-            text_sentiment = text_analyzer(text)[0]
-            
-            return {
-                "text": text,
-                "emotions": emotions,
-                "sentiment": text_sentiment,
-                "features": acoustic_features
-            }
-        except Exception as e:
-            if attempt == max_retries - 1:
-                raise e
-            print(f"Attempt {attempt + 1} failed, retrying...")
-            continue
-
-def generate_detailed_prompt(text, emotions, text_sentiment):
-    """감정 기반 상세 프롬프트 생성"""
-    emotion_colors = {
-        "기쁨/열정": "밝은 노랑과 따뜻한 주황색",
-        "분노/강조": "강렬한 빨강과 짙은 검정",
-        "놀람/흥분": "선명한 파랑과 밝은 보라",
-        "관심/호기심": "연한 하늘색과 민트색",
-        "슬픔/우울": "어두운 파랑과 회색",
-        "피로/무기력": "탁한 갈색과 짙은 회색",
-        "평온/안정": "부드러운 초록과 베이지",
-        "차분/진지": "차분한 남색과 깊은 보라"
-    }
-
-    if emotions["intensity"] > 70:
-        visual_style = "역동적인 붓질과 강한 대비"
-    elif emotions["intensity"] > 40:
-        visual_style = "균형잡힌 구도와 중간 톤의 조화"
-    else:
-        visual_style = "부드러운 그라데이션과 차분한 톤"
-
-    prompt = f"한국 전통 민화 스타일의 추상화, {emotion_colors.get(emotions['primary'], '자연스러운 색상')} 기반. "
-    prompt += f"{visual_style}로 표현된 {emotions['primary']}의 감정. "
-    prompt += f"음성의 특징({', '.join(emotions['characteristics'])})을 화면의 동적 요소로 표현. "
-    prompt += f"발화 내용 '{text}'에서 느껴지는 감정(강도: {text_sentiment['score']}/5)을 은유적 이미지로 담아내기."
-    
-    return prompt
-
 def update_final_prompt(state):
     """청신의 감상들을 종합하여 최종 프롬프트 업데이트"""
     combined_prompt = "한국 전통 민화 스타일의 추상화, 온천천에서의 감상과 소원을 담아내기:\n\n"
@@ -221,9 +313,9 @@ def save_reflection(text, state):
         print(f"Error in save_reflection: {str(e)}")
         return state, []
 
-# Part 3/3 - Interface and Main
+
+# Part 4/4 - Interface and Main
 def create_interface():
-    # DB 초기화
     db = SimpleDB()
     
     with gr.Blocks(theme=gr.themes.Soft()) as app:
@@ -240,10 +332,9 @@ def create_interface():
         header = gr.Markdown("# 디지털 굿판")
         user_display = gr.Markdown("")
 
-        # 탭 구성
         with gr.Tabs() as tabs:
             # 입장
-            with gr.Tab("입장", id="intro"):
+            with gr.Tab("입장"):
                 gr.Markdown(WELCOME_MESSAGE)
                 name_input = gr.Textbox(
                     label="이름을 알려주세요",
@@ -251,17 +342,14 @@ def create_interface():
                 )
                 worldview_display = gr.Markdown(visible=False)
                 start_btn = gr.Button("여정 시작하기")
-                continue_btn = gr.Button("다음 단계로", visible=False)
 
             # 기준 설정
-            with gr.Tab("기준 설정", id="baseline"):
-                gr.Markdown("""
-                ### 축원의 문장을 평온한 마음으로 읽어주세요
+            with gr.Tab("기준 설정"):
+                gr.Markdown("""### 축원의 문장을 평온한 마음으로 읽어주세요
                 
                 먼저, 평온한 마음으로 축원의 문장을 읽어주세요. 
                 이 축원은 당신에게 평화와 안정을 불러일으키며, 
-                감정을 정확히 이해하기 위한 **기준점**이 될 것입니다.
-                """)
+                감정을 정확히 이해하기 위한 **기준점**이 될 것입니다.""")
                 gr.Markdown("'당신의 건강과 행복이 늘 가득하기를'")
                 baseline_audio = gr.Audio(
                     label="축원 문장 녹음하기",
@@ -271,14 +359,10 @@ def create_interface():
                 baseline_status = gr.Markdown("")
 
             # 청신
-            with gr.Tab("청신", id="cleansing"):
-                gr.Markdown("""
-                ## 청신 - 소리로 정화하기
+            with gr.Tab("청신"):
+                gr.Markdown("""## 청신 - 소리로 정화하기
                 
-                온천천의 물소리에 귀 기울이며 **30분간 마음을 정화**해보세요.
-                장전역까지 이어지는 이 여정을 함께하며, 
-                차분히 자연의 소리에 마음을 기울여보세요.
-                """)
+                온천천의 물소리에 귀 기울이며 **30분간 마음을 정화**해보세요.""")
                 play_music_btn = gr.Button("온천천의 소리 듣기")
                 with gr.Row():
                     audio = gr.Audio(
@@ -300,45 +384,25 @@ def create_interface():
                         )
 
             # 기원
-            with gr.Tab("기원", id="prayer"):
-                gr.Markdown("""
-                ## 기원 - 소원을 전해보세요
-                
-                당신의 소원을 온전히 담아 이곳에 전해주세요.
-                당신의 목소리와 감정이 영적 메시지가 되어 전해지며,
-                이 기원이 당신에게 평화와 안정을 불러오기를 바랍니다.
-                """)
+            with gr.Tab("기원"):
+                gr.Markdown("## 기원 - 소원을 전해보세요")
                 with gr.Row():
                     with gr.Column():
                         voice_input = gr.Audio(
                             label="소원을 나누고 싶은 마음을 말해주세요",
                             sources=["microphone"]
                         )
+                        clear_btn = gr.Button("녹음 지우기")
                         analyze_btn = gr.Button("소원 분석하기")
                     
                     with gr.Column():
-                        transcribed_text = gr.Textbox(
-                            label="인식된 텍스트",
-                            interactive=False
-                        )
-                        voice_emotion = gr.Textbox(
-                            label="음성 감정 분석",
-                            interactive=False
-                        )
-                        text_emotion = gr.Textbox(
-                            label="텍스트 감정 분석",
-                            interactive=False
-                        )
+                        transcribed_text = gr.Textbox(label="인식된 텍스트")
+                        voice_emotion = gr.Textbox(label="음성 감정 분석")
+                        text_emotion = gr.Textbox(label="텍스트 감정 분석")
 
             # 송신
-            with gr.Tab("송신", id="sending"):
-                gr.Markdown("""
-                ## 송신 - 마음의 그림을 남기고, 보내기
-                
-                당신의 마음을 시각화하여 그려봅니다. 
-                자연과 영적 교감을 통해 얻은 평온과 치유의 흔적을, 
-                하나의 그림으로 담아보세요.
-                """)
+            with gr.Tab("송신"):
+                gr.Markdown("## 송신 - 마음의 그림을 남기고, 보내기")
                 final_prompt = gr.Textbox(
                     label="생성된 프롬프트",
                     interactive=False,
@@ -348,54 +412,23 @@ def create_interface():
                     generate_btn = gr.Button("마음의 그림 그리기")
                     save_image_btn = gr.Button("이미지 저장하기")
                 result_image = gr.Image(label="생성된 이미지")
-                image_timer = gr.Markdown(
-                    "이미지는 30초 후 자동으로 사라집니다...",
-                    visible=False
-                )
-                
-                # 최종 감상
-                gr.Markdown("""
-                ## 마지막 감상을 남겨주세요
                 
-                이제 당신의 여정이 마무리되었습니다. 
-                마지막으로 느낀 감상을 한 줄로 남겨주세요.
-                """)
+                gr.Markdown("## 마지막 감상을 남겨주세요")
                 final_reflection = gr.Textbox(
                     label="마지막 감상",
                     placeholder="한 줄로 남겨주세요..."
                 )
                 save_final_btn = gr.Button("감상 남기기")
 
-        # 이벤트 핸들러
-        def start_journey(name):
-            if not name.strip():
-                return "이름을 입력해주세요", gr.update(), gr.update()
-            
-            state = {"user_name": name}
-            return (
-                WORLDVIEW_MESSAGE,
-                gr.update(visible=True),
-                gr.update(visible=True)
-            )
-
-        def save_wish_to_db(text, state):
-            if text and state.get("user_name"):
-                db.save_wish(state["user_name"], text)
-                return "소원이 안전하게 저장되었습니다."
-            return "저장에 실패했습니다."
-
-        def handle_image_generation(prompt):
-            image_content, image_path = generate_image_from_prompt(prompt)
-            if image_content:
-                gr.update(visible=True)  # 타이머 표시
-                return image_content
-            return None
-
         # 이벤트 연결
         start_btn.click(
-            fn=start_journey,
+            fn=lambda name: (
+                WORLDVIEW_MESSAGE if name.strip() else "이름을 입력해주세요",
+                gr.update(visible=True) if name.strip() else gr.update(),
+                {"user_name": name} if name.strip() else state
+            ),
             inputs=[name_input],
-            outputs=[worldview_display, continue_btn, tabs]
+            outputs=[worldview_display, tabs, state]
         )
 
         set_baseline_btn.click(
@@ -410,25 +443,30 @@ def create_interface():
             outputs=[state, reflections_display]
         )
 
+        clear_btn.click(
+            fn=lambda: None,
+            outputs=[voice_input]
+        )
+
         analyze_btn.click(
             fn=analyze_voice,
             inputs=[voice_input, state],
-            outputs=[transcribed_text, voice_emotion, text_emotion, state]
+            outputs=[state, transcribed_text, voice_emotion, text_emotion, final_prompt]
         )
 
         generate_btn.click(
-            fn=handle_image_generation,
+            fn=lambda p: generate_image_from_prompt(p)[0],
             inputs=[final_prompt],
             outputs=[result_image]
         )
 
         save_final_btn.click(
-            fn=save_wish_to_db,
+            fn=lambda t, s: (db.save_wish(s["user_name"], t), "감상이 저장되었습니다."),
             inputs=[final_reflection, state],
-            outputs=[gr.Markdown("")]  # 저장 상태 메시지
+            outputs=[gr.Markdown("")]
         )
 
-        # 이미지 자동 사라짐 설정
+        # 이미지 자동 사라짐
         result_image.change(
             fn=lambda: gr.update(value=None),
             inputs=[],
@@ -441,4 +479,3 @@ def create_interface():
 if __name__ == "__main__":
     demo = create_interface()
     demo.launch(debug=True)
-