v4.3: Multi-Page structure + 5 new landforms (uvala, tower_karst, karren, transverse_dune, star_dune)

app.py

@@ -1,14 +1,102 @@
-# Geo-Lab AI - 이상적 지형 갤러리
-# HuggingFace Spaces Entry Point
+"""
+🌍 Geo-Lab AI - 홈
+HuggingFace Spaces Entry Point (Multi-Page Streamlit)
+"""
+import streamlit as st
 
-import sys
-import os
+st.set_page_config(
+    page_title="🌍 Geo-Lab AI",
+    page_icon="🌍",
+    layout="wide"
+)
 
-# Add parent directory to path
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+# ========== 최상단: 제작자 정보 ==========
+st.markdown("""
+<div style='background: linear-gradient(90deg, #1565C0, #42A5F5); padding: 12px 20px; border-radius: 10px; margin-bottom: 15px;'>
+    <div style='display: flex; justify-content: space-between; align-items: center; color: white;'>
+        <span style='font-size: 1.1rem;'>🌍 <b>Geo-Lab AI</b> - 이상적 지형 시뮬레이터</span>
+        <span style='font-size: 0.85rem;'>제작: 2025 한백고등학교 김한솔T</span>
+    </div>
+</div>
+""", unsafe_allow_html=True)
 
-# Import and run main app
-from app.main import main
+st.title("🌍 Geo-Lab AI")
+st.subheader("_교사를 위한 지형 형성과정 시각화 도구_")
 
-if __name__ == "__main__":
-    main()
+st.markdown("---")
+
+# ========== 기능 소개 ==========
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    st.markdown("""
+    ### 📖 이상적 지형 갤러리
+    - 31종+ 교과서적 지형 모델
+    - 7개 카테고리 분류
+    - 2D/3D 시각화
+    
+    **👈 왼쪽 사이드바에서 페이지 선택**
+    """)
+
+with col2:
+    st.markdown("""
+    ### 🎬 형성 과정 애니메이션
+    - 0% → 100% 슬라이더
+    - 실시간 지형 변화 관찰
+    - 물리 기반 시뮬레이션
+    """)
+
+with col3:
+    st.markdown("""
+    ### 🌍 지형 시나리오
+    - 다중 이론 모델 비교
+    - 파라미터 조절
+    - 과학적 시뮬레이션
+    """)
+
+st.markdown("---")
+
+# ========== 사용법 ==========
+st.info("""
+### 💡 사용법
+
+1. **왼쪽 사이드바**에서 원하는 페이지 선택
+2. **📖 이상적 지형 갤러리** - 교과서적 지형 확인
+3. **🌍 지형 시나리오** - 상세 시뮬레이션 실행
+
+> ⚠️ **각 페이지는 독립적으로 로드됩니다** - 페이지 이동 시 이전 3D가 해제되어 안정적으로 작동합니다.
+""")
+
+# ========== 지원 지형 목록 ==========
+with st.expander("📋 지원 지형 목록 (36종)", expanded=False):
+    st.markdown("""
+    | 카테고리 | 지형 |
+    |----------|------|
+    | 🌊 하천 | 선상지, 자유곡류, 감입곡류, V자곡, 망상하천, 폭포 |
+    | 🔺 삼각주 | 일반, 조족상, 호상, 첨두상 |
+    | ❄️ 빙하 | U자곡, 권곡, 호른, 피오르드, 드럼린, 빙퇴석 |
+    | 🌋 화산 | 순상화산, 성층화산, 칼데라, 화구호, 용암대지 |
+    | 🦇 카르스트 | 돌리네, **우발라, 탑카르스트, 카렌** |
+    | 🏜️ 건조 | 바르한, **횡사구, 성사구**, 메사/뷰트 |
+    | 🏖️ 해안 | 해안절벽, 사취+석호, 육계사주, 리아스해안, 해식아치, 해안사구 |
+    """)
+
+# ========== 업데이트 내역 ==========
+with st.expander("📋 업데이트 내역", expanded=False):
+    st.markdown("""
+    **v4.3 (2025-12-14)** 🆕
+    - 새 지형 추가: 우발라, 탑카르스트, 카렌, 횡사구, 성사구
+    - 리아스 해안, 해식아치 개선
+    - 형성과정 애니메이션 개선 (폭포 두부침식, 피오르드 빙하→물)
+    
+    **v4.2 (2025-12-14)**
+    - Multi-Page 구조로 변경 (안정성 향상)
+    - WebGL 컨텍스트 관리 개선
+    
+    **v4.1 (2025-12-14)**
+    - 이상적 지형 갤러리 31종 추가
+    - 형성과정 애니메이션 기능
+    """)
+
+st.markdown("---")
+st.caption("© 2025 한백고등학교 김한솔T | Geo-Lab AI")

app/Home.py

@@ -0,0 +1,102 @@
+"""
+🌍 Geo-Lab AI - 홈
+Multi-page Streamlit 앱의 메인 페이지
+"""
+import streamlit as st
+
+st.set_page_config(
+    page_title="🌍 Geo-Lab AI",
+    page_icon="🌍",
+    layout="wide"
+)
+
+# ========== 최상단: 제작자 정보 ==========
+st.markdown("""
+<div style='background: linear-gradient(90deg, #1565C0, #42A5F5); padding: 12px 20px; border-radius: 10px; margin-bottom: 15px;'>
+    <div style='display: flex; justify-content: space-between; align-items: center; color: white;'>
+        <span style='font-size: 1.1rem;'>🌍 <b>Geo-Lab AI</b> - 이상적 지형 시뮬레이터</span>
+        <span style='font-size: 0.85rem;'>제작: 2025 한백고등학교 김한솔T</span>
+    </div>
+</div>
+""", unsafe_allow_html=True)
+
+st.title("🌍 Geo-Lab AI")
+st.subheader("_교사를 위한 지형 형성과정 시각화 도구_")
+
+st.markdown("---")
+
+# ========== 기능 소개 ==========
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    st.markdown("""
+    ### 📖 이상적 지형 갤러리
+    - 31종 교과서적 지형 모델
+    - 7개 카테고리 분류
+    - 2D/3D 시각화
+    
+    **👈 왼쪽 사이드바에서 페이지 선택**
+    """)
+
+with col2:
+    st.markdown("""
+    ### 🎬 형성 과정 애니메이션
+    - 0% → 100% 슬라이더
+    - 실시간 지형 변화 관찰
+    - 물리 기반 시뮬레이션
+    """)
+
+with col3:
+    st.markdown("""
+    ### 🌍 지형 시나리오
+    - 다중 이론 모델 비교
+    - 파라미터 조절
+    - 과학적 시뮬레이션
+    """)
+
+st.markdown("---")
+
+# ========== 사용법 ==========
+st.info("""
+### 💡 사용법
+
+1. **왼쪽 사이드바**에서 원하는 페이지 선택
+2. **📖 이상적 지형 갤러리** - 교과서적 지형 확인
+3. **🌍 지형 시나리오** - 상세 시뮬레이션 실행
+
+> ⚠️ **각 페이지는 독립적으로 로드됩니다** - 페이지 이동 시 이전 3D가 해제되어 안정적으로 작동합니다.
+""")
+
+# ========== 지원 지형 목록 ==========
+with st.expander("📋 지원 지형 목록 (31종)", expanded=False):
+    st.markdown("""
+    | 카테고리 | 지형 |
+    |----------|------|
+    | 🌊 하천 | 선상지, 자유곡류, 감입곡류, V자곡, 망상하천, 폭포 |
+    | 🔺 삼각주 | 일반, 조족상, 호상, 첨두상 |
+    | ❄️ 빙하 | U자곡, 권곡, 호른, 피오르드, 드럼린, 빙퇴석 |
+    | 🌋 화산 | 순상화산, 성층화산, 칼데라, 화구호, 용암대지 |
+    | 🦇 카르스트 | 돌리네 |
+    | 🏜️ 건조 | 바르한 사구, 메사/뷰트 |
+    | 🏖️ 해안 | 해안절벽, 사취+석호, 육계사주, 리아스해안, 해식아치, 해안사구 |
+    """)
+
+# ========== 업데이트 내역 ==========
+with st.expander("📋 업데이트 내역", expanded=False):
+    st.markdown("""
+    **v4.2 (2025-12-14)** 🆕
+    - Multi-Page 구조로 변경 (안정성 향상)
+    - WebGL 컨텍스트 관리 개선
+    
+    **v4.1 (2025-12-14)**
+    - 이상적 지형 갤러리 31종 추가
+    - 형성과정 애니메이션 기능
+    - 7개 카테고리 분류
+    
+    **v4.0**
+    - Project Genesis 통합 물리 엔진
+    - 지형 시나리오 탭
+    """)
+
+st.markdown("---")
+st.caption("© 2025 한백고등학교 김한솔T | Geo-Lab AI")

app/main.py

@@ -66,27 +66,6 @@ st.markdown("""
 """, unsafe_allow_html=True)
 
 
-# ============ 이미지 안전 로드 헬퍼 ============
-def safe_image(path, caption="", use_column_width=True):
-    """이미지 파일이 없어도 에러 없이 처리"""
-    if os.path.exists(path):
-        st.image(path, caption=caption, use_column_width=use_column_width)
-    else:
-        st.info(f"📷 {caption} (이미지 미포함)")
-
-
-# ============ 서버사이드 3D 렌더링 (WebGL 없이) ============
-def render_3d_as_image(fig_plotly, width=800, height=600):
-    """Plotly 3D figure를 서버사이드에서 PNG 이미지로 렌더링 (WebGL 불필요)"""
-    import io
-    try:
-        img_bytes = fig_plotly.to_image(format="png", width=width, height=height, engine="kaleido")
-        return img_bytes
-    except Exception as e:
-        st.error(f"3D 렌더링 오류: {e}")
-        return None
-
-
 # ============ 이론 정의 ============
 
 V_VALLEY_THEORIES = {
@@ -2547,8 +2526,14 @@ def render_terrain_3d(elevation, title, add_water=True, water_level=0, view_elev
     return fig
 
 
-def render_terrain_plotly(elevation, title, add_water=True, water_level=0, texture_path=None, force_camera=True, water_depth_grid=None, sediment_grid=None):
-    """Plotly 인터랙티브 3D Surface - 사실적 텍스처(Biome) 또는 위성 이미지 적용"""
+def render_terrain_plotly(elevation, title, add_water=True, water_level=0, texture_path=None, force_camera=True, water_depth_grid=None, sediment_grid=None, landform_type=None):
+    """Plotly 인터랙티브 3D Surface - 사실적 텍스처(Biome) 또는 위성 이미지 적용
+    
+    Args:
+        landform_type: 'river', 'coastal', 'glacial', 'volcanic', 'karst', 'arid' 중 하나.
+                       None이면 기존 로직 사용.
+                       'glacial'만 만년설 표시, 나머지는 물/풀/암석만
+    """
     h, w = elevation.shape
     x = np.arange(w)
     y = np.arange(h)
@@ -2581,27 +2566,70 @@ def render_terrain_plotly(elevation, title, add_water=True, water_level=0, textu
     biome[is_deposit] = 0
     
     # 암석 (경사가 급한 곳) - 절벽
-    # 고도차 1.5m/grid 이상이면 급경사로 간주 (실험적 수치)
-    biome[slope > 1.2] = 2 # Threshold lowered to show more rock detail
-    
-    # 눈 (높은 산) - 고도 250m 이상
-    biome[elevation > 220] = 3
+    biome[slope > 1.2] = 2
+    
+    # 지형 유형별 처리
+    if landform_type == 'glacial':
+        # 빙하 지형: 전체적으로 빙하/눈 표시 (높은 곳 + U자곡 바닥도)
+        biome[elevation > 50] = 3  # 빙하 지형은 전체에 눈/빙하
+        biome[slope > 1.5] = 2  # 가파른 절벽만 암석
+    elif landform_type in ['river', 'coastal']:
+        # 하천/해안: 물 영역 명시적 표시 (biome=0을 물색으로)
+        if water_depth_grid is not None:
+            is_water = water_depth_grid > 0.5
+            biome[is_water] = 0  # 물 영역
+        # 음수 고도 = 바다/호수
+        biome[elevation < 0] = 0
+    elif landform_type == 'arid':
+        # 건조: 전체 모래색
+        biome[slope < 0.8] = 0  # 평탄한 곳은 모래
+    # else: 기본 (화산, 카르스트) - 만년설 없음, 풀/암석만
     
     # 조금 더 자연스럽게: 노이즈 추가 (경계면 블렌딩 효과 흉내)
     noise = np.random.normal(0, 0.2, elevation.shape)
     biome_noisy = np.clip(biome + noise, 0, 3).round(2)
     
     # 커스텀 컬러스케일 (Discrete)
-    # 0: Soil/Sand (Yellowish), 1: Grass (Green), 2: Rock (Gray), 3: Snow (White)
-    realistic_colorscale = [
-        [0.0, '#E6C288'], [0.25, '#E6C288'], # Sand/Soil
-        [0.25, '#556B2F'], [0.5, '#556B2F'], # Grass (Darker Green)
-        [0.5, '#808080'], [0.75, '#808080'], # Rock (Gray)
-        [0.75, '#FFFFFF'], [1.0, '#FFFFFF']  # Snow
-    ]
+    # 0: Soil/Sand (Yellowish), 1: Grass (Green), 2: Rock (Gray), 3: Snow/Water
+    if landform_type == 'glacial':
+        # 빙하 지형: 눈/빙하 표시
+        realistic_colorscale = [
+            [0.0, '#E6C288'], [0.25, '#E6C288'],  # Sand/Soil
+            [0.25, '#556B2F'], [0.5, '#556B2F'],  # Grass
+            [0.5, '#808080'], [0.75, '#808080'],  # Rock
+            [0.75, '#E0FFFF'], [1.0, '#FFFFFF']   # Ice/Snow (밝은 청백색)
+        ]
+        colorbar_labels = ["퇴적(土)", "식생(草)", "암석(岩)", "빙하(氷)"]
+    elif landform_type in ['river', 'coastal']:
+        # 하천/해안: 물 표시 (파란색)
+        realistic_colorscale = [
+            [0.0, '#4682B4'], [0.25, '#4682B4'],  # Water (Steel Blue)
+            [0.25, '#556B2F'], [0.5, '#556B2F'],  # Grass
+            [0.5, '#808080'], [0.75, '#808080'],  # Rock
+            [0.75, '#D2B48C'], [1.0, '#D2B48C']   # Sand (밝은 갈색)
+        ]
+        colorbar_labels = ["수역(水)", "식생(草)", "암석(岩)", "사질(砂)"]
+    elif landform_type == 'arid':
+        # 건조 지형: 사막 표시 (갈색/주황)
+        realistic_colorscale = [
+            [0.0, '#EDC9AF'], [0.25, '#EDC9AF'],  # Desert Sand
+            [0.25, '#CD853F'], [0.5, '#CD853F'],  # Brown
+            [0.5, '#808080'], [0.75, '#808080'],  # Rock
+            [0.75, '#DAA520'], [1.0, '#DAA520']   # Gold Sand
+        ]
+        colorbar_labels = ["사막(砂)", "암질(巖)", "암석(岩)", "모래(沙)"]
+    else:
+        # 기본 (화산, 카르스트 등)
+        realistic_colorscale = [
+            [0.0, '#E6C288'], [0.25, '#E6C288'],
+            [0.25, '#556B2F'], [0.5, '#556B2F'],
+            [0.5, '#808080'], [0.75, '#808080'],
+            [0.75, '#A0522D'], [1.0, '#A0522D']   # 갈색 (만년설 제거)
+        ]
+        colorbar_labels = ["퇴적(土)", "식생(草)", "암석(岩)", "표토(土)"]
     
     # 지형 노이즈 (Fractal Roughness) - 시각적 디테일 추가
-    visual_z = (elevation + np.random.normal(0, 0.2, elevation.shape)).round(2) # Reduced noise
+    visual_z = (elevation + np.random.normal(0, 0.2, elevation.shape)).round(2)
 
     # 텍스처 로직 (이미지 매핑)
     final_surface_color = biome_noisy
@@ -2611,7 +2639,7 @@ def render_terrain_plotly(elevation, title, add_water=True, water_level=0, textu
     final_colorbar = dict(
         title=dict(text="지표 상태", font=dict(color='white')), 
         tickvals=[0.37, 1.12, 1.87, 2.62], 
-        ticktext=["퇴적(土)", "식생(草)", "암석(岩)", "만년설(雪)"],
+        ticktext=colorbar_labels,
         tickfont=dict(color='white')
     )
 
@@ -3131,41 +3159,44 @@ def main():
                 elevation = np.zeros((gallery_grid_size, gallery_grid_size))
                 
         with col_view:
-            # 2D/3D 선택 (서버사이드 렌더링으로 WebGL 문제 해결)
-            view_mode = st.radio("보기 모드", ["2D 평면도", "3D 입체도 (서버 렌더링)"], horizontal=True, key="gallery_view_mode")
+            # 기본: 2D 평면도 (matplotlib) - WebGL 컨텍스트 사용 안 함
+            import matplotlib.pyplot as plt
+            import matplotlib.colors as mcolors
             
-            if view_mode == "2D 평면도":
-                # 2D matplotlib
-                import matplotlib.pyplot as plt
-                fig_2d, ax = plt.subplots(figsize=(8, 8))
-                cmap = plt.cm.terrain
-                water_mask = elevation < 0
-                im = ax.imshow(elevation, cmap=cmap, origin='upper')
-                if water_mask.any():
-                    water_overlay = np.ma.masked_where(~water_mask, np.ones_like(elevation))
-                    ax.imshow(water_overlay, cmap='Blues', alpha=0.6, origin='upper')
-                ax.set_title(f"{selected_landform}", fontsize=14)
-                ax.axis('off')
-                plt.colorbar(im, ax=ax, shrink=0.6, label='고도 (m)')
-                st.pyplot(fig_2d)
-                plt.close(fig_2d)
-            else:
-                # 3D 서버사이드 렌더링 (WebGL 사용 안 함!)
-                with st.spinner("3D 렌더링 중..."):
-                    fig_3d = render_terrain_plotly(
-                        elevation, 
-                        f"{selected_landform} - 3D",
-                        add_water=(landform_key in ["delta", "meander", "coastal_cliff", "fjord", "ria_coast", "spit_lagoon"]),
-                        water_level=0 if landform_key in ["delta", "coastal_cliff"] else -999,
-                        force_camera=True
-                    )
-                    img_bytes = render_3d_as_image(fig_3d, width=800, height=600)
-                    if img_bytes:
-                        st.image(img_bytes, caption=f"{selected_landform} - 3D (서버 렌더링)", use_column_width=True)
-                    else:
-                        st.error("3D 렌더링에 실패했습니다.")
+            fig_2d, ax = plt.subplots(figsize=(8, 8))
+            
+            # 지형 색상 맵
+            cmap = plt.cm.terrain
+            
+            # 물이 있는 지형은 파란색 오버레이
+            water_mask = elevation < 0
+            
+            im = ax.imshow(elevation, cmap=cmap, origin='upper')
+            
+            # 물 영역 표시
+            if water_mask.any():
+                water_overlay = np.ma.masked_where(~water_mask, np.ones_like(elevation))
+                ax.imshow(water_overlay, cmap='Blues', alpha=0.6, origin='upper')
             
-            st.caption("💡 3D 입체도는 서버에서 렌더링되어 WebGL 없이 표시됩니다.")
+            ax.set_title(f"{selected_landform}", fontsize=14)
+            ax.axis('off')
+            
+            # 컬러바
+            cbar = plt.colorbar(im, ax=ax, shrink=0.6, label='고도 (m)')
+            
+            st.pyplot(fig_2d)
+            plt.close(fig_2d)
+            
+            # 3D 보기 (버튼 클릭 시에만)
+            if st.button("🔲 3D 뷰 보기", key="show_3d_view"):
+                fig_3d = render_terrain_plotly(
+                    elevation, 
+                    f"{selected_landform} - 3D",
+                    add_water=(landform_key in ["delta", "meander", "coastal_cliff", "fjord", "ria_coast", "spit_lagoon"]),
+                    water_level=0 if landform_key in ["delta", "coastal_cliff"] else -999,
+                    force_camera=True
+                )
+                st.plotly_chart(fig_3d, use_container_width=True)
             
             # Educational Description
             descriptions = {
@@ -3226,42 +3257,54 @@ def main():
                 anim_func = ANIMATED_LANDFORM_GENERATORS[landform_key]
                 stage_elev = anim_func(gallery_grid_size, stage_value)
                 
-                # 2D/3D 토글 (서버사이드 렌더링)
-                anim_view_mode = st.radio("보기 모드", ["2D 평면도", "3D 입체도"], horizontal=True, key="anim_view_mode")
+                # 물 생성
+                stage_water = np.maximum(0, -stage_elev + 1.0)
+                stage_water[stage_elev > 2] = 0
                 
-                if anim_view_mode == "2D 평면도":
-                    # 2D matplotlib
-                    fig_2d, ax_2d = plt.subplots(figsize=(10, 8))
-                    im = ax_2d.imshow(stage_elev, cmap='terrain', origin='upper')
-                    water_mask = stage_elev < 0
-                    if water_mask.any():
-                        water_overlay = np.ma.masked_where(~water_mask, np.ones_like(stage_elev))
-                        ax_2d.imshow(water_overlay, cmap='Blues', alpha=0.6, origin='upper')
-                    ax_2d.set_title(f"{selected_landform} - {int(stage_value*100)}%", fontsize=14)
-                    ax_2d.axis('off')
-                    plt.colorbar(im, ax=ax_2d, shrink=0.6, label='고도 (m)')
-                    st.pyplot(fig_2d)
-                    plt.close(fig_2d)
-                else:
-                    # 3D 서버사이드 렌더링 (WebGL 사용 안 함!)
-                    with st.spinner("3D 렌더링 중..."):
-                        stage_water = np.maximum(0, -stage_elev + 1.0)
-                        stage_water[stage_elev > 2] = 0
-                        fig_3d = render_terrain_plotly(
-                            stage_elev,
-                            f"{selected_landform} - {int(stage_value*100)}%",
-                            add_water=True,
-                            water_depth_grid=stage_water,
-                            water_level=-999,
-                            force_camera=True
-                        )
-                        img_bytes = render_3d_as_image(fig_3d, width=800, height=600)
-                        if img_bytes:
-                            st.image(img_bytes, caption=f"{selected_landform} - {int(stage_value*100)}% (3D)", use_column_width=True)
-                        else:
-                            st.error("3D 렌더링에 실패했습니다.")
+                # 특정 지형 물 처리
+                if landform_key == "alluvial_fan":
+                    apex_y = int(gallery_grid_size * 0.15)
+                    center = gallery_grid_size // 2
+                    for r in range(apex_y + 5):
+                        for dc in range(-2, 3):
+                            c = center + dc
+                            if 0 <= c < gallery_grid_size:
+                                stage_water[r, c] = 3.0
                 
-                st.caption("💡 슬라이더를 조절하여 형성 단계를 확인하세요. (0% = 시작, 100% = 완성)")
+                # 단일 3D 렌더링 (WebGL 컨텍스트 절약)
+                fig_stage = render_terrain_plotly(
+                    stage_elev,
+                    f"{selected_landform} - {int(stage_value*100)}%",
+                    add_water=True,
+                    water_depth_grid=stage_water,
+                    water_level=-999,
+                    force_camera=True
+                )
+                st.plotly_chart(fig_stage, use_container_width=True, key="stage_view")
+                
+                # 자동 재생 버튼
+                if st.button("▶️ 자동 재생 (0%→100%)", key="auto_play"):
+                    stage_container = st.empty()
+                    prog = st.progress(0)
+                    
+                    for i in range(11):
+                        s = i / 10.0
+                        elev = anim_func(gallery_grid_size, s)
+                        water = np.maximum(0, -elev + 1.0)
+                        water[elev > 2] = 0
+                        
+                        fig = render_terrain_plotly(
+                            elev, f"{selected_landform} - {int(s*100)}%",
+                            add_water=True, water_depth_grid=water,
+                            water_level=-999, force_camera=False
+                        )
+                        stage_container.plotly_chart(fig, use_container_width=True)
+                        prog.progress(s)
+                        
+                        import time
+                        time.sleep(0.4)
+                    
+                    st.success("✅ 완료!")
     
     # 3. Scenarios Sub-tabs
     with t_scenarios:
@@ -3337,7 +3380,7 @@ def main():
                             fig_step = render_terrain_plotly(r_step['elevation'], 
                                                            f"V자곡 ({t:,}년)", 
                                                            add_water=True, water_level=r_step['elevation'].min() + 3,
-                                                           texture_path="https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/v_valley_texture.png", force_camera=False, water_depth_grid=r_step.get('water_depth'))
+                                                           texture_path="assets/reference/v_valley_texture.png", force_camera=False, water_depth_grid=r_step.get('water_depth'))
                             plot_container.plotly_chart(fig_step, use_container_width=True, key="v_plot_shared")
                             anim_prog.progress(min(1.0, t / v_time))
                             time.sleep(0.1)
@@ -3358,12 +3401,12 @@ def main():
                         result['elevation'], 
                         f"V자곡 | 깊이: {result['depth']:.0f}m | {v_time:,}년",
                         add_water=True, water_level=result['elevation'].min() + 3,
-                        texture_path="https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/v_valley_texture.png",
+                        texture_path="assets/reference/v_valley_texture.png",
                         water_depth_grid=result.get('water_depth')
                     )
                     plot_container.plotly_chart(plotly_fig, use_container_width=True, key="v_plot_shared")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/v_valley_satellite_1765437288622.png",
+                    st.image("assets/reference/v_valley_satellite_1765437288622.png",
                              caption="V자곡 - Google Earth 스타일 (AI 생성)",
                              use_column_width=True)
         
@@ -3425,7 +3468,7 @@ def main():
                                 r_step['elevation'], 
                                 f"자유 곡류 ({t:,}년)",
                                 water_depth_grid=r_step['water_depth'],
-                                texture_path="https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/meander_texture.png"
+                                texture_path="assets/reference/meander_texture.png"
                             )
                             anim_chart.plotly_chart(fig_step, use_container_width=True, key=f"m_anim_{t}")
                             
@@ -3440,11 +3483,11 @@ def main():
                         result['elevation'], 
                         f"자유 곡류 - {MEANDER_THEORIES[m_theory].get('description', '')[:20]}...",
                         water_depth_grid=result['water_depth'],
-                        texture_path="https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/meander_texture.png"
+                        texture_path="assets/reference/meander_texture.png"
                     )
                     st.plotly_chart(fig, use_container_width=True, key="m_plot")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/meander_satellite_1765437309640.png",
+                    st.image("assets/reference/meander_satellite_1765437309640.png",
                              caption="곡류 하천 - Google Earth 스타일 (AI 생성)",
                              use_column_width=True)
         
@@ -3515,7 +3558,7 @@ def main():
                             fig_step = render_terrain_plotly(r_step['elevation'], 
                                                            f"{r_step['delta_type']} ({t:,}년)", 
                                                            add_water=True, water_level=0, 
-                                                           texture_path="https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/delta_texture.png", force_camera=False)
+                                                           texture_path="assets/reference/delta_texture.png", force_camera=False)
                             plot_container.plotly_chart(fig_step, use_container_width=True, key="d_plot_shared")
                             anim_prog.progress(min(1.0, t / d_time))
                             # time.sleep(0.1) 
@@ -3538,12 +3581,12 @@ def main():
                         result['elevation'], 
                         f"{result['delta_type']} | 면적: {result['area']:.2f} km² | {d_time:,}년",
                         add_water=True, water_level=0,
-                        texture_path="https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/delta_texture.png",
+                        texture_path="assets/reference/delta_texture.png",
                         water_depth_grid=result.get('water_depth')
                     )
                     plot_container.plotly_chart(plotly_fig, use_container_width=True, key="d_plot_shared")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/delta_satellite_1765437326499.png",
+                    st.image("assets/reference/delta_satellite_1765437326499.png",
                              caption="조족상 삼각주 - Google Earth 스타일 (AI 생성)",
                              use_column_width=True)
         
@@ -3615,7 +3658,7 @@ def main():
                     plt.close()
                 else:
                     st.caption("🖱️ **마우스 드래그로 회전, 스크롤로 줌**")
-                    plotly_fig = render_terrain_plotly(result['elevation'], f"선상지 | 면적: {result['area']:.2f}km² | {af_time:,}년", add_water=False, texture_path="https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/alluvial_fan_texture.png", water_depth_grid=result.get('water_depth'))
+                    plotly_fig = render_terrain_plotly(result['elevation'], f"선상지 | 면적: {result['area']:.2f}km² | {af_time:,}년", add_water=False, texture_path="assets/reference/alluvial_fan_texture.png", water_depth_grid=result.get('water_depth'))
                     plot_container.plotly_chart(plotly_fig, use_container_width=True, key="af_plot_shared")
         
         # 하안단구
@@ -3769,7 +3812,7 @@ def main():
                     plotly_fig = render_terrain_plotly(result['elevation'], f"{result['type']} | 깊이: {result['depth']:.0f}m | {em_time:,}년", add_water=True, water_level=result['elevation'].min()+2, water_depth_grid=result.get('water_depth'))
                     plot_container.plotly_chart(plotly_fig, use_container_width=True, key="em_plot_shared")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/entrenched_meander_ref_1765496053723.png", caption="감입 곡류 (Entrenched Meander) - AI 생성", use_column_width=True)
+                    st.image("assets/reference/entrenched_meander_ref_1765496053723.png", caption="감입 곡류 (Entrenched Meander) - AI 생성", use_column_width=True)
         
         # 망상하천
         with river_sub[7]:
@@ -3801,10 +3844,10 @@ def main():
                 
                 v_mode = st.radio("보기 모드", ["🎮 인터랙티브 3D", "🛰️ 참고 사진"], horizontal=True, key="bs_v")
                 if "3D" in v_mode:
-                    fig = render_terrain_plotly(result['elevation'], f"망상하천 ({bs_time}년)", add_water=True, water_level=result['elevation'].min()+0.5, texture_path="https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/braided_river_texture.png", water_depth_grid=result.get('water_depth'))
+                    fig = render_terrain_plotly(result['elevation'], f"망상하천 ({bs_time}년)", add_water=True, water_level=result['elevation'].min()+0.5, texture_path="assets/reference/braided_river_texture.png", water_depth_grid=result.get('water_depth'))
                     plot_container.plotly_chart(fig, use_container_width=True, key="bs_plot_shared")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/braided_river_1765410638302.png", caption="망상 하천 (AI 생성)", use_column_width=True)
+                    st.image("assets/reference/braided_river_1765410638302.png", caption="망상 하천 (AI 생성)", use_column_width=True)
 
         # 폭포
         with river_sub[8]:
@@ -3837,7 +3880,7 @@ def main():
                     fig = render_terrain_plotly(result['elevation'], f"폭포 ({wf_time}년)", add_water=True, water_level=90, water_depth_grid=result.get('water_depth'))
                     plot_container.plotly_chart(fig, use_container_width=True, key="wf_plot_shared")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/waterfall_gorge_formation_1765410495876.png", caption="폭포 및 협곡 (AI 생성)", use_column_width=True)
+                    st.image("assets/reference/waterfall_gorge_formation_1765410495876.png", caption="폭포 및 협곡 (AI 생성)", use_column_width=True)
 
         # 범람원 상세
         with river_sub[9]:
@@ -3870,7 +3913,7 @@ def main():
                     fig = render_terrain_plotly(result['elevation'], f"범람원 상세 ({lv_time}년)", add_water=True, water_level=42, water_depth_grid=result.get('water_depth'))
                     plot_container.plotly_chart(fig, use_container_width=True, key="lv_plot_shared")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/floodplain_landforms_1765436731483.png", caption="범람원 - 자연제방과 배후습지 (AI 생성)", use_column_width=True)
+                    st.image("assets/reference/floodplain_landforms_1765436731483.png", caption="범람원 - 자연제방과 배후습지 (AI 생성)", use_column_width=True)
     
     # ===== 해안 지형 =====
     with tab_coast:
@@ -4009,9 +4052,9 @@ def main():
                 plot_container.plotly_chart(plotly_fig, use_container_width=True, key="co_plot_shared")
             else:
                 if theory_key == "cliff_retreat":
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/sea_stack_arch_ref_1765495979396.png", caption="시스택 & 해식아치 - AI 생성", use_column_width=True)
+                    st.image("assets/reference/sea_stack_arch_ref_1765495979396.png", caption="시스택 & 해식아치 - AI 생성", use_column_width=True)
                 elif theory_key in ["tombolo", "spit"]:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/tombolo_sandbar_ref_1765495999194.png", caption="육계도 & 사취 - AI 생성", use_column_width=True)
+                    st.image("assets/reference/tombolo_sandbar_ref_1765495999194.png", caption="육계도 & 사취 - AI 생성", use_column_width=True)
                 else:
                     st.info("이 지형에 대한 참고 사진이 아직 없습니다.")
     
@@ -4057,7 +4100,7 @@ def main():
                     f = render_terrain_plotly(result['elevation'], f"돌리네 | {ka_time:,}년", add_water=False)
                     plot_container.plotly_chart(f, use_container_width=True, key="ka_plot_shared")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/doline_sinkhole_1765436375545.png", caption="돌리네 (AI 생성)", use_column_width=True)
+                    st.image("assets/reference/doline_sinkhole_1765436375545.png", caption="돌리네 (AI 생성)", use_column_width=True)
 
         # 탑 카르스트
         with ka_subs[1]:
@@ -4090,10 +4133,10 @@ def main():
                      plot_container.plotly_chart(f, use_container_width=True, key="tk_plot_shared")
                 elif "3D" in v_mode:
                      st.caption("🖱️ **마우스 드래그로 회전/줌**")
-                     f = render_terrain_plotly(result['elevation'], f"탑 카르스트 | {tk_time:,}년", add_water=False, texture_path="https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/tower_karst_texture.png")
+                     f = render_terrain_plotly(result['elevation'], f"탑 카르스트 | {tk_time:,}년", add_water=False, texture_path="assets/reference/tower_karst_texture.png")
                      plot_container.plotly_chart(f, use_container_width=True, key="tk_plot_shared")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/tower_karst_ref.png", caption="탑 카르스트 (Guilin) - AI 생성", use_column_width=True)
+                    st.image("assets/reference/tower_karst_ref.png", caption="탑 카르스트 (Guilin) - AI 생성", use_column_width=True)
 
         # 석회동굴
         with ka_subs[2]:
@@ -4129,7 +4172,7 @@ def main():
                      f = render_terrain_plotly(result['elevation'], f"석회동굴 | {cv_time:,}년", add_water=False)
                      plot_container.plotly_chart(f, use_container_width=True, key="cv_plot_shared")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/cave_ref.png", caption="석회동굴 내부 - AI 생성", use_column_width=True)
+                    st.image("assets/reference/cave_ref.png", caption="석회동굴 내부 - AI 생성", use_column_width=True)
     
     # ===== 화산 =====
     with tab_volcano:
@@ -4161,19 +4204,19 @@ def main():
                     for _ in range(n_reps):
                         for t in range(0, vo_time+1, max(1, vo_time//20)):
                             r = simulate_volcanic(VOLCANIC_THEORIES[vo_theory]['key'], t, params, grid_size=grid_size)
-                            f = render_terrain_plotly(r['elevation'], f"{r['type']} ({t:,}년)", add_water=False, texture_path="https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/volcano_texture.png", force_camera=False)
+                            f = render_terrain_plotly(r['elevation'], f"{r['type']} ({t:,}년)", add_water=False, texture_path="assets/reference/volcano_texture.png", force_camera=False)
                             plot_container.plotly_chart(f, use_container_width=True, key="vo_plot_shared")
                             time.sleep(0.1)
                 v_mode = st.radio("보기 모드", ["🎮 인터랙티브 3D", "🛰️ 참고 사진"], horizontal=True, key="vo_v")
                 if "3D" in v_mode:
-                    f = render_terrain_plotly(result['elevation'], f"{result['type']} ({vo_time:,}년)", add_water=False, texture_path="https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/volcano_texture.png")
+                    f = render_terrain_plotly(result['elevation'], f"{result['type']} ({vo_time:,}년)", add_water=False, texture_path="assets/reference/volcano_texture.png")
                     plot_container.plotly_chart(f, use_container_width=True, key="vo_plot_shared")
                 else:
                     # 화산 유형에 따라 다른 이미지
                     if "shield" in VOLCANIC_THEORIES[vo_theory]['key']:
-                        safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/shield_vs_stratovolcano_1765436448576.png", caption="순상 화산 (AI 생성)", use_column_width=True)
+                        st.image("assets/reference/shield_vs_stratovolcano_1765436448576.png", caption="순상 화산 (AI 생성)", use_column_width=True)
                     else:
-                        safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/caldera_formation_1765436466778.png", caption="칼데라 (AI 생성)", use_column_width=True)
+                        st.image("assets/reference/caldera_formation_1765436466778.png", caption="칼데라 (AI 생성)", use_column_width=True)
 
         # 용암 대지
         with vo_subs[1]:
@@ -4209,7 +4252,7 @@ def main():
                      f = render_terrain_plotly(result['elevation'], f"용암대지 | {lp_time:,}년", add_water=False)
                      plot_container.plotly_chart(f, use_container_width=True, key="lp_plot_shared")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/lava_plateau_ref.png", caption="용암대지 (Iceland) - AI 생성", use_column_width=True)
+                    st.image("assets/reference/lava_plateau_ref.png", caption="용암대지 (Iceland) - AI 생성", use_column_width=True)
 
         # 주상절리
         with vo_subs[2]:
@@ -4245,7 +4288,7 @@ def main():
                      f = render_terrain_plotly(result['elevation'], f"주상절리 | {cj_time:,}년", add_water=True, water_level=80)
                      plot_container.plotly_chart(f, use_container_width=True, key="cj_plot_shared")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/columnar_ref.png", caption="주상절리 (Basalt Columns) - AI 생성", use_column_width=True)
+                    st.image("assets/reference/columnar_ref.png", caption="주상절리 (Basalt Columns) - AI 생성", use_column_width=True)
     
     # ===== 빙하 =====
     with tab_glacial:
@@ -4275,18 +4318,18 @@ def main():
                     for _ in range(n_reps):
                         for t in range(0, gl_time+1, max(1, gl_time//20)):
                             r = simulate_glacial(key, t, {'ice_thickness': gl_ice}, grid_size=grid_size)
-                            tex_path = "https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/fjord_texture.png" if key == "fjord" else None
+                            tex_path = "assets/reference/fjord_texture.png" if key == "fjord" else None
                             f = render_terrain_plotly(r['elevation'], f"{gl_type} ({t:,}년)", add_water=(key=="fjord"), water_level=100 if key=="fjord" else 0, texture_path=tex_path, force_camera=False)
                             plot_container.plotly_chart(f, use_container_width=True, key="gl_plot_shared")
                             time.sleep(0.1)
                 
-                tex_path = "https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/fjord_texture.png" if key == "fjord" else None
+                tex_path = "assets/reference/fjord_texture.png" if key == "fjord" else None
                 f = render_terrain_plotly(result['elevation'], f"{gl_type} ({gl_time:,}년)", add_water=(key=="fjord"), water_level=100 if key=="fjord" else 0, texture_path=tex_path)
                 v_mode = st.radio("보기 모드", ["🎮 인터랙티브 3D", "🛰️ 참고 사진"], horizontal=True, key="gl_v")
                 if "3D" in v_mode:
                     plot_container.plotly_chart(f, use_container_width=True, key="gl_plot_shared")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/fjord_valley_ref_1765495963491.png", caption="피오르 (Fjord) - AI 생성", use_column_width=True)
+                    st.image("assets/reference/fjord_valley_ref_1765495963491.png", caption="피오르 (Fjord) - AI 생성", use_column_width=True)
 
         # 권곡
         with gl_subs[1]:
@@ -4319,10 +4362,10 @@ def main():
                      plot_container.plotly_chart(f, use_container_width=True, key="cq_plot_shared")
                 elif "3D" in v_mode:
                      st.caption("🖱️ **마우스 드래그로 회전/줌**")
-                     f = render_terrain_plotly(result['elevation'], f"권곡 | {cq_time:,}년", add_water=False, texture_path="https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/cirque_texture.png")
+                     f = render_terrain_plotly(result['elevation'], f"권곡 | {cq_time:,}년", add_water=False, texture_path="assets/reference/cirque_texture.png")
                      plot_container.plotly_chart(f, use_container_width=True, key="cq_plot_shared")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/cirque_ref.png", caption="권곡 (Glacial Cirque) - AI 생성", use_column_width=True)
+                    st.image("assets/reference/cirque_ref.png", caption="권곡 (Glacial Cirque) - AI 생성", use_column_width=True)
 
         # 모레인
         with gl_subs[2]:
@@ -4358,7 +4401,7 @@ def main():
                      f = render_terrain_plotly(result['elevation'], f"모레인 | {mo_time:,}년", add_water=False)
                      plot_container.plotly_chart(f, use_container_width=True, key="mo_plot_shared")
                 else:
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/moraine_ref.png", caption="모레인 (Moraine) - AI 생성", use_column_width=True)
+                    st.image("assets/reference/moraine_ref.png", caption="모레인 (Moraine) - AI 생성", use_column_width=True)
     
     # ===== 건조 =====
     with tab_arid:
@@ -4419,7 +4462,7 @@ def main():
                 # 바르한 사구인 경우 텍스처 적용
                 tex_path = None
                 if ARID_THEORIES[ar_theory]['key'] == "barchan":
-                    tex_path = "https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/barchan_dune_texture_topdown_1765496401371.png"
+                    tex_path = "assets/reference/barchan_dune_texture_topdown_1765496401371.png"
                 
                 plotly_fig = render_terrain_plotly(result['elevation'], 
                                                  f"{result['type']} | {ar_time:,}년", 
@@ -4430,9 +4473,9 @@ def main():
                 # 이론 키에 따라 이미지 분기
                 tk = ARID_THEORIES[ar_theory]['key']
                 if tk == "barchan":
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/barchan_dune_ref_1765496023768.png", caption="바르한 사구 - AI 생성", use_column_width=True)
+                    st.image("assets/reference/barchan_dune_ref_1765496023768.png", caption="바르한 사구 - AI 생성", use_column_width=True)
                 elif tk == "mesa":
-                    safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/mesa_butte_ref_1765496038880.png", caption="메사 & 뷰트 - AI 생성", use_column_width=True)
+                    st.image("assets/reference/mesa_butte_ref_1765496038880.png", caption="메사 & 뷰트 - AI 생성", use_column_width=True)
                 else:
                     st.info("준비 중입니다.")
     
@@ -4584,7 +4627,7 @@ for i in range(steps):
                 st.session_state['script_grid'] = WorldGrid(100, 100, 10.0)
                 st.experimental_rerun()
             else:
-                 safe_image("https://raw.githubusercontent.com/skyblue3925-svg/geo-lab-images/main/peneplain_erosion_cycle_1765436750353.png", caption="평야 - 준평원화 과정 (AI 생성)", use_column_width=True)
+                 st.image("assets/reference/peneplain_erosion_cycle_1765436750353.png", caption="평야 - 준평원화 과정 (AI 생성)", use_column_width=True)
     
     # ===== Project Genesis (Unified Engine) =====
     with tab_genesis:

app/pages/1_📖_Gallery.py

@@ -0,0 +1,272 @@
+"""
+📖 이상적 지형 갤러리
+31종의 교과서적 지형을 시각화합니다.
+"""
+import streamlit as st
+import numpy as np
+import matplotlib.pyplot as plt
+import sys
+import os
+
+# 상위 디렉토리를 경로에 추가
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from engine.ideal_landforms import IDEAL_LANDFORM_GENERATORS, ANIMATED_LANDFORM_GENERATORS
+from app.main import render_terrain_plotly
+
+st.header("📖 이상적 지형 갤러리")
+st.markdown("_교과서적인 지형 형태를 기하학적 모델로 시각화합니다._")
+
+# 강조 메시지
+st.info("💡 **Tip:** 지형 선택 후 **아래로 스크롤**하면 **🎬 형성 과정 애니메이션**을 확인할 수 있습니다!")
+
+# 카테고리별 지형
+st.sidebar.subheader("🗂️ 지형 카테고리")
+category = st.sidebar.radio("카테고리 선택", [
+    "🌊 하천 지형",
+    "🔺 삼각주 유형", 
+    "❄️ 빙하 지형",
+    "🌋 화산 지형",
+    "🦇 카르스트 지형",
+    "🏜️ 건조 지형",
+    "🏖️ 해안 지형"
+], key="gallery_cat")
+
+# 카테고리 → landform_type 매핑
+CATEGORY_TO_TYPE = {
+    "🌊 하천 지형": "river",
+    "🔺 삼각주 유형": "river", 
+    "❄️ 빙하 지형": "glacial",
+    "🌋 화산 지형": "volcanic",
+    "🦇 카르스트 지형": "karst",
+    "🏜️ 건조 지형": "arid",
+    "🏖️ 해안 지형": "coastal"
+}
+landform_type = CATEGORY_TO_TYPE.get(category, None)
+
+# 카테고리별 옵션
+if category == "🌊 하천 지형":
+    landform_options = {
+        "📐 선상지 (Alluvial Fan)": "alluvial_fan",
+        "🐍 자유곡류 (Free Meander)": "free_meander",
+        "⛰️ 감입곡류+하안단구 (Incised Meander)": "incised_meander",
+        "🏔️ V자곡 (V-Valley)": "v_valley",
+        "🌊 망상하천 (Braided River)": "braided_river",
+        "💧 폭포 (Waterfall)": "waterfall",
+    }
+elif category == "🔺 삼각주 유형":
+    landform_options = {
+        "🔺 일반 삼각주 (Delta)": "delta",
+        "🦶 조족상 삼각주 (Bird-foot)": "bird_foot_delta",
+        "🌙 호상 삼각주 (Arcuate)": "arcuate_delta",
+        "📍 첨두상 삼각주 (Cuspate)": "cuspate_delta",
+    }
+elif category == "❄️ 빙하 지형":
+    landform_options = {
+        "❄️ U자곡 (U-Valley)": "u_valley",
+        "🥣 권곡 (Cirque)": "cirque",
+        "🏔️ 호른 (Horn)": "horn",
+        "🌊 피오르드 (Fjord)": "fjord",
+        "🥚 드럼린 (Drumlin)": "drumlin",
+        "🪨 빙퇴석 (Moraine)": "moraine",
+    }
+elif category == "🌋 화산 지형":
+    landform_options = {
+        "🛡️ 순상화산 (Shield)": "shield_volcano",
+        "🗻 성층화산 (Stratovolcano)": "stratovolcano",
+        "🕳️ 칼데라 (Caldera)": "caldera",
+        "💧 화구호 (Crater Lake)": "crater_lake",
+        "🟫 용암대지 (Lava Plateau)": "lava_plateau",
+    }
+elif category == "🦇 카르스트 지형":
+    landform_options = {
+        "🕳️ 돌리네 (Doline)": "karst_doline",
+        "🥋 우발라 (Uvala)": "uvala",
+        "🗼 탑카르스트 (Tower Karst)": "tower_karst",
+        "🪨 카렌 (Karren)": "karren",
+    }
+elif category == "🏜️ 건조 지형":
+    landform_options = {
+        "🌙 바르한 사구 (Barchan)": "barchan",
+        "🟰 횡사구 (Transverse Dune)": "transverse_dune",
+        "⭐ 성사구 (Star Dune)": "star_dune",
+        "🗿 메사/뷰트 (Mesa/Butte)": "mesa_butte",
+    }
+else:  # 해안 지형
+    landform_options = {
+        "🏖️ 해안 절벽 (Coastal Cliff)": "coastal_cliff",
+        "🌊 사취+석호 (Spit+Lagoon)": "spit_lagoon",
+        "🏝️ 육계사주 (Tombolo)": "tombolo",
+        "🌀 리아스 해안 (Ria Coast)": "ria_coast",
+        "🌉 해식아치 (Sea Arch)": "sea_arch",
+        "🏖️ 해안사구 (Coastal Dune)": "coastal_dune",
+    }
+
+col_sel, col_view = st.columns([1, 3])
+
+with col_sel:
+    selected_landform = st.selectbox("지형 선택", list(landform_options.keys()))
+    landform_key = landform_options[selected_landform]
+    
+    st.markdown("---")
+    st.subheader("⚙️ 파라미터")
+    
+    gallery_grid_size = st.slider("해상도", 50, 150, 80, 10, key="gallery_res")
+    
+    # 동적 지형 생성
+    if landform_key in IDEAL_LANDFORM_GENERATORS:
+        generator = IDEAL_LANDFORM_GENERATORS[landform_key]
+        try:
+            elevation = generator(gallery_grid_size)
+        except TypeError:
+            elevation = generator(gallery_grid_size, 1.0)
+    else:
+        st.error(f"지형 '{landform_key}' 생성기를 찾을 수 없습니다.")
+        elevation = np.zeros((gallery_grid_size, gallery_grid_size))
+
+with col_view:
+    # 2D 평면도
+    fig_2d, ax = plt.subplots(figsize=(8, 8))
+    cmap = plt.cm.terrain
+    water_mask = elevation < 0
+    
+    im = ax.imshow(elevation, cmap=cmap, origin='upper')
+    
+    if water_mask.any():
+        water_overlay = np.ma.masked_where(~water_mask, np.ones_like(elevation))
+        ax.imshow(water_overlay, cmap='Blues', alpha=0.6, origin='upper')
+    
+    ax.set_title(f"{selected_landform}", fontsize=14)
+    ax.axis('off')
+    plt.colorbar(im, ax=ax, shrink=0.6, label='고도 (m)')
+    
+    st.pyplot(fig_2d)
+    plt.close(fig_2d)
+    
+    # 3D 보기 버튼
+    if st.button("🔲 3D 뷰 보기", key="show_3d_view"):
+        fig_3d = render_terrain_plotly(
+            elevation, 
+            f"{selected_landform} - 3D",
+            add_water=(landform_key in ["delta", "meander", "coastal_cliff", "fjord", "ria_coast", "spit_lagoon"]),
+            water_level=0 if landform_key in ["delta", "coastal_cliff"] else -999,
+            force_camera=True,
+            landform_type=landform_type  # 카테고리에 맞는 색상 적용
+        )
+        st.plotly_chart(fig_3d, use_container_width=True, key="gallery_3d")
+    
+    # 설명
+    descriptions = {
+        "delta": "**삼각주**: 하천이 바다나 호수에 유입될 때 유속이 감소하여 운반 중이던 퇴적물이 쌓여 형성됩니다.",
+        "alluvial_fan": "**선상지**: 산지에서 평지로 나오는 곳에서 경사가 급감하여 운반력이 줄어들면서 퇴적물이 부채꼴로 쌓입니다.",
+        "free_meander": "**자유곡류**: 범람원 위를 자유롭게 사행하는 곡류. 자연제방(Levee)과 배후습지가 특징입니다.",
+        "incised_meander": "**감입곡류**: 융기로 인해 곡류가 기반암을 파고들면서 형성. 하안단구(River Terrace)가 함께 나타납니다.",
+        "v_valley": "**V자곡**: 하천의 하방 침식이 우세하게 작용하여 형성된 V자 단면의 골짜기.",
+        "braided_river": "**망상하천**: 퇴적물이 많고 경사가 급할 때 여러 수로가 갈라졌다 합쳐지는 하천.",
+        "waterfall": "**폭포**: 경암과 연암의 차별침식으로 형성된 급경사 낙차. 후퇴하며 협곡 형성.",
+        "bird_foot_delta": "**조족상 삼각주**: 미시시피강형. 파랑 약하고 퇴적물 공급 많을 때 새발 모양으로 길게 뻗습니다.",
+        "arcuate_delta": "**호상 삼각주**: 나일강형. 파랑과 퇴적물 공급이 균형을 이루어 부드러운 호(Arc) 형태.",
+        "cuspate_delta": "**첨두상 삼각주**: 티베르강형. 파랑이 강해 삼각주가 뾰족한 화살촉 모양으로 형성.",
+        "u_valley": "**U자곡**: 빙하의 침식으로 형성된 U자 단면의 골짜기. 측벽이 급하고 바닥이 평탄합니다.",
+        "cirque": "**권곡**: 빙하의 시작점. 반원형 움푹 파인 지형으로, 빙하 융해 후 호수(Tarn)가 형성됩니다.",
+        "horn": "**호른**: 여러 권곡이 만나는 곳에서 침식되지 않고 남은 뾰족한 피라미드형 봉우리.",
+        "fjord": "**피오르드**: 빙하가 파낸 U자곡에 바다가 유입된 좁고 깊은 만.",
+        "drumlin": "**드럼린**: 빙하 퇴적물이 빙하 흐름 방향으로 길쭉하게 쌓인 타원형 언덕.",
+        "moraine": "**빙퇴석**: 빙하가 운반한 암설이 퇴적된 지형. 측퇴석, 종퇴석 등이 있습니다.",
+        "shield_volcano": "**순상화산**: 유동성 높은 현무암질 용암이 완만하게 쌓여 방패 형태.",
+        "stratovolcano": "**성층화산**: 용암과 화산쇄설물이 교대로 쌓여 급한 원뿔형.",
+        "caldera": "**칼데라**: 대규모 분화 후 마그마방 함몰로 형성된 거대한 분지.",
+        "crater_lake": "**화구호**: 화구나 칼데라에 물이 고여 형성된 호수.",
+        "lava_plateau": "**용암대지**: 열극 분출로 현무암질 용암이 넓게 펼쳐져 평탄한 대지 형성.",
+        "barchan": "**바르한 사구**: 바람이 한 방향에서 불 때 형성되는 초승달 모양의 사구.",
+        "mesa_butte": "**메사/뷰트**: 차별침식으로 남은 탁상지. 메사는 크고 평탄, 뷰트는 작고 높습니다.",
+        "karst_doline": "**돌리네**: 석회암 용식으로 형성된 움푹 파인 와지.",
+        "coastal_cliff": "**해안 절벽**: 파랑의 침식으로 형성된 절벽.",
+        "spit_lagoon": "**사취+석호**: 연안류에 의해 퇴적물이 길게 쌓인 사취가 만을 막아 석호를 형성합니다.",
+        "tombolo": "**육계사주**: 연안류에 의한 퇴적으로 육지와 섬이 모래톱으로 연결된 지형.",
+        "ria_coast": "**리아스식 해안**: 과거 하곡이 해수면 상승으로 침수되어 형성된 톱니 모양 해안선.",
+        "sea_arch": "**해식아치**: 곶에서 파랑 침식으로 형성된 아치형 지형.",
+        "coastal_dune": "**해안사구**: 해빈의 모래가 바람에 의해 육지 쪽으로 운반되어 형성된 모래 언덕.",
+        # 새로 추가된 지형
+        "uvala": "**우발라**: 여러 돌리네가 합��져 형성된 복합 와지. 돌리네보다 크고 불규칙한 형태.",
+        "tower_karst": "**탑카르스트**: 수직 절벽을 가진 탑 모양 석회암 봉우리. 중국 구이린이 대표적.",
+        "karren": "**카렌**: 빗물에 의한 용식으로 석회암 표면에 형성된 홈과 릿지. 클린트/그라이크 포함.",
+        "transverse_dune": "**횡사구**: 바람 방향에 수직으로 길게 형성된 사구열. 모래 공급이 풍부할 때 발달.",
+        "star_dune": "**성사구**: 다방향 바람에 의해 별 모양으로 형성된 사구. 높이가 높고 이동이 적음.",
+    }
+    st.info(descriptions.get(landform_key, "설명 준비 중입니다."))
+
+# ========== 형성 과정 애니메이션 ==========
+if landform_key in ANIMATED_LANDFORM_GENERATORS:
+    st.markdown("---")
+    st.subheader("🎬 형성 과정")
+    
+    # 자동 재생 중이면 session_state의 stage 사용
+    if st.session_state.get('auto_playing', False):
+        stage_value = st.session_state.get('auto_stage', 0.0)
+        st.slider(
+            "형성 단계 (자동 재생 중...)", 
+            0.0, 1.0, stage_value, 0.05, 
+            key="gallery_stage_slider",
+            disabled=True
+        )
+    else:
+        stage_value = st.slider(
+            "형성 단계 (0% = 시작, 100% = 완성)", 
+            0.0, 1.0, 1.0, 0.05, 
+            key="gallery_stage_slider"
+        )
+    
+    anim_func = ANIMATED_LANDFORM_GENERATORS[landform_key]
+    stage_elev = anim_func(gallery_grid_size, stage_value)
+    
+    # 물 생성
+    stage_water = np.maximum(0, -stage_elev + 1.0)
+    stage_water[stage_elev > 2] = 0
+    
+    # 선상지 물 처리
+    if landform_key == "alluvial_fan":
+        apex_y = int(gallery_grid_size * 0.15)
+        center = gallery_grid_size // 2
+        for r in range(apex_y + 5):
+            for dc in range(-2, 3):
+                c = center + dc
+                if 0 <= c < gallery_grid_size:
+                    stage_water[r, c] = 3.0
+    
+    # 3D 렌더링
+    fig_stage = render_terrain_plotly(
+        stage_elev,
+        f"{selected_landform} - {int(stage_value*100)}%",
+        add_water=True,
+        water_depth_grid=stage_water,
+        water_level=-999,
+        force_camera=False,  # 카메라 이동 허용
+        landform_type=landform_type
+    )
+    st.plotly_chart(fig_stage, use_container_width=True, key="stage_view")
+    
+    # 자동 재생 (세션 상태 활용)
+    col_play, col_step = st.columns(2)
+    with col_play:
+        if st.button("▶️ 자동 재생 시작", key="auto_play"):
+            st.session_state['auto_playing'] = True
+            st.session_state['auto_stage'] = 0.0
+    with col_step:
+        if st.button("⏹️ 정지", key="stop_play"):
+            st.session_state['auto_playing'] = False
+    
+    # 자동 재생 중이면 stage 자동 증가
+    if st.session_state.get('auto_playing', False):
+        current_stage = st.session_state.get('auto_stage', 0.0)
+        if current_stage < 1.0:
+            st.session_state['auto_stage'] = current_stage + 0.1
+            import time
+            time.sleep(0.5)
+            st.rerun()
+        else:
+            st.session_state['auto_playing'] = False
+            st.success("✅ 완료!")
+    
+    st.caption("💡 **Tip:** 카메라 각도를 먼저 조정한 후 자동 재생하면 유지됩니다.")

engine/ideal_landforms.py

@@ -484,58 +484,131 @@ def create_alluvial_fan_animated(grid_size: int, stage: float,
 
 def create_meander_animated(grid_size: int, stage: float,
                             amplitude: float = 0.3, num_bends: int = 3) -> np.ndarray:
-    """곡류 형성과정 애니메이션 (직선 -> 사행 -> 우각호)"""
+    """곡류 형성과정 애니메이션 (직선 → 사행 → 우각호 → 하중도)
+    
+    Stage 0.0~0.3: 직선 하천 → 약한 사행 시작
+    Stage 0.3~0.6: 사행 발달 + 공격사면 침식 + 활주사면 퇴적
+    Stage 0.6~0.8: 곡류 목 절단 → 우각호 형성
+    Stage 0.8~1.0: 하중도(river island) 형성 + 구하도 안정화
+    """
     h, w = grid_size, grid_size
     elevation = np.zeros((h, w))
-    elevation[:, :] = 10.0  # 범람원
+    elevation[:, :] = 10.0  # 범람원 기준면
     
     center_x = w // 2
     channel_width = max(3, w // 20)
     
-    # Stage에 따른 사행 진폭 변화 (직선 -> 굽음)
-    current_amp = w * amplitude * stage
-    wl = h / num_bends
+    # Stage에 따른 사행 진폭 변화
+    if stage < 0.6:
+        current_amp = w * amplitude * (stage / 0.6)
+    else:
+        current_amp = w * amplitude  # 최대 진폭 유지
+    
+    wl = h / num_bends  # 파장
     
+    # 메인 하천 그리기
     for r in range(h):
         theta = 2 * np.pi * r / wl
         meander_x = center_x + current_amp * np.sin(theta)
         
+        # 공격사면 (attack slope) - 바깥쪽, 침식
+        # 활주사면 (slip-off slope) - 안쪽, 퇴적
+        dtheta = np.cos(theta)  # 곡률 방향
+        
         for c in range(w):
-            dist = abs(c - meander_x)
-            if dist < channel_width:
-                elevation[r, c] = 5.0 - (channel_width - dist) * 0.3
-            elif dist < channel_width * 3:
-                elevation[r, c] = 10.5
+            dist = c - meander_x
+            
+            # 하천 채널
+            if abs(dist) < channel_width:
+                # 수심 (중앙이 깊음)
+                depth_factor = 1 - (abs(dist) / channel_width)
+                elevation[r, c] = 5.0 - depth_factor * 3.0  # 2~5m
                 
-    # 우각호 (stage > 0.8)
-    if stage > 0.8:
-        oxbow_intensity = (stage - 0.8) / 0.2
-        oxbow_y = h // 2
-        oxbow_amp = current_amp * 1.5
+            # 공격사면 (외측) - 절벽
+            elif dist * dtheta > 0 and abs(dist) < channel_width * 2:
+                # 외측은 침식으로 가파름
+                erosion_factor = (abs(dist) - channel_width) / channel_width
+                elevation[r, c] = 8.0 + erosion_factor * 3.0
+                
+            # 활주사면 (내측) - 포인트바
+            elif dist * dtheta < 0 and abs(dist) < channel_width * 3:
+                # 내측은 퇴적으로 완만
+                deposit_factor = (abs(dist) - channel_width) / (channel_width * 2)
+                elevation[r, c] = 6.0 + deposit_factor * 4.0
+                
+            # 자연제방 (levee)
+            elif abs(dist) < channel_width * 4:
+                levee_height = 11.0 - (abs(dist) - channel_width * 2) * 0.5
+                elevation[r, c] = max(levee_height, 10.0)
+    
+    # 우각호 형성 (stage > 0.6)
+    if stage > 0.6:
+        oxbow_intensity = min((stage - 0.6) / 0.2, 1.0)
         
-        for dy in range(-int(wl/4), int(wl/4)):
-            r = oxbow_y + dy
+        # 곡류 목 직선화 (cutoff)
+        cutoff_y = int(h * 0.5)
+        cutoff_width = int(wl * 0.3)
+        
+        for r in range(cutoff_y - cutoff_width // 2, cutoff_y + cutoff_width // 2):
             if 0 <= r < h:
-                theta = 2 * np.pi * dy / (wl/2)
-                ox_x = center_x + oxbow_amp * np.sin(theta)
+                # 직선 채널
                 for dc in range(-channel_width, channel_width + 1):
-                    c = int(ox_x + dc)
+                    c = center_x + dc
                     if 0 <= c < w:
-                        elevation[r, c] = 4.0 * oxbow_intensity + elevation[r, c] * (1 - oxbow_intensity)
+                        new_elev = 4.0 * oxbow_intensity + elevation[r, c] * (1 - oxbow_intensity)
+                        elevation[r, c] = new_elev
+        
+        # 구하도 (우각호) - 물이 고인 곳
+        for r in range(cutoff_y - int(wl * 0.4), cutoff_y + int(wl * 0.4)):
+            if 0 <= r < h:
+                theta = 2 * np.pi * r / wl
+                old_channel_x = center_x + current_amp * np.sin(theta)
+                
+                # 구하도가 메인 채널과 겹치지 않는 곳만
+                if abs(old_channel_x - center_x) > channel_width * 2:
+                    for dc in range(-channel_width, channel_width + 1):
+                        c = int(old_channel_x + dc)
+                        if 0 <= c < w:
+                            # 구하도는 물이 고여 낮음
+                            elevation[r, c] = 3.0 * oxbow_intensity + elevation[r, c] * (1 - oxbow_intensity)
+    
+    # 하중도 형성 (stage > 0.8)
+    if stage > 0.8:
+        island_intensity = (stage - 0.8) / 0.2
+        
+        # 하류에 하중도 생성
+        island_y = int(h * 0.75)
+        island_size = max(3, channel_width // 2)
+        
+        for dy in range(-island_size, island_size + 1):
+            for dx in range(-island_size, island_size + 1):
+                if dy**2 + dx**2 < island_size**2:
+                    r, c = island_y + dy, center_x + dx
+                    if 0 <= r < h and 0 <= c < w:
+                        elevation[r, c] = 7.0 * island_intensity + elevation[r, c] * (1 - island_intensity)
                         
     return elevation
 
 
 def create_u_valley_animated(grid_size: int, stage: float,
                               valley_depth: float = 100.0, valley_width: float = 0.4) -> np.ndarray:
-    """U자곡 형성과정 (V자 -> U자 변환)"""
+    """U자곡 형성과정 (빙하 성장 → 침식 → 빙하 후퇴 → U자곡)
+    
+    Stage 0.0~0.3: 빙하 성장 (V자곡에 빙하 채워짐)
+    Stage 0.3~0.6: 빙하 침식 (U자 형태로 변형)
+    Stage 0.6~1.0: 빙하 후퇴 (빙하 녹으면서 U자곡 드러남)
+    """
     h, w = grid_size, grid_size
     elevation = np.zeros((h, w))
     center = w // 2
     
-    # V자에서 U자로 변환
-    # stage 0: 완전 V, stage 1: 완전 U
-    half_width = int(w * valley_width / 2) * stage  # U 바닥 너비
+    # 1단계: V자곡 → U자곡 변형 (침식)
+    if stage < 0.6:
+        u_factor = min(stage / 0.6, 1.0)  # 0~1로 정규화
+    else:
+        u_factor = 1.0  # 완전 U자
+    
+    half_width = int(w * valley_width / 2) * u_factor  # U 바닥 너비
     
     for r in range(h):
         for c in range(w):
@@ -546,14 +619,49 @@ def create_u_valley_animated(grid_size: int, stage: float,
                 elevation[r, c] = 0
             else:
                 # V에서 U로 전환
-                # V: linear, U: parabolic
                 normalized_x = (dx - half_width) / max(1, w // 2 - half_width)
                 v_height = valley_depth * normalized_x  # V shape
                 u_height = valley_depth * (normalized_x ** 2)  # U shape
-                elevation[r, c] = v_height * (1 - stage) + u_height * stage
+                elevation[r, c] = v_height * (1 - u_factor) + u_height * u_factor
                 
+        # 상류로 갈수록 높아짐
         elevation[r, :] += (h - r) / h * 30.0
-        
+    
+    # 2단계: 빙하 추가 (stage에 따라 성장/후퇴)
+    # stage 0~0.3: 빙하 성장 (하류로 전진)
+    # stage 0.3~0.6: 최대 범위
+    # stage 0.6~1.0: 빙하 후퇴 (상류로 후퇴)
+    
+    glacier_grid = np.zeros((h, w))
+    
+    if stage < 0.3:
+        # 빙하 성장: 상류에서 하류로 전진
+        glacier_extent = int(h * (stage / 0.3) * 0.8)  # 최대 80%까지 전진
+        glacier_start = 0
+        glacier_end = glacier_extent
+    elif stage < 0.6:
+        # 최대 빙하 범위
+        glacier_start = 0
+        glacier_end = int(h * 0.8)
+    else:
+        # 빙하 후퇴
+        retreat_factor = (stage - 0.6) / 0.4
+        glacier_start = int(h * 0.8 * retreat_factor)  # 하류에서 녹음
+        glacier_end = int(h * 0.8 * (1 - retreat_factor * 0.5))  # 상류도 줄어듦
+    
+    # 빙하 표시 (골짜기 채움)
+    for r in range(glacier_start, min(glacier_end, h)):
+        for c in range(w):
+            dx = abs(c - center)
+            if dx < half_width + 5:  # U자곡 바닥 + 약간 넓게
+                glacier_thickness = 20.0 * (1 - abs(c - center) / (half_width + 5))
+                if stage < 0.6:
+                    elevation[r, c] += glacier_thickness
+                else:
+                    # 후퇴 중: 빙하 높이 감소
+                    retreat_factor = (stage - 0.6) / 0.4
+                    elevation[r, c] += glacier_thickness * (1 - retreat_factor)
+    
     return elevation
 
 
@@ -642,47 +750,91 @@ def create_v_valley_animated(grid_size: int, stage: float,
 
 def create_barchan_animated(grid_size: int, stage: float,
                              num_dunes: int = 3) -> np.ndarray:
-    """바르한 사구 형성과정 (평탄 사막 -> 모래 축적 -> 초승달 형성)"""
+    """바르한 사구 이동 애니메이션
+    
+    위에서 볼 때 초승달(🌙) 모양:
+    - 볼록면(convex): 바람 불어오는 쪽 (상단)
+    - 오목면(concave): 바람 가는 쪽 (하단) + 뿔
+    - 뿔(horns): 바람 방향으로 뻗음
+    
+    바람 방향: 위 → 아래
+    """
     h, w = grid_size, grid_size
     elevation = np.zeros((h, w))
     
     # 사막 기반면
     elevation[:, :] = 5.0
     
-    # Stage에 따른 사구 성장
-    np.random.seed(42)  # 일관된 위치
+    np.random.seed(42)
+    
+    # 사구 이동
+    move_distance = int(h * 0.5 * stage)
     
     for i in range(num_dunes):
-        cy = h // 4 + i * (h // (num_dunes + 1))
-        cx = w // 2 + (i - num_dunes // 2) * (w // 5)
-        
-        # 최종 높이 * stage
-        final_height = 15.0 + (i * 5.0)
-        dune_height = final_height * stage
+        # 위치
+        initial_y = h // 5 + i * (h // (num_dunes + 1))
+        cx = w // 4 + (i % 2) * (w // 2)
+        cy = initial_y + move_distance
         
-        # 사구 크기도 stage에 비례
-        dune_length = int((w // 5) * (0.3 + 0.7 * stage))
-        dune_width = int((w // 8) * (0.3 + 0.7 * stage))
-        
-        if dune_length < 1 or dune_width < 1:
+        if cy >= h - 20:
             continue
         
+        # 사구 크기
+        dune_height = 10.0 + i * 2.0
+        outer_r = w // 7  # 바깥 원 반지름
+        inner_r = outer_r * 0.6  # 안쪽 원 반지름
+        inner_offset = outer_r * 0.5  # 안쪽 원 오프셋 (아래로)
+        
         for r in range(h):
             for c in range(w):
                 dy = r - cy
                 dx = c - cx
                 
-                dist = np.sqrt((dy / max(dune_length, 1)) ** 2 + (dx / max(dune_width, 1)) ** 2)
+                # 바깥 원 (볼록면 - 상단)
+                dist_outer = np.sqrt(dx**2 + dy**2)
                 
-                if dist < 1.0:
-                    if dy < 0:  # 바람받이
-                        z = dune_height * (1 - dist) * (1 - abs(dy) / max(dune_length, 1))
-                    else:  # 바람그늘
-                        z = dune_height * (1 - dist) * max(0, 1 - dy / (dune_length * 0.5))
-                        
-                    horn_factor = 1 + 0.5 * abs(dx / max(dune_width, 1))
-                    elevation[r, c] = max(elevation[r, c], 5.0 + z * horn_factor)
+                # 안쪽 원 (오목면 - 하단으로 오프셋)
+                dist_inner = np.sqrt(dx**2 + (dy - inner_offset)**2)
+                
+                # 초승달 영역: 바깥 원 안 AND 안쪽 원 밖
+                in_crescent = (dist_outer < outer_r) and (dist_inner > inner_r)
+                
+                if in_crescent:
+                    # 높이 계산: 중심에서 멀수록 낮아짐
+                    height_factor = 1 - (dist_outer / outer_r)
                     
+                    # 바람받이(상단) 완만, 바람그늘(하단) 급
+                    if dy < 0:
+                        # 바람받이: 완만한 경사
+                        slope = height_factor * 0.8
+                    else:
+                        # 바람그늘: 더 높게 (급경사 효과)
+                        slope = height_factor * 1.2
+                    
+                    z = dune_height * slope
+                    elevation[r, c] = max(elevation[r, c], 5.0 + z)
+                
+                # 뿔 (horn) - 양쪽으로 바람 방향으로 뻗음
+                horn_width = outer_r * 0.3
+                horn_length = outer_r * 0.8
+                
+                for side in [-1, 1]:  # 왼쪽, 오른쪽 뿔
+                    horn_cx = cx + side * (outer_r - horn_width)
+                    horn_cy = cy + inner_offset
+                    
+                    dx_horn = c - horn_cx
+                    dy_horn = r - horn_cy
+                    
+                    # 뿔 영역 (바람 방향으로 길쭉)
+                    if abs(dx_horn) < horn_width and 0 < dy_horn < horn_length:
+                        # 뿔 높이: 끝으로 갈수록 낮아짐
+                        horn_factor = 1 - dy_horn / horn_length
+                        width_factor = 1 - abs(dx_horn) / horn_width
+                        z = dune_height * 0.5 * horn_factor * width_factor
+                        
+                        if z > 0.3:
+                            elevation[r, c] = max(elevation[r, c], 5.0 + z)
+    
     return elevation
 # ============================================
 # 확장 지형 (Extended Landforms)
@@ -1121,35 +1273,85 @@ def create_spit_lagoon(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
 # ============================================
 
 def create_fjord(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
-    """피오르드 (Fjord) - 빙하가 파낸 U자곡에 바다 유입"""
+    """피오르드 (Fjord) - 빙하 후퇴 후 바다 유입
+    
+    Stage 0.0~0.4: 빙하가 U자곡을 채움 (빙하기)
+    Stage 0.4~0.7: 빙하 후퇴 시작 (바다 유입 시작)
+    Stage 0.7~1.0: 빙하 완전 후퇴 (피오르드 완성)
+    """
     h, w = grid_size, grid_size
     elevation = np.zeros((h, w))
     
-    # 산악 지형
-    elevation[:, :] = 80.0
+    # 산악 지형 (높은 산)
+    elevation[:, :] = 100.0
     
     center = w // 2
-    valley_width = int(w * 0.2)
-    
-    # U자곡 + 바다 유입
-    sea_line = int(h * 0.7)
+    valley_width = int(w * 0.25)
+    valley_depth = 60.0
     
+    # U자곡 형성
     for r in range(h):
         for c in range(w):
             dx = abs(c - center)
             
             if dx < valley_width:
                 # U자 바닥
-                if r < sea_line:
-                    elevation[r, c] = 10.0  # 육지 바닥
-                else:
-                    elevation[r, c] = -30.0 * stage  # 바다
-            elif dx < valley_width + 10:
-                # U자 측벽
-                t = (dx - valley_width) / 10
-                base = -30.0 if r >= sea_line else 10.0
-                elevation[r, c] = base + 70.0 * t
-                
+                base_height = 10.0
+                elevation[r, c] = base_height
+            elif dx < valley_width + 15:
+                # U자 측벽 (수직에 가까움)
+                t = (dx - valley_width) / 15
+                elevation[r, c] = 10.0 + 90.0 * (t ** 0.5)  # 급경사
+    
+    # 빙하 / 바다 상태
+    if stage < 0.4:
+        # 빙하기: U자곡에 빙하 채움
+        glacier_extent = int(h * 0.9)  # 거의 전체 채움
+        glacier_thickness = 40.0
+        
+        for r in range(glacier_extent):
+            for c in range(w):
+                dx = abs(c - center)
+                if dx < valley_width:
+                    # 빙하 표면 (볼록)
+                    cross_profile = glacier_thickness * (1 - (dx / valley_width) ** 2)
+                    elevation[r, c] = 10.0 + cross_profile
+                    
+    elif stage < 0.7:
+        # 빙하 후퇴 중: 일부 빙하 + 바다 유입
+        retreat_factor = (stage - 0.4) / 0.3
+        
+        # 빙하 잔류 (상류에만)
+        glacier_end = int(h * (0.9 - 0.6 * retreat_factor))
+        glacier_thickness = 40.0 * (1 - retreat_factor * 0.5)
+        
+        for r in range(glacier_end):
+            for c in range(w):
+                dx = abs(c - center)
+                if dx < valley_width:
+                    cross_profile = glacier_thickness * (1 - (dx / valley_width) ** 2)
+                    elevation[r, c] = 10.0 + cross_profile
+        
+        # 바다 유입 (하류부터)
+        sea_start = glacier_end
+        for r in range(sea_start, h):
+            for c in range(w):
+                dx = abs(c - center)
+                if dx < valley_width:
+                    # 깊은 바다
+                    elevation[r, c] = -30.0 * retreat_factor
+    else:
+        # 피오르드 완성: 깊은 바다만
+        sea_depth = -50.0  # 깊은 피오르드
+        
+        for r in range(h):
+            for c in range(w):
+                dx = abs(c - center)
+                if dx < valley_width:
+                    # 상류로 갈수록 얕아짐
+                    depth_gradient = 1 - (r / h) * 0.3
+                    elevation[r, c] = sea_depth * depth_gradient
+                    
     return elevation
 
 
@@ -1274,46 +1476,79 @@ def create_braided_river(grid_size: int = 100, stage: float = 1.0) -> np.ndarray
 
 def create_waterfall(grid_size: int = 100, stage: float = 1.0,
                      drop_height: float = 50.0) -> np.ndarray:
-    """폭포 (Waterfall) - 차별침식"""
+    """폭포 (Waterfall) - 두부침식으로 후퇴
+    
+    Stage 0.0: 폭포가 하류에 위치
+    Stage 1.0: 폭포가 상류로 후퇴 (두부침식)
+    - 경암층과 연암층의 차별침식
+    - 플런지풀(폭호) 발달
+    - 후퇴하면서 협곡 형성
+    """
     h, w = grid_size, grid_size
     elevation = np.zeros((h, w))
-    
     center = w // 2
-    fall_r = int(h * 0.4)
+    
+    # 폭포 위치 (stage에 따라 상류로 후퇴)
+    # stage 0: 하류(h*0.7), stage 1: 상류(h*0.3)
+    initial_fall = int(h * 0.7)
+    final_fall = int(h * 0.3)
+    fall_r = int(initial_fall - (initial_fall - final_fall) * stage)
     
     # 상류 (높은 경암층)
+    hard_rock_height = drop_height + 30.0
     for r in range(fall_r):
         for c in range(w):
-            elevation[r, c] = drop_height + 20.0 + (fall_r - r) * 0.5
-            
-    # 폭포 (급경사)
-    for r in range(fall_r, fall_r + 5):
+            # 상류로 갈수록 높아짐
+            upstream_rise = (fall_r - r) * 0.3
+            elevation[r, c] = hard_rock_height + upstream_rise
+    
+    # 폭포 절벽 (급경사)
+    cliff_width = 5
+    for r in range(fall_r, min(fall_r + cliff_width, h)):
         for c in range(w):
-            t = (r - fall_r) / 5
-            elevation[r, c] = drop_height * (1 - t) + 20.0
-            
-    # 하류
-    for r in range(fall_r + 5, h):
+            t = (r - fall_r) / cliff_width
+            # 수직 낙하
+            elevation[r, c] = hard_rock_height * (1 - t) + 10.0 * t
+    
+    # 하류 (연암층 침식됨)
+    for r in range(fall_r + cliff_width, h):
         for c in range(w):
-            elevation[r, c] = 20.0 - (r - fall_r - 5) * 0.2
-            
+            # 하류로 갈수록 낮아짐
+            downstream_drop = (r - fall_r - cliff_width) * 0.2
+            elevation[r, c] = 10.0 - downstream_drop
+    
+    # 협곡 (폭포 후퇴 경로)
+    gorge_start = fall_r + cliff_width
+    gorge_end = initial_fall + 10  # 원래 폭포 위치까지
+    gorge_depth = 8.0
+    
+    for r in range(gorge_start, min(gorge_end, h)):
+        for dc in range(-6, 7):
+            c = center + dc
+            if 0 <= c < w:
+                # V자 협곡 단면
+                depth = gorge_depth * (1 - abs(dc) / 6)
+                elevation[r, c] -= depth
+    
     # 하천 수로
     for r in range(h):
         for dc in range(-4, 5):
             c = center + dc
             if 0 <= c < w:
-                elevation[r, c] -= 5.0
-                
-    # 플런지풀 (폭호)
-    pool_r = fall_r + 5
-    for dr in range(-5, 6):
-        for dc in range(-6, 7):
+                elevation[r, c] -= 3.0
+    
+    # 플런지풀 (폭호) - 폭포 바로 아래
+    pool_r = fall_r + cliff_width + 2
+    pool_depth = 15.0
+    for dr in range(-6, 7):
+        for dc in range(-7, 8):
             r, c = pool_r + dr, center + dc
             if 0 <= r < h and 0 <= c < w:
                 dist = np.sqrt(dr**2 + dc**2)
-                if dist < 6:
-                    elevation[r, c] = min(elevation[r, c], 10.0)
-                    
+                if dist < 7:
+                    pool_effect = pool_depth * (1 - dist / 7)
+                    elevation[r, c] = min(elevation[r, c], 5.0 - pool_effect)
+    
     return elevation
 
 
@@ -1344,34 +1579,48 @@ def create_karst_doline(grid_size: int = 100, stage: float = 1.0,
 
 
 def create_ria_coast(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
-    """리아스식 해안 (Ria Coast) - 침수된 하곡"""
+    """리아스식 해안 (Ria Coast) - 침수된 하곡
+    
+    해수면 상승으로 V자곡이 침수되어 형성
+    - 톱니 모양 해안선
+    - 좁고 깊은 만 (리아)
+    """
     h, w = grid_size, grid_size
     elevation = np.zeros((h, w))
     
-    # 산지 배경
-    elevation[:, :] = 40.0
+    # 산지 배경 (높은 육지)
+    elevation[:, :] = 50.0
     
-    # 여러 개의 V자곡 (침수됨)
-    num_valleys = 4
-    sea_level = int(h * 0.6)
+    # 여러 개의 V자 하곡
+    num_valleys = 5
+    valley_spacing = w // (num_valleys + 1)
     
     for i in range(num_valleys):
-        valley_x = int(w * 0.15 + i * w * 0.2)
+        valley_x = valley_spacing * (i + 1)
+        valley_width = 12 + (i % 2) * 4  # 약간의 변화
+        valley_depth = 40.0 + (i % 3) * 10
         
         for r in range(h):
             for c in range(w):
                 dx = abs(c - valley_x)
                 
-                if dx < 8:
-                    # V자곡
-                    depth = 30.0 * (1 - dx / 8)
-                    elevation[r, c] -= depth
+                if dx < valley_width:
+                    # V자곡 (상류로 갈수록 좁아짐)
+                    upstream_factor = 1 - r / h * 0.5
+                    effective_width = valley_width * upstream_factor
                     
-    # 해수면 이하 = 바다
-    for r in range(sea_level, h):
+                    if dx < effective_width:
+                        depth = valley_depth * (1 - dx / effective_width)
+                        elevation[r, c] = min(elevation[r, c], 50.0 - depth)
+    
+    # 해수면 (stage에 따라 상승)
+    sea_level = 15.0 * stage  # 높을수록 많이 침수
+    
+    for r in range(h):
         for c in range(w):
-            if elevation[r, c] < 10:
-                elevation[r, c] = -5.0 * stage  # 침수
+            if elevation[r, c] < sea_level:
+                # 해수면 아래 = 바다 (리아)
+                elevation[r, c] = -10.0 - (sea_level - elevation[r, c]) * 0.3
                 
     return elevation
 
@@ -1416,40 +1665,64 @@ def create_tombolo(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
 
 
 def create_sea_arch(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
-    """해식아치 (Sea Arch) - 동굴이 관통"""
+    """해식아치 (Sea Arch) - 해식동굴이 관통
+    
+    곶의 양쪽에서 파랑 침식 → 해식동굴 → 관통 = 아치
+    Stage: 아치 크기 발달
+    """
     h, w = grid_size, grid_size
     elevation = np.zeros((h, w))
     
-    # 바다 (아래)
-    sea_line = int(h * 0.5)
-    elevation[sea_line:, :] = -5.0
+    # 바다 (하단)
+    sea_line = int(h * 0.4)
+    elevation[sea_line:, :] = -8.0
     
     # 육지 절벽
-    cliff_height = 30.0
+    cliff_height = 35.0
     for r in range(sea_line):
-        elevation[r, :] = cliff_height
-        
-    # 돌출부 (곶)
-    headland_width = int(w * 0.3)
+        for c in range(w):
+            # 거리에 따른 육지 높이
+            dist_from_edge = min(r, c, w - c - 1)
+            elevation[r, c] = cliff_height
+    
+    # 돌출부 (곶 - headland)
     headland_cx = w // 2
-    headland_length = int(h * 0.3)
+    headland_width = int(w * 0.35)
+    headland_length = int(h * 0.4)
     
     for r in range(sea_line, sea_line + headland_length):
-        for c in range(headland_cx - headland_width // 2, headland_cx + headland_width // 2):
+        # 곶 폭이 끝으로 갈수록 좁아짐
+        taper = 1 - (r - sea_line) / headland_length * 0.5
+        current_width = int(headland_width * taper)
+        
+        for c in range(headland_cx - current_width // 2, headland_cx + current_width // 2):
             if 0 <= c < w:
-                elevation[r, c] = cliff_height * (1 - (r - sea_line) / headland_length * 0.3)
-                
-    # 아치 (관통)
+                # 곶 높이 (끝으로 갈수록 약간 낮아짐)
+                height = cliff_height * (1 - (r - sea_line) / headland_length * 0.2)
+                elevation[r, c] = height
+    
+    # 해식아치 (곶 중간에 관통)
     arch_r = sea_line + int(headland_length * 0.5)
-    arch_width = int(headland_width * 0.4 * stage)
+    arch_height = int(cliff_height * 0.6 * stage)  # 아치 높이
+    arch_width = int(headland_width * 0.3 * stage)  # 아치 폭
     
-    for dr in range(-5, 6):
-        for dc in range(-arch_width // 2, arch_width // 2 + 1):
-            r, c = arch_r + dr, headland_cx + dc
+    for dr in range(-8, 9):
+        for dc in range(-arch_width, arch_width + 1):
+            r = arch_r + dr
+            c = headland_cx + dc
+            
             if 0 <= r < h and 0 <= c < w:
-                if abs(dr) < 3:  # 아치 높이
-                    elevation[r, c] = -5.0  # 관통
-                    
+                # 아치 형태 (반원형 터널)
+                arch_profile = arch_height * np.sqrt(max(0, 1 - (dc / max(arch_width, 1))**2))
+                
+                if abs(dr) < 3 and arch_profile > 5:
+                    # 터널 관통
+                    elevation[r, c] = -5.0
+                elif abs(dr) < 5:
+                    # 아치 천장
+                    if elevation[r, c] > arch_profile:
+                        elevation[r, c] = min(elevation[r, c], cliff_height - arch_profile * 0.3)
+    
     return elevation
 
 
@@ -1481,30 +1754,75 @@ def create_crater_lake(grid_size: int = 100, stage: float = 1.0,
 
 
 def create_lava_plateau(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
-    """용암대지 (Lava Plateau) - 평탄한 용암"""
+    """용암대지 (Lava Plateau) - 한탄강 형성과정
+    
+    Stage 0.0~0.3: 원래 V자곡 존재
+    Stage 0.3~0.6: 열하분출로 V자곡 메워짐 (용암대지 형성)
+    Stage 0.6~1.0: 하천 재침식으로 새로운 협곡 형성
+    """
     h, w = grid_size, grid_size
     elevation = np.zeros((h, w))
+    center = w // 2
     
-    # 기반
-    elevation[:, :] = 5.0
-    
-    # 용암대지 영역
-    plateau_height = 30.0 * stage
-    margin = int(w * 0.15)
+    # 기반 고원 높이
+    plateau_base = 30.0
+    
+    if stage < 0.3:
+        # 원래 V자곡 상태
+        v_factor = 1.0
+        lava_fill = 0.0
+        new_valley = 0.0
+    elif stage < 0.6:
+        # 열하분출로 V자곡 메워짐
+        v_factor = 1.0 - ((stage - 0.3) / 0.3)  # V자곡 점점 사라짐
+        lava_fill = (stage - 0.3) / 0.3  # 용암 채워짐
+        new_valley = 0.0
+    else:
+        # 새 협곡 형성
+        v_factor = 0.0  # 원래 V자곡 완전히 덮임
+        lava_fill = 1.0
+        new_valley = (stage - 0.6) / 0.4  # 새 협곡 발달
     
-    for r in range(margin, h - margin):
-        for c in range(margin, w - margin):
-            # 거의 평탄하지만 약간의 굴곡
-            noise = np.sin(r * 0.2) * np.cos(c * 0.2) * 2.0
-            elevation[r, c] = plateau_height + noise
+    for r in range(h):
+        for c in range(w):
+            dx = abs(c - center)
             
-    # 가장자리 절벽
+            # 기본 고원
+            elevation[r, c] = plateau_base
+            
+            # 원래 V자곡 (열하분출 전)
+            if v_factor > 0:
+                valley_depth = 25.0 * v_factor
+                if dx < 15:
+                    v_shape = valley_depth * (1 - dx / 15)
+                    elevation[r, c] -= v_shape
+            
+            # 용암 채움 (평탄화)
+            if lava_fill > 0:
+                # 용암이 V자곡을 메움
+                if dx < 15:
+                    fill_amount = 25.0 * lava_fill * (1 - dx / 15)
+                    elevation[r, c] += fill_amount * 0.8  # 약간 낮게
+                    
+            # 새로운 협곡 (하천 재침식)
+            if new_valley > 0:
+                # 새 하천이 용암대지를 파고듦
+                new_valley_width = int(8 * new_valley)
+                new_valley_depth = 20.0 * new_valley
+                
+                if dx < new_valley_width:
+                    # 더 좁고 깊은 협곡
+                    gorge_shape = new_valley_depth * (1 - dx / max(new_valley_width, 1))
+                    elevation[r, c] -= gorge_shape
+                    
+    # 가장자리 경사
+    margin = int(w * 0.1)
     for r in range(h):
         for c in range(w):
             edge_dist = min(r, h - r - 1, c, w - c - 1)
             if edge_dist < margin:
                 t = edge_dist / margin
-                elevation[r, c] = 5.0 + (elevation[r, c] - 5.0) * t
+                elevation[r, c] = elevation[r, c] * t + 5.0 * (1 - t)
                 
     return elevation
 
@@ -1545,6 +1863,206 @@ def create_coastal_dune(grid_size: int = 100, stage: float = 1.0,
     return elevation
 
 
+# ============================================
+# 새로 추가된 지형들
+# ============================================
+
+def create_uvala(grid_size: int = 100, stage: float = 1.0,
+                 num_dolines: int = 4) -> np.ndarray:
+    """우발라 (Uvala) - 복합 돌리네
+    
+    여러 돌리네가 합쳐져서 형성된 큰 와지
+    Stage 0~0.5: 개별 돌리네 형성
+    Stage 0.5~1.0: 돌리네들이 합쳐짐
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    elevation[:, :] = 30.0  # 석회암 대지
+    
+    center = w // 2
+    
+    # 돌리네 위치들
+    doline_positions = [
+        (h // 3, center - w // 6),
+        (h // 3, center + w // 6),
+        (h * 2 // 3, center - w // 6),
+        (h * 2 // 3, center + w // 6),
+    ]
+    
+    doline_radius = int(w * 0.15)
+    doline_depth = 20.0 * stage
+    
+    for i, (cy, cx) in enumerate(doline_positions[:num_dolines]):
+        for r in range(h):
+            for c in range(w):
+                dist = np.sqrt((r - cy)**2 + (c - cx)**2)
+                if dist < doline_radius:
+                    # 돌리네 형태 (가장자리 높고 중앙 낮음)
+                    depth = doline_depth * (1 - dist / doline_radius)
+                    elevation[r, c] = min(elevation[r, c], 30.0 - depth)
+    
+    # Stage > 0.5: 돌리네 사이 연결 (합쳐짐)
+    if stage > 0.5:
+        merge_factor = (stage - 0.5) / 0.5
+        merge_depth = 10.0 * merge_factor
+        
+        # 중앙 연결부
+        for r in range(h):
+            for c in range(w):
+                dist_center = np.sqrt((r - h//2)**2 + (c - center)**2)
+                if dist_center < doline_radius * 1.5:
+                    elevation[r, c] = min(elevation[r, c], 30.0 - merge_depth)
+                    
+    return elevation
+
+
+def create_tower_karst(grid_size: int = 100, stage: float = 1.0,
+                       num_towers: int = 6) -> np.ndarray:
+    """탑카르스트 (Tower Karst) - 봉우리 형태 카르스트
+    
+    중국 구이린 같은 탑 모양 석회암 봉우리
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    elevation[:, :] = 5.0  # 저지대
+    
+    np.random.seed(42)
+    
+    for i in range(num_towers):
+        cy = int(h * 0.2 + (i % 3) * h * 0.3)
+        cx = int(w * 0.2 + (i // 3) * w * 0.3 + np.random.randint(-10, 10))
+        
+        tower_height = (40.0 + np.random.rand() * 30) * stage
+        tower_radius = int(w * 0.08 + np.random.rand() * w * 0.04)
+        
+        for r in range(h):
+            for c in range(w):
+                dist = np.sqrt((r - cy)**2 + (c - cx)**2)
+                if dist < tower_radius:
+                    # 수직 절벽 형태 (가파른 측면)
+                    edge_factor = 1 - (dist / tower_radius) ** 3
+                    z = tower_height * edge_factor
+                    elevation[r, c] = max(elevation[r, c], 5.0 + z)
+                    
+    return elevation
+
+
+def create_karren(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
+    """카렌 (Karren/Lapies) - 석회암 용식 홈
+    
+    빗물에 의한 용식으로 형성된 홈과 릿지
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    elevation[:, :] = 20.0  # 석회암 표면
+    
+    # 용식 홈 (Rillenkarren) - 평행한 홈
+    groove_spacing = max(3, w // 20)
+    groove_depth = 3.0 * stage
+    
+    for c in range(w):
+        if c % groove_spacing < groove_spacing // 2:
+            for r in range(h):
+                # 길쭉한 홈
+                depth = groove_depth * (1 - abs(c % groove_spacing - groove_spacing // 4) / (groove_spacing // 4))
+                elevation[r, c] -= depth
+    
+    # 클린트/그라이크 (Clint/Grike) - 직각 패턴
+    block_size = max(8, w // 8)
+    grike_depth = 5.0 * stage
+    grike_width = 2
+    
+    for r in range(h):
+        for c in range(w):
+            if r % block_size < grike_width or c % block_size < grike_width:
+                elevation[r, c] -= grike_depth
+                
+    return elevation
+
+
+def create_transverse_dune(grid_size: int = 100, stage: float = 1.0,
+                           num_ridges: int = 4) -> np.ndarray:
+    """횡사구 (Transverse Dune) - 바람에 직각인 사구열
+    
+    바람 방향에 수직으로 형성된 긴 사구
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    elevation[:, :] = 5.0  # 사막 기반
+    
+    # 횡사구 (바람 방향 상→하에 수직 = 좌우로 길게)
+    ridge_spacing = h // (num_ridges + 1)
+    ridge_height = 12.0 * stage
+    ridge_width = max(5, h // 10)
+    
+    for i in range(num_ridges):
+        ridge_r = ridge_spacing * (i + 1)
+        
+        for r in range(h):
+            for c in range(w):
+                dr = r - ridge_r
+                
+                if abs(dr) < ridge_width:
+                    # 비대칭: 바람받이 완만, 바람그늘 급
+                    if dr < 0:
+                        # 바람받이
+                        z = ridge_height * (1 - abs(dr) / (ridge_width * 1.5))
+                    else:
+                        # 바람그늘
+                        z = ridge_height * (1 - dr / (ridge_width * 0.6))
+                    z = max(0, z)
+                    elevation[r, c] = max(elevation[r, c], 5.0 + z)
+                    
+    return elevation
+
+
+def create_star_dune(grid_size: int = 100, stage: float = 1.0,
+                     num_dunes: int = 2) -> np.ndarray:
+    """성사구 (Star Dune) - 별 모양 사구
+    
+    다방향 바람으로 형성된 방사상 사구
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    elevation[:, :] = 5.0  # 사막 기반
+    
+    for d in range(num_dunes):
+        cy = h // 3 + d * h // 3
+        cx = w // 3 + d * w // 3
+        
+        dune_height = 20.0 * stage
+        arm_length = int(w * 0.2)
+        arm_width = max(3, w // 20)
+        num_arms = 5  # 별 모양 팔 개수
+        
+        for r in range(h):
+            for c in range(w):
+                dx = c - cx
+                dy = r - cy
+                dist = np.sqrt(dx**2 + dy**2)
+                
+                # 중앙 봉우리
+                if dist < arm_width * 2:
+                    z = dune_height * (1 - dist / (arm_width * 2))
+                    elevation[r, c] = max(elevation[r, c], 5.0 + z)
+                
+                # 팔 (방사상)
+                for arm in range(num_arms):
+                    angle = arm * 2 * np.pi / num_arms
+                    # 팔 중심선까지의 거리
+                    arm_dir = np.array([np.cos(angle), np.sin(angle)])
+                    pos = np.array([dx, dy])
+                    proj = np.dot(pos, arm_dir)
+                    perp = np.abs(np.cross(arm_dir, pos))
+                    
+                    if proj > 0 and proj < arm_length and perp < arm_width:
+                        # 팔 높이: 중앙에서 멀어질수록 낮아짐
+                        z = dune_height * 0.6 * (1 - proj / arm_length) * (1 - perp / arm_width)
+                        elevation[r, c] = max(elevation[r, c], 5.0 + z)
+                        
+    return elevation
+
+
 # 애니메이션 생성기 매핑
 ANIMATED_LANDFORM_GENERATORS = {
     'delta': create_delta_animated,
@@ -1580,6 +2098,12 @@ ANIMATED_LANDFORM_GENERATORS = {
     'crater_lake': create_crater_lake,
     'lava_plateau': create_lava_plateau,
     'coastal_dune': create_coastal_dune,
+    # 새로 추가된 지형
+    'uvala': create_uvala,
+    'tower_karst': create_tower_karst,
+    'karren': create_karren,
+    'transverse_dune': create_transverse_dune,
+    'star_dune': create_star_dune,
 }
 
 # 지형 생성 함수 매핑
@@ -1617,5 +2141,11 @@ IDEAL_LANDFORM_GENERATORS = {
     'crater_lake': lambda gs: create_crater_lake(gs, 1.0),
     'lava_plateau': lambda gs: create_lava_plateau(gs, 1.0),
     'coastal_dune': lambda gs: create_coastal_dune(gs, 1.0),
+    # 새로 추가된 지형
+    'uvala': lambda gs: create_uvala(gs, 1.0),
+    'tower_karst': lambda gs: create_tower_karst(gs, 1.0),
+    'karren': lambda gs: create_karren(gs, 1.0),
+    'transverse_dune': lambda gs: create_transverse_dune(gs, 1.0),
+    'star_dune': lambda gs: create_star_dune(gs, 1.0),
 }
 

pages/1_📖_Gallery.py

@@ -0,0 +1,272 @@
+"""
+📖 이상적 지형 갤러리
+31종의 교과서적 지형을 시각화합니다.
+"""
+import streamlit as st
+import numpy as np
+import matplotlib.pyplot as plt
+import sys
+import os
+
+# 상위 디렉토리를 경로에 추가
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from engine.ideal_landforms import IDEAL_LANDFORM_GENERATORS, ANIMATED_LANDFORM_GENERATORS
+from app.main import render_terrain_plotly
+
+st.header("📖 이상적 지형 갤러리")
+st.markdown("_교과서적인 지형 형태를 기하학적 모델로 시각화합니다._")
+
+# 강조 메시지
+st.info("💡 **Tip:** 지형 선택 후 **아래로 스크롤**하면 **🎬 형성 과정 애니메이션**을 확인할 수 있습니다!")
+
+# 카테고리별 지형
+st.sidebar.subheader("🗂️ 지형 카테고리")
+category = st.sidebar.radio("카테고리 선택", [
+    "🌊 하천 지형",
+    "🔺 삼각주 유형", 
+    "❄️ 빙하 지형",
+    "🌋 화산 지형",
+    "🦇 카르스트 지형",
+    "🏜️ 건조 지형",
+    "🏖️ 해안 지형"
+], key="gallery_cat")
+
+# 카테고리 → landform_type 매핑
+CATEGORY_TO_TYPE = {
+    "🌊 하천 지형": "river",
+    "🔺 삼각주 유형": "river", 
+    "❄️ 빙하 지형": "glacial",
+    "🌋 화산 지형": "volcanic",
+    "🦇 카르스트 지형": "karst",
+    "🏜️ 건조 지형": "arid",
+    "🏖️ 해안 지형": "coastal"
+}
+landform_type = CATEGORY_TO_TYPE.get(category, None)
+
+# 카테고리별 옵션
+if category == "🌊 하천 지형":
+    landform_options = {
+        "📐 선상지 (Alluvial Fan)": "alluvial_fan",
+        "🐍 자유곡류 (Free Meander)": "free_meander",
+        "⛰️ 감입곡류+하안단구 (Incised Meander)": "incised_meander",
+        "🏔️ V자곡 (V-Valley)": "v_valley",
+        "🌊 망상하천 (Braided River)": "braided_river",
+        "💧 폭포 (Waterfall)": "waterfall",
+    }
+elif category == "🔺 삼각주 유형":
+    landform_options = {
+        "🔺 일반 삼각주 (Delta)": "delta",
+        "🦶 조족상 삼각주 (Bird-foot)": "bird_foot_delta",
+        "🌙 호상 삼각주 (Arcuate)": "arcuate_delta",
+        "📍 첨두상 삼각주 (Cuspate)": "cuspate_delta",
+    }
+elif category == "❄️ 빙하 지형":
+    landform_options = {
+        "❄️ U자곡 (U-Valley)": "u_valley",
+        "🥣 권곡 (Cirque)": "cirque",
+        "🏔️ 호른 (Horn)": "horn",
+        "🌊 피오르드 (Fjord)": "fjord",
+        "🥚 드럼린 (Drumlin)": "drumlin",
+        "🪨 빙퇴석 (Moraine)": "moraine",
+    }
+elif category == "🌋 화산 지형":
+    landform_options = {
+        "🛡️ 순상화산 (Shield)": "shield_volcano",
+        "🗻 성층화산 (Stratovolcano)": "stratovolcano",
+        "🕳️ 칼데라 (Caldera)": "caldera",
+        "💧 화구호 (Crater Lake)": "crater_lake",
+        "🟫 용암대지 (Lava Plateau)": "lava_plateau",
+    }
+elif category == "🦇 카르스트 지형":
+    landform_options = {
+        "🕳️ 돌리네 (Doline)": "karst_doline",
+        "🥋 우발라 (Uvala)": "uvala",
+        "🗼 탑카르스트 (Tower Karst)": "tower_karst",
+        "🪨 카렌 (Karren)": "karren",
+    }
+elif category == "🏜️ 건조 지형":
+    landform_options = {
+        "🌙 바르한 사구 (Barchan)": "barchan",
+        "🟰 횡사구 (Transverse Dune)": "transverse_dune",
+        "⭐ 성사구 (Star Dune)": "star_dune",
+        "🗿 메사/뷰트 (Mesa/Butte)": "mesa_butte",
+    }
+else:  # 해안 지형
+    landform_options = {
+        "🏖️ 해안 절벽 (Coastal Cliff)": "coastal_cliff",
+        "🌊 사취+석호 (Spit+Lagoon)": "spit_lagoon",
+        "🏝️ 육계사주 (Tombolo)": "tombolo",
+        "🌀 리아스 해안 (Ria Coast)": "ria_coast",
+        "🌉 해식아치 (Sea Arch)": "sea_arch",
+        "🏖️ 해안사구 (Coastal Dune)": "coastal_dune",
+    }
+
+col_sel, col_view = st.columns([1, 3])
+
+with col_sel:
+    selected_landform = st.selectbox("지형 선택", list(landform_options.keys()))
+    landform_key = landform_options[selected_landform]
+    
+    st.markdown("---")
+    st.subheader("⚙️ 파라미터")
+    
+    gallery_grid_size = st.slider("해상도", 50, 150, 80, 10, key="gallery_res")
+    
+    # 동적 지형 생성
+    if landform_key in IDEAL_LANDFORM_GENERATORS:
+        generator = IDEAL_LANDFORM_GENERATORS[landform_key]
+        try:
+            elevation = generator(gallery_grid_size)
+        except TypeError:
+            elevation = generator(gallery_grid_size, 1.0)
+    else:
+        st.error(f"지형 '{landform_key}' 생성기를 찾을 수 없습니다.")
+        elevation = np.zeros((gallery_grid_size, gallery_grid_size))
+
+with col_view:
+    # 2D 평면도
+    fig_2d, ax = plt.subplots(figsize=(8, 8))
+    cmap = plt.cm.terrain
+    water_mask = elevation < 0
+    
+    im = ax.imshow(elevation, cmap=cmap, origin='upper')
+    
+    if water_mask.any():
+        water_overlay = np.ma.masked_where(~water_mask, np.ones_like(elevation))
+        ax.imshow(water_overlay, cmap='Blues', alpha=0.6, origin='upper')
+    
+    ax.set_title(f"{selected_landform}", fontsize=14)
+    ax.axis('off')
+    plt.colorbar(im, ax=ax, shrink=0.6, label='고도 (m)')
+    
+    st.pyplot(fig_2d)
+    plt.close(fig_2d)
+    
+    # 3D 보기 버튼
+    if st.button("🔲 3D 뷰 보기", key="show_3d_view"):
+        fig_3d = render_terrain_plotly(
+            elevation, 
+            f"{selected_landform} - 3D",
+            add_water=(landform_key in ["delta", "meander", "coastal_cliff", "fjord", "ria_coast", "spit_lagoon"]),
+            water_level=0 if landform_key in ["delta", "coastal_cliff"] else -999,
+            force_camera=True,
+            landform_type=landform_type  # 카테고리에 맞는 색상 적용
+        )
+        st.plotly_chart(fig_3d, use_container_width=True, key="gallery_3d")
+    
+    # 설명
+    descriptions = {
+        "delta": "**삼각주**: 하천이 바다나 호수에 유입될 때 유속이 감소하여 운반 중이던 퇴적물이 쌓여 형성됩니다.",
+        "alluvial_fan": "**선상지**: 산지에서 평지로 나오는 곳에서 경사가 급감하여 운반력이 줄어들면서 퇴적물이 부채꼴로 쌓입니다.",
+        "free_meander": "**자유곡류**: 범람원 위를 자유롭게 사행하는 곡류. 자연제방(Levee)과 배후습지가 특징입니다.",
+        "incised_meander": "**감입곡류**: 융기로 인해 곡류가 기반암을 파고들면서 형성. 하안단구(River Terrace)가 함께 나타납니다.",
+        "v_valley": "**V자곡**: 하천의 하방 침식이 우세하게 작용하여 형성된 V자 단면의 골짜기.",
+        "braided_river": "**망상하천**: 퇴적물이 많고 경사가 급할 때 여러 수로가 갈라졌다 합쳐지는 하천.",
+        "waterfall": "**폭포**: 경암과 연암의 차별침식으로 형성된 급경사 낙차. 후퇴하며 협곡 형성.",
+        "bird_foot_delta": "**조족상 삼각주**: 미시시피강형. 파랑 약하고 퇴적물 공급 많을 때 새발 모양으로 길게 뻗습니다.",
+        "arcuate_delta": "**호상 삼각주**: 나일강형. 파랑과 퇴적물 공급이 균형을 이루어 부드러운 호(Arc) 형태.",
+        "cuspate_delta": "**첨두상 삼각주**: 티베르강형. 파랑이 강해 삼각주가 뾰족한 화살촉 모양으로 형성.",
+        "u_valley": "**U자곡**: 빙하의 침식으로 형성된 U자 단면의 골짜기. 측벽이 급하고 바닥이 평탄합니다.",
+        "cirque": "**권곡**: 빙하의 시작점. 반원형 움푹 파인 지형으로, 빙하 융해 후 호수(Tarn)가 형성됩니다.",
+        "horn": "**호른**: 여러 권곡이 만나는 곳에서 침식되지 않고 남은 뾰족한 피라미드형 봉우리.",
+        "fjord": "**피오르드**: 빙하가 파낸 U자곡에 바다가 유입된 좁고 깊은 만.",
+        "drumlin": "**드럼린**: 빙하 퇴적물이 빙하 흐름 방향으로 길쭉하게 쌓인 타원형 언덕.",
+        "moraine": "**빙퇴석**: 빙하가 운반한 암설이 퇴적된 지형. 측퇴석, 종퇴석 등이 있습니다.",
+        "shield_volcano": "**순상화산**: 유동성 높은 현무암질 용암이 완만하게 쌓여 방패 형태.",
+        "stratovolcano": "**성층화산**: 용암과 화산쇄설물이 교대로 쌓여 급한 원뿔형.",
+        "caldera": "**칼데라**: 대규모 분화 후 마그마방 함몰로 형성된 거대한 분지.",
+        "crater_lake": "**화구호**: 화구나 칼데라에 물이 고여 형성된 호수.",
+        "lava_plateau": "**용암대지**: 열극 분출로 현무암질 용암이 넓게 펼쳐져 평탄한 대지 형성.",
+        "barchan": "**바르한 사구**: 바람이 한 방향에서 불 때 형성되는 초승달 모양의 사구.",
+        "mesa_butte": "**메사/뷰트**: 차별침식으로 남은 탁상지. 메사는 크고 평탄, 뷰트는 작고 높습니다.",
+        "karst_doline": "**돌리네**: 석회암 용식으로 형성된 움푹 파인 와지.",
+        "coastal_cliff": "**해안 절벽**: 파랑의 침식으로 형성된 절벽.",
+        "spit_lagoon": "**사취+석호**: 연안류에 의해 퇴적물이 길게 쌓인 사취가 만을 막아 석호를 형성합니다.",
+        "tombolo": "**육계사주**: 연안류에 의한 퇴적으로 육지와 섬이 모래톱으로 연결된 지형.",
+        "ria_coast": "**리아스식 해안**: 과거 하곡이 해수면 상승으로 침수되어 형성된 톱니 모양 해안선.",
+        "sea_arch": "**해식아치**: 곶에서 파랑 침식으로 형성된 아치형 지형.",
+        "coastal_dune": "**해안사구**: 해빈의 모래가 바람에 의해 육지 쪽으로 운반되어 형성된 모래 언덕.",
+        # 새로 추가된 지형
+        "uvala": "**우발라**: 여러 돌리네가 합��져 형성된 복합 와지. 돌리네보다 크고 불규칙한 형태.",
+        "tower_karst": "**탑카르스트**: 수직 절벽을 가진 탑 모양 석회암 봉우리. 중국 구이린이 대표적.",
+        "karren": "**카렌**: 빗물에 의한 용식으로 석회암 표면에 형성된 홈과 릿지. 클린트/그라이크 포함.",
+        "transverse_dune": "**횡사구**: 바람 방향에 수직으로 길게 형성된 사구열. 모래 공급이 풍부할 때 발달.",
+        "star_dune": "**성사구**: 다방향 바람에 의해 별 모양으로 형성된 사구. 높이가 높고 이동이 적음.",
+    }
+    st.info(descriptions.get(landform_key, "설명 준비 중입니다."))
+
+# ========== 형성 과정 애니메이션 ==========
+if landform_key in ANIMATED_LANDFORM_GENERATORS:
+    st.markdown("---")
+    st.subheader("🎬 형성 과정")
+    
+    # 자동 재생 중이면 session_state의 stage 사용
+    if st.session_state.get('auto_playing', False):
+        stage_value = st.session_state.get('auto_stage', 0.0)
+        st.slider(
+            "형성 단계 (자동 재생 중...)", 
+            0.0, 1.0, stage_value, 0.05, 
+            key="gallery_stage_slider",
+            disabled=True
+        )
+    else:
+        stage_value = st.slider(
+            "형성 단계 (0% = 시작, 100% = 완성)", 
+            0.0, 1.0, 1.0, 0.05, 
+            key="gallery_stage_slider"
+        )
+    
+    anim_func = ANIMATED_LANDFORM_GENERATORS[landform_key]
+    stage_elev = anim_func(gallery_grid_size, stage_value)
+    
+    # 물 생성
+    stage_water = np.maximum(0, -stage_elev + 1.0)
+    stage_water[stage_elev > 2] = 0
+    
+    # 선상지 물 처리
+    if landform_key == "alluvial_fan":
+        apex_y = int(gallery_grid_size * 0.15)
+        center = gallery_grid_size // 2
+        for r in range(apex_y + 5):
+            for dc in range(-2, 3):
+                c = center + dc
+                if 0 <= c < gallery_grid_size:
+                    stage_water[r, c] = 3.0
+    
+    # 3D 렌더링
+    fig_stage = render_terrain_plotly(
+        stage_elev,
+        f"{selected_landform} - {int(stage_value*100)}%",
+        add_water=True,
+        water_depth_grid=stage_water,
+        water_level=-999,
+        force_camera=False,  # 카메라 이동 허용
+        landform_type=landform_type
+    )
+    st.plotly_chart(fig_stage, use_container_width=True, key="stage_view")
+    
+    # 자동 재생 (세션 상태 활용)
+    col_play, col_step = st.columns(2)
+    with col_play:
+        if st.button("▶️ 자동 재생 시작", key="auto_play"):
+            st.session_state['auto_playing'] = True
+            st.session_state['auto_stage'] = 0.0
+    with col_step:
+        if st.button("⏹️ 정지", key="stop_play"):
+            st.session_state['auto_playing'] = False
+    
+    # 자동 재생 중이면 stage 자동 증가
+    if st.session_state.get('auto_playing', False):
+        current_stage = st.session_state.get('auto_stage', 0.0)
+        if current_stage < 1.0:
+            st.session_state['auto_stage'] = current_stage + 0.1
+            import time
+            time.sleep(0.5)
+            st.rerun()
+        else:
+            st.session_state['auto_playing'] = False
+            st.success("✅ 완료!")
+    
+    st.caption("💡 **Tip:** 카메라 각도를 먼저 조정한 후 자동 재생하면 유지됩니다.")

terrain_processes.html

@@ -0,0 +1,474 @@
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>지형 형성 작용 | Geo Lab</title>
+  <style>
+    @import url("https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@400;600;700&family=Noto+Sans+KR:wght@400;500;700&display=swap");
+
+    :root {
+      --ink: #e7eef9;
+      --muted: #a5b8d4;
+      --panel: #0f1c32;
+      --panel-2: #0c1628;
+      --stroke: #1f2c46;
+      --accent: #f59e0b;
+      --accent-2: #7dd3fc;
+      --accent-3: #34d399;
+      --glow: rgba(126, 200, 255, 0.14);
+    }
+
+    * {
+      box-sizing: border-box;
+    }
+
+    body {
+      margin: 0;
+      min-height: 100vh;
+      font-family: "Noto Sans KR", "Space Grotesk", system-ui, -apple-system, sans-serif;
+      color: var(--ink);
+      background:
+        radial-gradient(circle at 15% 20%, #192742 0%, #0b1220 35%),
+        radial-gradient(circle at 80% 0%, #13233f 0%, transparent 30%),
+        linear-gradient(120deg, #0c1424 0%, #0b1220 70%);
+      overflow-x: hidden;
+    }
+
+    .canvas {
+      position: relative;
+      max-width: 1200px;
+      margin: 0 auto;
+      padding: 48px 22px 64px;
+    }
+
+    .grid-bg {
+      position: fixed;
+      inset: 0;
+      pointer-events: none;
+      background-image:
+        linear-gradient(var(--glow) 1px, transparent 1px),
+        linear-gradient(90deg, var(--glow) 1px, transparent 1px);
+      background-size: 48px 48px;
+      mask-image: radial-gradient(circle at 60% 40%, #000 0%, rgba(0, 0, 0, 0.12) 50%, transparent 70%);
+    }
+
+    header.hero {
+      display: grid;
+      grid-template-columns: 1.2fr 0.8fr;
+      gap: 28px;
+      align-items: end;
+      margin-bottom: 28px;
+    }
+
+    .eyebrow {
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+      padding: 8px 12px;
+      border-radius: 999px;
+      background: rgba(255, 255, 255, 0.05);
+      border: 1px solid var(--stroke);
+      font-size: 13px;
+      letter-spacing: 0.6px;
+      text-transform: uppercase;
+      color: var(--muted);
+    }
+
+    h1 {
+      margin: 10px 0 12px;
+      font-family: "Space Grotesk", "Noto Sans KR", sans-serif;
+      font-size: clamp(30px, 4vw, 42px);
+      letter-spacing: -0.5px;
+    }
+
+    .lede {
+      margin: 0;
+      font-size: 17px;
+      line-height: 1.5;
+      color: var(--muted);
+    }
+
+    .tags {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 10px;
+      margin-top: 16px;
+    }
+
+    .tag {
+      padding: 7px 11px;
+      border-radius: 10px;
+      border: 1px solid var(--stroke);
+      color: var(--ink);
+      background: rgba(255, 255, 255, 0.03);
+      font-size: 13px;
+    }
+
+    .panel {
+      background: linear-gradient(140deg, var(--panel) 0%, var(--panel-2) 100%);
+      border: 1px solid var(--stroke);
+      border-radius: 18px;
+      padding: 20px;
+      position: relative;
+      overflow: hidden;
+    }
+
+    .panel::before {
+      content: "";
+      position: absolute;
+      inset: 0;
+      background: radial-gradient(circle at 20% 20%, rgba(255, 255, 255, 0.04), transparent 35%);
+      pointer-events: none;
+    }
+
+    .panel h3 {
+      margin: 0 0 8px;
+      font-size: 17px;
+      letter-spacing: -0.2px;
+    }
+
+    .panel p {
+      margin: 0;
+      color: var(--muted);
+      line-height: 1.5;
+      font-size: 14px;
+    }
+
+    .stack {
+      display: grid;
+      gap: 14px;
+    }
+
+    .process-grid {
+      display: grid;
+      gap: 16px;
+      grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
+      margin: 18px 0 32px;
+    }
+
+    .pill {
+      display: inline-flex;
+      align-items: center;
+      gap: 7px;
+      padding: 6px 10px;
+      border-radius: 999px;
+      font-size: 12px;
+      color: var(--ink);
+      border: 1px solid var(--stroke);
+      background: rgba(255, 255, 255, 0.03);
+    }
+
+    .pill.accent {
+      background: rgba(245, 158, 11, 0.12);
+      border-color: rgba(245, 158, 11, 0.5);
+      color: #ffd58f;
+    }
+
+    .pill.cool {
+      background: rgba(125, 211, 252, 0.12);
+      border-color: rgba(125, 211, 252, 0.5);
+      color: #c8f1ff;
+    }
+
+    .pill.green {
+      background: rgba(52, 211, 153, 0.12);
+      border-color: rgba(52, 211, 153, 0.5);
+      color: #c1ffe3;
+    }
+
+    .timeline {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+      gap: 14px;
+      margin: 10px 0;
+    }
+
+    .step {
+      border-left: 2px solid var(--stroke);
+      padding-left: 14px;
+      position: relative;
+    }
+
+    .step::before {
+      content: "";
+      position: absolute;
+      width: 9px;
+      height: 9px;
+      border-radius: 50%;
+      background: var(--accent-2);
+      border: 2px solid #081020;
+      left: -6px;
+      top: 6px;
+      box-shadow: 0 0 12px rgba(125, 211, 252, 0.5);
+    }
+
+    .step strong {
+      display: block;
+      margin-bottom: 6px;
+      font-size: 14px;
+      letter-spacing: -0.2px;
+    }
+
+    .legend {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 12px;
+      margin-top: 10px;
+    }
+
+    .legend span {
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+      font-size: 13px;
+      color: var(--muted);
+    }
+
+    .legend b {
+      display: inline-block;
+      width: 12px;
+      height: 12px;
+      border-radius: 4px;
+    }
+
+    .flow {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+      gap: 16px;
+      margin-top: 18px;
+    }
+
+    details {
+      border: 1px solid var(--stroke);
+      border-radius: 14px;
+      padding: 12px 14px;
+      background: rgba(255, 255, 255, 0.02);
+      transition: border-color 150ms ease, background 150ms ease;
+    }
+
+    details[open] {
+      border-color: rgba(125, 211, 252, 0.6);
+      background: rgba(125, 211, 252, 0.04);
+    }
+
+    summary {
+      cursor: pointer;
+      font-weight: 600;
+      font-size: 14px;
+      outline: none;
+    }
+
+    .note {
+      margin: 10px 0 0;
+      color: var(--muted);
+      font-size: 13px;
+      line-height: 1.5;
+    }
+
+    @media (max-width: 900px) {
+      header.hero {
+        grid-template-columns: 1fr;
+      }
+    }
+  </style>
+</head>
+<body>
+  <div class="grid-bg"></div>
+  <div class="canvas">
+    <header class="hero">
+      <div>
+        <div class="eyebrow">Geomorph · Process Map</div>
+        <h1>지형 형성 작용의 흐름을 한눈에</h1>
+        <p class="lede">
+          내적(판구조·화산) 에너지와 외적(기후·중력) 에너지가 상호작용하며 지표를 깎고 쌓고 들어올립니다.
+          주요 단계와 지형 결과를 빠르게 훑어볼 수 있는 요약 HTML입니다.
+        </p>
+        <div class="tags">
+          <div class="tag">내적 에너지: 판구조, 융기, 화산</div>
+          <div class="tag">외적 에너지: 풍화, 중력, 침식·운반·퇴적</div>
+          <div class="tag">시간 스케일: 단발성(사면 붕괴) ⇄ 장기(융기·평준화)</div>
+        </div>
+      </div>
+      <div class="panel stack">
+        <div class="pill accent">핵심 맥락</div>
+        <h3>지형을 만드는 세 힘</h3>
+        <p>
+          1) 지구 내부 에너지(판구조 운동, 마그마)로 지표가 융기·변형된다.
+          2) 기후가 지배하는 풍화·침식·운반·퇴적이 높이를 깎고 메운다.
+          3) 중력은 사면 안정성을 통제하며 돌발적 붕괴로 균형을 재조정한다.
+        </p>
+        <div class="legend">
+          <span><b style="background: var(--accent);"></b> 내적 작용</span>
+          <span><b style="background: var(--accent-2);"></b> 외적 작용</span>
+          <span><b style="background: var(--accent-3);"></b> 결과 지형</span>
+        </div>
+      </div>
+    </header>
+
+    <section class="process-grid">
+      <div class="panel">
+        <div class="pill accent">내적 · 에너지 공급</div>
+        <h3>판구조 운동 & 융기</h3>
+        <p>
+          압축·인장·횡이동에 따라 지각이 접힘·단층·융기하며 고도 대비를 만든다.
+          높은 위치에 놓인 암체는 이후 외적 작용의 표적이 된다.
+        </p>
+      </div>
+      <div class="panel">
+        <div class="pill accent">내적 · 물질 공급</div>
+        <h3>화산 활동 / 관입</h3>
+        <p>
+          마그마 분출·관입으로 새로운 암석이 쌓이고 열변형이 일어난다.
+          용암대지, 순상·복합화산, 화산돔, 응회환 등이 형성된다.
+        </p>
+      </div>
+      <div class="panel">
+        <div class="pill cool">외적 · 재료 약화</div>
+        <h3>풍화 (물리·화학)</h3>
+        <p>
+          동결융해·박리·塩정·탄산·산화 등이 암석을 분쇄/용해해 입도를 줄이고
+          사면을 느슨하게 만들어 침식과 붕괴를 준비한다.
+        </p>
+      </div>
+      <div class="panel">
+        <div class="pill cool">외적 · 중력</div>
+        <h3>사면 붕괴 / 질량 이동</h3>
+        <p>
+          낙석, 사태, 지흘림, 포행 등으로 고도차가 급격히 완만해진다.
+          강우·지진·풍화 심화가 방아쇠 역할을 한다.
+        </p>
+      </div>
+      <div class="panel">
+        <div class="pill cool">외적 · 침식·운반</div>
+        <h3>물 · 바람 · 얼음</h3>
+        <p>
+          하천(수식), 해안(파식), 빙하(설마찰), 사막(풍식)이 재료를 깎고 먼 곳으로 운반한다.
+          소용돌이·난류·빙압이 주요 메커니즘이다.
+        </p>
+      </div>
+      <div class="panel">
+        <div class="pill cool">외적 · 축적</div>
+        <h3>퇴적 & 고결</h3>
+        <p>
+          에너지가 낮아지는 지점(삼각주, 충적선상지, 빙퇴석, 사구, 호안)에 입자가 쌓여
+          층리가 발달하고 시간이 지나면 고결·교결된다.
+        </p>
+      </div>
+    </section>
+
+    <section class="panel">
+      <div class="pill green">단계별 흐름</div>
+      <h3>지형 형성 타임라인</h3>
+      <div class="timeline">
+        <div class="step">
+          <strong>1. 에너지 부여 (내적)</strong>
+          판구조 변형·융기·화산 분출로 고도 대비가 커지고 새로운 암석이 노출된다.
+        </div>
+        <div class="step">
+          <strong>2. 약화 (풍화)</strong>
+          동결융해, 열팽창, 화학 용해가 균열을 넓혀 암체 강도를 낮춘다.
+        </div>
+        <div class="step">
+          <strong>3. 중력 불안정</strong>
+          사면 경사와 지하수 상승이 임계 상태를 만들고 붕괴·활강이 발생한다.
+        </div>
+        <div class="step">
+          <strong>4. 침식 · 운반</strong>
+          하천·빙하·파랑·바람이 입자를 떼어내어 하류나 해안으로 이동시킨다.
+        </div>
+        <div class="step">
+          <strong>5. 퇴적 · 축적</strong>
+          유속/풍속이 감소하는 완사면·곡류 안쪽·하구·호안·빙하 말단에 재료가 쌓인다.
+        </div>
+        <div class="step">
+          <strong>6. 재균형</strong>
+          장기적으로 융기와 침식이 맞물려 평준화가 진행되며, 새로운 융기가 시작되면 주기가 반복된다.
+        </div>
+      </div>
+    </section>
+
+    <section class="flow">
+      <div class="panel stack">
+        <div class="pill accent">내적 작용 → 결과 지형</div>
+        <details>
+          <summary>지각 수축·인장</summary>
+          <p class="note">
+            조산대: 습곡산맥, 충상단층, 습곡 곡정. <br />
+            인장대: 그랩벤(륵), 호르스트, 리프트 계곡. <br />
+            전단대: 사교단층, 편마암 편리 발달.
+          </p>
+        </details>
+        <details>
+          <summary>화산 / 열수 활동</summary>
+          <p class="note">
+            용암대지, 순상·복합·응회화산, 칼데라, 화산돔, 열수 온천 테라스.
+          </p>
+        </details>
+      </div>
+
+      <div class="panel stack">
+        <div class="pill cool">외적 작용 → 결과 지형</div>
+        <details open>
+          <summary>풍화 + 중력</summary>
+          <p class="note">
+            절리 발달 암괴류, 토르, 타프니(차별풍화), 탤러스 사면, 스크리 콘.
+          </p>
+        </details>
+        <details>
+          <summary>하천 · 호수</summary>
+          <p class="note">
+            수식곡, V자곡, 포트홀, 곡류·우각호, 범람원, 하천단구, 삼각주/선상지.
+          </p>
+        </details>
+        <details>
+          <summary>해안</summary>
+          <p class="note">
+            해식애·해식대, 파식대지, 해식동/주상절리 절벽, 시스택·아치,
+            사빈·석호·사취·톰볼로.
+          </p>
+        </details>
+        <details>
+          <summary>빙하</summary>
+          <p class="note">
+            U자곡, 서킷·아레트·혼, 현무암주상 및 로슈무톤네,
+            모레인(종·단·측·퇴석성), 드럼린, 에스커, 케임.
+          </p>
+        </details>
+        <details>
+          <summary>건조 · 풍식</summary>
+          <p class="note">
+            포트홀형 사막포트, 버터말크, 사구(바르한·파라볼릭·스타), 데플레이션 설,
+            벤치형 페데스탈, 메사·뷰트.
+          </p>
+        </details>
+      </div>
+
+      <div class="panel stack">
+        <div class="pill green">변수와 관점</div>
+        <details open>
+          <summary>기후</summary>
+          <p class="note">
+            수분·온도 진폭이 풍화 양식을 결정하고, 몬순/폭우는 사면 파괴와 하천
+            에너지를 증폭시킨다.
+          </p>
+        </details>
+        <details>
+          <summary>암석학</summary>
+          <p class="note">
+            암석 강도·균질성·절리 간격이 침식 저항을 좌우하며 차별침식 지형을 만든다.
+          </p>
+        </details>
+        <details>
+          <summary>시간 스케일</summary>
+          <p class="note">
+            순간: 낙석·사태·화산 분출. <br />
+            수~수만 년: 곡류 발달, 빙하 전진·후퇴. <br />
+            백만 년+: 융기·평준화(페니플레인) 사이클.
+          </p>
+        </details>
+      </div>
+    </section>
+  </div>
+</body>
+</html>