import matplotlib.pyplot as plt
import numpy as np
from typing import Tuple, List, Optional, Union

def create_sine_plot(
    x_range: Tuple[float, float] = (0, 10),
    num_points: int = 100,
    color: str = 'b-',
    title: str = '기본 사인 그래프',
    figsize: Tuple[int, int] = (10, 6)
) -> None:
    """사인 함수의 그래프를 생성하고 표시하는 함수
    
    Args:
        x_range: x축 범위 (시작, 끝)
        num_points: 데이터 포인트 수
        color: 선 색상 및 스타일
        title: 그래프 제목
        figsize: 그래프 크기 (가로, 세로) 인치 단위
    """
    # 데이터 생성
    x = np.linspace(x_range[0], x_range[1], num_points)
    y = np.sin(x)

    # 그래프 생성
    plt.figure(figsize=figsize)
    plt.plot(x, y, color, label='sin(x)')
    plt.title(title)
    plt.xlabel('x 축')
    plt.ylabel('y 축')
    plt.legend()
    plt.grid(True)
    plt.show()

# 기본 사용 예시
create_sine_plot()

# 사용자 정의 설정 예시
create_sine_plot(
    x_range=(-5, 5),
    num_points=200,
    color='r--',
    title='사용자 정의 사인 그래프',
    figsize=(12, 8)
)

# 직접 그래프 그리기
x = np.linspace(0, 10, 100)
y = np.sin(x)
y2 = np.cos(x)

plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-', label='sin(x)')
plt.plot(x, y2, 'r--', label='cos(x)')
plt.title('사인과 코사인 그래프')
plt.xlabel('x 축')
plt.ylabel('y 축')
plt.legend()
plt.grid(True)
plt.savefig('sine_cosine.png', dpi=300)  # 고해상도로 저장
plt.show()

import matplotlib.pyplot as plt
import numpy as np
from typing import List, Tuple, Dict, Optional, Union, Any

class PlotGenerator:
    """다양한 그래프 생성을 위한 클래스"""
    
    def __init__(self, style: str = 'default'):
        """초기화 함수
        
        Args:
            style: 적용할 matplotlib 스타일
        """
        if style != 'default':
            plt.style.use(style)
    
    def scatter_plot(
        self,
        x: np.ndarray,
        y: np.ndarray,
        figsize: Tuple[int, int] = (10, 6),
        color: Union[str, np.ndarray] = 'blue',
        alpha: float = 0.5,
        title: str = '산점도',
        save_path: Optional[str] = None
    ) -> None:
        """산점도 그래프 생성
        
        Args:
            x: x 좌표 데이터
            y: y 좌표 데이터
            figsize: 그래프 크기
            color: 점의 색상
            alpha: 투명도 (0~1)
            title: 그래프 제목
            save_path: 저장할 파일 경로
        """
        plt.figure(figsize=figsize)
        plt.scatter(x, y, c=color, alpha=alpha)
        plt.title(title)
        plt.grid(True, linestyle='--', alpha=0.7)
        
        if save_path:
            plt.savefig(save_path, dpi=300, bbox_inches='tight')
        
        plt.show()
    
    def bar_plot(
        self,
        categories: List[str],
        values: List[float],
        figsize: Tuple[int, int] = (8, 6),
        color: Union[str, List[str]] = 'skyblue',
        title: str = '막대 그래프',
        save_path: Optional[str] = None
    ) -> None:
        """막대 그래프 생성
        
        Args:
            categories: 범주 레이블
            values: 각 범주별 값
            figsize: 그래프 크기
            color: 막대 색상
            title: 그래프 제목
            save_path: 저장할 파일 경로
        """
        plt.figure(figsize=figsize)
        bars = plt.bar(categories, values, color=color)
        
        # 막대 위에 값 표시
        for bar in bars:
            height = bar.get_height()
            plt.text(
                bar.get_x() + bar.get_width()/2.,
                height,
                f'{height:.1f}',
                ha='center', va='bottom'
            )
        
        plt.title(title)
        plt.grid(True, axis='y', linestyle='--', alpha=0.7)
        
        if save_path:
            plt.savefig(save_path, dpi=300, bbox_inches='tight')
        
        plt.show()
    
    def histogram(
        self,
        data: np.ndarray,
        bins: int = 30,
        figsize: Tuple[int, int] = (10, 6),
        color: str = 'skyblue',
        title: str = '히스토그램',
        save_path: Optional[str] = None
    ) -> None:
        """히스토그램 생성
        
        Args:
            data: 데이터 배열
            bins: 구간 수
            figsize: 그래프 크기
            color: 히스토그램 색상
            title: 그래프 제목
            save_path: 저장할 파일 경로
        """
        plt.figure(figsize=figsize)
        plt.hist(data, bins=bins, color=color, edgecolor='black', alpha=0.7)
        plt.title(title)
        plt.grid(True, linestyle='--', alpha=0.7)
        plt.xlabel('값')
        plt.ylabel('빈도')
        
        if save_path:
            plt.savefig(save_path, dpi=300, bbox_inches='tight')
        
        plt.show()
    
    def pie_chart(
        self,
        sizes: List[float],
        labels: List[str],
        figsize: Tuple[int, int] = (8, 8),
        colors: Optional[List[str]] = None,
        explode: Optional[List[float]] = None,
        title: str = '파이 차트',
        save_path: Optional[str] = None
    ) -> None:
        """파이 차트 생성
        
        Args:
            sizes: 각 조각의 크기
            labels: 각 조각의 레이블
            figsize: 그래프 크기
            colors: 각 조각의 색상
            explode: 특정 조각을 분리하기 위한 값 (예: [0, 0.1, 0])
            title: 그래프 제목
            save_path: 저장할 파일 경로
        """
        plt.figure(figsize=figsize)
        plt.pie(
            sizes, 
            labels=labels, 
            colors=colors,
            explode=explode,
            autopct='%1.1f%%',
            shadow=True,
            startangle=90
        )
        plt.axis('equal')  # 원형 유지
        plt.title(title)
        
        if save_path:
            plt.savefig(save_path, dpi=300, bbox_inches='tight')
        
        plt.show()

# 사용 예시
plot_gen = PlotGenerator(style='seaborn-v0_8-whitegrid')

# 산점도 예시
x = np.random.randn(100)
y = np.random.randn(100)
plot_gen.scatter_plot(x, y, title='랜덤 분포 산점도')

# 막대 그래프 예시
categories = ['A', 'B', 'C', 'D']
values = [4, 7, 2, 5]
plot_gen.bar_plot(categories, values, color=['red', 'green', 'blue', 'orange'])

# 히스토그램 예시
data = np.random.normal(0, 1, 1000)
plot_gen.histogram(data, bins=30, title='정규 분포 히스토그램')

# 파이 차트 예시
sizes = [35, 30, 20, 15]
labels = ['A', 'B', 'C', 'D']
explode = [0, 0.1, 0, 0]  # B 조각만 분리
plot_gen.pie_chart(sizes, labels, explode=explode, title='카테고리 분포')

import matplotlib.pyplot as plt
import numpy as np
from typing import Optional, Tuple, List, Dict, Any
import matplotlib.cm as cm

def apply_style_demo(style_name: str = 'default') -> None:
    """다양한 스타일 적용 데모
    
    Args:
        style_name: 적용할 matplotlib 스타일
    """
    if style_name != 'default':
        plt.style.use(style_name)
    
    # 데이터 생성
    x = np.linspace(0, 10, 100)
    y1 = np.sin(x)
    y2 = np.cos(x)
    
    # 그래프 생성
    fig, ax = plt.subplots(figsize=(10, 6))
    ax.plot(x, y1, label='sin(x)')
    ax.plot(x, y2, label='cos(x)')
    ax.set_title(f'스타일: {style_name}')
    ax.set_xlabel('x 축')
    ax.set_ylabel('y 축')
    ax.legend()
    ax.grid(True)
    plt.show()

# 컬러맵 데모 함수
def colormap_demo(cmap_name: str = 'viridis') -> None:
    """다양한 컬러맵 사용 데모
    
    Args:
        cmap_name: 사용할 컬러맵 이름
    """
    # 데이터 생성
    x = np.random.randn(1000)
    y = np.random.randn(1000)
    colors = np.random.rand(1000)
    
    fig, ax = plt.subplots(figsize=(10, 6))
    scatter = ax.scatter(x, y, c=colors, cmap=cmap_name, s=50, alpha=0.7)
    
    # 컬러바 추가
    cbar = plt.colorbar(scatter)
    cbar.set_label('값')
    
    ax.set_title(f'컬러맵: {cmap_name}')
    ax.set_xlabel('X')
    ax.set_ylabel('Y')
    ax.grid(True, linestyle='--', alpha=0.7)
    plt.show()

# 사용 가능한 스타일 출력
available_styles = plt.style.available
print(f"사용 가능한 스타일: {len(available_styles)}개")
print(available_styles[:5])  # 처음 5개만 출력

# 몇 가지 스타일 데모
for style in ['default', 'seaborn-v0_8-darkgrid', 'ggplot', 'bmh']:
    apply_style_demo(style)

# 컬러맵 데모
for cmap in ['viridis', 'plasma', 'inferno', 'cividis', 'coolwarm']:
    colormap_demo(cmap)

# 사용자 정의 색상 팔레트
x = np.linspace(0, 10, 100)
fig, ax = plt.subplots(figsize=(10, 6))

# 사용자 정의 색상 설정
colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd']
for i, alpha in enumerate([0.2, 0.4, 0.6, 0.8, 1.0]):
    ax.plot(x, np.sin(x + i*0.5), color=colors[i], 
            linewidth=2, alpha=alpha, 
            label=f'sin(x + {i*0.5:.1f})')

ax.set_title('사용자 정의 색상 팔레트')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.legend()
ax.grid(True)
plt.show()

import matplotlib.pyplot as plt
import numpy as np
from typing import Tuple, List, Dict, Optional, Union
import matplotlib.gridspec as gridspec

class MultiplotManager:
    """여러 그래프를 효과적으로 관리하는 클래스"""
    
    def __init__(self, style: str = 'default'):
        """초기화 함수
        
        Args:
            style: 적용할 matplotlib 스타일
        """
        if style != 'default':
            plt.style.use(style)
    
    def create_basic_grid(
        self,
        rows: int,
        cols: int,
        figsize: Tuple[int, int] = (12, 10),
        title: Optional[str] = None
    ) -> Tuple[plt.Figure, np.ndarray]:
        """기본 그리드 레이아웃 생성
        
        Args:
            rows: 행 수
            cols: 열 수
            figsize: 전체 그림 크기
            title: 전체 그림 제목
            
        Returns:
            튜플(Figure, Axes 배열)
        """
        fig, axes = plt.subplots(rows, cols, figsize=figsize)
        
        if title:
            fig.suptitle(title, fontsize=16)
        
        # 단일 Axes인 경우 배열로 변환
        if rows == 1 and cols == 1:
            axes = np.array([[axes]])
        elif rows == 1:
            axes = axes.reshape(1, cols)
        elif cols == 1:
            axes = axes.reshape(rows, 1)
        
        return fig, axes
    
    def create_complex_grid(
        self,
        layout: List[Dict[str, Union[int, Tuple[int, int, int, int]]]],
        figsize: Tuple[int, int] = (12, 10),
        title: Optional[str] = None
    ) -> Tuple[plt.Figure, Dict[str, plt.Axes]]:
        """복잡한 그리드 레이아웃 생성
        
        Args:
            layout: 레이아웃 정의 (각 요소는 name과 position을 포함)
            figsize: 전체 그림 크기
            title: 전체 그림 제목
            
        Returns:
            튜플(Figure, 이름-Axes 사전)
        """
        fig = plt.figure(figsize=figsize)
        if title:
            fig.suptitle(title, fontsize=16)
        
        gs = gridspec.GridSpec(12, 12)  # 12x12 그리드 사용
        axes_dict = {}
        
        for item in layout:
            name = item['name']
            pos = item['position']  # (row_start, row_end, col_start, col_end)
            
            axes_dict[name] = fig.add_subplot(
                gs[pos[0]:pos[1], pos[2]:pos[3]]
            )
        
        return fig, axes_dict
    
    def example_basic_grid(self) -> None:
        """기본 그리드 예시"""
        # 데이터 준비
        x = np.linspace(0, 10, 100)
        categories = ['A', 'B', 'C', 'D']
        values = [4, 7, 2, 5]
        random_data = np.random.randn(1000)
        
        # 2x2 그리드 생성
        fig, axes = self.create_basic_grid(2, 2, title="기본 서브플롯 그리드")
        
        # 첫 번째 그래프: 선 그래프
        axes[0, 0].plot(x, np.sin(x))
        axes[0, 0].set_title('사인 함수')
        axes[0, 0].grid(True)
        
        # 두 번째 그래프: 산점도
        scatter_x = np.random.randn(30)
        scatter_y = np.random.randn(30)
        axes[0, 1].scatter(scatter_x, scatter_y)
        axes[0, 1].set_title('산점도')
        axes[0, 1].grid(True)
        
        # 세 번째 그래프: 막대 그래프
        axes[1, 0].bar(categories, values)
        axes[1, 0].set_title('막대 그래프')
        
        # 네 번째 그래프: 히스토그램
        axes[1, 1].hist(random_data, bins=30)
        axes[1, 1].set_title('히스토그램')
        
        plt.tight_layout()
        plt.show()
    
    def example_complex_grid(self) -> None:
        """복잡한 그리드 예시"""
        # 레이아웃 정의
        layout = [
            {'name': 'main', 'position': (0, 8, 0, 8)},  # 큰 메인 플롯
            {'name': 'right_top', 'position': (0, 4, 8, 12)},  # 오른쪽 상단
            {'name': 'right_bottom', 'position': (4, 8, 8, 12)},  # 오른쪽 하단
            {'name': 'bottom', 'position': (8, 12, 0, 12)}  # 하단 전체
        ]
        
        fig, axes = self.create_complex_grid(layout, title="복잡한 레이아웃 예시")
        
        # 데이터 준비
        x = np.linspace(0, 10, 100)
        t = np.linspace(0, 1, 100)
        
        # 메인 플롯: 2D 컬러맵
        X, Y = np.meshgrid(x, x)
        Z = np.sin(X) * np.cos(Y)
        main = axes['main'].contourf(X, Y, Z, cmap='viridis')
        axes['main'].set_title('2D 컬러맵')
        plt.colorbar(main, ax=axes['main'])
        
        # 오른쪽 상단: 선 그래프
        axes['right_top'].plot(x, np.sin(x), 'r-')
        axes['right_top'].set_title('사인 함수')
        
        # 오른쪽 하단: 산점도
        scatter_x = np.random.randn(50)
        scatter_y = np.random.randn(50)
        axes['right_bottom'].scatter(scatter_x, scatter_y)
        axes['right_bottom'].set_title('산점도')
        
        # 하단: 여러 선 그래프
        for i, freq in enumerate([1, 2, 3, 4]):
            axes['bottom'].plot(t, np.sin(2*np.pi*freq*t), 
                             label=f'f={freq} Hz')
        axes['bottom'].set_title('다양한 주파수')
        axes['bottom'].legend()
        
        plt.tight_layout()
        plt.show()

# 사용 예시
manager = MultiplotManager(style='seaborn-v0_8-whitegrid')
manager.example_basic_grid()
manager.example_complex_grid()

import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.animation import FuncAnimation
import matplotlib.patches as patches
from typing import Tuple, List, Dict, Optional, Callable, Any, Union

class AdvancedPlotting:
    """Matplotlib의 고급 기능을 활용하는 클래스"""
    
    def plot_3d_surface(
        self,
        x_range: Tuple[float, float] = (-5, 5),
        y_range: Tuple[float, float] = (-5, 5),
        grid_size: int = 100,
        func: Callable[[np.ndarray, np.ndarray], np.ndarray] = None,
        cmap: str = 'viridis',
        figsize: Tuple[int, int] = (10, 7),
        view_angle: Tuple[float, float] = (30, 45)
    ) -> None:
        """3D 표면 플롯 생성
        
        Args:
            x_range: x축 범위
            y_range: y축 범위
            grid_size: 그리드 크기
            func: 표면을 정의하는 함수, 기본값은 sin(sqrt(x^2+y^2))
            cmap: 컬러맵
            figsize: 그래프 크기
            view_angle: 시야각 (elevation, azimuth)
        """
        if func is None:
            func = lambda x, y: np.sin(np.sqrt(x**2 + y**2))
        
        # 데이터 생성
        x = np.linspace(x_range[0], x_range[1], grid_size)
        y = np.linspace(y_range[0], y_range[1], grid_size)
        X, Y = np.meshgrid(x, y)
        Z = func(X, Y)
        
        # 3D 플롯 생성
        fig = plt.figure(figsize=figsize)
        ax = fig.add_subplot(111, projection='3d')
        
        # 서피스 플롯
        surface = ax.plot_surface(X, Y, Z, cmap=cmap, 
                                 edgecolor='none', alpha=0.8)
        
        # 등고선 추가
        ax.contour(X, Y, Z, zdir='z', offset=Z.min(), cmap='coolwarm')
        
        # 시야각 설정
        ax.view_init(elev=view_angle[0], azim=view_angle[1])
        
        # 제목과 레이블
        ax.set_title('3D 표면 플롯', fontsize=14)
        ax.set_xlabel('X')
        ax.set_ylabel('Y')
        ax.set_zlabel('Z')
        
        # 컬러바 추가
        fig.colorbar(surface, ax=ax, shrink=0.5, aspect=5)
        
        plt.show()
    
    def create_animation(
        self,
        frames: int = 100,
        interval: int = 50,
        figsize: Tuple[int, int] = (8, 6),
        save_path: Optional[str] = None
    ) -> None:
        """애니메이션 생성
        
        Args:
            frames: 프레임 수
            interval: 프레임 간 간격(밀리초)
            figsize: 그래프 크기
            save_path: 저장 경로
        """
        fig, ax = plt.subplots(figsize=figsize)
        ax.set_xlim(0, 2*np.pi)
        ax.set_ylim(-1.5, 1.5)
        
        line, = ax.plot([], [], lw=2)
        ax.grid(True)
        
        # 초기화 함수
        def init():
            line.set_data([], [])
            return line,
        
        # 애니메이션 프레임 업데이트 함수
        def animate(i):
            x = np.linspace(0, 2*np.pi, 1000)
            phase = 2*np.pi * i / frames
            y = np.sin(x + phase)
            line.set_data(x, y)
            ax.set_title(f'사인 파동 (위상: {phase:.2f} 라디안)')
            return line,
        
        # 애니메이션 생성
        anim = FuncAnimation(fig, animate, init_func=init,
                            frames=frames, interval=interval, blit=True)
        
        # 저장
        if save_path:
            anim.save(save_path, writer='pillow', fps=30)
        
        plt.show()
    
    def custom_plot_with_annotations(
        self,
        figsize: Tuple[int, int] = (10, 6)
    ) -> None:
        """주석과 사용자 정의 요소가 있는 플롯
        
        Args:
            figsize: 그래프 크기
        """
        fig, ax = plt.subplots(figsize=figsize)
        
        # 데이터 생성
        x = np.linspace(0, 10, 100)
        y = np.sin(x)
        
        # 기본 플롯
        ax.plot(x, y, 'b-', lw=2)
        
        # 특정 지점 강조
        max_point_idx = np.argmax(y)
        min_point_idx = np.argmin(y)
        
        # 특정 지점에 마커 추가
        ax.plot(x[max_point_idx], y[max_point_idx], 'ro', ms=10)
        ax.plot(x[min_point_idx], y[min_point_idx], 'go', ms=10)
        
        # 텍스트 주석 추가
        ax.annotate('최대값', xy=(x[max_point_idx], y[max_point_idx]),
                  xytext=(x[max_point_idx]+0.5, y[max_point_idx]+0.3),
                  arrowprops=dict(facecolor='red', shrink=0.05))
        
        ax.annotate('최소값', xy=(x[min_point_idx], y[min_point_idx]),
                  xytext=(x[min_point_idx]+0.5, y[min_point_idx]-0.3),
                  arrowprops=dict(facecolor='green', shrink=0.05))
        
        # 영역 강조
        ax.axvspan(2, 4, alpha=0.2, color='yellow')
        
        # 사용자 정의 패치 추가
        rect = patches.Rectangle((7, 0.5), 2, 0.4, linewidth=1, 
                                edgecolor='r', facecolor='lightblue', alpha=0.5)
        ax.add_patch(rect)
        ax.text(8, 0.7, '관심 영역', ha='center')
        
        # 제목과 레이블
        ax.set_title('주석이 있는 그래프', fontsize=14)
        ax.set_xlabel('X')
        ax.set_ylabel('Y')
        ax.grid(True, linestyle='--', alpha=0.7)
        
        plt.tight_layout()
        plt.show()

# 사용 예시
advanced = AdvancedPlotting()

# 3D 표면 플롯
advanced.plot_3d_surface()

# 다른 함수로 3D 플롯
advanced.plot_3d_surface(
    func=lambda x, y: np.cos(x) * np.sin(y),
    cmap='plasma',
    view_angle=(40, 30)
)

# 애니메이션
advanced.create_animation(save_path='wave_animation.gif')

# 주석이 있는 플롯
advanced.custom_plot_with_annotations()