Add 6 new landforms, improve animation, add Overview page

app/pages/1_📖_Gallery.py

@@ -54,6 +54,7 @@ if category == "🌊 하천 지형":
         "🏔️ V자곡 (V-Valley)": "v_valley",
         "🌊 망상하천 (Braided River)": "braided_river",
         "💧 폭포 (Waterfall)": "waterfall",
+        "🚧 천정천 (Perched River)": "perched_river",
     }
 elif category == "🔺 삼각주 유형":
     landform_options = {
@@ -61,6 +62,7 @@ elif category == "🔺 삼각주 유형":
         "🦶 조족상 삼각주 (Bird-foot)": "bird_foot_delta",
         "🌙 호상 삼각주 (Arcuate)": "arcuate_delta",
         "📍 첨두상 삼각주 (Cuspate)": "cuspate_delta",
+        "🌊 에스추어리 (Estuary)": "estuary",
     }
 elif category == "❄️ 빙하 지형":
     landform_options = {
@@ -70,6 +72,7 @@ elif category == "❄️ 빙하 지형":
         "🌊 피오르드 (Fjord)": "fjord",
         "🥚 드럼린 (Drumlin)": "drumlin",
         "🪨 빙퇴석 (Moraine)": "moraine",
+        "🗡️ 아레트 (Arête)": "arete",
     }
 elif category == "🌋 화산 지형":
     landform_options = {
@@ -92,6 +95,9 @@ elif category == "🏜️ 건조 지형":
         "🟰 횡사구 (Transverse Dune)": "transverse_dune",
         "⭐ 성사구 (Star Dune)": "star_dune",
         "🗿 메사/뷰트 (Mesa/Butte)": "mesa_butte",
+        "🏜️ 와디 (Wadi)": "wadi",
+        "🪶 플라야 (Playa)": "playa",
+        "🍄 버섯바위 (Pedestal Rock)": "pedestal_rock",
     }
 else:  # 해안 지형
     landform_options = {

engine/ideal_landforms.py

@@ -2063,7 +2063,281 @@ def create_star_dune(grid_size: int = 100, stage: float = 1.0,
     return elevation
 
 
+# ============================================
+# 추가 확장 지형들 (Additional Expansion)
+# ============================================
+
+def create_perched_river(grid_size: int = 100, stage: float = 1.0):
+    """천정천 (Perched River) - 자연제방 발달로 하상이 주변보다 높음
+    
+    Stage 0~0.5: 범람원 형성 + 자연제방 발달
+    Stage 0.5~1.0: 하상 퇴적으로 주변보다 높아짐 (천정천)
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 범람원 기본 높이
+    base_height = 10.0
+    elevation[:] = base_height
+    
+    # 하천 중심선
+    center = w // 2
+    
+    # 자연제방 발달 (stage에 따라)
+    levee_height = 8.0 * stage
+    levee_width = int(w * 0.15)
+    
+    for c in range(w):
+        dist_from_center = abs(c - center)
+        
+        if dist_from_center < levee_width:
+            # 하상 (하천 바닥) - 주변보다 높아짐
+            if dist_from_center < 5:
+                river_bed_height = base_height + levee_height * 0.8 * stage
+                elevation[:, c] = river_bed_height
+            else:
+                # 자연제방 (제방)
+                decay = 1 - (dist_from_center - 5) / (levee_width - 5)
+                elevation[:, c] = base_height + levee_height * decay * stage
+        else:
+            # 배후습지 (낮은 곳)
+            backswamp_depth = 3.0 * stage
+            elevation[:, c] = base_height - backswamp_depth
+    
+    return elevation
+
+
+def create_arete(grid_size: int = 100, stage: float = 1.0):
+    """아레트 (Arête) - 빙하에 의해 형성된 날카로운 능선
+    
+    두 권곡 사이의 날카로운 능선
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 기본 고산 지형
+    base_height = 100.0
+    elevation[:] = base_height
+    
+    center = w // 2
+    
+    # 양쪽에 권곡 형성
+    cirque_depth = 60.0 * stage
+    cirque_radius = int(w * 0.35)
+    
+    for r in range(h):
+        for c in range(w):
+            # 왼쪽 권곡
+            left_cx = center - int(w * 0.25)
+            left_cy = int(h * 0.5)
+            dist_left = np.sqrt((r - left_cy)**2 + (c - left_cx)**2)
+            
+            # 오른쪽 권곡
+            right_cx = center + int(w * 0.25)
+            right_cy = int(h * 0.5)
+            dist_right = np.sqrt((r - right_cy)**2 + (c - right_cx)**2)
+            
+            if dist_left < cirque_radius:
+                bowl_depth = cirque_depth * (1 - (dist_left / cirque_radius)**2)
+                elevation[r, c] = min(elevation[r, c], base_height - bowl_depth)
+            
+            if dist_right < cirque_radius:
+                bowl_depth = cirque_depth * (1 - (dist_right / cirque_radius)**2)
+                elevation[r, c] = min(elevation[r, c], base_height - bowl_depth)
+    
+    # 중앙 능선 (아레트) 강조
+    ridge_width = 5
+    for c in range(center - ridge_width, center + ridge_width):
+        if 0 <= c < w:
+            sharpness = 1 - abs(c - center) / ridge_width
+            elevation[:, c] = base_height + 10.0 * sharpness * stage
+    
+    return elevation
+
+
+def create_wadi(grid_size: int = 100, stage: float = 1.0):
+    """와디 (Wadi) - 건조지역 일시적 하천 계곡
+    
+    평상시 건조, 우기에만 물이 흐르는 계곡
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 건조 고원
+    base_height = 50.0
+    elevation[:] = base_height
+    
+    # 와디 계곡 생성 (구불구불)
+    center = w // 2
+    valley_depth = 25.0 * stage
+    valley_width = int(w * 0.2)
+    
+    for r in range(h):
+        # 구불구불한 계곡 중심
+        offset = int(15 * np.sin(r * 0.08))
+        valley_center = center + offset
+        
+        for c in range(w):
+            dist = abs(c - valley_center)
+            if dist < valley_width:
+                # V자형 계곡
+                depth = valley_depth * (1 - dist / valley_width)
+                elevation[r, c] = base_height - depth
+    
+    # 모래/자갈 바닥 (평탄)
+    for r in range(h):
+        offset = int(15 * np.sin(r * 0.08))
+        valley_center = center + offset
+        for c in range(valley_center - 3, valley_center + 3):
+            if 0 <= c < w:
+                elevation[r, c] = base_height - valley_depth + 2  # 평탄한 바닥
+    
+    return elevation
+
+
+def create_playa(grid_size: int = 100, stage: float = 1.0):
+    """플라야 (Playa) - 건조 호수 바닥
+    
+    건조지역에서 물이 증발하고 남은 평탄한 호수 바닥
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 분지 지형
+    center_r, center_c = h // 2, w // 2
+    basin_radius = int(min(h, w) * 0.4)
+    
+    for r in range(h):
+        for c in range(w):
+            dist = np.sqrt((r - center_r)**2 + (c - center_c)**2)
+            
+            if dist < basin_radius:
+                # 분지 내부 (플라야)
+                # 매우 평탄한 호수 바닥
+                elevation[r, c] = 10.0 + np.random.uniform(0, 0.5)  # 거의 평탄
+            else:
+                # 분지 외부 (산지)
+                rim_height = 50.0 * (1 - basin_radius / (dist + 1))
+                elevation[r, c] = 30.0 + rim_height * stage
+    
+    # 소금 결정 패턴 (다각형)
+    if stage > 0.7:
+        for i in range(10):
+            poly_r = center_r + np.random.randint(-basin_radius//2, basin_radius//2)
+            poly_c = center_c + np.random.randint(-basin_radius//2, basin_radius//2)
+            poly_size = np.random.randint(5, 15)
+            for dr in range(-poly_size, poly_size):
+                for dc in range(-poly_size, poly_size):
+                    if 0 <= poly_r+dr < h and 0 <= poly_c+dc < w:
+                        if abs(dr) + abs(dc) == poly_size - 1:  # 테두리
+                            elevation[poly_r+dr, poly_c+dc] += 0.3
+    
+    return elevation
+
+
+def create_pedestal_rock(grid_size: int = 100, stage: float = 1.0):
+    """버섯바위 (Pedestal Rock) - 바람에 의한 차별풍화 지형
+    
+    Stage 0~0.3: 원래 암석 기둥
+    Stage 0.3~0.7: 바람에 의한 하부 침식 (연마작용)
+    Stage 0.7~1.0: 버섯 모양 완성 (줄기가 매우 얇아짐)
+    
+    바람에 실려온 모래가 하부를 깎아냄 (지표 가까울수록 모래 농도 높음)
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 사막 평원
+    base_height = 5.0
+    elevation[:] = base_height
+    
+    # 버섯바위 여러 개
+    num_rocks = 3
+    np.random.seed(42)
+    
+    for i in range(num_rocks):
+        # 위치
+        rock_r = np.random.randint(h // 4, 3 * h // 4)
+        rock_c = np.random.randint(w // 4, 3 * w // 4)
+        
+        # 원래 바위 크기 (stage 0에서의 크기)
+        original_radius = np.random.randint(10, 16)
+        rock_height = np.random.uniform(25, 40)
+        
+        # stage에 따른 침식 정도 (stage 높을수록 하부 더 깎임)
+        erosion_factor = stage  # 0~1
+        
+        for r in range(h):
+            for c in range(w):
+                dist = np.sqrt((r - rock_r)**2 + (c - rock_c)**2)
+                
+                if dist < original_radius:
+                    # 바위 내부 - 높이에 따라 반경이 다름
+                    # 상부: 원래 반경 유지
+                    # 하부: stage에 따라 깎임
+                    
+                    # 각 높이에서의 유효 반경 계산
+                    for z_level in range(int(rock_height)):
+                        # 지표에서의 높이 비율 (0=바닥, 1=꼭대기)
+                        height_ratio = z_level / rock_height
+                        
+                        # 하부일수록 바람 침식 심함 (지표 가까울수록)
+                        if height_ratio < 0.5:
+                            # 하부: 침식으로 반경 감소
+                            erosion_at_height = erosion_factor * (1 - height_ratio * 2)  # 바닥에서 최대
+                            current_radius = original_radius * (1 - erosion_at_height * 0.7)
+                        else:
+                            # 상부: 원래 반경 유지 (모자 부분)
+                            current_radius = original_radius
+                        
+                        if dist < current_radius:
+                            elevation[r, c] = max(elevation[r, c], base_height + z_level)
+    
+    return elevation
+
+
+def create_estuary(grid_size: int = 100, stage: float = 1.0):
+    """에스추어리 (Estuary) - 삼각강, 조석 영향
+    
+    조석의 영향을 받는 넓은 하구
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 육지 기본
+    land_height = 20.0
+    elevation[:] = land_height
+    
+    # 에스추어리 (깔때기 모양)
+    apex_row = int(h * 0.1)
+    center = w // 2
+    
+    for r in range(h):
+        # 하류로 갈수록 넓어짐
+        progress = (r - apex_row) / (h - apex_row) if r > apex_row else 0
+        estuary_width = int(5 + 40 * progress * stage)
+        
+        for c in range(w):
+            dist = abs(c - center)
+            
+            if r < apex_row:
+                # 상류 하천 (좁음)
+                if dist < 5:
+                    elevation[r, c] = -5.0
+            elif dist < estuary_width:
+                # 에스추어리 영역
+                depth = 10.0 * (1 - dist / estuary_width) * (0.5 + 0.5 * progress)
+                elevation[r, c] = -depth
+            
+            # 조간대 (tide flat)
+            if dist >= estuary_width - 10 and dist < estuary_width and r > apex_row:
+                elevation[r, c] = max(elevation[r, c], -1.0)  # 조간대 (얕음)
+    
+    return elevation
+
+
 # 애니메이션 생성기 매핑
+
 ANIMATED_LANDFORM_GENERATORS = {
     'delta': create_delta_animated,
     'alluvial_fan': create_alluvial_fan_animated,
@@ -2104,6 +2378,13 @@ ANIMATED_LANDFORM_GENERATORS = {
     'karren': create_karren,
     'transverse_dune': create_transverse_dune,
     'star_dune': create_star_dune,
+    # 추가 확장 지형
+    'perched_river': create_perched_river,
+    'arete': create_arete,
+    'wadi': create_wadi,
+    'playa': create_playa,
+    'pedestal_rock': create_pedestal_rock,
+    'estuary': create_estuary,
 }
 
 # 지형 생성 함수 매핑
@@ -2147,5 +2428,12 @@ IDEAL_LANDFORM_GENERATORS = {
     '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),
+    # 추가 확장 지형
+    'perched_river': lambda gs: create_perched_river(gs, 1.0),
+    'arete': lambda gs: create_arete(gs, 1.0),
+    'wadi': lambda gs: create_wadi(gs, 1.0),
+    'playa': lambda gs: create_playa(gs, 1.0),
+    'pedestal_rock': lambda gs: create_pedestal_rock(gs, 1.0),
+    'estuary': lambda gs: create_estuary(gs, 1.0),
 }
 

pages/1_📖_Gallery.py

@@ -8,25 +8,12 @@ import matplotlib.pyplot as plt
 import sys
 import os
 
-# 상위 디렉토리를 경로에 추가 (HuggingFace 호환)
-root_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-sys.path.insert(0, root_dir)
+# 상위 디렉토리를 경로에 추가
+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__)))))
 
-try:
-    from engine.ideal_landforms import IDEAL_LANDFORM_GENERATORS, ANIMATED_LANDFORM_GENERATORS
-    from renderer import render_terrain_plotly
-    IMPORT_OK = True
-except Exception as e:
-    st.error(f"Import Error: {e}")
-    IMPORT_OK = False
-    IDEAL_LANDFORM_GENERATORS = {}
-    ANIMATED_LANDFORM_GENERATORS = {}
-
-# 세션 상태 초기화 (auto_playing 상태 확인)
-if 'auto_playing' not in st.session_state:
-    st.session_state['auto_playing'] = False
-if 'auto_stage' not in st.session_state:
-    st.session_state['auto_stage'] = 0.0
+from engine.ideal_landforms import IDEAL_LANDFORM_GENERATORS, ANIMATED_LANDFORM_GENERATORS
+from app.main import render_terrain_plotly
 
 st.header("📖 이상적 지형 갤러리")
 st.markdown("_교과서적인 지형 형태를 기하학적 모델로 시각화합니다._")
@@ -67,6 +54,7 @@ if category == "🌊 하천 지형":
         "🏔️ V자곡 (V-Valley)": "v_valley",
         "🌊 망상하천 (Braided River)": "braided_river",
         "💧 폭포 (Waterfall)": "waterfall",
+        "🚧 천정천 (Perched River)": "perched_river",
     }
 elif category == "🔺 삼각주 유형":
     landform_options = {
@@ -74,6 +62,7 @@ elif category == "🔺 삼각주 유형":
         "🦶 조족상 삼각주 (Bird-foot)": "bird_foot_delta",
         "🌙 호상 삼각주 (Arcuate)": "arcuate_delta",
         "📍 첨두상 삼각주 (Cuspate)": "cuspate_delta",
+        "🌊 에스추어리 (Estuary)": "estuary",
     }
 elif category == "❄️ 빙하 지형":
     landform_options = {
@@ -83,6 +72,7 @@ elif category == "❄️ 빙하 지형":
         "🌊 피오르드 (Fjord)": "fjord",
         "🥚 드럼린 (Drumlin)": "drumlin",
         "🪨 빙퇴석 (Moraine)": "moraine",
+        "🗡️ 아레트 (Arête)": "arete",
     }
 elif category == "🌋 화산 지형":
     landform_options = {
@@ -105,6 +95,9 @@ elif category == "🏜️ 건조 지형":
         "🟰 횡사구 (Transverse Dune)": "transverse_dune",
         "⭐ 성사구 (Star Dune)": "star_dune",
         "🗿 메사/뷰트 (Mesa/Butte)": "mesa_butte",
+        "🏜️ 와디 (Wadi)": "wadi",
+        "🪶 플라야 (Playa)": "playa",
+        "🍄 버섯바위 (Pedestal Rock)": "pedestal_rock",
     }
 else:  # 해안 지형
     landform_options = {
@@ -220,14 +213,14 @@ if landform_key in ANIMATED_LANDFORM_GENERATORS:
         stage_value = st.session_state.get('auto_stage', 0.0)
         st.slider(
             "형성 단계 (자동 재생 중...)", 
-            0.0, 1.0, stage_value, 0.05, 
+            0.0, 1.0, stage_value, 0.02, 
             key="gallery_stage_slider",
             disabled=True
         )
     else:
         stage_value = st.slider(
             "형성 단계 (0% = 시작, 100% = 완성)", 
-            0.0, 1.0, 1.0, 0.05, 
+            0.0, 1.0, 1.0, 0.02, 
             key="gallery_stage_slider"
         )
     
@@ -249,50 +242,37 @@ if landform_key in ANIMATED_LANDFORM_GENERATORS:
                     stage_water[r, c] = 3.0
     
     # 3D 렌더링
-    st.write(f"🔍 Debug: stage_elev shape = {stage_elev.shape}, min={stage_elev.min():.1f}, max={stage_elev.max():.1f}")
+    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")
     
-    try:
-        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.write("✅ Debug: render_terrain_plotly 성공!")
-        st.plotly_chart(fig_stage, use_container_width=True, key="stage_view")
-    except Exception as e:
-        st.error(f"❌ Render Error: {e}")
+    # 자동 재생 (세션 상태 활용)
+    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
     
-    # 환경 감지: HuggingFace에서는 SPACE_ID 환경변수�� 있음
-    is_huggingface = os.environ.get('SPACE_ID') is not None
+    # 자동 재생 중이면 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.04
+            import time
+            time.sleep(0.15)
+            st.rerun()
+        else:
+            st.session_state['auto_playing'] = False
+            st.success("✅ 완료!")
     
-    if not is_huggingface:
-        # 로컬 환경: 자동 재생 기능 활성화
-        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
-        
-        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:** 카메라 각도를 먼저 조정한 후 자동 재생하면 유지됩니다.")
-    else:
-        # HuggingFace: 슬라이더만 사용
-        st.caption("💡 **Tip:** 슬라이더를 드래그해서 형성 과정을 확인하세요. 마우스로 3D 회전 가능!")
-
+    st.caption("💡 **Tip:** 카메라 각도를 먼저 조정한 후 자동 재생하면 유지됩니다.")

pages/2_🗺️_Overview.py

@@ -0,0 +1,124 @@
+"""
+🗺️ 카테고리 전체 뷰
+각 카테고리의 모든 지형을 한눈에 비교합니다.
+"""
+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__))))
+
+from engine.ideal_landforms import IDEAL_LANDFORM_GENERATORS
+
+st.set_page_config(layout="wide")
+st.header("🗺️ 카테고리 전체 뷰")
+st.markdown("_각 카테고리의 모든 지형을 한눈에 비교합니다._")
+
+# 카테고리 정의
+CATEGORIES = {
+    "🌊 하천 지형": {
+        "alluvial_fan": "선상지",
+        "free_meander": "자유곡류", 
+        "incised_meander": "감입곡류",
+        "v_valley": "V자곡",
+        "braided_river": "망상하천",
+        "waterfall": "폭포",
+        "perched_river": "천정천",
+    },
+    "🔺 삼각주 유형": {
+        "delta": "일반 삼각주",
+        "bird_foot_delta": "조족상",
+        "arcuate_delta": "호상",
+        "cuspate_delta": "첨두상",
+        "estuary": "에스추어리",
+    },
+    "❄️ 빙하 지형": {
+        "u_valley": "U자곡",
+        "cirque": "권곡",
+        "horn": "호른",
+        "fjord": "피오르드",
+        "drumlin": "드럼린",
+        "moraine": "빙퇴석",
+        "arete": "아레트",
+    },
+    "🌋 화산 지형": {
+        "shield_volcano": "순상화산",
+        "stratovolcano": "성층화산",
+        "caldera": "칼데라",
+        "crater_lake": "화구호",
+        "lava_plateau": "용암대지",
+    },
+    "🦇 카르스트 지형": {
+        "karst_doline": "돌리네",
+        "uvala": "우발라",
+        "tower_karst": "탑카르스트",
+        "karren": "카렌",
+    },
+    "🏜️ 건조 지형": {
+        "barchan": "바르한",
+        "transverse_dune": "횡사구",
+        "star_dune": "성사구",
+        "mesa_butte": "메사/뷰트",
+        "wadi": "와디",
+        "playa": "플라야",
+        "pedestal_rock": "버섯바위",
+    },
+    "🏖️ 해안 지형": {
+        "coastal_cliff": "해안절벽",
+        "spit_lagoon": "사취+석호",
+        "tombolo": "육계사주",
+        "ria_coast": "리아스해안",
+        "sea_arch": "해식아치",
+        "coastal_dune": "해안사구",
+    },
+}
+
+# 카테고리 선택
+category = st.sidebar.selectbox("카테고리 선택", list(CATEGORIES.keys()))
+landforms = CATEGORIES[category]
+
+# 그리드 크기
+grid_size = st.sidebar.slider("해상도", 50, 120, 80)
+
+st.subheader(f"{category} - {len(landforms)}종")
+
+# 컬럼 수 계산
+num_landforms = len(landforms)
+cols_per_row = min(4, num_landforms)
+rows = (num_landforms + cols_per_row - 1) // cols_per_row
+
+# 지형 생성 및 표시
+landform_items = list(landforms.items())
+
+for row_idx in range(rows):
+    cols = st.columns(cols_per_row)
+    for col_idx, col in enumerate(cols):
+        item_idx = row_idx * cols_per_row + col_idx
+        if item_idx < num_landforms:
+            key, name = landform_items[item_idx]
+            
+            with col:
+                st.markdown(f"**{name}**")
+                
+                if key in IDEAL_LANDFORM_GENERATORS:
+                    try:
+                        elevation = IDEAL_LANDFORM_GENERATORS[key](grid_size)
+                        
+                        # 2D 탑뷰 이미지
+                        fig, ax = plt.subplots(figsize=(4, 4))
+                        im = ax.imshow(elevation, cmap='terrain', origin='lower')
+                        ax.set_title(name, fontsize=10)
+                        ax.axis('off')
+                        plt.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
+                        st.pyplot(fig)
+                        plt.close(fig)
+                    except Exception as e:
+                        st.error(f"오류: {e}")
+                else:
+                    st.warning(f"{key} 미구현")
+
+st.markdown("---")
+st.caption("💡 각 지형을 클릭하면 Gallery 페이지에서 3D로 상세하게 볼 수 있습니다.")