플러터닷(Flutter.Dart)

[파이썬] 초등학교 교가 동영상 만들기 코드

FDG — Tue, 30 Jun 2026 21:07:00 +0900

사진 폴더, 교가 mp3, 타이틀화면, 유지시간, 해상도, 가사 캡션 입력할 수 있다.

클로드에 요청해서 만든 코드.

"""
photo_to_mp4.py  (moviepy 2.x 호환 / 타이틀 + 자막 오버레이 + 전환효과)
========================================================================
사용법 (파워셀):
python .\photo_to_mp4.py `
    --folder ".\사진들\사용" `
    --audio ".\교가1절.mp3" `
    --output "교가1절_26년_1920x1080.mp4" `
    --title ".\처음화면_16vs9_text2.jpg" `
    --title-duration 14 `
    --width 1920 `
    --height 1080 `
    --caption "15,8,40,가사" `
    --caption "24,8,40,가사" `
    --caption "32.5,9.5,40,가사" `
    --caption "42,9,40,가사" `
    --caption "51,8,40,가사" `
    --caption "59,8,40,가사"

자막 형식: 시작초,지속초,하단여백px,텍스트

의존 패키지:
    pip install moviepy pillow mutagen numpy pydub
"""

import argparse
import os
import random
import sys
from pathlib import Path

import numpy as np

# ── moviepy import (2.x / 1.x 자동 감지) ────────────────────────────────────
try:
    from moviepy import ImageClip, AudioFileClip, concatenate_videoclips, CompositeVideoClip, VideoClip
    MOVIEPY_V2 = True
except ImportError:
    try:
        from moviepy.editor import ImageClip, AudioFileClip, concatenate_videoclips, CompositeVideoClip, VideoClip
        MOVIEPY_V2 = False
    except ImportError:
        print("❌ moviepy 가 없습니다.  pip install moviepy  후 다시 실행하세요.")
        sys.exit(1)

try:
    from PIL import Image, ImageDraw, ImageFont
except ImportError:
    print("❌ Pillow 가 없습니다.  pip install pillow  후 다시 실행하세요.")
    sys.exit(1)

try:
    from mutagen import File as MutagenFile
except ImportError:
    print("❌ mutagen 이 없습니다.  pip install mutagen  후 다시 실행하세요.")
    sys.exit(1)


# ── 상수 ─────────────────────────────────────────────────────────────────────
IMAGE_EXTS          = {".jpg", ".jpeg", ".png", ".bmp", ".gif", ".tiff", ".webp"}
TRANSITION_DURATION = 1    # crossfade 전환 길이 (초)
CAPTION_FONT_SIZE   = 36*2
CAPTION_BG_ALPHA    = 160    # 자막 배경 투명도 (0=완전투명, 255=불투명)
CAPTION_PAD         = 12     # 자막 박스 내부 패딩 (px)


# ─────────────────────────────────────────────────────────────────────────────
# 유틸
# ─────────────────────────────────────────────────────────────────────────────

def get_audio_duration(audio_path: str) -> float:
    audio = MutagenFile(audio_path)
    if audio is None or not hasattr(audio, "info"):
        raise ValueError(f"오디오 파일을 읽을 수 없습니다: {audio_path}")
    return float(audio.info.length)

def collect_subfolders(root: str) -> list:
    root_path = Path(root)
    folders = []
    for dirpath, dirnames, filenames in os.walk(root_path):
        dirnames.sort()
        if any(Path(f).suffix.lower() in IMAGE_EXTS for f in filenames):
            folders.append(Path(dirpath))
    return folders

def pick_all_images_from_folders(folders: list) -> list:
    """각 폴더의 모든 이미지를 수집합니다. shuffle=True 이면 랜덤 순서로 반환합니다."""
    all_images = []
    for folder in folders:
        images = sorted(p for p in folder.iterdir()
                        if p.is_file() and p.suffix.lower() in IMAGE_EXTS)
        all_images.extend(images)

    return all_images

def find_font(size: int):
    candidates = [
        "C:/Windows/Fonts/malgun.ttf",
        "C:/Windows/Fonts/malgunbd.ttf",
        "C:/Windows/Fonts/gulim.ttc",
        "C:/Windows/Fonts/batang.ttc",
        "/System/Library/Fonts/AppleSDGothicNeo.ttc",
        "/Library/Fonts/AppleGothic.ttf",
        "/usr/share/fonts/truetype/nanum/NanumGothic.ttf",
        "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
    ]
    for path in candidates:
        if os.path.exists(path):
            try:
                return ImageFont.truetype(path, size)
            except Exception:
                continue
    return ImageFont.load_default()

def prepare_image(img_path: Path, target_size: tuple, tmp_dir: Path, suffix: str = "") -> Path:
    """이미지를 target_size 캔버스에 중앙 배치 후 임시 JPEG로 저장합니다."""
    with open(img_path, "rb") as f:
        raw = Image.open(f)
        raw.load()
        im = raw.copy()

    im = im.convert("RGB")
    im.thumbnail(target_size, Image.LANCZOS)
    canvas = Image.new("RGB", target_size, (0, 0, 0))
    offset = ((target_size[0] - im.width) // 2,
              (target_size[1] - im.height) // 2)
    canvas.paste(im, offset)
    name = f"__tmp_{img_path.stem}_{img_path.parent.name}{suffix}.jpg"
    tmp_path = tmp_dir / name
    canvas.save(tmp_path, "JPEG", quality=95)
    return tmp_path


# ─────────────────────────────────────────────────────────────────────────────
# 자막 오버레이 (RGB + alpha 마스크 분리 방식)
# ─────────────────────────────────────────────────────────────────────────────

def render_caption_rgba(text: str, target_size: tuple, bottom_margin: int) -> np.ndarray:
    """자막을 RGBA numpy 배열로 렌더링합니다 (중앙 정렬, 하단 여백 지정)."""
    W, H = target_size
    font = find_font(CAPTION_FONT_SIZE)

    # 텍스트 크기 측정
    dummy = Image.new("RGBA", (1, 1))
    draw  = ImageDraw.Draw(dummy)
    bbox  = draw.textbbox((0, 0), text, font=font)
    tw = bbox[2] - bbox[0]
    th = bbox[3] - bbox[1]

    pad = CAPTION_PAD
    bw  = tw + pad * 2
    bh  = th + pad * 2

    # 수평 중앙, 하단에서 bottom_margin px 위
    bx = (W - bw) // 2
    by = H - bh - bottom_margin

    overlay = Image.new("RGBA", (W, H), (0, 0, 0, 0))
    draw    = ImageDraw.Draw(overlay)
    draw.rounded_rectangle(
        [bx, by, bx + bw, by + bh],
        radius=8,
        fill=(0, 0, 0, CAPTION_BG_ALPHA),
    )
    draw.text(
        (bx + pad - bbox[0], by + pad - bbox[1]),
        text,
        font=font,
        fill=(255, 255, 255, 255),
    )
    return np.array(overlay)  # shape: (H, W, 4)

def make_caption_clip(text: str, duration: float, start: float,
                      target_size: tuple, bottom_margin: int = 40):
    """
    자막을 동영상 위에 올릴 RGB VideoClip으로 생성합니다.
    배경은 투명(검정 0,0,0)이고 마스크로 알파를 전달하여
    CompositeVideoClip에서 올바르게 overlay됩니다.
    """
    rgba = render_caption_rgba(text, target_size, bottom_margin)
    rgb_arr   = rgba[..., :3].astype(np.uint8)          # (H,W,3)
    alpha_arr = (rgba[..., 3] / 255.0).astype(np.float32)  # (H,W) 0~1

    FADE = 0.3  # 등장/퇴장 페이드 시간

    def make_rgb_frame(t):
        return rgb_arr

    def make_mask_frame(t):
        scale = 1.0
        if t < FADE:
            scale = t / FADE
        elif t > duration - FADE:
            scale = max(0.0, (duration - t) / FADE)
        return (alpha_arr * scale)   # (H,W) float 0~1, moviepy mask 형식

    # RGB 클립
    rgb_clip = VideoClip(make_rgb_frame, duration=duration)

    # 마스크 클립 (is_mask=True → 0~1 float 단채널)
    mask_clip = VideoClip(make_mask_frame, duration=duration, is_mask=True)

    caption_clip = rgb_clip.with_mask(mask_clip) if MOVIEPY_V2 else rgb_clip.set_mask(mask_clip)
    caption_clip = caption_clip.with_start(start) if MOVIEPY_V2 else caption_clip.set_start(start)
    return caption_clip


# ─────────────────────────────────────────────────────────────────────────────
# CrossFade (numpy 기반 fade-in / fade-out)
# ─────────────────────────────────────────────────────────────────────────────


def apply_crossfade(clips: list, transition: float):
    """
    클립 사이를 진짜 dissolve로 연결합니다.
    각 클립은 독립적으로 배치하지 않고,
    전환 구간에서 앞/뒤 프레임을 numpy로 직접 weighted blend합니다.
    결과는 단일 VideoClip 하나로 반환됩니다.
    """
    if len(clips) == 0:
        return [], 0.0
 
    # 각 클립의 시작/종료 시간 계산 (겹침 없이 순수 표시 시간 기준)
    # 실제 타임라인상 시작점
    starts = []
    t = 0.0
    for i, clip in enumerate(clips):
        starts.append(t)
        t += clip.duration - (transition if i < len(clips) - 1 else 0)
    total_duration = t
 
    def make_frame(current_t):
        # current_t 가 속하는 클립 찾기
        # 전환 구간이면 두 클립을 blend
        frame = None
        for i, clip in enumerate(clips):
            clip_start = starts[i]
            clip_end   = clip_start + clip.duration
 
            # 이 클립의 로컬 시간
            local_t = current_t - clip_start
 
            if local_t < 0 or local_t > clip.duration:
                continue
 
            # 이 클립에서의 프레임
            local_t_clamped = min(max(local_t, 0), clip.duration - 1/30)
            try:
                f = clip.get_frame(local_t_clamped).astype(float)
            except Exception:
                continue
 
            # 전환 구간 alpha 계산
            # 뒤쪽 전환: 클립 끝 transition초
            if i < len(clips) - 1 and local_t > clip.duration - transition:
                progress = (local_t - (clip.duration - transition)) / transition  # 0→1
                alpha = 1.0 - progress
            # 앞쪽 전환: 클립 시작 transition초
            elif i > 0 and local_t < transition:
                progress = local_t / transition  # 0→1
                alpha = progress
            else:
                alpha = 1.0
 
            if frame is None:
                frame = f * alpha
            else:
                frame = frame + f * alpha
 
        if frame is None:
            # 혹시 빈 구간이면 검정
            h, w = clips[0].size[1], clips[0].size[0]
            return np.zeros((h, w, 3), dtype=np.uint8)
 
        return frame.clip(0, 255).astype(np.uint8)
 
    if MOVIEPY_V2:
        result_clip = VideoClip(make_frame, duration=total_duration)
    else:
        result_clip = VideoClip(make_frame, duration=total_duration)
 
    return [result_clip], total_duration
 
# ─────────────────────────────────────────────────────────────────────────────
# 헬퍼
# ─────────────────────────────────────────────────────────────────────────────

def set_duration(clip, dur):
    return clip.with_duration(dur) if MOVIEPY_V2 else clip.set_duration(dur)

def set_audio(clip, audio):
    return clip.with_audio(audio) if MOVIEPY_V2 else clip.set_audio(audio)


# ─────────────────────────────────────────────────────────────────────────────
# 핵심 빌드
# ─────────────────────────────────────────────────────────────────────────────

def build_video(image_paths: list,
                audio_path: str,
                output_path: str,
                captions: list,           # [(start_sec, dur_sec, bottom_margin, text), ...]
                title_path=None,
                title_duration: float = 5.0,
                fps: int = 24,
                target_size: tuple = (1280, 720)) -> None:

    if not image_paths and not title_path:
        raise ValueError("선택된 이미지가 없습니다.")

    T           = TRANSITION_DURATION
    total_audio = get_audio_duration(audio_path)

    # 타이틀 시간을 제외한 나머지를 일반 사진에 균등 배분
    if title_path:
        body_audio = max(total_audio - title_duration + T, 0)
    else:
        body_audio = total_audio

    n = len(image_paths)
    if n > 1:
        duration_each = (body_audio + (n - 1) * T) / n
    elif n == 1:
        duration_each = body_audio
    else:
        duration_each = 0

    print(f"  일반 사진 수   : {n}")
    print(f"  오디오 총 길이 : {total_audio:.2f} 초")
    if title_path:
        print(f"  타이틀 이미지  : {title_path}  ({title_duration:.1f}초)")
    print(f"⏱️  사진당 시간    : {duration_each:.2f} 초")
    if captions:
        print(f"  자막 수        : {len(captions)}")

    tmp_dir = Path(output_path).parent / "__tmp_frames"
    tmp_dir.mkdir(exist_ok=True)
    tmp_files = []

    try:
        all_clips = []

        # ── 타이틀 클립 ─────────────────────────────────────────────────────
        if title_path:
            print(f"\n  타이틀 이미지 처리 중: {title_path}")
            t_tmp = prepare_image(Path(title_path), target_size, tmp_dir, suffix="_title")
            tmp_files.append(t_tmp)
            all_clips.append(ImageClip(str(t_tmp), duration=title_duration))

        # ── 일반 이미지 클립 ─────────────────────────────────────────────────
        if n > 0:
            print(f"\n ️  이미지 클립 생성 중...")
            for i, img_path in enumerate(image_paths, 1):
                print(f"  [{i}/{n}] {img_path.name}")
                tmp_path = prepare_image(img_path, target_size, tmp_dir)
                tmp_files.append(tmp_path)
                all_clips.append(ImageClip(str(tmp_path), duration=duration_each))

        # ── CrossFade 배치 ──────────────────────────────────────────────────
        print("\n  전환 효과 적용 중...")
        positioned, _ = apply_crossfade(all_clips, T)

        base_video = CompositeVideoClip(positioned, size=target_size)
        base_video = set_duration(base_video, total_audio)

        # ── 자막 오버레이 ───────────────────────────────────────────────────
        layers = [base_video]
        if captions:
            print("\n  자막 생성 중...")
            for (start_sec, dur_sec, bottom_margin, text) in captions:
                if start_sec >= total_audio:
                    print(f"  ⚠️  [{start_sec}s] 영상 길이 초과 → 건너뜀: {text}")
                    continue
                actual_dur = min(dur_sec, total_audio - start_sec)
                print(f"  [{start_sec:.1f}s ~ {start_sec+actual_dur:.1f}s]  margin={bottom_margin}px  {text}")
                layers.append(
                    make_caption_clip(text, actual_dur, start_sec, target_size, bottom_margin)
                )

        final_video = CompositeVideoClip(layers, size=target_size) if len(layers) > 1 else base_video
        final_video = set_duration(final_video, total_audio)

        # ── 오디오 ─────────────────────────────────────────────────────────
        print("\n  오디오 합치는 중...")
        audio = AudioFileClip(audio_path)
        try:
            audio = audio.subclipped(0, total_audio)
        except AttributeError:
            audio = audio.subclip(0, total_audio)
        final_video = set_audio(final_video, audio)

        # ── MP4 저장 ────────────────────────────────────────────────────────
        print(f"\n  MP4 저장 중: {output_path}")
        final_video.write_videofile(
            output_path,
            fps=fps,
            codec="libx264",
            audio_codec="aac",
            logger="bar",
        )
        print(f"\n✅ 완료! → {output_path}")

    finally:
        for tmp in tmp_files:
            if Path(tmp).exists():
                Path(tmp).unlink()
        try:
            tmp_dir.rmdir()
        except OSError:
            pass


# ─────────────────────────────────────────────────────────────────────────────
# CLI
# ─────────────────────────────────────────────────────────────────────────────

def parse_caption(s: str):
    """'시작초,지속초,하단여백px,텍스트' 또는 '시작초,지속초,텍스트' 형식 파싱."""
    parts = s.split(",", 3)
    if len(parts) == 4:
        try:
            start  = float(parts[0])
            dur    = float(parts[1])
            margin = int(parts[2])
            text   = parts[3]
        except ValueError:
            raise argparse.ArgumentTypeError(f"자막 형식 오류: '{s}'")
    elif len(parts) == 3:
        try:
            start  = float(parts[0])
            dur    = float(parts[1])
            margin = 40
            text   = parts[2]
        except ValueError:
            raise argparse.ArgumentTypeError(f"자막 형식 오류: '{s}'")
    else:
        raise argparse.ArgumentTypeError(
            f"자막 형식 오류: '{s}'  →  올바른 형식: 시작초,지속초,하단여백px,텍스트"
        )
    return (start, dur, margin, text)


def main():
    parser = argparse.ArgumentParser(
        description="하위 폴더 사진 랜덤 1장씩 + 타이틀 + WMA → 전환효과·자막 오버레이 MP4",
        formatter_class=argparse.RawTextHelpFormatter,
    )
    parser.add_argument("--folder",         required=True)
    parser.add_argument("--audio",          required=True)
    parser.add_argument("--output",         default="output.mp4")
    parser.add_argument("--fps",            type=int,   default=24)
    parser.add_argument("--width",          type=int,   default=1280)
    parser.add_argument("--height",         type=int,   default=720)
    parser.add_argument("--title",          default=None)
    parser.add_argument("--title-duration", type=float, default=5.0)
    parser.add_argument(
        "--caption", dest="captions", action="append", type=parse_caption, default=[],
        metavar="시작초,지속초,하단여백px,텍스트",
        help="자막 (여러 번 사용 가능)\n  예) --caption \"5,3,40,환영합니다\"",
    )
    args, unknown = parser.parse_known_args()
    if unknown:
        print(f"⚠️  인식되지 않은 인수 (무시됨): {unknown}")

    if not os.path.isdir(args.folder):
        print(f"❌ 폴더를 찾을 수 없습니다: {args.folder}"); sys.exit(1)
    if not os.path.isfile(args.audio):
        print(f"❌ 오디오 파일을 찾을 수 없습니다: {args.audio}"); sys.exit(1)
    if args.title and not os.path.isfile(args.title):
        print(f"❌ 타이틀 이미지를 찾을 수 없습니다: {args.title}"); sys.exit(1)

    folders = collect_subfolders(args.folder)
    if not folders:
        print("❌ 이미지가 있는 하위 폴더가 없습니다."); sys.exit(1)

    print(f"  발견된 폴더 수: {len(folders)}")
    image_paths = pick_all_images_from_folders(folders)
    print(f"\n선택된 이미지:")
    for i, p in enumerate(image_paths, 1):
        print(f"  [{i:3d}] {p}")

    build_video(
        image_paths    = image_paths,
        audio_path     = args.audio,
        output_path    = args.output,
        captions       = args.captions,
        title_path     = args.title,
        title_duration = args.title_duration,
        fps            = args.fps,
        target_size    = (args.width, args.height),
    )

# ─────────────────────────────────────────────────────────────────────────────
# ★ 직접 실행 설정 (USE_DIRECT = True 일 때 아래 값 사용)
# ─────────────────────────────────────────────────────────────────────────────
if __name__ == "__main__":
    
    main()

챗지피티를 이용한 파이썬 바이브 코딩 - 미점등 LED 픽셀 위치 파악하기

FDG — Sat, 21 Feb 2026 23:43:58 +0900

챗지피티, 클로드, 퍼플렉시티, 제미나이, 그록으로 간단하게 요청해서 코딩을 시작했는데,

모두 제대로 검출을 하지 못했음. 문제 있는 부분 수정해 달라고 했지만, 내가 생각하는 바가 정확하게 전달이 되지 않는 느낌 받음.

챗지피티로 다시 시작했고 내가 "문제"를 인식하는 과정을 순서대로 알려주고 단계별로 결과를 출력하게 해서 점검하고 문제없으면 확장하는 방식으로 바이브 코딩 진행.

느낀 점은 구체적으로 조건을 주고, 단계별로 확인을 하면서 다음 단계로 넘어가야 한다는 점.

복잡할수록 단계 정해서 시켜야 함. 어떤 문제가 발생했을 때도 구체적으로 알려줘야 코드 개선이 됨.

"문제"는 이미지를 보고 이빨이 빠진 곳의 위치를 찾으라는 것이었는데, x, y 개수가 몇 개인지를 고정한 후부터 정확도가 올라갔음.

사람이라면 전체가 몇 개인지, x, y 개수가 몇 개인지 몰라도 점으로 선을 만들어 따라가면서 좌우 비교해 보면 빠진 느낌을 받을 수가 있고 그곳이 이빨 빠진 곳이라는 감을 잡을 수 있는데...

바이브 코딩에서는 x, y 개수가 몇 개인지를 알려주기 전까지는 정확도가 낮았음.

AGI가 나오기 전까지는 구체적으로 지시를 할 수 있는 사람이 능력 있는 사람일 거 같음.

대학에서도 바이브 코딩으로 문제를 해결하는 과목이 생길 것 같음.

문제 이미지. 디지털 카메라로 찍어서 회전돼 있고 렌즈 왜곡이 있음.

distorsion_image.jpg

0.35MB

픽셀 찾아서 GRID 인식하는 과정

이빨 빠진 곳 확인한 이미지

등간격 GRID로 미점등 위치를 재구성!

import cv2
import numpy as np

# ============================================================
# Distorted LED Grid Analyzer (with debug exports)
# (modified for separate grid_row_n, grid_col_n)
# ============================================================

# 아래 코드는 카메라로 찍혀 왜곡(회전/기울어짐/렌즈왜곡)이 있는 LED 점등 사진에서
# 흰색으로 켜진 LED 점(블롭)을 검출하고
# 그 점들이 **50×50 격자(행/열)**라는 가정 하에
# **행 곡선(행 라인), 열 곡선(열 라인)**을 각각 모델링(다항식+RANSAC)해서
# 각 격자 교차점에 LED가 실제로 존재하는지(최근접 거리로) 판단하고
# **꺼진 위치(row,col + 이미지좌표)**를 저장하는 파이프라인입니다.
    
# ---------- colors (BGR) ----------
PINK  = (255, 0, 255)
GREEN = (0, 255, 0)
RED   = (0, 0, 255)
CYAN  = (255, 255, 0)   # rows
WHITE = (255, 255, 255)
YELLOW= (0, 255, 255)   # cols

def detect_led_components(img_bgr,
                          thr_mode="otsu", fixed_thr=220,
                          morph_open=1,
                          area_band=0.60,
                          max_led=5000):
    gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
    gray = cv2.GaussianBlur(gray, (3, 3), 0)

    if thr_mode == "otsu":
        _, bw = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    elif thr_mode == "fixed":
        _, bw = cv2.threshold(gray, fixed_thr, 255, cv2.THRESH_BINARY)
    else:
        raise ValueError("thr_mode must be 'otsu' or 'fixed'")

    if morph_open and morph_open > 0:
        k = 2 * morph_open + 1
        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (k, k))
        bw = cv2.morphologyEx(bw, cv2.MORPH_OPEN, kernel, iterations=1)

    nlab, labels, stats, centroids = cv2.connectedComponentsWithStats(bw, connectivity=8)
    if nlab <= 1:
        return bw, labels, stats, centroids, []

    areas = stats[1:, cv2.CC_STAT_AREA].astype(np.float32)
    med = float(np.median(areas))
    low = med * (1 - area_band)
    high = med * (1 + area_band)

    keep = (areas >= low) & (areas <= high)
    kept_labels = (np.where(keep)[0] + 1).astype(int)

    if len(kept_labels) > max_led:
        kept_areas = areas[keep]
        diffs = np.abs(kept_areas - med)
        order = np.argsort(diffs)[:max_led]
        kept_labels = kept_labels[order]

    return bw, labels, stats, centroids, kept_labels.tolist()

def minrect_top_edge(points_xy: np.ndarray):
    rect = cv2.minAreaRect(points_xy.astype(np.float32))
    box = cv2.boxPoints(rect).astype(np.float32)

    idx = np.argsort(box[:, 1])
    top2 = box[idx[:2]]

    if top2[0, 0] <= top2[1, 0]:
        A, B = top2[0], top2[1]
    else:
        A, B = top2[1], top2[0]

    v = B - A
    L = float(np.linalg.norm(v) + 1e-9)
    e = (v / L).astype(np.float32)
    n = np.array([-e[1], e[0]], dtype=np.float32)
    n /= (np.linalg.norm(n) + 1e-9)
    return box, A.astype(np.float32), B.astype(np.float32), e, n

def to_edge_coords(pts_xy, origin, e, n):
    d = pts_xy - origin
    x = d @ e
    y = d @ n
    return x.astype(np.float32), y.astype(np.float32)

def from_edge_coords(x, y, origin, e, n):
    return (origin[None, :] + np.outer(x, e) + np.outer(y, n)).astype(np.float32)

def kmeans_1d(values, k, attempts=10, seed=0):
    v = values.astype(np.float32).reshape(-1, 1)
    criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 200, 1e-4)
    cv2.setRNGSeed(int(seed))
    _, labels, centers = cv2.kmeans(v, k, None, criteria, attempts, cv2.KMEANS_PP_CENTERS)
    labels = labels.reshape(-1)
    centers = centers.reshape(-1)
    order = np.argsort(centers)
    centers_sorted = centers[order]
    inv = np.empty_like(order)
    inv[order] = np.arange(k)
    labels_sorted = inv[labels]
    return centers_sorted, labels_sorted

def fit_poly_and_score(x, y, degree):
    coef = np.polyfit(x, y, degree)
    yhat = np.polyval(coef, x)
    ss_res = float(np.sum((y - yhat) ** 2))
    ss_tot = float(np.sum((y - np.mean(y)) ** 2) + 1e-9)
    r2 = 1.0 - ss_res / ss_tot
    rmse = float(np.sqrt(ss_res / max(1, len(y))))
    return coef, r2, rmse

def polyfit_ransac(x, y, degree=2, iters=800, inlier_sigma=3.0, min_inliers=20, seed=0):
    rng = np.random.default_rng(seed)
    N = len(x)
    if N < degree + 2:
        return None, np.zeros(N, dtype=bool), -np.inf, np.inf

    med = np.median(y)
    mad = np.median(np.abs(y - med)) + 1e-6
    thr = float(inlier_sigma * mad)

    best = None
    sample_n = degree + 2

    for _ in range(iters):
        try:
            idx = rng.choice(N, size=sample_n, replace=False)
        except ValueError:
            break
        try:
            coef0 = np.polyfit(x[idx], y[idx], degree)
        except np.linalg.LinAlgError:
            continue

        resid = np.abs(y - np.polyval(coef0, x))
        mask = resid <= thr
        if mask.sum() < min_inliers:
            continue

        try:
            coef, r2, rmse = fit_poly_and_score(x[mask], y[mask], degree)
        except np.linalg.LinAlgError:
            continue

        score = float(mask.sum()) + 5.0 * r2 - 0.02 * rmse
        if best is None or score > best[0]:
            best = (score, coef, mask, r2, rmse)

    if best is None:
        coef, r2, rmse = fit_poly_and_score(x, y, degree)
        return coef, np.ones(N, dtype=bool), r2, rmse

    _, coef, mask, r2, rmse = best
    return coef, mask, r2, rmse

def fit_rows_cols(points_xy_img, origin_A, e, n,
                  grid_row_n=50,
                  grid_col_n=50,
                  row_degree=2,
                  col_degree=2,
                  row_band_factor=0.45,
                  col_band_factor=0.45,
                  inlier_sigma=3.0,
                  seed=0):
    x_all, y_all = to_edge_coords(points_xy_img, origin=origin_A, e=e, n=n)

    # 행/열 개수 분리
    y_centers, _ = kmeans_1d(y_all, grid_row_n, seed=seed + 10)
    x_centers, _ = kmeans_1d(x_all, grid_col_n, seed=seed + 20)

    dy_step = float(np.median(np.diff(np.sort(y_centers))))
    dx_step = float(np.median(np.diff(np.sort(x_centers))))

    row_band = max(2.0, row_band_factor * dy_step)
    col_band = max(2.0, col_band_factor * dx_step)

    rows = []
    cols = []

    # rows
    for r in range(grid_row_n):
        target_y = float(y_centers[r])
        idx = np.where(np.abs(y_all - target_y) <= row_band)[0]
        if len(idx) < 12:
            rows.append(None)
            continue

        xr = x_all[idx]
        yr = y_all[idx]
        coef, inliers, r2, rmse = polyfit_ransac(
            xr, yr, degree=row_degree,
            iters=1200, inlier_sigma=inlier_sigma,
            min_inliers=max(12, int(0.35*len(idx))),
            seed=seed + 100 + r
        )
        if coef is None or inliers.sum() < 8:
            rows.append(None)
            continue

        rows.append({"r": r, "target_y": target_y, "coef": coef, "r2": float(r2), "rmse": float(rmse)})

    # cols
    for c in range(grid_col_n):
        target_x = float(x_centers[c])
        idx = np.where(np.abs(x_all - target_x) <= col_band)[0]
        if len(idx) < 12:
            cols.append(None)
            continue

        yc = y_all[idx]
        xc = x_all[idx]
        coef, inliers, r2, rmse = polyfit_ransac(
            yc, xc, degree=col_degree,
            iters=1200, inlier_sigma=inlier_sigma,
            min_inliers=max(12, int(0.35*len(idx))),
            seed=seed + 200 + c
        )
        if coef is None or inliers.sum() < 8:
            cols.append(None)
            continue

        cols.append({"c": c, "target_x": target_x, "coef": coef, "r2": float(r2), "rmse": float(rmse)})

    frame = {
        "A": origin_A, "e": e, "n": n,
        "x_all": x_all, "y_all": y_all,
        "x_centers": x_centers, "y_centers": y_centers,
        "dx_step": dx_step, "dy_step": dy_step,
        "row_band": row_band, "col_band": col_band,
        "grid_row_n": grid_row_n,
        "grid_col_n": grid_col_n,
    }
    return frame, rows, cols

def draw_rows_cols_on_original(img_bgr, frame, rows, cols,
                               grid_row_n=50,
                               grid_col_n=50,
                               samples=300,
                               thickness=2):
    out = img_bgr.copy()
    A, e, n = frame["A"], frame["e"], frame["n"]

    x_min = float(np.min(frame["x_all"]))
    x_max = float(np.max(frame["x_all"]))
    y_min = float(np.min(frame["y_all"]))
    y_max = float(np.max(frame["y_all"]))

    xs = np.linspace(x_min, x_max, samples).astype(np.float32)
    for r in range(grid_row_n):
        row = rows[r]
        if row is None:
            continue
        ys = np.polyval(row["coef"], xs).astype(np.float32)
        pts = from_edge_coords(xs, ys, origin=A, e=e, n=n).astype(np.int32).reshape(-1, 1, 2)
        cv2.polylines(out, [pts], False, CYAN, thickness, cv2.LINE_AA)

    ys = np.linspace(y_min, y_max, samples).astype(np.float32)
    for c in range(grid_col_n):
        col = cols[c]
        if col is None:
            continue
        xs2 = np.polyval(col["coef"], ys).astype(np.float32)
        pts = from_edge_coords(xs2, ys, origin=A, e=e, n=n).astype(np.int32).reshape(-1, 1, 2)
        cv2.polylines(out, [pts], False, YELLOW, thickness, cv2.LINE_AA)

    return out

def save_debug_lines(img_bgr, frame, rows, cols,
                     grid_row_n=50,
                     grid_col_n=50,
                     samples=500,
                     thickness=2,
                     prefix="line",
                     start_index=0):
    A, e, n = frame["A"], frame["e"], frame["n"]
    x_min = float(np.min(frame["x_all"]))
    x_max = float(np.max(frame["x_all"]))
    y_min = float(np.min(frame["y_all"]))
    y_max = float(np.max(frame["y_all"]))

    idx = int(start_index)

    xs = np.linspace(x_min, x_max, samples).astype(np.float32)
    for r in range(grid_row_n):
        canvas = img_bgr.copy()
        row = rows[r]
        if row is not None:
            ys = np.polyval(row["coef"], xs).astype(np.float32)
            pts = from_edge_coords(xs, ys, origin=A, e=e, n=n).astype(np.int32).reshape(-1, 1, 2)
            cv2.polylines(canvas, [pts], False, CYAN, thickness, cv2.LINE_AA)
            cv2.putText(canvas, f"ROW {r:02d}  R2={row['r2']:.3f} RMSE={row['rmse']:.2f}px",
                        (20, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.8, WHITE, 2, cv2.LINE_AA)
        else:
            cv2.putText(canvas, f"ROW {r:02d}  (NOT FOUND)",
                        (20, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.8, RED, 2, cv2.LINE_AA)

        cv2.imwrite(f"{prefix}{idx:04d}.jpg", canvas)
        idx += 1

    ys = np.linspace(y_min, y_max, samples).astype(np.float32)
    for c in range(grid_col_n):
        canvas = img_bgr.copy()
        col = cols[c]
        if col is not None:
            xs2 = np.polyval(col["coef"], ys).astype(np.float32)
            pts = from_edge_coords(xs2, ys, origin=A, e=e, n=n).astype(np.int32).reshape(-1, 1, 2)
            cv2.polylines(canvas, [pts], False, YELLOW, thickness, cv2.LINE_AA)
            cv2.putText(canvas, f"COL {c:02d}  R2={col['r2']:.3f} RMSE={col['rmse']:.2f}px",
                        (20, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.8, WHITE, 2, cv2.LINE_AA)
        else:
            cv2.putText(canvas, f"COL {c:02d}  (NOT FOUND)",
                        (20, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.8, RED, 2, cv2.LINE_AA)

        cv2.imwrite(f"{prefix}{idx:04d}.jpg", canvas)
        idx += 1

    return idx

def compute_intersections_and_occupancy(frame, rows, cols,
                                        grid_row_n=50,
                                        grid_col_n=50,
                                        iters=8,
                                        nn_thr_factor=0.45):
    A, e, n = frame["A"], frame["e"], frame["n"]
    pts_base = np.stack([frame["x_all"], frame["y_all"]], axis=1).astype(np.float32)
    flann = cv2.flann_Index(pts_base, dict(algorithm=1, trees=5))
    nn_thr = float(nn_thr_factor * min(frame["dx_step"], frame["dy_step"]))

    occ = np.zeros((grid_row_n, grid_col_n), dtype=bool)
    node_xy_img  = np.zeros((grid_row_n, grid_col_n, 2), dtype=np.float32)
    nn_dist = np.full((grid_row_n, grid_col_n), np.inf, dtype=np.float32)

    x_centers = frame["x_centers"]
    y_centers = frame["y_centers"]

    for r in range(grid_row_n):
        row = rows[r]
        if row is None:
            continue
        for c in range(grid_col_n):
            col = cols[c]
            if col is None:
                continue

            x = float(x_centers[c])
            y = float(y_centers[r])

            for _ in range(iters):
                y = float(np.polyval(row["coef"], x))
                x = float(np.polyval(col["coef"], y))

            q = np.array([[x, y]], dtype=np.float32)
            _, d2 = flann.knnSearch(q, 1, params={})
            dist = float(np.sqrt(d2[0, 0]))
            nn_dist[r, c] = dist
            occ[r, c] = (dist <= nn_thr)

            p_img = from_edge_coords(np.array([x], np.float32),
                                     np.array([y], np.float32),
                                     origin=A, e=e, n=n)[0]
            node_xy_img[r, c] = p_img

    return occ, node_xy_img, nn_dist, nn_thr

def render_regular_grid_image(occ, cell=20, margin=20, radius=6):
    H = margin * 2 + (occ.shape[0] - 1) * cell
    W = margin * 2 + (occ.shape[1] - 1) * cell
    img = np.zeros((H, W, 3), dtype=np.uint8)
    for r in range(occ.shape[0]):
        y = margin + r * cell
        for c in range(occ.shape[1]):
            x = margin + c * cell
            color = GREEN if occ[r, c] else RED
            cv2.circle(img, (x, y), radius, color, 1, cv2.LINE_AA)
    return img

def run_pipeline(img_path="distorsion_image.jpg",
                 grid_row_n=50,
                 grid_col_n=50,
                 thr_mode="otsu",
                 fixed_thr=220,
                 morph_open=1,
                 area_band=0.60,
                 max_led=5000,
                 row_degree=2,
                 col_degree=2,
                 inlier_sigma=3.0,
                 seed=0,
                 debug=False,
                 debug_prefix="line"):

    img = cv2.imread(img_path, cv2.IMREAD_COLOR)
    if img is None:
        raise FileNotFoundError(img_path)

    bw, labels_map, stats, centroids, kept_labels = detect_led_components(
        img,
        thr_mode=thr_mode,
        fixed_thr=fixed_thr,
        morph_open=morph_open,
        area_band=area_band,
        max_led=max_led
    )
    cv2.imwrite("binary.png", bw)

    if len(kept_labels) < 200:
        raise RuntimeError(f"검출된 점이 너무 적습니다: {len(kept_labels)}")

    pts_img = centroids[np.array(kept_labels, dtype=int)].astype(np.float32)

    box, A, B, e, n = minrect_top_edge(pts_img)

    frame, rows, cols = fit_rows_cols(
        pts_img,
        origin_A=A, e=e, n=n,
        grid_row_n=grid_row_n,
        grid_col_n=grid_col_n,
        row_degree=row_degree,
        col_degree=col_degree,
        row_band_factor=0.45,
        col_band_factor=0.45,
        inlier_sigma=inlier_sigma,
        seed=seed
    )

    overlay_curves = draw_rows_cols_on_original(
        img, frame, rows, cols,
        grid_row_n=grid_row_n,
        grid_col_n=grid_col_n,
        samples=300,
        thickness=1,
    )
    cv2.imwrite("overlay_curves.png", overlay_curves)

    if debug:
        save_debug_lines(
            img_bgr=img,
            frame=frame,
            rows=rows,
            cols=cols,
            grid_row_n=grid_row_n,
            grid_col_n=grid_col_n,
            samples=500,
            thickness=1,
            prefix=debug_prefix,
            start_index=0
        )

    occ, node_xy_img, nn_dist, nn_thr = compute_intersections_and_occupancy(
        frame, rows, cols,
        grid_row_n=grid_row_n,
        grid_col_n=grid_col_n,
        iters=8,
        nn_thr_factor=0.45
    )
    np.save(f"occupancy_{grid_row_n}x{grid_col_n}.npy", occ)

    missing = np.argwhere(~occ)
    
    # 1) 기존: row col만 저장
    # np.savetxt("missing_rc.txt", missing, fmt="%d", header="row col", comments="")

    # 2) 추가: row col x y 같이 저장
    #    node_xy_img[r, c] 가 float32 (x,y) 이미지 좌표
    if len(missing) > 0:
        miss_xy = node_xy_img[missing[:, 0], missing[:, 1]]  # (N,2)
        miss_rcxy = np.hstack([missing.astype(np.int32), miss_xy.astype(np.float32)])  # (N,4)

        np.savetxt(
            "missing_rcxy.txt",
            miss_rcxy,
            fmt=["%d", "%d", "%.2f", "%.2f"],
            header="row col x_img y_img",
            comments=""
        )
    else:
        # 빈 파일도 헤더는 남기고 싶으면:
        with open("missing_rcxy.txt", "w", encoding="utf-8") as f:
            f.write("row col x_img y_img\n")

    print(f"NN threshold (base-frame): {nn_thr:.2f}")
    print(f"Missing count: {len(missing)} / {grid_row_n*grid_col_n}")
    overlay_nodes = img.copy()
    for r in range(grid_row_n):
        for c in range(grid_col_n):
            x, y = node_xy_img[r, c]
            if not np.isfinite(x) or not np.isfinite(y):
                continue
            color = GREEN if occ[r, c] else RED
            cv2.circle(overlay_nodes, (int(round(x)), int(round(y))), 7, color, 1, cv2.LINE_AA)
    cv2.imwrite("overlay_nodes_on_original.png", overlay_nodes)

    grid_img = render_regular_grid_image(occ, cell=20, margin=20, radius=6)
    cv2.imwrite("grid_regular.png", grid_img)

    print("Saved:")
    print("- binary.png")
    print("- overlay_curves.png (rows=CYAN, cols=YELLOW)  [ORIGINAL base]")
    print("- overlay_nodes_on_original.png")
    print("- grid_regular.png")
    # print("- missing_rc.txt")
    print("- missing_rcxy.txt  (row,col + x_img,y_img)")
    if debug:
        print(f"- {debug_prefix}0000.jpg ... (per-line debug)")

    return {"occ": occ, "missing_rc": missing, "frame": frame}

if __name__ == "__main__":
    run_pipeline(
        img_path="distorsion_image.jpg",
        grid_row_n=50,
        grid_col_n=50,   # 예: 50 x 50 배열
        thr_mode="otsu",
        fixed_thr=220,
        morph_open=1,
        area_band=0.60,
        max_led=5000,
        row_degree=2,
        col_degree=2,
        inlier_sigma=3.0,
        seed=0,
        debug=False,  # debug=True이면 과정들을 line0000.jpg ...로 출력 
        debug_prefix="line"
    )
    print('Defective LED inspection has been finished.')

LED 미점등 수량 파악하기_파이썬_바이브코딩_챗지피티.ipynb

0.02MB

함수별 목적 + 언제 어떻게 튜닝하는지

1) detect_led_components(...)

목적

입력 이미지에서 밝은 LED 픽셀을 이진화 → connectedComponentsWithStats로 점(컴포넌트) 검출
면적(Area) 통계로 “LED로 보이는 점”만 골라 kept_labels로 반환

핵심 파라미터 튜닝

thr_mode="otsu" | "fixed"
- 조명/노출이 매번 바뀌면 otsu가 편함.
- LED 밝기가 늘 비슷하고, 배경이 들쭉날쭉하면 fixed가 더 안정적일 때가 많음.
fixed_thr=220
- fixed 모드에서 LED가 덜 잡히면 낮추고(예: 200, 180), 배경 잡음이 많이 잡히면 올림(예: 235).
morph_open=1
- 점 주변에 노이즈가 붙어서 컴포넌트가 울퉁불퉁/붙는 경우 값을 올림(2~3).
- 반대로 LED가 작은데 열림(open) 때문에 점이 사라지면 0 또는 1로 낮춤.
area_band=0.60
- LED 점 크기 분포가 안정적이면 0.4~0.6 권장.
- 렌즈왜곡/가장자리 흐림으로 점 크기 편차가 커지면 0.8~1.2로 늘려 “너무 많이 버리는 문제”를 줄임.
- 반대로 먼지/반사 등 이상하게 큰/작은 점이 섞이면 0.3~0.5로 좁혀 걸러냄.
max_led=5000
- “과검출” 폭주 방지용. 50×50이면 정상 점등이 2500 근처일 텐데, 환경 따라 더 잡힐 수 있어 5000 정도는 무난.

2) minrect_top_edge(points_xy)

목적

검출된 점들의 외곽을 기반으로 minAreaRect를 구하고
그 사각형의 **상단 모서리 방향을 기준축(e)**으로 잡아
- e: “가로축(열 방향)”에 해당하는 단위 벡터
- n: “세로축(행 방향)”에 해당하는 단위 벡터(법선)
즉, 사진이 회전돼 있어도 **격자 좌표계(엣지 좌표)**를 하나 잡는 단계

튜닝 포인트

직접 파라미터는 없고, 여기서 방향이 이상하게 잡히면 대부분 검출 점들이 엉망(배경 과검출, LED 점이 너무 적음)인 경우라 detect_led_components 쪽을 먼저 개선하는 게 우선입니다.

3) to_edge_coords(pts_xy, origin, e, n) / from_edge_coords(x, y, origin, e, n)

목적

이미지 좌표(x_img, y_img)를 “엣지 좌표계(x_edge, y_edge)”로 변환 / 역변환
이후 모든 라인 피팅과 교차점 계산을 이 좌표계에서 수행 (회전/기울어짐에 강해짐)

튜닝

없음. (좌표계 품질은 2번의 축 추정 품질에 좌우)

4) kmeans_1d(values, k, ...)

목적

1차원 값들을 k개 군집으로 분할해 행 중심들(y_centers), **열 중심들(x_centers)**을 추정
“LED가 50행/50열에 분포한다”는 가정을 직접 사용

언제 문제가 생기나 / 튜닝

일부가 많이 꺼져 있거나(결측이 많음) 한쪽이 거의 안 잡히면 kmeans가 중심을 이상하게 배치할 수 있음.
튜닝은 주로 seed, 그리고 근본적으로는 검출 품질(1번) + **밴드폭(6번 row_band/col_band)**로 해결합니다.

5) fit_poly_and_score(x, y, degree) / polyfit_ransac(...)

목적

fit_poly_and_score: 단순 다항식 피팅 후 R², RMSE 평가
polyfit_ransac:
- 랜덤 샘플로 초기 다항식을 만들고
- 잔차 기반 inlier를 모아
- inlier로 재피팅 → 가장 좋은 모델 선택
- 결과: 왜곡/오검출 점들(아웃라이어)을 버리고 “그럴듯한 라인”을 얻음

핵심 파라미터 튜닝

degree=2 (row_degree/col_degree)
- 렌즈왜곡이 약하면 1(직선)이 더 안정적일 수 있음.
- 휘어짐이明显하면 2 유지, 심하면 3도 가능하지만 과적합(라인이 출렁) 위험 증가.
iters=1200
- 점이 많고 아웃라이어가 많으면 증가(2000~4000).
- 너무 느리면 감소.
inlier_sigma=3.0
- 라인 주변 점들이 퍼져 있으면(검출 jitter/블러) ↑ (예: 4~6)
- 아웃라이어를 더 강하게 배제하고 싶으면 ↓ (예: 2~2.5)
min_inliers
- 현재는 max(12, int(0.35*len(idx)))라 꽤 보수적.
- LED 결측이 많아 라인 점이 적으면 0.2~0.25 수준으로 완화하는 방식도 가능.

6) fit_rows_cols(...)

목적

전체 점을 엣지좌표로 변환
kmeans로 행 중심(y_centers), 열 중심(x_centers) 추정
각 행/열마다 “중심선 주변 점들”만 모아서 RANSAC 다항식 피팅
- rows: y = f(x)
- cols: x = g(y)
결과로 frame(좌표계+센터+스텝/밴드 등) + rows/cols 모델 리스트 생성

가장 중요한 튜닝 포인트

row_band_factor, col_band_factor (현재 0.45)
- 라인 주변 점을 얼마나 넓게 모을지 결정
- 라인이 자주 None(“NOT FOUND”)로 뜨면 → 밴드 폭을 키우세요
  - 예: 0.45 → 0.6~0.9
- 반대로 서로 다른 행/열 점이 섞여 피팅이 흔들리면 → 줄이세요
  - 예: 0.45 → 0.3~0.4
inlier_sigma
- 밴드 내에 점을 충분히 모아도 RANSAC이 자꾸 실패하면 inlier_sigma를 키우는 쪽이 빠른 해결책인 경우가 많습니다.
grid_row_n, grid_col_n
- 50×50이 확실할 때만 고정. (다르면 kmeans부터 틀어집니다)

7) draw_rows_cols_on_original(...)

목적

rows(청록), cols(노랑) 곡선을 원본 이미지 위에 오버레이해서 overlay_curves.png 저장

튜닝

samples: 라인 부드러움(많을수록 매끈, 느려짐)
thickness: 보기 좋게 조절

8) save_debug_lines(...)

목적

디버깅용으로 한 장에 한 줄(row/col)만 그린 이미지를 줄줄이 저장
row/col별 R2, RMSE를 찍어서 “어느 라인이 망가졌는지” 빠르게 확인

언제 켜나

row/col이 많이 None이거나, overlay_curves가 이상할 때 debug=True로 켜고
- “몇 번째 행/열부터 무너지는지” 확인하면 튜닝 방향이 바로 나옵니다.
보통 이걸 보고 row_band_factor/col_band_factor, inlier_sigma, degree를 조절합니다.

9) compute_intersections_and_occupancy(...)

목적

각 (r,c)에 대해
- 시작점: (x_centers[c], y_centers[r])
- 반복:
  - row식으로 y 업데이트
  - col식으로 x 업데이트
    → row와 col의 교차점을 수치적으로 수렴시키는 방식
그 교차점이 실제 LED 점과 가까운지 **최근접거리(NN)**로 판정
출력:
- occ[r,c]: 점등(검출됨) 여부
- node_xy_img[r,c]: 해당 격자 노드의 이미지 좌표
- nn_dist[r,c]: 최근접거리
- nn_thr: 점등 판정 임계치

가장 중요한 튜닝 포인트

nn_thr_factor=0.45
- 검출 점이 교차점과 조금 멀어도 “켜짐”으로 인정하려면 ↑ (0.55~0.8)
- 오검출을 줄이고 엄격하게 하려면 ↓ (0.3~0.45)
iters=8
- 라인 곡률이 크면 10~15로 늘리면 수렴이 좋아질 때가 있음.
- 너무 늘리면 큰 차이는 없고 느려짐.

10) render_regular_grid_image(occ, ...)

목적

결과를 “정규격자”로 보기 좋게 렌더링 (grid_regular.png)
- 초록: 켜짐
- 빨강: 꺼짐(또는 미검출)

튜닝

cell, radius 등은 시각화만

11) run_pipeline(...)

목적

전체 과정을 순서대로 실행하고 결과 파일 저장
missing_rcxy.txt로 결함 위치를 (row,col,x_img,y_img)로 저장

실전에서 파라미터 조정 순서(추천)

detect_led_components가 제대로 점을 잡는지부터
- binary.png에서 LED만 깔끔히 흰색인지 확인
- 문제 있으면 thr_mode/fixed_thr/morph_open/area_band 조정
overlay_curves.png에서 행/열 라인이 그럴듯한지 확인
- 라인이 중간중간 끊기면 row_band_factor/col_band_factor ↑ 또는 inlier_sigma ↑
- 라인이 출렁이면 degree ↓ 또는 밴드 ↓
overlay_nodes_on_original.png에서 노드가 LED 위치에 잘 얹히는지 확인
- 노드는 맞는데 miss가 과하게 뜨면 nn_thr_factor ↑
- 반대로 대충 다 켜짐 처리되면 nn_thr_factor ↓

“이럴 때는 이렇게” 빠른 처방전

LED 점이 거의 안 잡힘:
thr_mode="fixed" + fixed_thr 낮추기(220→200→180), morph_open 0~1
배경 반사/노이즈가 너무 많이 잡힘:
fixed_thr 올리기, morph_open 2~3, area_band 줄이기(0.6→0.4)
행/열 라인이 많이 None:
row_band_factor/col_band_factor 올리기(0.45→0.7), inlier_sigma 올리기(3→4~6)
라인이 구불구불 과적합 느낌:
degree를 2→1로 낮추거나, 밴드를 줄이기(0.45→0.35)
결함(missing)이 과하게 뜸(실제로는 켜졌는데):
nn_thr_factor 올리기(0.45→0.6~0.75)
결함이 너무 적게 뜸(꺼진 것도 켜짐으로 판정):
nn_thr_factor 내리기(0.45→0.35~0.4)

폴더에서 이미지 읽고 GIF 또는 MP4 파일로 만드는 파이썬 코드

FDG — Sat, 21 Feb 2026 22:17:29 +0900

출처: 퍼플렉시티.ai

JPG를 GIF로 (pip install pillow)

import os
from pathlib import Path
from PIL import Image

# 설정 부분 -----------------------------
input_dir = r"C:\Users\ABCD\Downloads\py\py\1\2"        # JPG들이 들어있는 폴더 경로
output_gif = r"C:\Users\ABCD\Downloads\py\py\1\2\output.gif"   # 저장할 GIF 파일 경로
size = (1000, 1000)              # (가로, 세로) 원하는 사이즈
duration = 100                 # 프레임당 표시 시간(ms), 100=0.1초
loop = 0                       # 0: 무한 반복
# -------------------------------------

def make_gif_from_jpgs(input_dir, output_gif, size, duration=100, loop=0):
    input_path = Path(input_dir)

    print(input_path)
    # 폴더에서 jpg / jpeg 파일 읽고 이름으로 정렬
    jpg_files = sorted(
        [p for p in input_path.iterdir()
         if p.suffix.lower() in [".jpg"]]
    )

    if not jpg_files:
        raise FileNotFoundError("지정한 폴더에 JPG 파일이 없습니다.")

    frames = []
    for i, img_path in enumerate(jpg_files):
        img = Image.open(img_path).convert("RGB")  # GIF 호환을 위해 RGB
        img = img.resize(size, Image.LANCZOS)      # 리사이즈
        frames.append(img)

    # 첫 프레임 기준으로 나머지를 append_images로 붙여 GIF 생성
    first_frame = frames[0]
    first_frame.save(
        output_gif,
        save_all=True,
        append_images=frames[1:],
        format="GIF",
        duration=duration,
        loop=loop,
    )

if __name__ == "__main__":
    make_gif_from_jpgs(input_dir, output_gif, size, duration, loop)

JPG를 MP4로 (pip install opencv-python)

import cv2
import os
from pathlib import Path

input_dir = r"C:\Users\ABCD\Downloads\py\py\1\2"        # JPG들이 들어있는 폴더 경로
output_mp4 = r"C:\Users\ABCD\Downloads\py\py\1\2\output.mp4" # 결과 mp4
# fps = 1  # 초당 프레임 수. 1이면 1초에 그림 한장. 그림이 60장이면 1분 걸림
fps = 10

def jpgs_to_mp4(input_dir, output_mp4, fps=10):
    input_path = Path(input_dir)
    jpg_files = sorted(
        [p for p in input_path.iterdir()
         if p.suffix.lower() in [".jpg"]]
    )
    if not jpg_files:
        raise FileNotFoundError("JPG 파일이 없습니다.")

    # 첫 이미지 크기 기준
    first = cv2.imread(str(jpg_files[0]))
    h, w, _ = first.shape
    size = (w, h)

    fourcc = cv2.VideoWriter_fourcc(*"mp4v")  # 또는 'X264' (코덱 설치 필요)
    out = cv2.VideoWriter(output_mp4, fourcc, fps, size)

    for p in jpg_files:
        img = cv2.imread(str(p))
        img = cv2.resize(img, size)
        out.write(img)

    out.release()

if __name__ == "__main__":
    jpgs_to_mp4(input_dir, output_mp4, fps)

갤럭시 안드로이드폰에서 파이썬과 주피터 노트북 사용하기

FDG — Sat, 21 Feb 2026 00:06:56 +0900

1. statsmodels을 제외한 과학 패키지를 주피터 노트북으로 돌려보고 싶으면 termux에서 termux_science_setup 사용해 패키지 설치!
2. statsmodels이 꼭 필요하다면 주피터 노트북 포기하고 proot-distro 이용해서 linux설치 후에 CLI로만 python 구동

오래전 termux에서 패키지가 잘 설치가 안 된 기억이 있어서 proot-distro를 사용해 리눅스를 설치해 봤다.

■ 데비안
설치 문제없음
vnc 서버 설치, 맥에서 vnc로 접속해서 리눅스 GUI 가동 확인
(처음에는 맥에서 접속이 됐는데 몇 번 설치하고 나서는 localhost에서만 접속이 가능했음. 명령어 차이인지 모르겠음)
(termux 낮은 버전을 깔았을 때 됐던 건가?..)

x11을 이용해서 XQuartz로 연결해 봤는데 GUI까지는 못 띄움
★ 노트북 주피터 설치되나 셀에서 실행 결과가 안 나옴

■ 우분투
elementary-xfce-icon-theme(50%)에서 오래 기다리다가 연결 에러 나면서 설치 중단됨.
elementary-xfce-icon-theme 0.18을 받아서 설치하고 버전 변경 못하게 하고
apt install wget -y
wget http://launchpadlibrarian.net/685949203/elementary-xfce-icon-theme_0.18-1_all.deb
apt install ./elementary-xfce-icon-theme_0.19-1_all.deb

apt install -y xfce4 재시도해보니 에러 없이 설치 잘 됨

vnc로 보기 위해 아래와 같이 입력
apt install -y xfce4 xfce4-goodies tigervnc-standalone-server dbus-x11
vncpasswd 설정하고 vnc 접속됨 확인

파이썬 설치하고 가상환경 설치하고 파이썬 모듈 설치
가상환경을 만들어야 에러가 발생하지 않음
apt install -y python3-venv
python3 -m venv ~/pyenv
source ~/pyenv/bin/activate

python3 -m pip install --upgrade pip
python3 -m pip install jupyterlab

★ 데비안과 마찬가지로 주피터 노트북 셀에서 명령어 실행 안됨

★ root에서 하나 user로 하나 안 됨

기본 브라우저로 세팅해봐도 안 되고,
apt install firefox-esr
xdg-settings set default-web-browser firefox-esr.desktop

root에서 해봐도 안됨
jupyter lab --allow-root

스파이더는 설치하다가 에러 나고
vscode도 받아서 설치해 봤는데 안 됨. 안 되는 이유가 구체적으로 나오는데, 해결 못 했음.
(vscode는 arm64.deb wget후 apt install로 했는데 에러 나서
dpkg -i ... 로 설치하고 apt -f install 해서 설치 완료)

■ turmux 에서 주피터 노트북 실행 : 이게 되는 건가 했는데 된다.

pkg update && pkg upgrade -y

pkg install -y libzmq rust clang cmake make binutils ← 주피터 설치하려면 이게 필요
pkg install -y jupyter
jupyter notebook --ip=0.0.0.0 --port=8888 --no-browser

안드로이드 웹브라우져에서 실행

노트북에서 안드로이드 ip 사용해 접속

설치해 본 패키지들
pkg install ninja patchelf ← 매트플롯 설치하려면 이게 필요
pip install matplotlib (pkg install matplotlib는 안 해봤음)

pkg install opencv-python

pip install pandas ← numpy 자동 설치
pip install seaborn

pkg install python-scipy

아래 패키지는 설치 안 됨
pip install scikit-learn : build 할 때 g95(포트란)과 ifort(인텔포트란)가 필요한데 termux에 설치 불가
pip install scikit-image
pip install statsmodels : build 할 때 g95(포트란)과 ifort(인텔포트란)가 필요한데 termux에 설치 불가

모든 패키지를 쓸 수는 없지만 여하튼 노트북에서도 안드로이드 접속해서 주피터 노트북 사용이 가능하다!

■ turmux에서 누가 만들어 놓은 과학용 패키지 자동설치 파일 사용

https://github.com/FGBASTANTE/termux_science_setup
링크에서 아래 패키지들이 설치 된다고 하는데,

NumPy, SciPy, Pandas
Matplotlib, Seaborn
Scikit-learn, Statsmodels
OpenCV
Jupyter Lab
Gemini-Cli

opencv는 import 하면 에러 발생했고 $PREFIX/lib/libdbus-1.so를 만들어서 해결했음

pkg update && pkg upgrade -y
pkg install dbus -y

statsmodels은 설치가 안 됐음!

[파이썬] DXF CAD 형상 깨지지 않게 matplotlib 에서 plot하기

FDG — Sat, 8 Nov 2025 23:50:54 +0900

cad

plot

ezdxf에서 entity 불러와 matplotlib plot 가능하게 선으로 변환

테스트 dxf 파일 : AC1021 - 2007/2008/2009, AC1009 - 11/12(LT R1/R2)

import ezdxf
import numpy as np
import math
import matplotlib.pyplot as plt
from typing import List, Tuple, Sequence

# ---------- 타입 정의 ----------
Point = Sequence[float]         # (x, y) or (x, y, z)
Shape = List[Point]             # [(x,y), (x,y), ...]
Shapes = List[Shape]            # [shape1, shape2, ...]

# ---------- 보조 함수 ----------
def _xy(p: Point) -> Tuple[float, float]:
    """3D 포인트가 와도 x,y만 사용"""
    return float(p[0]), float(p[1])

def _dist2(a: Point, b: Point) -> float:
    """유클리드 거리 제곱(속도 위해 제곱만 비교)"""
    ax, ay = _xy(a); bx, by = _xy(b)
    dx, dy = ax - bx, ay - by
    return dx*dx + dy*dy

# ---------- 센터, 스케일, 회전 이용한 좌표 변환 ----------
def transform_points(pts: Shape, insert, scale=(1, 1), rotation=0.0) -> Shape:
    """scale + rotation + translation 적용"""
    angle = math.radians(rotation)
    cos_a, sin_a = math.cos(angle), math.sin(angle)
    sx, sy = scale
    tx, ty, *_ = insert

    out = []
    for x, y in pts:
        xs, ys = x * sx, y * sy
        xr = xs * cos_a - ys * sin_a
        yr = xs * sin_a + ys * cos_a
        out.append((xr + tx, yr + ty))
    return out

from ezdxf import path as ezpath

Point = Tuple[float, float]

# -------------------- 보조: 폴리라인을 목표 세그 길이에 맞춰 재샘플 --------------------
def _resample_by_seglen(pts: List[Point], seg_len: float, closed: bool = False) -> List[Point]:
    if not pts or seg_len <= 0:
        return pts

    # 닫힌 곡선이면 마지막 중복점 제거 후 길이계산
    work = pts[:]
    if closed and len(work) > 1 and work[0] == work[-1]:
        work = work[:-1]

    # 누적 길이 계산
    dists = [0.0]
    for i in range(1, len(work)):
        dx = work[i][0] - work[i-1][0]
        dy = work[i][1] - work[i-1][1]
        dists.append(dists[-1] + math.hypot(dx, dy))

    total = dists[-1]
    if total == 0:
        # 모든 점이 동일
        out = [work[0]]
        if closed:
            out.append(out[0])
        return out

    # 목표 샘플 위치들 (0, seg_len, 2*seg_len, ..., total)
    nseg = max(1, int(math.ceil(total / seg_len)))
    targets = [i * (total / nseg) for i in range(nseg + 1)]  # 끝점 포함

    # 이진탐색/선형보간으로 점 생성
    out: List[Point] = []
    j = 0
    for t in targets:
        while j+1 < len(dists) and dists[j+1] < t:
            j += 1
        if j+1 >= len(dists):
            out.append(work[-1])
        else:
            # [j, j+1] 구간에서 보간
            t0, t1 = dists[j], dists[j+1]
            if t1 == t0:
                out.append(work[j])
            else:
                s = (t - t0) / (t1 - t0)
                x = work[j][0] + s * (work[j+1][0] - work[j][0])
                y = work[j][1] + s * (work[j+1][1] - work[j][1])
                out.append((x, y))

    if closed:
        if out[0] != out[-1]:
            out.append(out[0])
    return out

# 벌지에서 arc 만들기
def _arc_points_from_bulge(p0: Point, p1: Point, bulge: float, seg_len: float) -> List[Point]:
    """
    bulge(=tan(θ/4))로 정의된 p0→p1 호를 seg_len에 맞게 선분으로 샘플.
    bulge>0: CCW, bulge<0: CW
    """
    x0, y0 = p0; x1, y1 = p1
    dx, dy = x1 - x0, y1 - y0
    L = math.hypot(dx, dy)
    if L == 0 or abs(bulge) < 1e-12:
        return [p0, p1]

    theta = 4.0 * math.atan(bulge)              # 중앙각(부호 포함)
    R = (L / 2.0) / math.sin(abs(theta) / 2.0)  # 반지름(양수)
    # chord 단위 벡터 & 좌측 법선
    ux, uy = dx / L, dy / L
    nx, ny = -uy, ux
    sgn = 1.0 if bulge > 0 else -1.0

    # chord 중점 → 중심
    mx, my = (x0 + x1) * 0.5, (y0 + y1) * 0.5
    d = R * math.cos(theta / 2.0)               # 중심까지 거리(부호 포함)
    cx = mx + sgn * d * nx
    cy = my + sgn * d * ny

    # 시작/끝 각도
    a0 = math.atan2(y0 - cy, x0 - cx)
    a1 = math.atan2(y1 - cy, x1 - cx)

    # 진행방향 보정
    if theta > 0:
        while a1 <= a0: a1 += 2 * math.pi  # CCW
    else:
        while a1 >= a0: a1 -= 2 * math.pi  # CW

    sweep = a1 - a0  # 부호 포함
    arc_len = abs(R * sweep)
    nseg = max(1, int(math.ceil(arc_len / max(seg_len, 1e-9))))
    angs = np.linspace(a0, a1, nseg)

    pts = [(cx + R * math.cos(t), cy + R * math.sin(t)) for t in angs]
    pts.append((x1, y1))  # 끝점 포함
    return pts

# bulge가 있는지 검색하여 arc로 만드는 것과 선으로 나누는 것을 분류
def _poly_vertices_to_xy(points_bulge: List[Tuple[float, float, float]], closed: bool, seg_len: float) -> List[Point]:
    """
    (x,y,bulge) 시퀀스를 직선/호로 풀어 선분 점열로 반환.
    bulge=0 → 직선, ≠0 → _arc_points_from_bulge
    """
    out: List[Point] = []
    n = len(points_bulge)
    if n == 0:
        return out

    def add_pts(seg_pts: List[Point]):
        nonlocal out
        if not seg_pts: 
            return
        if not out:
            out.extend(seg_pts)
        else:
            # 중복 첫점 제거
            if out[-1] == seg_pts[0]:
                out.extend(seg_pts[1:])
            else:
                out.extend(seg_pts)

    last = n if closed else n - 1
    for i in range(last):
        x0, y0, b0 = points_bulge[i]
        j = (i + 1) % n
        x1, y1, _ = points_bulge[j]
        if abs(b0) < 1e-12:
            add_pts([(x0, y0), (x1, y1)])
        else:
            add_pts(_arc_points_from_bulge((x0, y0), (x1, y1), b0, seg_len))
    return out

# 타원을 선분으로 만들기
def _ellipse_points(center: Point,
                    major_axis: Tuple[float, float],
                    ratio: float,
                    start_param: float,
                    end_param: float,
                    ccw: bool,
                    seg_len: float) -> List[Point]:
    """
    타원 파라메트릭:
      P(t) = C + R(φ) @ [ a*cos t, b*sin t ]
      - major_axis = (ax, ay) (길이 = a)
      - ratio = b/a (0<ratio<=1)
      - t 범위: start_param → end_param (ccw 여부 고려)
    세그 길이 기반으로 분할 개수 결정.
    """
    cx, cy = center
    ax, ay = major_axis
    a = math.hypot(ax, ay)
    b = a * float(ratio)
    if a <= 0 or b <= 0:
        return [(cx, cy)]

    # 타원 회전각
    phi = math.atan2(ay, ax)
    cosp, sinp = math.cos(phi), math.sin(phi)

    # t 진행 방향 정리
    t0 = float(start_param)
    t1 = float(end_param)
    if ccw:
        while t1 <= t0:
            t1 += 2*math.pi
    else:
        while t1 >= t0:
            t1 -= 2*math.pi
    sweep = t1 - t0  # 부호 포함

    # 타원 둘레 근사(라마누잔)로 전체 길이 추정 → 분할 개수
    # 부분호 길이는 sweep 비율로 단순 근사
    perim = math.pi * (3*(a+b) - math.sqrt((3*a+b)*(a+3*b)))
    arc_len_est = abs(sweep) / (2*math.pi) * perim
    nseg = max(3, int(math.ceil(arc_len_est / max(seg_len, 1e-9))))

    ts = np.linspace(t0, t1, nseg + 1)
    pts = []
    for t in ts:
        x = cx + (a*math.cos(t))*cosp - (b*math.sin(t))*sinp
        y = cy + (a*math.cos(t))*sinp + (b*math.sin(t))*cosp
        pts.append((x, y))
    return pts

# -------------------- 엔티티 → 점 리스트 (seg_len 기준) --------------------
# 곡선의 경우 정해진 길이에 맞춰 분할
# 폴리라인에서 벌지가 있을 경우, arc, circle, 타원은 선분으로 구성
# 해치라인의 외곽 인식

def entity_to_xy(e, seg_len: float = 0.2) -> List[Tuple[float, float]]:
    """
    DXF 엔티티를 (x,y) 점 리스트로 변환.
    - ARC/CIRCLE/SPLINE 은 'seg_len'에 가까운 선 길이로 분해
    - LWPOLYLINE/POLYLINE 은 기존 로직 유지(필요시 여기에도 재샘플 호출 가능)
    """
    t = e.dxftype()
    pts: List[Point] = []

    # LINE (그대로)
    if t == "LINE":
        return [(e.dxf.start.x, e.dxf.start.y), (e.dxf.end.x, e.dxf.end.y)]

    # LWPOLYLINE (rounded rectangle 포함)
    elif t == "LWPOLYLINE":
        ptsb: List[Tuple[float, float, float]] = []
        for x, y, b in e.get_points("xyb"):
            ptsb.append((float(x), float(y), float(b or 0.0)))
        closed = bool(e.closed)
        pts = _poly_vertices_to_xy(ptsb, closed, seg_len=seg_len)
        if closed and pts and pts[0] != pts[-1]:
            pts.append(pts[0])
        return pts

    # POLYLINE + VERTEX (구식 폴리라인의 bulge)
    elif t == "POLYLINE":
        # ezdxf 버전에 따라 vertices가 메서드/속성 모두 고려
        verts_attr = getattr(e, "vertices", None)
        verts_iter = verts_attr() if callable(verts_attr) else (verts_attr or [])
        ptsb: List[Tuple[float, float, float]] = []
        for v in verts_iter:
            if hasattr(v.dxf, "location"):
                x = float(v.dxf.location.x); y = float(v.dxf.location.y)
            else:
                x = float(getattr(v.dxf, "x", 0.0)); y = float(getattr(v.dxf, "y", 0.0))
            b = float(getattr(v.dxf, "bulge", 0.0) or 0.0)
            ptsb.append((x, y, b))
        closed = bool(getattr(e, "is_closed", getattr(e, "closed", False)))
        pts = _poly_vertices_to_xy(ptsb, closed, seg_len=seg_len)
        if closed and pts and pts[0] != pts[-1]:
            pts.append(pts[0])
        return pts

    # ARC → 길이 기반 분해
    elif t == "ARC":
        c = e.dxf.center
        r = float(e.dxf.radius)
        a0 = math.radians(float(e.dxf.start_angle))
        a1 = math.radians(float(e.dxf.end_angle))
        if a1 < a0:
            a1 += 2 * math.pi
        sweep = a1 - a0
        arc_len = abs(sweep) * r
        nseg = max(1, int(math.ceil(arc_len / max(seg_len, 1e-9))))
        ang = np.linspace(a0, a1, nseg + 1)
        pts = [(c.x + r * math.cos(t), c.y + r * math.sin(t)) for t in ang]
        return pts

    # CIRCLE → 길이 기반 분해(닫힘)
    elif t == "CIRCLE":
        c = e.dxf.center
        r = float(e.dxf.radius)
        circ = 2 * math.pi * r
        nseg = max(3, int(math.ceil(circ / max(seg_len, 1e-9))))  # 최소 삼각형
        ang = np.linspace(0, 2 * math.pi, nseg + 1)
        pts = [(c.x + r * math.cos(t), c.y + r * math.sin(t)) for t in ang]
        if pts[0] != pts[-1]:
            pts.append(pts[0])
        return pts

    elif t == "ELLIPSE":
        c = e.dxf.center
        maj = e.dxf.major_axis  # Vec3
        ratio = float(e.dxf.ratio)  # b/a
        sp = float(getattr(e.dxf, "start_param", 0.0))
        ep = float(getattr(e.dxf, "end_param", 2*math.pi))
        is_ccw = bool(getattr(e.dxf, "ccw", True))  # ezdxf는 보통 ccw 기준

        return _ellipse_points(
            (float(c.x), float(c.y)),
            (float(maj.x), float(maj.y)),
            ratio, sp, ep, is_ccw, seg_len
        )
    # SPLINE → 먼저 촘촘 평탄화 → 균등 길이 재샘플
    elif t == "SPLINE":
        dense: List[Point] = []
        # 1) path 기반 평탄화(가장 견고)
        try:
            path = ezpath.make_path(e)
            for sub in path.flattening(distance=seg_len/4):
                for p in sub:
                    dense.append((p.x, p.y) if hasattr(p, "x") else (p[0], p[1]))
        except Exception:
            dense = []
        # 2) 엔티티 직접 평탄화
        if not dense:
            try:
                for p in e.flattening(distance=seg_len/4):
                    dense.append((p.x, p.y) if hasattr(p, "x") else (p[0], p[1]))
            except Exception:
                dense = []
        # 3) approximate(n) 폴백
        if not dense:
            try:
                n = max(64, int(math.ceil(4.0 / max(seg_len, 1e-6))))  # 대충 충분히 촘촘하게
                for p in e.approximate(n):
                    dense.append((p.x, p.y) if hasattr(p, "x") else (p[0], p[1]))
            except Exception:
                dense = []
        # 4) 그래도 없으면 fit_points 폴백
        if not dense:
            try:
                fp = list(getattr(e, "fit_points", []) or [])
                dense = [(p.x, p.y) if hasattr(p, "x") else (p[0], p[1]) for p in fp]
            except Exception:
                dense = []

        if not dense:
            return []

        closed = bool(getattr(e, "closed", False))
        if closed and dense[0] != dense[-1]:
            dense.append(dense[0])

        # 목표 세그 길이로 재샘플
        return _resample_by_seglen(dense, seg_len, closed=closed)

    # 기타 엔티티는 스킵
    return pts

# HATCH 경계의 edge(Line/Arc/Ellipse/Spline)를 점열로 변환
def _hatch_path_edge_points(edge, seg_len: float) -> List[Point]:
    etype = getattr(edge, "type", None)  # 또는 isinstance 체크 (버전별 다름)

    # LineEdge: .start, .end (Vec2/3)
    if etype == "LineEdge" or hasattr(edge, "start") and hasattr(edge, "end"):
        s = edge.start; e = edge.end
        return [ (float(s.x), float(s.y)), (float(e.x), float(e.y)) ]

    # ArcEdge: .center, .radius, .start_angle, .end_angle, .ccw
    if etype == "ArcEdge" or hasattr(edge, "radius"):
        c = edge.center
        r = float(edge.radius)
        a0 = math.radians(float(edge.start_angle))
        a1 = math.radians(float(edge.end_angle))
        ccw = bool(getattr(edge, "ccw", True))
        # 진행방향 보정
        if ccw:
            while a1 <= a0: a1 += 2*math.pi
        else:
            while a1 >= a0: a1 -= 2*math.pi
        sweep = a1 - a0
        arc_len = abs(r * sweep)
        nseg = max(1, int(math.ceil(arc_len / max(seg_len, 1e-9))))
        ang = np.linspace(a0, a1, nseg + 1)
        return [ (float(c.x) + r*math.cos(t), float(c.y) + r*math.sin(t)) for t in ang ]

    # EllipseEdge: .center, .major_axis, .ratio, .start_angle, .end_angle, .ccw
    if etype == "EllipseEdge" or hasattr(edge, "ratio"):
        c = edge.center
        maj = edge.major_axis
        ratio = float(edge.ratio)
        a0 = math.radians(float(edge.start_angle))
        a1 = math.radians(float(edge.end_angle))
        ccw = bool(getattr(edge, "ccw", True))
        return _ellipse_points(
            (float(c.x), float(c.y)),
            (float(maj.x), float(maj.y)),
            ratio, a0, a1, ccw, seg_len
        )

    # SplineEdge: .control_points / .fit_points 등 (버전별 차이)
    if etype == "SplineEdge" or hasattr(edge, "control_points") or hasattr(edge, "fit_points"):
        dense: List[Point] = []
        # 1) fit_points 우선
        fp = list(getattr(edge, "fit_points", []) or [])
        if fp:
            dense = [(float(p.x), float(p.y)) for p in fp]
        else:
            # 2) control_points 기반 근사
            cps = list(getattr(edge, "control_points", []) or [])
            if cps:
                try:
                    from ezdxf.math import BSpline, Vec3
                    deg = int(getattr(edge, "degree", 3))
                    bs = BSpline([Vec3(p) for p in cps], order=deg+1)
                    n = max(64, int(math.ceil(4.0 / max(seg_len, 1e-6))))
                    approx = bs.approximate(n)
                    dense = [(float(p.x), float(p.y)) for p in approx]
                except Exception:
                    pass
        if not dense:
            return []
        # 균등 길이 재샘플(선택) — 간단 버전
        # 길이 누적
        lens = [0.0]
        for i in range(1, len(dense)):
            dx = dense[i][0]-dense[i-1][0]; dy = dense[i][1]-dense[i-1][1]
            lens.append(lens[-1] + math.hypot(dx, dy))
        total = lens[-1]
        if total <= 0:
            return [dense[0]]
        nseg = max(1, int(math.ceil(total / max(seg_len, 1e-9))))
        targets = [i*(total/nseg) for i in range(nseg+1)]
        out: List[Point] = []
        j = 0
        for tlen in targets:
            while j+1 < len(lens) and lens[j+1] < tlen:
                j += 1
            if j+1 >= len(lens):
                out.append(dense[-1]); break
            t0, t1 = lens[j], lens[j+1]
            if t1 == t0:
                out.append(dense[j])
            else:
                s = (tlen - t0)/(t1 - t0)
                x = dense[j][0] + s*(dense[j+1][0]-dense[j][0])
                y = dense[j][1] + s*(dense[j+1][1]-dense[j][1])
                out.append((x, y))
        return out

    # 알 수 없는 에지는 스킵
    return []

def hatch_paths_to_shapes(hatch, seg_len: float = 0.2) -> List[List[Point]]:
# HATCH 엔티티의 모든 경계 경로를 선분화하여 shape 리스트로 반환.
# 각 BoundaryPath → 하나의 shape.

    shapes: List[List[Point]] = []
    for path in hatch.paths:  # BoundaryPath
        path_pts: List[Point] = []
        # 1) Edge 모드 (선/호/타원/스플라인) 경계
        if getattr(path, "has_edge_data", False):
            for edge in path.edges:
                seg = _hatch_path_edge_points(edge, seg_len)
                if not seg: 
                    continue
                if not path_pts:
                    path_pts.extend(seg)
                else:
                    # 중복 첫점 제거
                    if path_pts[-1] == seg[0]:
                        path_pts.extend(seg[1:])
                    else:
                        path_pts.extend(seg)
        # 2) Polyline 경계 (bulge 포함 가능)
        elif getattr(path, "has_polyline_data", False):
            verts = getattr(path, "polyline_path", None)
            if verts:
                # verts = list of (x, y, bulge)
                from math import isclose
                def add_pts(a, b, bulge):
                    if abs(bulge) < 1e-12:
                        return [a, b]
                    return _arc_points_from_bulge(a, b, bulge, seg_len)

                temp: List[Point] = []
                n = len(verts)
                for i in range(n - (0 if path.is_closed else 1)):
                    x0, y0, b0 = verts[i]
                    x1, y1, _  = verts[(i+1) % n]
                    seg = add_pts((x0, y0), (x1, y1), b0 or 0.0)
                    if not temp:
                        temp.extend(seg)
                    else:
                        if temp[-1] == seg[0]:
                            temp.extend(seg[1:])
                        else:
                            temp.extend(seg)
                path_pts = temp

        if path_pts:
            # 닫힘 표시
            if path.is_closed and path_pts[0] != path_pts[-1]:
                path_pts.append(path_pts[0])
            shapes.append(path_pts)
    return shapes

Point  = Tuple[float, float]
Shape  = List[Point]
Shapes = List[Shape]

def plot_dxf(doc, seg_len: float = 0.2) -> Tuple[Shapes, Shapes]:
    """
    모델공간에서:
      - INSERT(블록 참조) 안의 엔티티 → block_shapes
      - INSERT가 아닌 직접 엔티티      → shapes
    둘 다 plt.plot으로 그려주고 (block 먼저/후는 자유),
    (block_shapes, shapes) 를 반환한다.
    """
    msp = doc.modelspace()
    inserts = list(msp.query("INSERT"))

    # 수집 컨테이너
    block_shapes: Shapes = []
    shapes: Shapes = []

    fig, ax = plt.subplots(figsize=(8, 8))
    ax.set_aspect("equal", adjustable="box")
    ax.grid(True, linestyle=":", linewidth=0.5)

    # 1) 모델공간의 '직접' 엔티티 먼저 수집 (INSERT 제외)
    for e in msp:
        dxftype = e.dxftype()
        if dxftype == "HATCH":
            shapes.extend(hatch_paths_to_shapes(e, seg_len))
        elif dxftype in ("LINE","LWPOLYLINE","POLYLINE","ARC","CIRCLE","SPLINE","ELLIPSE"):
            pts = entity_to_xy(e, seg_len)
            if len(pts) >= 2:
                shapes.append(pts)

    # 2) INSERT(블록 참조) 처리 → block_shapes 에 수집
    if inserts:
        print(f"Found {len(inserts)} INSERT entities.")
        for insert in inserts:
            name    = insert.dxf.name
            ins_pt  = insert.dxf.insert
            xscale  = getattr(insert.dxf, "xscale", 1.0)
            yscale  = getattr(insert.dxf, "yscale", 1.0)
            rotation = getattr(insert.dxf, "rotation", 0.0)

            if name not in doc.blocks:
                print(f"[skip] block '{name}' not found")
                continue

            block = doc.blocks[name]
            for e in block:
                local_pts = entity_to_xy(e, seg_len)
                if len(local_pts) >= 2:
                    world_pts = transform_points(local_pts, ins_pt, (xscale, yscale), rotation)
                    block_shapes.append(world_pts)

            # 블록 라벨(옵션)
            ax.text(ins_pt[0], ins_pt[1], name, fontsize=8)

    # 3) 플롯: 원하면 레이어나 출처에 따라 스타일 다르게 줄 수 있음
    #   - 직접 엔티티
    for pts in shapes:
        xs, ys = zip(*pts)
        ax.plot(xs, ys, linewidth=1.0)

    #   - 블록 엔티티
    for pts in block_shapes:
        xs, ys = zip(*pts)
        ax.plot(xs, ys, linewidth=1.0)

    plt.show()

    #  요청대로: 블록에서 온 것(block_shapes), 직접 엔티티(shapes) 둘 다 반환
    return block_shapes, shapes

cad

dxf_path = r"C:\py\cad\1.dxf"
doc = ezdxf.readfile(dxf_path)
block_shapes, shapes=plot_dxf(doc, 20) # 곡선을 선으로 만들 때는 20mm 최소 단위로 곡선을 직선화

Found 2 INSERT entities.

(x,y) tuple로 모아 놓으면 곡선들이 선으로 분리되면서 순서가 바뀌어 형상이 깨짐

fig, ax = plt.subplots(figsize=(8, 8))
ax.set_aspect("equal", adjustable="box")

mpt=[(x,y) for s in shapes for (x, y) in s ]
xs, ys = zip(*mpt)
ax.plot(xs, ys, linewidth=1.0)

mpt=[(x,y) for s in block_shapes for (x, y) in s ]
xs, ys = zip(*mpt)
ax.plot(xs, ys, linewidth=1.0)

plt.show()

붙어 있는 객체와 떨어진 객체를 분리해 group으로 나누고 각 group은 선의 시작과 끝이 만나도록 정렬

from typing import List, Sequence, Tuple, Optional

Point  = Sequence[float]            # (x,y) 또는 (x,y,z)
Shape  = List[Tuple[float, float]]  # [(x,y), ...]
Shapes = List[Shape]

def _xy(p: Point) -> Tuple[float, float]:
    return float(p[0]), float(p[1])

def _dist2(a: Point, b: Point) -> float:
    ax, ay = _xy(a); bx, by = _xy(b)
    dx, dy = ax - bx, ay - by
    return dx*dx + dy*dy

def _is_closed(s: Shape) -> bool:
    return len(s) >= 2 and s[0] == s[-1]

def _rotate_closed_to_nearest(s: Shape, ref: Tuple[float, float]) -> Shape:
    """폐곡선 s에서 ref에 가장 가까운 꼭짓점을 시작점으로 회전."""
    if not _is_closed(s) or len(s) <= 2:
        return s
    # 마지막 중복점 제거 후 가장 가까운 꼭짓점 찾기
    core = s[:-1]
    best_i, best_d2 = 0, float("inf")
    for i, p in enumerate(core):
        d2 = _dist2(p, ref)
        if d2 < best_d2:
            best_d2, best_i = d2, i
    rotated = core[best_i:] + core[:best_i]
    rotated.append(rotated[0])  # 다시 닫기
    return rotated

def _snap_point(p: Tuple[float, float], snap: float) -> Tuple[float, float]:
    x, y = p
    return (round(x / snap) * snap, round(y / snap) * snap)

def reorder_shapes_grouped(
    shapes: Shapes,
    tol: float,
    start_index: int = 0,
    snap: Optional[float] = None,
    rotate_closed: bool = True,
) -> List[Shapes]:
    """
    - 첫 그룹: start_index 형상으로 시작해서, 현재 끝점과 tol 이내로 이어붙일 수 있는
      가장 가까운 shape를 탐욕적으로 선택(+ 필요시 뒤집기/회전) → 그룹 완성.
    - tol 이내 후보가 더 이상 없으면, 남은 shape들 중 '어떤 그룹의 끝점'과 가장 가까운 것을 골라
      새 그룹을 시작. (모든 shape가 소진될 때까지 반복)
    - 반환: 그룹들의 리스트 [ [shape1, shape2, ...], [shapeA, ...], ... ]
      (각 shape는 (x,y) 튜플의 리스트)
    """
    # 1) 유효/정규화 + 스냅
    pool: Shapes = []
    for s in shapes:
        if not s:
            continue
        clean = [tuple(_xy(p)) for p in s]
        if snap:
            clean = [_snap_point(p, snap) for p in clean]
        pool.append(clean)
    if not pool:
        return []

    # 2) 시작 shape 선택
    start_index = max(0, min(start_index, len(pool) - 1))
    groups: List[Shapes] = []

    # 아직 배치 안 된 shape 집합
    unplaced = pool[:]

    # 각 그룹의 '현재 끝점'들을 추적
    # 그룹 단위로 진행하되, 내부에서는 탐욕적으로 tol 이내 연결
    while unplaced:
        # --- 새 그룹 시작 후보 선정: 기존 모든 그룹 끝점들과의 최단거리 비교로 가장 가까운 shape 고르기
        if not groups:
            # 첫 그룹은 사용자가 지정한 start_index로
            current = unplaced.pop(start_index)
        else:
            # 기존 그룹들 끝점들 수집
            frontier_pts: List[Tuple[float, float]] = []
            for g in groups:
                last_shape = g[-1]
                frontier_pts.append(last_shape[-1])  # 그룹의 현재 끝점
            # 남은 shape 중 any frontier에 가장 가까운 shape 선택
            best_i, best_ref_idx, best_d2 = None, None, float("inf")
            best_reverse = False
            for i, s in enumerate(unplaced):
                # 후보 s의 양 끝 비교
                for fi, ref in enumerate(frontier_pts):
                    d2_start = _dist2(ref, s[0])
                    d2_end   = _dist2(ref, s[-1])
                    if d2_start < best_d2:
                        best_i, best_ref_idx, best_d2, best_reverse = i, fi, d2_start, False
                    if d2_end < best_d2:
                        best_i, best_ref_idx, best_d2, best_reverse = i, fi, d2_end, True
            current = unplaced.pop(best_i)
            # 가까운 그룹 뒤에 이어붙일 것이므로 그 그룹을 이어갈지, 새로 시작할지 결정
            # 요구사항: '연결되지 않으면 별도로 분리'이므로 tol 밖이면 새 그룹 시작
            # (가까운 ref가 tol 이내면 그 그룹 뒤에 바로 붙이고, 밖이면 새 그룹으로 시작)
            # 일단 current를 새 그룹 seed로 만들고, 아래에서 연결을 시도
        # 새 그룹 초기화
        group: Shapes = []

        # 그룹 내부 탐욕 연결 루프
        # 그룹의 '현재 끝점' 정의
        # 폐곡선이면 필요 시 회전
        if rotate_closed and _is_closed(current):
            # 그룹 시작점 기준으로 회전할 ref는 "현재 그룹 끝점" 개념이 없으니 그냥 current[0] 유지
            pass
        group.append(current)
        cur_end = current[-1]

        # 그룹 내부: tol 이내로만 이어붙임
        while unplaced:
            # 가장 가까운 후보 찾기
            best_i, best_d2, best_reverse = None, float("inf"), False
            for i, s in enumerate(unplaced):
                # 폐곡선이라도 시작/끝 두 점 비교 (닫힘이면 거의 동일)
                d2_start = _dist2(cur_end, s[0])
                d2_end   = _dist2(cur_end, s[-1])
                if d2_start < best_d2:
                    best_i, best_d2, best_reverse = i, d2_start, False
                if d2_end < best_d2:
                    best_i, best_d2, best_reverse = i, d2_end, True

            # tol 이내 없으면 그룹 종료
            if best_i is None or best_d2 > tol*tol:
                break

            # 이어붙일 shape 꺼내기
            nxt = unplaced.pop(best_i)

            # 폐곡선이면 ref에 가깝도록 회전
            if rotate_closed and _is_closed(nxt):
                nxt = _rotate_closed_to_nearest(nxt, cur_end)

            # 필요시 뒤집기
            if best_reverse:
                nxt.reverse()

            group.append(nxt)
            cur_end = nxt[-1]

        # 그룹 완성
        groups.append(group)

    return groups

groups = reorder_shapes_grouped(shapes, tol=0.05, snap=1e-3, rotate_closed=True)

fig, ax = plt.subplots()
ax.set_aspect('equal', adjustable='box')
ax.grid(True, linestyle=':', linewidth=0.5)

for gi, group in enumerate(groups, 1):
    for pts in group:
        xs, ys = zip(*pts)
        ax.plot(xs, ys, linewidth=1.2)
    # 그룹 라벨 (첫 shape의 첫 점)
    ax.text(group[0][0][0], group[0][0][1], f"Group {gi}", fontsize=8)

plt.show()

block_groups = reorder_shapes_grouped(block_shapes, tol=0.05, snap=1e-3, rotate_closed=True)

fig, ax = plt.subplots()
ax.set_aspect('equal', adjustable='box')
ax.grid(True, linestyle=':', linewidth=0.5)

for gi, group in enumerate(groups, 1):
    g_pts=[(x,y) for s in group for (x, y) in s ]
    xs, ys = zip(*g_pts)
    ax.plot(xs, ys, linewidth=1.2)
    # 그룹 라벨 (첫 shape의 첫 점)
    ax.text(group[0][0][0], group[0][0][1], f"Group {gi}", fontsize=8)


for bgi, block_group in enumerate(block_groups, gi+1):
    g_pts=[(x,y) for s in block_group for (x, y) in s ]
    xs, ys = zip(*g_pts)
    ax.plot(xs, ys, linewidth=1.2)
    # 그룹 라벨 (첫 shape의 첫 점)
    ax.text(block_group[0][0][0], block_group[0][0][1], f"Group {bgi}", fontsize=8)

plt.show()

[파이썬] 워피지, 휨 보정, 스케일링 코드 예제

FDG — Wed, 23 Jul 2025 03:24:39 +0900

In [1]:

import numpy as np

def warpage_data(i,X,Y):
    if i==0:
        # 오목하면서 X,Y방향으로 기울어져 있는 경우
        z_true = 0.0001 * (X**2 + Y**2) + 0.02*Y + 0.002*X # 중심부가 볼록한 형태 (단위: mm)
    elif i==1:
        # 오목하면서 X,Y방향으로 기울어져 있는 경우
        z_true = -0.0001 * (X**2 + Y**2) - 0.002*Y + 0.02*X # 중심부가 볼록한 형태 (단위: mm)
    elif i==2:
        # 오목하면서 X,Y방향으로 기울어져 있는 경우
        z_true = -0.00001 * (X**3 + Y**2) - 0.002*Y + 0.02*X # 중심부가 볼록한 형태 (단위: mm)
    elif i==3:
        # 말 안장형 휨 데이터 생성 (쌍곡면 형태)
        z_true = 0.0001 * (X**2 - Y**2)+0.02*y
    elif i==4:
        z_true = np.sin(2 * np.pi * X / 100) + np.cos(2 * np.pi * Y / 100)-0.01*Y
    elif i==5:
    
        z_true = -0.0001 * (X**2 + Y**2) + 0.02*X
        
        # 특정 위치에 오목한 부분 삽입 (가우시안 딥)
        dip_center_x = 100
        dip_center_y = -70
        sigma = 15
        dip_depth = 3
        
        z_true -= dip_depth * np.exp(-((X - dip_center_x)**2 + (Y - dip_center_y)**2) / (2 * sigma**2))

    else:
          z_true = (X-X+Y-Y)

    return z_true

In [2]:

import matplotlib.pyplot as plt
import matplotlib.ticker as ticker

# 가상 워피지 데이터 생성 (볼록형태 + 약간의 노이즈)
N = 101  # 측정 mesh 크기
x = np.linspace(-100, 100, N)
y = np.linspace(-70, 70, N)
X, Y = np.meshgrid(x, y)

for i in range(7):
    z_true=warpage_data(i,X,Y)
    
    # 이차 곡면 (ex: 볼록 워피지) + 노이즈
    noise = np.random.normal(scale=0.01, size=X.shape)  # 측정 노이즈
    Z = z_true + noise
    
    # --- 평면 기울기 보정(plane subtraction) ---
    xy1 = np.stack([X.ravel(), Y.ravel(), np.ones(N*N)], axis=1)
    fit_coef, _, _, _ = np.linalg.lstsq(xy1, Z.ravel(), rcond=None)  # [a, b, c]
    plane = (fit_coef[0] * X) + (fit_coef[1] * Y) + fit_coef[2]
    Z_corr = Z - plane  # 보정 워피지
    
    # 3D 플롯(원본/보정 후)
    fig = plt.figure(figsize=(10, 5))
    
    # ----------------------------
    ax0 = fig.add_subplot(1, 3, 1, projection='3d')
    ax0.plot_surface(X, Y, plane, color='gray', alpha=0.3, linewidth=0, antialiased=False)
    
    c_surf0 = ax0.plot_surface(X, Y, Z, cmap='jet')
    
    # 축, 눈금, 면 모두 숨기기
    for axis in [ax0.xaxis, ax0.yaxis, ax0.zaxis]:
        axis.pane.set_visible(False)   # xy, yz, xz 평면 숨김
        axis.line.set_color((1.0, 1.0, 1.0, 0.0))  # 축 라인 숨김
    
    ax0.set_xticks([])
    ax0.set_yticks([])
    ax0.set_zticks([])
    ax0.set_xlabel("")
    ax0.set_ylabel("")
    ax0.set_zlabel("")
    
    
    ax0.set_title('Original Warpage')
    # fig.colorbar(c_surf0, ax=ax0, shrink=0.5, aspect=10)  # color bar 출력
    
    print(Z.max()-Z.min())
    
    
    # -------------------------
    ax1 = fig.add_subplot(1, 3, 2, projection='3d')
    ax1.plot_surface(X, Y, np.zeros_like(X), color='gray', alpha=0.3, linewidth=0, antialiased=False)
    
    c_surf1 = ax1.plot_surface(X, Y, Z_corr, cmap='jet')
    
    for axis in [ax1.xaxis, ax1.yaxis, ax1.zaxis]:
        axis.pane.set_visible(False)
        axis.line.set_color((1.0, 1.0, 1.0, 0.0))
    
    ax1.set_xticks([])
    ax1.set_yticks([])
    ax1.set_zticks([])
    ax1.set_xlabel("")
    ax1.set_ylabel("")
    ax1.set_zlabel("")
    
    ax1.set_title('Planarity Corrected')
    # fig.colorbar(c_surf1, ax=ax1, shrink=0.5, aspect=10)  # color bar 출력
    
    print(Z_corr.max()-Z_corr.min())

    #-------------------

    Z_DISPLAY_SCALE=3
    ax2 = fig.add_subplot(1, 3, 3, projection='3d')
    
    ax2.plot_surface(X, Y, np.zeros_like(X), color='gray', alpha=0.3, linewidth=0, antialiased=False)
    
    Z_normal=(Z_corr-Z_corr.min())/(Z_corr.max()-Z_corr.min())
    c_surf2 = ax2.plot_surface(X, Y, Z_normal, cmap='jet')
    
    ax2.set_zlim(0, Z_normal.max()*Z_DISPLAY_SCALE)

    for axis in [ax2.xaxis, ax2.yaxis, ax2.zaxis]:
        axis.pane.set_visible(False)
        axis.line.set_color((1.0, 1.0, 1.0, 0.0))
    
    ax2.set_xticks([])
    ax2.set_yticks([])
    ax2.set_zticks([])
    ax2.set_xlabel("")
    ax2.set_ylabel("")
    ax2.set_zlabel("")
    
    ax2.set_title('+ Nomarlization')
    # fig.colorbar(c_surf1, ax=ax1, shrink=0.5, aspect=10)  # color bar 출력
    
    print(Z_normal.max()-Z_normal.min())

    # ---------------------
    
    # 소수점 둘째자리까지 표시
    cbar = fig.colorbar(c_surf0, ax=ax0,shrink=0.5, aspect=10)
    cbar.ax.yaxis.set_major_formatter(ticker.FormatStrFormatter('%.2f'))
    
    cbar = fig.colorbar(c_surf1, ax=ax1, shrink=0.5, aspect=10)
    cbar.ax.yaxis.set_major_formatter(ticker.FormatStrFormatter('%.2f'))

    cbar = fig.colorbar(c_surf1, ax=ax2, shrink=0.5, aspect=10) # 컬러바는 surf1을 썼음. 표준화시켜서 항상 1이기 때문에.
    cbar.ax.yaxis.set_major_formatter(ticker.FormatStrFormatter('%.2f'))
    
    plt.show()

4.024296357139563
1.5191537074322066
1.0

4.659225345284985
1.5399055747323422
1.0

16.29333653104451
7.840909239895743
1.0

3.402694231278083
1.5183150400888612
1.0

4.549707836021346
4.263005665608675
1.0

4.513539760915915
4.3136575910643735
1.0

0.07789903523704239
0.0779190605255776
1.0

In [ ]:

warpage and scaling_250723.ipynb

0.70MB

인공지능 AI 출현, 등장 이야기 - 챗GPT(LLM)는 어디서 왔는가?

FDG — Thu, 22 May 2025 22:05:18 +0900

https://www.yes24.com/product/goods/122661870

프롬프트 엔지니어링 - 예스24

챗GPT 베스트셀러 작가이자 인공지능 전문가가 쓴 프롬프트 엔지니어링의 모든 것프롬프트 엔지니어링은 챗GPT, 바드, 빙, 하이퍼클로바X 등 대화형 인공지능의 원리를 이해하여 훨씬 더 좋은 답

www.yes24.com

챗GPT는 어디서 왔는가가 궁금했는데, 그 궁금증을 해결해 준 책이다.

2013년

구글 Word2vec 단어 이해

2014년

구글 Seq2seq 문장 이해(단어 배열 순서)

인코더(이해) 디코더(표현( 개념이 정립됨

2017년

구글 트랜스포머(어텐션) : 여러개의 인코더와 여러개의 디코더를 사용. 인코더와 디코더는 여러 모듈로 구성돼 있는데 이 모듈에 어텐션이 붙어 있음

어텐션을 활용해 그림이나 작곡을 학습시킨후 만들게 되는 게 가능해짐. 이미지 생성에서는 픽셀 간의 공간적 관계를, 음악에서는 시간적 의존성을 포착.

*GPT의 T가 트랜스포머

2018년

GPT는 디코더 위주로 구성

BERT는 인코더 위주로 구성

*인코더(이해)가 많은 BERT 성능이 GPT보다 월등

*연구자들은 BERT 연구를 더 많이 함. GTP의 12배 수준으로 연구.

2020년

BERT보다 583배 큰 GPT-3 발표

* AI 부피가 2배 커지면 성능은 5% 증가하기 때문에 이때까지만 해도 부피를 키우는 것은 친환경적이지도 않고, 비효율적이라는 분위기가 지배적.

2023년

LLaMA발표. GPT-3의 절반 크기에서 학습 데이터를 4배 더 주입하니 성능이 좋아진다는 연구 결과 발표.

(퍼플렉시티에 질문 : 인공지능에서 트랜스포머는 여러개의 인코더와 디코더로 구성돼 있다. 어텐션은 가각의 모듈에 부착이 돼 있다고 하는데, 모듈이란 무엇인가? 모듈의 구성은?)

. 인코더 모듈의 구성

인코더 한 개의 층(layer)은 다음 두 가지 모듈로 구성됩니다:

멀티 헤드 셀프 어텐션(Multi-Head Self-Attention)
- 입력 시퀀스의 각 단어가 다른 단어와 어떤 관계를 가지는지 계산합니다.
- 병렬로 작동하는 여러 개의 "어텐션 헤드"를 사용해 다양한 관점에서 문맥을 분석합니다12.
- 수식:Attention(Q,K,V)=softmax(QKTdk)V여기서 Q(Query), K(Key), V(Value)는 입력 벡터의 변환 결과입니다4.
위치별 피드 포워드 네트워크(Position-wise FFN)
- 각 단어 위치에 독립적으로 적용되는 2층 신경망입니다.
- 활성화 함수(ReLU)를 사용해 비선형 변환을 수행합니다14.
- 하이퍼파라미터: dmodel=512, dff=20481.

추가 구조:

**잔차 연결(Residual Connection)**과 **층 정규화(LayerNorm)**가 각 모듈 뒤에 적용되어 학습 안정성을 높입니다4.

2. 디코더 모듈의 구성

디코더 한 개의 층은 세 가지 모듈로 구성됩니다:

마스크된 멀티 헤드 셀프 어텐션(Masked Multi-Head Self-Attention)
- 디코더가 미래 단어를 참조하지 못하도록 마스킹을 적용합니다24.
인코더-디코더 어텐션(Encoder-Decoder Attention)
- 인코더의 출력을 Key/Value로 사용해 디코더의 Query와 연관성을 계산합니다4.
위치별 피드 포워드 네트워크(Position-wise FFN)
- 인코더와 동일한 구조입니다.

3. 모듈의 계층적 구조

트랜스포머는 이러한 인코더와 디코더 모듈을 여러 층으로 쌓습니다:

인코더 층 수: 6개 (논문 기준)1.
디코더 층 수: 6개 (논문 기준)1.
각 층의 출력은 다음 층으로 전달되며, 최종적으로 문맥을 반영한 표현을 생성합니다4.

4. 모듈 간 데이터 흐름 예시

입력 문장이 **포지셔널 인코딩(Positional Encoding)**을 거쳐 인코더에 입력됩니다24.
인코더의 각 층에서 셀프 어텐션 → FFN 순서로 처리됩니다.
디코더는 마스크된 어텐션으로 시작해 인코더 출력과의 상호 작용을 거칩니다4.
최종 출력은 소프트맥스 계층을 통해 다음 단어 예측으로 변환됩니다2.

이러한 모듈화된 설계는 병렬 처리와 확장성을 가능하게 하며, 트랜스포머가 장문 맥락을 효과적으로 학습하는 핵심 원리입니다1 24.

퍼플렉시티에서 첨삭 받음

LLM(초거대 언어모델) 발전 연대표

연도	사건 및 내용
1950	앨런 튜링, "튜링 테스트" 제안 (AI 개념적 시초)
1966	MIT, ELIZA 개발 (최초의 대화형 NLP 프로그램)
1980년대	IBM, 최초의 신경망 기반 소형 언어 모델 개발
1990년대	N-gram 등 통계 기반 언어 모델 대중화
2001	LDA(Latent Dirichlet Allocation) 등 토픽 모델링 발전
2010	RNN 기반 신경망 언어 모델(Mikolov 등)
2013	Google, Word2Vec 발표 (단어 임베딩 혁신)
2014	Google, Seq2Seq 발표 (인코더-디코더 구조)
2015	Attention 메커니즘 도입 (Bahdanau 등)
2017	Google, Transformer(트랜스포머) 논문 발표 ("Attention is All You Need")
2018	OpenAI, GPT-1 발표 (디코더 기반, 1.1억 파라미터)
2018	Google, BERT 발표 (인코더 기반, 양방향 문맥 이해)
2019	OpenAI, GPT-2 발표 (15억 파라미터, 일부만 공개)
2020	OpenAI, GPT-3 발표 (1750억 파라미터, API 제공)
2021	Google, Switch Transformer(1.6조 파라미터) 발표
2022	OpenAI, ChatGPT 출시 (GPT-3.5 기반, 대중적 성공)
2023	Meta, LLaMA 발표 (경량화 및 고성능 LLM)
2023	OpenAI, GPT-4 발표 (멀티모달 지원)
2023	Google, Bard(Gemini 전신) 출시
2023	Anthropic, Claude 출시
2024	다양한 오픈소스 LLM(Dolly, Alpaca 등) 확산

주요 발전사 요약

1950~2010년대: 규칙 기반 → 통계 기반 → 신경망 기반으로 NLP 진화
2013~2017년: Word2Vec, Seq2Seq, Attention, Transformer 등 혁신적 모델 등장
2018~2020년: BERT(이해 특화), GPT(생성 특화) 등 대형 모델 경쟁
2020년대: 초거대 LLM(GPT-3, GPT-4, LLaMA 등)과 오픈소스 생태계 확산, 멀티모달 및 대화형 AI 대중화

챗GPT에서 첨삭 받음

대규모 언어 모델(LLM)의 발전사: 핵심 연도별 정리

2013 – Word2Vec (Google)

기술: 단어를 의미 있는 벡터로 변환하는 기법
공헌: 단어 간 의미 유사성을 수치적으로 표현 (예: king - man + woman ≈ queen)
한계: 문맥이 반영되지 않는 정적(static) 임베딩

2014 – Seq2Seq + 인코더-디코더 구조 (Google)

기술: 문장을 벡터로 압축해 다른 문장으로 디코딩 (번역 등)
공헌: 인코더(이해) – 디코더(생성) 구조의 기반을 마련
활용: 기계번역, 챗봇, 요약 등
✅ 정정: "인코더 디코더가 붙어 개념이 정립됨" → 처음 개념화됨은 맞지만, 이후 트랜스포머에서 더 발전함

2015 – Attention Mechanism 도입 (Bahdanau 등)

기술: 번역 시, 입력 문장의 특정 부분에 주의를 기울이도록 함
공헌: 트랜스포머의 핵심 아이디어의 전신

2017 – Transformer 발표 (Google)

논문: Attention is All You Need
기술: RNN 없이도 문맥을 처리 가능한 구조
구성: 여러 개의 인코더와 디코더 → Self-Attention 기반
✅ 정정: "어텐션이 붙어 있음" → 정확히는 Self-Attention + Feed Forward + Residual 등으로 구성됨
의의: NLP 혁명의 시작

2018 – GPT & BERT 발표

GPT-1 (OpenAI)
- 트랜스포머 디코더 기반
- Autoregressive (왼→오) 방식
- 자연어 생성에 강함
BERT (Google)
- 트랜스포머 인코더 기반
- 양방향 문맥 이해 가능 (Masked Language Modeling)
- 자연어 이해에 탁월
  ✅ 정정: "BERT 성능이 GPT보다 월등" → BERT는 이해(Task)에, GPT는 생성(Generation)에 특화됨
  ✅ 정정: "연구자들이 GPT보다 BERT를 12배 많이 연구함" → 정확한 수치는 다르지만, BERT가 한동안 학계 주류였던 것은 사실

2019 – GPT-2 (OpenAI)

성장: 15억 파라미터, 원래는 공개 거부 → 후에 공개
능력: Zero-shot, Few-shot 능력의 가능성 보여줌
우려: **"너무 잘 만들어서 위험하다"**는 이유로 공개 연기됨

2020 – GPT-3 (OpenAI)

규모: 1750억 파라미터 (BERT보다 수백 배 큼)
혁신:
- Few-shot, Zero-shot 학습 본격화
- 다양한 작업에 하나의 모델로 대응 가능
✅ 정정: "2배 커지면 5% 향상" → 이는 일반적인 추정치이며, 논문마다 다름. 다만 수익 대비 효율이 낮아지는 건 맞음
비판: 계산 비용과 탄소 배출량 등의 환경적 우려 제기

2021 – Codex, DALL·E, CLIP (OpenAI)

Codex: 코드 생성 특화 모델 (GitHub Copilot 기반)
CLIP: 텍스트-이미지 이해 모델
DALL·E: 텍스트를 이미지로 변환
의의: LLM을 텍스트 외 영역으로 확장

2022 – ChatGPT (GPT-3.5 기반)

출시: 2022년 11월
혁신:
- 대화형 튜닝 + RLHF (강화 학습 기반 사용자 피드백)
- 인간과 유사한 대화 생성
대중 반응: 수억 명이 사용하며 대중적 AI의 시대 개막

2023 – GPT-4 & LLaMA (OpenAI / Meta)

GPT-4 (3월)
- 멀티모달 지원: 이미지 입력 가능 (텍스트+이미지 이해)
- 더 정확한 문맥 이해, 응답 품질 향상
LLaMA (Meta)
- 작은 모델 크기 (GPT-3의 절반)
- 더 많은 양질의 데이터로 학습 → 성능 대폭 향상
  ✅ 정정: "4배 더 주입" → 더 나은 토큰 품질과 전처리 전략 사용이 핵심
- 오픈 소스 커뮤니티 기반 모델 붐을 촉진

2024 – GPT-4.5 및 Claude 3, Gemini 등 경쟁 모델 출시

GPT-4.5: 더욱 빠르고 정제된 버전
Anthropic Claude 3: 뛰어난 응답 품질과 문서 이해력
Gemini (Google): 멀티모달 & 검색 결합
Mistral, Mixtral 등 오픈 소스 모델 약진

요약

연도사건/모델핵심 공헌

2013	Word2Vec	단어를 벡터로 표현 (정적)
2014	Seq2Seq	인코더-디코더 구조
2017	Transformer	어텐션 기반 처리 혁명
2018	GPT-1 / BERT	생성 vs 이해 모델 분화
2020	GPT-3	초거대 모델, Few-shot 가능성
2022	ChatGPT	LLM의 대중화와 실용화
2023	GPT-4 / LLaMA	멀티모달, 소형 고성능 모델 경쟁
2024	GPT-4.5 등	고도화·경쟁 심화, 오픈소스 가속화

[파이썬] t-분포 데이터 만들기, t-검정, 모평균차에 대한 추론

FDG — Tue, 6 May 2025 23:00:00 +0900

교재 보면서 예제 만들어 봤음

t검정_250506.ipynb

0.10MB

표본크기가 작고, 모표준편차가 다를 때의 모평균 차에 대한 추론¶

수록 문제 참고

In [1]:

import numpy as np

from scipy import stats

def make_t_data(n,desired_mean,desired_std):
    
    df = n - 1

    # 1. t분포에서 표본 추출 (평균 0, 표준편차 1)
    sample = stats.t.rvs(df=df, size=n)

    # 2. 표본의 평균과 표본 표준편차 계산
    sample_mean = np.mean(sample)
    sample_std = np.std(sample, ddof=1)

    # 3. 표본을 원하는 평균과 표본 표준편차로 변환
    sample_scaled = (sample - sample_mean) / sample_std * desired_std + desired_mean
    return sample_scaled

A=make_t_data(13,2.4,0.72)
B=make_t_data(11,2.15,0.35)

# 검정 통계량 구하기
confidence_level = 0.95
alpha=1-confidence_level
df = np.min([len(A),len(B)]) - 1 # 작은 것의 자유도를 선택

# ---------------------------------
#  t.ppf : t-분포의 누적 확률(CDF)에 대응하는 검정통계량을 구하는 함수
t_crit = stats.t.ppf(1 - alpha/2, df) 
nA=A.mean()
nB=B.mean()
sA=A.std(ddof=1)
sB=B.std(ddof=1)

t_= (nA-nB) / (sA**2/len(A) + sB**2/len(B))**0.5
print('s_pool')
print(t_crit,'>',t_,'is',t_crit>t_)

# 양측검정 p값
p_value = 2 * (1 - stats.t.cdf(abs(t_), df))
print(f"t-statistic: {t_:.3f}, p-value: {p_value:.3f}")

# ---------------------------------
# scipy.stats.ttest_ind 사용
t_stat, p_value = stats.ttest_ind(A, B, alternative='two-sided', equal_var=False)  # equal_var=False로 하면 Welch's t-test를 사용
print('\nttest_ind')
print(f"t-statistic: {t_stat:.3f}, p-value: {p_value:.3f}")
if p_value < 0.05:
    print("A와 B는 다름")
else:
    print("A와 B는 같음")

s_pool
2.2281388519649385 > 1.106874432753606 is True
t-statistic: 1.107, p-value: 0.294

ttest_ind
t-statistic: 1.107, p-value: 0.283
A와 B는 같음

In [2]:

import matplotlib.pyplot as plt

# 예시: 자유도, 유의수준, t-검정 통계량
# df = 10
# alpha = 0.05

# 임계값 (양측)
t_crit = stats.t.ppf(1 - alpha/2, df)
t_ = 2.3  # 예시로 t-값 입력(실제 검정값으로 대체)

# x축 범위
x = np.linspace(-4, 4, 500)
y = stats.t.pdf(x, df)

plt.figure(figsize=(8, 5))
plt.plot(x, y, label=f't-distribution (df={df})', color='black')

# 기각역 채우기
plt.fill_between(x, y, where=(x <= -t_crit), color='red', alpha=0.3, label='Rejection region')
plt.fill_between(x, y, where=(x >= t_crit), color='red', alpha=0.3)

# 임계값 선
plt.axvline(-t_crit, color='red', linestyle='dashed', label=f'-t_crit = {(-t_crit):.2f}')
plt.axvline(t_crit, color='red', linestyle='dashed', label=f't_crit = {t_crit:.2f}')

# 실제 t-값 위치
plt.axvline(t_stat, color='blue', linestyle='dashed', label=f't_stat = {t_stat:.2f}')

plt.title('t-distribution with rejection regions')
plt.xlabel('t')
plt.ylabel('Density')
plt.legend()
plt.grid(True)
plt.show()