중간

fletimageanalysis/.env

@@ -0,0 +1,19 @@
+# 환경 변수 설정 파일
+# 실제 사용 시 이 파일을 .env로 복사하고 실제 값으로 변경하세요
+
+# Gemini API 키 (필수)
+GEMINI_API_KEY=AIzaSyA4XUw9LJp5zQ5CkB3GVVAQfTL8z6BGVcs
+
+# 애플리케이션 설정
+APP_TITLE=PDF 도면 분석기
+APP_VERSION=1.0.0
+DEBUG=False
+
+# 파일 업로드 설정
+MAX_FILE_SIZE_MB=50
+ALLOWED_EXTENSIONS=pdf
+UPLOAD_FOLDER=uploads
+
+# Gemini API 설정
+GEMINI_MODEL=gemini-2.5-flash
+DEFAULT_PROMPT=pdf 이미지 분석하여 도면인지 어떤 정보들이 있는지 알려줘.

fletimageanalysis/.env.example

@@ -0,0 +1,19 @@
+# 환경 변수 설정 파일
+# 실제 사용 시 이 파일을 .env로 복사하고 실제 값으로 변경하세요
+
+# Gemini API 키 (필수)
+GEMINI_API_KEY=your_gemini_api_key_here
+
+# 애플리케이션 설정
+APP_TITLE=PDF 도면 분석기
+APP_VERSION=1.0.0
+DEBUG=False
+
+# 파일 업로드 설정
+MAX_FILE_SIZE_MB=50
+ALLOWED_EXTENSIONS=pdf
+UPLOAD_FOLDER=uploads
+
+# Gemini API 설정
+GEMINI_MODEL=gemini-2.5-flash
+DEFAULT_PROMPT=pdf 이미지 분석하여 도면인지 어떤 정보들이 있는지 알려줘.

fletimageanalysis/batch_cli.py

@@ -0,0 +1,216 @@
+"""
+배치 처리 명령줄 인터페이스
+WPF 애플리케이션에서 호출 가능한 간단한 배치 처리 도구
+
+Usage:
+    python batch_cli.py --files "file1.pdf,file2.dxf" --schema "한국도로공사" --concurrent 3 --batch-mode true --save-intermediate false --include-errors true --output "results.csv"
+"""
+
+import argparse
+import asyncio
+import logging
+import os
+import sys
+import time
+from datetime import datetime
+from typing import List
+
+# 프로젝트 모듈 임포트
+from config import Config
+from multi_file_processor import MultiFileProcessor, BatchProcessingConfig, generate_default_csv_filename
+
+# 로깅 설정
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+class BatchCLI:
+    """배치 처리 명령줄 인터페이스 클래스"""
+    
+    def __init__(self):
+        self.processor = None
+        self.start_time = None
+        
+    def setup_processor(self) -> bool:
+        """다중 파일 처리기 설정"""
+        try:
+            # 설정 검증
+            config_errors = Config.validate_config()
+            if config_errors:
+                for error in config_errors:
+                    print(f"ERROR: {error}")
+                return False
+            
+            # Gemini API 키 확인
+            gemini_api_key = Config.get_gemini_api_key()
+            if not gemini_api_key:
+                print("ERROR: Gemini API 키가 설정되지 않았습니다")
+                return False
+            
+            # 처리기 초기화
+            self.processor = MultiFileProcessor(gemini_api_key)
+            print("START: 배치 처리기 초기화 완료")
+            return True
+            
+        except Exception as e:
+            print(f"ERROR: 처리기 초기화 실패: {e}")
+            return False
+    
+    def parse_file_paths(self, files_arg: str) -> List[str]:
+        """파일 경로 문자열을 리스트로 파싱"""
+        if not files_arg:
+            return []
+        
+        # 쉼표로 구분된 파일 경로들을 분리
+        file_paths = [path.strip().strip('"\'') for path in files_arg.split(',')]
+        
+        # 파일 존재 여부 확인
+        valid_paths = []
+        for path in file_paths:
+            if os.path.exists(path):
+                valid_paths.append(path)
+                print(f"START: 파일 확인: {os.path.basename(path)}")
+            else:
+                print(f"ERROR: 파일을 찾을 수 없습니다: {path}")
+        
+        return valid_paths
+    
+    def parse_file_list_from_file(self, file_list_path: str) -> List[str]:
+        """파일 리스트 파일에서 파일 경로들을 읽어옴"""
+        if not file_list_path or not os.path.exists(file_list_path):
+            return []
+        
+        valid_paths = []
+        try:
+            with open(file_list_path, 'r', encoding='utf-8') as f:
+                for line in f:
+                    path = line.strip().strip('"\'')
+                    if path and os.path.exists(path):
+                        valid_paths.append(path)
+                        print(f"START: 파일 확인: {os.path.basename(path)}")
+                    elif path:
+                        print(f"ERROR: 파일을 찾을 수 없음: {path}")
+            
+            print(f"START: 총 {len(valid_paths)}개 파일 로드됨")
+            return valid_paths
+            
+        except Exception as e:
+            print(f"ERROR: 파일 리스트 읽기 실패: {e}")
+            return []
+    
+    def create_batch_config(self, args) -> BatchProcessingConfig:
+        """명령줄 인수에서 배치 설정 생성"""
+        config = BatchProcessingConfig(
+            organization_type=args.schema,
+            enable_gemini_batch_mode=args.batch_mode,
+            max_concurrent_files=args.concurrent,
+            save_intermediate_results=args.save_intermediate,
+            output_csv_path=args.output,
+            include_error_files=args.include_errors
+        )
+        return config
+    
+    def progress_callback(self, current: int, total: int, status: str):
+        """진행률 콜백 함수 - WPF가 기대하는 형식으로 출력"""
+        # WPF가 파싱할 수 있는 간단한 형식으로 출력
+        print(f"PROGRESS: {current}/{total}")
+        print(f"COMPLETED: {status}")
+    
+    async def run_batch_processing(self, file_paths: List[str], config: BatchProcessingConfig) -> bool:
+        """배치 처리 실행"""
+        try:
+            self.start_time = time.time()
+            total_files = len(file_paths)
+            
+            print(f"START: 배치 처리 시작: {total_files}개 파일")
+            
+            # 처리 실행
+            results = await self.processor.process_multiple_files(
+                file_paths, config, self.progress_callback
+            )
+            
+            # 처리 완료
+            end_time = time.time()
+            total_time = end_time - self.start_time
+            
+            # 요약 정보
+            summary = self.processor.get_processing_summary()
+            
+            print(f"COMPLETED: 배치 처리 완료!")
+            print(f"COMPLETED: 총 처리 시간: {total_time:.1f}초")
+            print(f"COMPLETED: 성공: {summary['success_files']}개, 실패: {summary['failed_files']}개")
+            print(f"COMPLETED: CSV 결과 저장: {config.output_csv_path}")
+            print(f"COMPLETED: JSON 결과 저장: {config.output_csv_path.replace('.csv', '.json')}")
+            
+            return True
+            
+        except Exception as e:
+            print(f"ERROR: 배치 처리 중 오류: {e}")
+            return False
+
+
+def str_to_bool(value: str) -> bool:
+    """문자열을 boolean으로 변환"""
+    return value.lower() in ["true", "1", "yes", "on"]
+
+
+async def main():
+    """메인 함수"""
+    parser = argparse.ArgumentParser(description="PDF/DXF 파일 배치 처리 도구")
+    
+    # 파일 입력 방식 (둘 중 하나 필수)
+    input_group = parser.add_mutually_exclusive_group(required=True)
+    input_group.add_argument("--files", "-f", help="처리할 파일 경로들 (쉼표로 구분)")
+    input_group.add_argument("--file-list", "-fl", help="처리할 파일 경로가 담긴 텍스트 파일")
+    
+    # 선택적 인수들
+    parser.add_argument("--schema", "-s", default="한국도로공사", help="분석 스키마")
+    parser.add_argument("--concurrent", "-c", type=int, default=3, help="동시 처리할 파일 수")
+    parser.add_argument("--batch-mode", "-b", default="false", help="배치 모드 사용 여부")
+    parser.add_argument("--save-intermediate", "-i", default="true", help="중간 결과 저장 여부")
+    parser.add_argument("--include-errors", "-e", default="true", help="오류 파일 포함 여부")
+    parser.add_argument("--output", "-o", help="출력 CSV 파일 경로 (JSON 파일도 함께 생성됨)")
+    
+    args = parser.parse_args()
+    
+    # CLI 인스턴스 생성
+    cli = BatchCLI()
+    
+    # 처리기 설정
+    if not cli.setup_processor():
+        sys.exit(1)
+    
+    # 파일 경로 파싱
+    if args.files:
+        input_files = cli.parse_file_paths(args.files)
+    else:
+        input_files = cli.parse_file_list_from_file(args.file_list)
+    
+    if not input_files:
+        print("ERROR: 처리할 파일이 없습니다.")
+        sys.exit(1)
+    
+    # boolean 변환
+    args.batch_mode = str_to_bool(args.batch_mode)
+    args.save_intermediate = str_to_bool(args.save_intermediate)
+    args.include_errors = str_to_bool(args.include_errors)
+    
+    # 배치 설정 생성
+    config = cli.create_batch_config(args)
+    
+    # 배치 처리 실행
+    success = await cli.run_batch_processing(input_files, config)
+    
+    if success:
+        print("SUCCESS: 배치 처리가 성공적으로 완료되었습니다.")
+        sys.exit(0)
+    else:
+        print("ERROR: 배치 처리 중 오류가 발생했습니다.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

fletimageanalysis/config.py

@@ -0,0 +1,74 @@
+"""
+설정 관리 모듈
+환경 변수 및 애플리케이션 설정을 관리합니다.
+"""
+
+import os
+from dotenv import load_dotenv
+from pathlib import Path
+
+# .env 파일 로드
+load_dotenv()
+
+class Config:
+    """애플리케이션 설정 클래스"""
+    
+    # 기본 애플리케이션 설정
+    APP_TITLE = os.getenv("APP_TITLE", "PDF/DXF 도면 분석기")
+    APP_VERSION = os.getenv("APP_VERSION", "1.1.0")
+    DEBUG = os.getenv("DEBUG", "False").lower() == "true"
+    
+    # API 설정
+    GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+    GEMINI_MODEL = os.getenv("GEMINI_MODEL", "gemini-2.5-pro")
+    DEFAULT_PROMPT = os.getenv(
+        "DEFAULT_PROMPT", 
+        "pdf 이미지 분석하여 도면인지 어떤 정보들이 있는지 알려줘.structured_output 이외에 정보도 기타에 넣어줘."
+    )
+    
+    # 파일 업로드 설정
+    MAX_FILE_SIZE_MB = int(os.getenv("MAX_FILE_SIZE_MB", "50"))
+    ALLOWED_EXTENSIONS = os.getenv("ALLOWED_EXTENSIONS", "pdf,dxf").split(",")
+    UPLOAD_FOLDER = os.getenv("UPLOAD_FOLDER", "uploads")
+    
+    # 경로 설정
+    BASE_DIR = Path(__file__).parent
+    UPLOAD_DIR = BASE_DIR / UPLOAD_FOLDER
+    ASSETS_DIR = BASE_DIR / "assets"
+    RESULTS_FOLDER = BASE_DIR / "results"
+    
+    @classmethod
+    def validate_config(cls):
+        """설정 유효성 검사"""
+        errors = []
+        
+        if not cls.GEMINI_API_KEY:
+            errors.append("GEMINI_API_KEY가 설정되지 않았습니다.")
+            
+        if not cls.UPLOAD_DIR.exists():
+            try:
+                cls.UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+            except Exception as e:
+                errors.append(f"업로드 폴더 생성 실패: {e}")
+                
+        return errors
+    
+    @classmethod
+    def get_file_size_limit_bytes(cls):
+        """파일 크기 제한을 바이트로 반환"""
+        return cls.MAX_FILE_SIZE_MB * 1024 * 1024
+    
+    @classmethod
+    def get_gemini_api_key(cls):
+        """Gemini API 키 반환"""
+        return cls.GEMINI_API_KEY
+
+# 설정 검증
+if __name__ == "__main__":
+    config_errors = Config.validate_config()
+    if config_errors:
+        print("설정 오류:")
+        for error in config_errors:
+            print(f"  - {error}")
+    else:
+        print("설정이 올바르게 구성되었습니다.")

fletimageanalysis/cross_tabulated_csv_exporter.py

@@ -0,0 +1,638 @@
+"""
+Cross-Tabulated CSV 내보내기 모듈 (개선된 통합 버전)
+JSON 형태의 분석 결과를 key-value 형태의 cross-tabulated CSV로 저장하는 기능을 제공합니다.
+관련 키들(value, x, y)을 하나의 행으로 통합하여 저장합니다.
+
+Author: Claude Assistant  
+Created: 2025-07-15
+Updated: 2025-07-16 (키 통합 개선 버전)
+Version: 2.0.0
+"""
+
+import pandas as pd
+import json
+import logging
+from datetime import datetime
+from typing import List, Dict, Any, Optional, Union, Tuple
+import os
+import re
+from collections import defaultdict
+
+# 로깅 설정
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class CrossTabulatedCSVExporter:
+    """Cross-Tabulated CSV 내보내기 클래스 (개선된 통합 버전)"""
+    
+    def __init__(self):
+        """Cross-Tabulated CSV 내보내기 초기화"""
+        self.coordinate_pattern = re.compile(r'\b(\d+)\s*,\s*(\d+)\b')  # x,y 좌표 패턴
+        self.debug_mode = True  # 디버깅 모드 활성화
+        
+        # 키 그룹핑을 위한 패턴들
+        self.value_suffixes = ['_value', '_val', '_text', '_content']
+        self.x_suffixes = ['_x', '_x_coord', '_x_position', '_left']
+        self.y_suffixes = ['_y', '_y_coord', '_y_position', '_top']
+        
+    def export_cross_tabulated_csv(
+        self,
+        processing_results: List[Any],
+        output_path: str,
+        include_coordinates: bool = True,
+        coordinate_source: str = "auto"  # "auto", "text_blocks", "analysis_result", "none"
+    ) -> bool:
+        """
+        처리 결과를 cross-tabulated CSV 형태로 저장 (키 통합 기능 포함)
+        
+        Args:
+            processing_results: 다중 파일 처리 결과 리스트
+            output_path: 출력 CSV 파일 경로
+            include_coordinates: 좌표 정보 포함 여부
+            coordinate_source: 좌표 정보 출처 ("auto", "text_blocks", "analysis_result", "none")
+            
+        Returns:
+            저장 성공 여부
+        """
+        try:
+            if self.debug_mode:
+                logger.info(f"=== Cross-tabulated CSV 저장 시작 (통합 버전) ===")
+                logger.info(f"입력된 결과 수: {len(processing_results)}")
+                logger.info(f"출력 경로: {output_path}")
+                logger.info(f"좌표 포함: {include_coordinates}, 좌표 출처: {coordinate_source}")
+            
+            # 입력 데이터 검증
+            if not processing_results:
+                logger.warning("입력된 처리 결과가 비어있습니다.")
+                return False
+            
+            # 각 결과 객체의 구조 분석
+            for i, result in enumerate(processing_results):
+                if self.debug_mode:
+                    logger.info(f"결과 {i+1}: {self._analyze_result_structure(result)}")
+            
+            # 모든 파일의 key-value 쌍을 수집
+            all_grouped_data = []
+            
+            for i, result in enumerate(processing_results):
+                try:
+                    if not hasattr(result, 'success'):
+                        logger.warning(f"결과 {i+1}: 'success' 속성이 없습니다. 스킵합니다.")
+                        continue
+                        
+                    if not result.success:
+                        if self.debug_mode:
+                            logger.info(f"결과 {i+1}: 실패한 파일, 스킵합니다 ({getattr(result, 'error_message', 'Unknown error')})")
+                        continue  # 실패한 파일은 제외
+                        
+                    # 기본 key-value 쌍 추출
+                    file_data = self._extract_key_value_pairs(result, include_coordinates, coordinate_source)
+                    
+                    if file_data:
+                        # 관련 키들을 그룹화하여 통합된 데이터 생성
+                        grouped_data = self._group_and_merge_keys(file_data, result)
+                        
+                        if grouped_data:
+                            all_grouped_data.extend(grouped_data)
+                            if self.debug_mode:
+                                logger.info(f"결과 {i+1}: {len(file_data)}개 key-value 쌍 → {len(grouped_data)}개 통합 행 생성")
+                        else:
+                            if self.debug_mode:
+                                logger.warning(f"결과 {i+1}: 그룹화 후 데이터가 없습니다")
+                    else:
+                        if self.debug_mode:
+                            logger.warning(f"결과 {i+1}: key-value 쌍을 추출할 수 없습니다")
+                            
+                except Exception as e:
+                    logger.error(f"결과 {i+1} 처리 중 오류: {str(e)}")
+                    continue
+            
+            if not all_grouped_data:
+                logger.warning("저장할 데이터가 없습니다. 모든 파일에서 유효한 key-value 쌍을 추출할 수 없었습니다.")
+                if self.debug_mode:
+                    self._print_debug_summary(processing_results)
+                return False
+            
+            # DataFrame 생성
+            df = pd.DataFrame(all_grouped_data)
+            
+            # 컬럼 순서 정렬
+            column_order = ['file_name', 'file_type', 'key', 'value']
+            if include_coordinates and coordinate_source != "none":
+                column_order.extend(['x', 'y'])
+            
+            # 추가 컬럼들을 뒤에 배치
+            existing_columns = [col for col in column_order if col in df.columns]
+            additional_columns = [col for col in df.columns if col not in existing_columns]
+            df = df[existing_columns + additional_columns]
+            
+            # 출력 디렉토리 생성
+            os.makedirs(os.path.dirname(output_path), exist_ok=True)
+            
+            # UTF-8 BOM으로 저장 (한글 호환성)
+            df.to_csv(output_path, index=False, encoding='utf-8-sig')
+            
+            logger.info(f"Cross-tabulated CSV 저장 완료: {output_path}")
+            logger.info(f"총 {len(all_grouped_data)}개 통합 행 저장")
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"Cross-tabulated CSV 저장 오류: {str(e)}")
+            return False
+    
+    def _group_and_merge_keys(self, raw_data: List[Dict[str, Any]], result: Any) -> List[Dict[str, Any]]:
+        """
+        관련된 키들을 그룹화하고 하나의 행으로 통합
+        
+        Args:
+            raw_data: 원시 key-value 쌍 리스트
+            result: 파일 처리 결과
+            
+        Returns:
+            통합된 데이터 리스트
+        """
+        # 파일 기본 정보
+        file_name = getattr(result, 'file_name', 'Unknown')
+        file_type = getattr(result, 'file_type', 'Unknown')
+        
+        # 키별로 데이터 그룹화
+        key_groups = defaultdict(dict)
+        
+        for data_row in raw_data:
+            key = data_row.get('key', '')
+            value = data_row.get('value', '')
+            x = data_row.get('x', '')
+            y = data_row.get('y', '')
+            
+            # 기본 키 추출 (예: "사업명_value" -> "사업명")
+            base_key = self._extract_base_key(key)
+            
+            # 키 타입 결정 (value, x, y 등)
+            key_type = self._determine_key_type(key)
+            
+            if self.debug_mode and not key_groups[base_key]:
+                logger.info(f"새 키 그룹 생성: '{base_key}' (원본: '{key}', 타입: '{key_type}')")
+            
+            # 그룹에 데이터 추가
+            if key_type == 'value':
+                key_groups[base_key]['value'] = value
+                # value에 좌표가 포함된 경우 사용
+                if not key_groups[base_key].get('x') and x:
+                    key_groups[base_key]['x'] = x
+                if not key_groups[base_key].get('y') and y:
+                    key_groups[base_key]['y'] = y
+            elif key_type == 'x':
+                key_groups[base_key]['x'] = value  # x 값은 value 컬럼에서 가져옴
+            elif key_type == 'y':
+                key_groups[base_key]['y'] = value  # y 값은 value 컬럼에서 가져옴
+            else:
+                # 일반적인 키인 경우 (suffix가 없는 경우)
+                if not key_groups[base_key].get('value'):
+                    key_groups[base_key]['value'] = value
+                if x and not key_groups[base_key].get('x'):
+                    key_groups[base_key]['x'] = x
+                if y and not key_groups[base_key].get('y'):
+                    key_groups[base_key]['y'] = y
+        
+        # 그룹화된 데이터를 최종 형태로 변환
+        merged_data = []
+        
+        for base_key, group_data in key_groups.items():
+            # 빈 값이나 의미없는 데이터 제외
+            if not group_data.get('value') or str(group_data.get('value')).strip() == '':
+                continue
+            
+            merged_row = {
+                'file_name': file_name,
+                'file_type': file_type,
+                'key': base_key,
+                'value': str(group_data.get('value', '')),
+                'x': str(group_data.get('x', '')) if group_data.get('x') else '',
+                'y': str(group_data.get('y', '')) if group_data.get('y') else '',
+            }
+            
+            merged_data.append(merged_row)
+            
+            if self.debug_mode:
+                logger.info(f"통합 행 생성: {base_key} = '{merged_row['value']}' ({merged_row['x']}, {merged_row['y']})")
+        
+        return merged_data
+    
+    def _extract_base_key(self, key: str) -> str:
+        """
+        키에서 기본 이름 추출 (suffix 제거)
+        
+        Args:
+            key: 원본 키 (예: "사업명_value", "사업명_x")
+            
+        Returns:
+            기본 키 이름 (예: "사업명")
+        """
+        if not key:
+            return key
+            
+        # 모든 가능한 suffix 확인
+        all_suffixes = self.value_suffixes + self.x_suffixes + self.y_suffixes
+        
+        for suffix in all_suffixes:
+            if key.endswith(suffix):
+                return key[:-len(suffix)]
+        
+        # suffix가 없는 경우 원본 반환
+        return key
+    
+    def _determine_key_type(self, key: str) -> str:
+        """
+        키의 타입 결정 (value, x, y, other)
+        
+        Args:
+            key: 키 이름
+            
+        Returns:
+            키 타입 ("value", "x", "y", "other")
+        """
+        if not key:
+            return "other"
+        
+        key_lower = key.lower()
+        
+        # value 타입 확인
+        for suffix in self.value_suffixes:
+            if key_lower.endswith(suffix.lower()):
+                return "value"
+        
+        # x 타입 확인
+        for suffix in self.x_suffixes:
+            if key_lower.endswith(suffix.lower()):
+                return "x"
+        
+        # y 타입 확인
+        for suffix in self.y_suffixes:
+            if key_lower.endswith(suffix.lower()):
+                return "y"
+        
+        return "other"
+    
+    def _analyze_result_structure(self, result: Any) -> str:
+        """결과 객체의 구조를 분석하여 문자열로 반환"""
+        try:
+            info = []
+            
+            # 기본 속성들 확인
+            if hasattr(result, 'file_name'):
+                info.append(f"file_name='{result.file_name}'")
+            if hasattr(result, 'file_type'):
+                info.append(f"file_type='{result.file_type}'")
+            if hasattr(result, 'success'):
+                info.append(f"success={result.success}")
+            
+            # PDF 관련 속성
+            if hasattr(result, 'pdf_analysis_result'):
+                pdf_result = result.pdf_analysis_result
+                if pdf_result:
+                    if isinstance(pdf_result, str):
+                        info.append(f"pdf_analysis_result=str({len(pdf_result)} chars)")
+                    else:
+                        info.append(f"pdf_analysis_result={type(pdf_result).__name__}")
+                else:
+                    info.append("pdf_analysis_result=None")
+            
+            # DXF 관련 속성
+            if hasattr(result, 'dxf_title_blocks'):
+                dxf_blocks = result.dxf_title_blocks
+                if dxf_blocks:
+                    info.append(f"dxf_title_blocks=list({len(dxf_blocks)} blocks)")
+                else:
+                    info.append("dxf_title_blocks=None")
+            
+            return " | ".join(info) if info else "구조 분석 실패"
+            
+        except Exception as e:
+            return f"분석 오류: {str(e)}"
+    
+    def _print_debug_summary(self, processing_results: List[Any]):
+        """디버깅을 위한 요약 정보 출력"""
+        logger.info("=== 디버깅 요약 ===")
+        
+        success_count = 0
+        pdf_count = 0
+        dxf_count = 0
+        has_pdf_data = 0
+        has_dxf_data = 0
+        
+        for i, result in enumerate(processing_results):
+            try:
+                if hasattr(result, 'success') and result.success:
+                    success_count += 1
+                    
+                    file_type = getattr(result, 'file_type', 'unknown').lower()
+                    if file_type == 'pdf':
+                        pdf_count += 1
+                        if getattr(result, 'pdf_analysis_result', None):
+                            has_pdf_data += 1
+                    elif file_type == 'dxf':
+                        dxf_count += 1
+                        if getattr(result, 'dxf_title_blocks', None):
+                            has_dxf_data += 1
+                            
+            except Exception as e:
+                logger.error(f"결과 {i+1} 분석 중 오류: {str(e)}")
+        
+        logger.info(f"총 결과: {len(processing_results)}개")
+        logger.info(f"성공한 결과: {success_count}개")
+        logger.info(f"PDF 파일: {pdf_count}개 (분석 데이터 있음: {has_pdf_data}개)")
+        logger.info(f"DXF 파일: {dxf_count}개 (타이틀블록 데이터 있음: {has_dxf_data}개)")
+    
+    def _extract_key_value_pairs(
+        self,
+        result: Any,
+        include_coordinates: bool,
+        coordinate_source: str
+    ) -> List[Dict[str, Any]]:
+        """
+        단일 파일 결과에서 key-value 쌍 추출
+        
+        Args:
+            result: 파일 처리 결과
+            include_coordinates: 좌표 정보 포함 여부
+            coordinate_source: 좌표 정보 출처
+            
+        Returns:
+            key-value 쌍 리스트
+        """
+        data_rows = []
+        
+        try:
+            # 기본 정보 확인
+            file_name = getattr(result, 'file_name', 'Unknown')
+            file_type = getattr(result, 'file_type', 'Unknown')
+            
+            base_info = {
+                'file_name': file_name,
+                'file_type': file_type,
+            }
+            
+            if self.debug_mode:
+                logger.info(f"처리 중: {file_name} ({file_type})")
+            
+            # PDF 분석 결과 처리
+            if file_type.lower() == 'pdf':
+                pdf_result = getattr(result, 'pdf_analysis_result', None)
+                if pdf_result:
+                    pdf_rows = self._extract_pdf_key_values(result, base_info, include_coordinates, coordinate_source)
+                    data_rows.extend(pdf_rows)
+                    if self.debug_mode:
+                        logger.info(f"PDF에서 {len(pdf_rows)}개 key-value 쌍 추출")
+                else:
+                    if self.debug_mode:
+                        logger.warning(f"PDF 분석 결과가 없습니다: {file_name}")
+            
+            # DXF 분석 결과 처리
+            elif file_type.lower() == 'dxf':
+                dxf_blocks = getattr(result, 'dxf_title_blocks', None)
+                if dxf_blocks:
+                    dxf_rows = self._extract_dxf_key_values(result, base_info, include_coordinates, coordinate_source)
+                    data_rows.extend(dxf_rows)
+                    if self.debug_mode:
+                        logger.info(f"DXF에서 {len(dxf_rows)}개 key-value 쌍 추출")
+                else:
+                    if self.debug_mode:
+                        logger.warning(f"DXF 타이틀블록 데이터가 없습니다: {file_name}")
+            
+            else:
+                if self.debug_mode:
+                    logger.warning(f"지원하지 않는 파일 형식: {file_type}")
+            
+        except Exception as e:
+            logger.error(f"Key-value 추출 오류 ({getattr(result, 'file_name', 'Unknown')}): {str(e)}")
+        
+        return data_rows
+    
+    def _extract_pdf_key_values(
+        self,
+        result: Any,
+        base_info: Dict[str, str],
+        include_coordinates: bool,
+        coordinate_source: str
+    ) -> List[Dict[str, Any]]:
+        """PDF 분석 결과에서 key-value 쌍 추출"""
+        data_rows = []
+        
+        try:
+            # PDF 분석 결과를 JSON으로 파싱
+            analysis_result = getattr(result, 'pdf_analysis_result', None)
+            
+            if not analysis_result:
+                return data_rows
+            
+            if isinstance(analysis_result, str):
+                try:
+                    analysis_data = json.loads(analysis_result)
+                except json.JSONDecodeError:
+                    # JSON이 아닌 경우 텍스트로 처리
+                    analysis_data = {"분석결과": analysis_result}
+            else:
+                analysis_data = analysis_result
+            
+            if self.debug_mode:
+                logger.info(f"PDF 분석 데이터 구조: {type(analysis_data).__name__}")
+                if isinstance(analysis_data, dict):
+                    logger.info(f"PDF 분석 데이터 키: {list(analysis_data.keys())}")
+            
+            # 중첩된 구조를 평탄화하여 key-value 쌍 생성
+            flattened_data = self._flatten_dict(analysis_data)
+            
+            for key, value in flattened_data.items():
+                if value is None or str(value).strip() == "":
+                    continue  # 빈 값 제외
+                
+                row_data = base_info.copy()
+                row_data.update({
+                    'key': key,
+                    'value': str(value),
+                })
+                
+                # 좌표 정보 추가
+                if include_coordinates and coordinate_source != "none":
+                    coordinates = self._extract_coordinates(key, value, coordinate_source)
+                    row_data.update(coordinates)
+                
+                data_rows.append(row_data)
+                
+        except Exception as e:
+            logger.error(f"PDF key-value 추출 오류: {str(e)}")
+        
+        return data_rows
+    
+    def _extract_dxf_key_values(
+        self,
+        result: Any,
+        base_info: Dict[str, str],
+        include_coordinates: bool,
+        coordinate_source: str
+    ) -> List[Dict[str, Any]]:
+        """DXF 분석 결과에서 key-value 쌍 추출"""
+        data_rows = []
+        
+        try:
+            title_blocks = getattr(result, 'dxf_title_blocks', None)
+            
+            if not title_blocks:
+                return data_rows
+            
+            if self.debug_mode:
+                logger.info(f"DXF 타이틀블록 수: {len(title_blocks)}")
+            
+            for block_idx, title_block in enumerate(title_blocks):
+                if not isinstance(title_block, dict):
+                    continue
+                    
+                block_name = title_block.get('block_name', 'Unknown')
+                
+                # 블록 정보
+                row_data = base_info.copy()
+                row_data.update({
+                    'key': f"{block_name}_블록명",
+                    'value': block_name,
+                })
+                
+                if include_coordinates and coordinate_source != "none":
+                    coordinates = self._extract_coordinates('블록명', block_name, coordinate_source)
+                    row_data.update(coordinates)
+                
+                data_rows.append(row_data)
+                
+                # 속성 정보
+                attributes = title_block.get('attributes', [])
+                if self.debug_mode:
+                    logger.info(f"블록 {block_idx+1} ({block_name}): {len(attributes)}개 속성")
+                
+                for attr_idx, attr in enumerate(attributes):
+                    if not isinstance(attr, dict):
+                        continue
+                        
+                    attr_text = attr.get('text', '')
+                    if not attr_text or str(attr_text).strip() == "":
+                        continue  # 빈 속성 제외
+                    
+                    # 속성별 key-value 쌍 생성
+                    attr_key = attr.get('tag', attr.get('prompt', f'Unknown_Attr_{attr_idx}'))
+                    attr_value = str(attr_text)
+                    
+                    row_data = base_info.copy()
+                    row_data.update({
+                        'key': attr_key,
+                        'value': attr_value,
+                    })
+                    
+                    # DXF 속성의 경우 insert 좌표 사용
+                    if include_coordinates and coordinate_source != "none":
+                        x_coord = attr.get('insert_x', '')
+                        y_coord = attr.get('insert_y', '')
+                        
+                        if x_coord and y_coord:
+                            row_data.update({
+                                'x': round(float(x_coord), 2) if isinstance(x_coord, (int, float)) else x_coord,
+                                'y': round(float(y_coord), 2) if isinstance(y_coord, (int, float)) else y_coord,
+                            })
+                        else:
+                            row_data.update({'x': '', 'y': ''})
+                    
+                    data_rows.append(row_data)
+                    
+        except Exception as e:
+            logger.error(f"DXF key-value 추출 오류: {str(e)}")
+        
+        return data_rows
+    
+    def _flatten_dict(self, data: Dict[str, Any], parent_key: str = '', sep: str = '_') -> Dict[str, Any]:
+        """
+        중첩된 딕셔너리를 평탄화
+        
+        Args:
+            data: 평탄화할 딕셔너리
+            parent_key: 부모 키
+            sep: 구분자
+            
+        Returns:
+            평탄화된 딕셔너리
+        """
+        items = []
+        
+        for k, v in data.items():
+            new_key = f"{parent_key}{sep}{k}" if parent_key else k
+            
+            if isinstance(v, dict):
+                # 중첩된 딕셔너리인 경우 재귀 호출
+                items.extend(self._flatten_dict(v, new_key, sep=sep).items())
+            elif isinstance(v, list):
+                # 리스트인 경우 인덱스와 함께 처리
+                for i, item in enumerate(v):
+                    if isinstance(item, dict):
+                        items.extend(self._flatten_dict(item, f"{new_key}_{i}", sep=sep).items())
+                    else:
+                        items.append((f"{new_key}_{i}", item))
+            else:
+                items.append((new_key, v))
+        
+        return dict(items)
+    
+    def _extract_coordinates(self, key: str, value: str, coordinate_source: str) -> Dict[str, str]:
+        """
+        텍스트에서 좌표 정보 추출
+        
+        Args:
+            key: 키
+            value: 값
+            coordinate_source: 좌표 정보 출처
+            
+        Returns:
+            좌표 딕셔너리
+        """
+        coordinates = {'x': '', 'y': ''}
+        
+        try:
+            # 값에서 좌표 패턴 찾기
+            matches = self.coordinate_pattern.findall(str(value))
+            
+            if matches:
+                # 첫 번째 매치 사용
+                x, y = matches[0]
+                coordinates = {'x': x, 'y': y}
+            else:
+                # 키에서 좌표 정보 찾기
+                key_matches = self.coordinate_pattern.findall(str(key))
+                if key_matches:
+                    x, y = key_matches[0]
+                    coordinates = {'x': x, 'y': y}
+        
+        except Exception as e:
+            logger.warning(f"좌표 추출 오류: {str(e)}")
+        
+        return coordinates
+
+
+def generate_cross_tabulated_csv_filename(base_name: str = "cross_tabulated_analysis") -> str:
+    """기본 Cross-tabulated CSV 파일명 생성"""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return f"{base_name}_results_{timestamp}.csv"
+
+
+# 사용 예시
+if __name__ == "__main__":
+    # 테스트용 예시
+    exporter = CrossTabulatedCSVExporter()
+    
+    # 샘플 처리 결과 (실제 데이터 구조에 맞게 수정)
+    sample_results = []
+    
+    # 실제 사용 시에는 processing_results를 전달
+    # success = exporter.export_cross_tabulated_csv(
+    #     sample_results,
+    #     "test_cross_tabulated.csv",
+    #     include_coordinates=True
+    # )
+    
+    print("Cross-tabulated CSV 내보내기 모듈 (통합 버전) 테스트 완료")

fletimageanalysis/csv_exporter.py

@@ -0,0 +1,306 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+CSV 저장 유틸리티 모듈
+DXF 타이틀블럭 Attribute 정보를 CSV 형식으로 저장
+"""
+
+import csv
+import os
+import logging
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+from config import Config
+
+logger = logging.getLogger(__name__)
+
+
+class TitleBlockCSVExporter:
+    """타이틀블럭 속성 정보 CSV 저장 클래스"""
+    
+    def __init__(self, output_dir: str = None):
+        """CSV 저장기 초기화"""
+        self.output_dir = output_dir or Config.RESULTS_FOLDER
+        os.makedirs(self.output_dir, exist_ok=True)
+        
+    def export_title_block_attributes(
+        self, 
+        title_block_info: Dict[str, Any], 
+        filename: str = None
+    ) -> Optional[str]:
+        """
+        타이틀블럭 속성 정보를 CSV 파일로 저장
+        
+        Args:
+            title_block_info: 타이틀블럭 정보 딕셔너리
+            filename: 저장할 파일명 (없으면 자동 생성)
+            
+        Returns:
+            저장된 파일 경로 또는 None (실패시)
+        """
+        try:
+            if not title_block_info or not title_block_info.get('all_attributes'):
+                logger.warning("타이틀블럭 속성 정보가 없습니다.")
+                return None
+            
+            # 파일명 생성
+            if not filename:
+                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                block_name = title_block_info.get('block_name', 'Unknown_Block')
+                filename = f"title_block_attributes_{block_name}_{timestamp}.csv"
+            
+            # 확장자 확인
+            if not filename.endswith('.csv'):
+                filename += '.csv'
+            
+            filepath = os.path.join(self.output_dir, filename)
+            
+            # CSV 헤더 정의
+            headers = [
+                'block_name',           # block_ref.name
+                'attr_prompt',          # attr.prompt
+                'attr_text',            # attr.text
+                'attr_tag',             # attr.tag
+                'attr_insert_x',        # attr.insert_x
+                'attr_insert_y',        # attr.insert_y
+                'bounding_box_min_x',   # attr.bounding_box.min_x
+                'bounding_box_min_y',   # attr.bounding_box.min_y
+                'bounding_box_max_x',   # attr.bounding_box.max_x
+                'bounding_box_max_y',   # attr.bounding_box.max_y
+                'bounding_box_width',   # attr.bounding_box.width
+                'bounding_box_height',  # attr.bounding_box.height
+                'attr_height',          # 추가: 텍스트 높이
+                'attr_rotation',        # 추가: 회전각
+                'attr_layer',           # 추가: 레이어
+                'attr_style',           # 추가: 스타일
+                'entity_handle'         # 추가: 엔티티 핸들
+            ]
+            
+            # CSV 데이터 준비
+            csv_rows = []
+            block_name = title_block_info.get('block_name', '')
+            
+            for attr in title_block_info.get('all_attributes', []):
+                row = {
+                    'block_name': block_name,
+                    'attr_prompt': attr.get('prompt', '') or '',
+                    'attr_text': attr.get('text', '') or '',
+                    'attr_tag': attr.get('tag', '') or '',
+                    'attr_insert_x': attr.get('insert_x', '') or '',
+                    'attr_insert_y': attr.get('insert_y', '') or '',
+                    'attr_height': attr.get('height', '') or '',
+                    'attr_rotation': attr.get('rotation', '') or '',
+                    'attr_layer': attr.get('layer', '') or '',
+                    'attr_style': attr.get('style', '') or '',
+                    'entity_handle': attr.get('entity_handle', '') or '',
+                }
+                
+                # 바운딩 박스 정보 추가
+                bbox = attr.get('bounding_box')
+                if bbox:
+                    row.update({
+                        'bounding_box_min_x': bbox.get('min_x', ''),
+                        'bounding_box_min_y': bbox.get('min_y', ''),
+                        'bounding_box_max_x': bbox.get('max_x', ''),
+                        'bounding_box_max_y': bbox.get('max_y', ''),
+                        'bounding_box_width': bbox.get('max_x', 0) - bbox.get('min_x', 0) if bbox.get('max_x') and bbox.get('min_x') else '',
+                        'bounding_box_height': bbox.get('max_y', 0) - bbox.get('min_y', 0) if bbox.get('max_y') and bbox.get('min_y') else '',
+                    })
+                else:
+                    row.update({
+                        'bounding_box_min_x': '',
+                        'bounding_box_min_y': '',
+                        'bounding_box_max_x': '',
+                        'bounding_box_max_y': '',
+                        'bounding_box_width': '',
+                        'bounding_box_height': '',
+                    })
+                
+                csv_rows.append(row)
+            
+            # CSV 파일 저장
+            with open(filepath, 'w', newline='', encoding='utf-8-sig') as csvfile:
+                writer = csv.DictWriter(csvfile, fieldnames=headers)
+                
+                # 헤더 작성
+                writer.writeheader()
+                
+                # 데이터 작성
+                writer.writerows(csv_rows)
+            
+            logger.info(f"타이틀블럭 속성 CSV 저장 완료: {filepath}")
+            return filepath
+            
+        except Exception as e:
+            logger.error(f"CSV 저장 중 오류: {e}")
+            return None
+    
+    def create_attribute_table_data(
+        self, 
+        title_block_info: Dict[str, Any]
+    ) -> List[Dict[str, str]]:
+        """
+        UI 테이블 표시용 데이터 생성
+        
+        Args:
+            title_block_info: 타이틀블럭 정보 딕셔너리
+            
+        Returns:
+            테이블 표시용 데이터 리스트
+        """
+        try:
+            if not title_block_info or not title_block_info.get('all_attributes'):
+                return []
+            
+            table_data = []
+            block_name = title_block_info.get('block_name', '')
+            
+            for i, attr in enumerate(title_block_info.get('all_attributes', [])):
+                # 바운딩 박스 정보 포맷팅
+                bbox_str = ""
+                bbox = attr.get('bounding_box')
+                if bbox:
+                    bbox_str = f"({bbox.get('min_x', 0):.1f}, {bbox.get('min_y', 0):.1f}) - ({bbox.get('max_x', 0):.1f}, {bbox.get('max_y', 0):.1f})"
+                
+                row = {
+                    'No.': str(i + 1),
+                    'Block Name': block_name,
+                    'Tag': attr.get('tag', ''),
+                    'Text': attr.get('text', '')[:30] + ('...' if len(attr.get('text', '')) > 30 else ''),  # 텍스트 길이 제한
+                    'Prompt': attr.get('prompt', '') or 'N/A',
+                    'X': f"{attr.get('insert_x', 0):.1f}",
+                    'Y': f"{attr.get('insert_y', 0):.1f}",
+                    'Bounding Box': bbox_str or 'N/A',
+                    'Height': f"{attr.get('height', 0):.1f}",
+                    'Layer': attr.get('layer', ''),
+                }
+                
+                table_data.append(row)
+            
+            return table_data
+            
+        except Exception as e:
+            logger.error(f"테이블 데이터 생성 중 오류: {e}")
+            return []
+
+
+def main():
+    """테스트용 메인 함수"""
+    logging.basicConfig(level=logging.INFO)
+    
+    # 테스트 데이터
+    test_title_block = {
+        'block_name': 'TEST_TITLE_BLOCK',
+        'all_attributes': [
+            {
+                'tag': 'DRAWING_NAME',
+                'text': '테스트 도면',
+                'prompt': '도면명을 입력하세요',
+                'insert_x': 100.0,
+                'insert_y': 200.0,
+                'height': 5.0,
+                'rotation': 0.0,
+                'layer': '0',
+                'style': 'Standard',
+                'entity_handle': 'ABC123',
+                'bounding_box': {
+                    'min_x': 100.0,
+                    'min_y': 200.0,
+                    'max_x': 180.0,
+                    'max_y': 210.0
+                }
+            },
+            {
+                'tag': 'DRAWING_NUMBER',
+                'text': 'TEST-001',
+                'prompt': '도면번호를 입력하세요',
+                'insert_x': 100.0,
+                'insert_y': 190.0,
+                'height': 4.0,
+                'rotation': 0.0,
+                'layer': '0',
+                'style': 'Standard',
+                'entity_handle': 'DEF456',
+                'bounding_box': {
+                    'min_x': 100.0,
+                    'min_y': 190.0,
+                    'max_x': 150.0,
+                    'max_y': 198.0
+                }
+            }
+        ]
+    }
+    
+    # CSV 저장 테스트
+    exporter = TitleBlockCSVExporter()
+    
+    # 테이블 데이터 생성 테스트
+    table_data = exporter.create_attribute_table_data(test_title_block)
+    print("테이블 데이터:")
+    for row in table_data:
+        print(row)
+    
+    # CSV 저장 테스트
+    saved_path = exporter.export_title_block_attributes(test_title_block, "test_export.csv")
+    if saved_path:
+        print(f"\nCSV 저장 성공: {saved_path}")
+    else:
+        print("\nCSV 저장 실패")
+
+
+    if __name__ == "__main__":
+        main()
+
+import json
+
+def export_analysis_results_to_csv(data: List[Dict[str, Any]], file_path: str):
+    """
+    분석 결과를 CSV 파일로 저장합니다. pdf_analysis_result 컬럼의 JSON 데이터를 평탄화합니다.
+    Args:
+        data: 분석 결과 딕셔너리 리스트
+        file_path: 저장할 CSV 파일 경로
+    """
+    if not data:
+        logger.warning("내보낼 데이터가 없습니다.")
+        return
+
+    all_keys = set()
+    processed_data = []
+
+    for row in data:
+        new_row = row.copy()
+        if 'pdf_analysis_result' in new_row and new_row['pdf_analysis_result']:
+            try:
+                json_data = new_row['pdf_analysis_result']
+                if isinstance(json_data, str):
+                    json_data = json.loads(json_data)
+
+                if isinstance(json_data, dict):
+                    for k, v in json_data.items():
+                        new_row[f"pdf_analysis_result_{k}"] = v
+                    del new_row['pdf_analysis_result']
+                else:
+                    new_row['pdf_analysis_result'] = str(json_data)
+            except (json.JSONDecodeError, TypeError) as e:
+                logger.warning(f"pdf_analysis_result 파싱 오류: {e}, 원본 데이터 유지: {new_row['pdf_analysis_result']}")
+                new_row['pdf_analysis_result'] = str(new_row['pdf_analysis_result'])
+        
+        processed_data.append(new_row)
+        all_keys.update(new_row.keys())
+
+    # 'pdf_analysis_result'가 평탄화된 경우 최종 키에서 제거
+    if 'pdf_analysis_result' in all_keys:
+        all_keys.remove('pdf_analysis_result')
+
+    sorted_keys = sorted(list(all_keys))
+
+    try:
+        with open(file_path, 'w', newline='', encoding='utf-8-sig') as output_file:
+            dict_writer = csv.DictWriter(output_file, sorted_keys)
+            dict_writer.writeheader()
+            dict_writer.writerows(processed_data)
+        logger.info(f"분석 결과 CSV 저장 완료: {file_path}")
+    except Exception as e:
+        logger.error(f"분석 결과 CSV 저장 중 오류: {e}")
+

fletimageanalysis/dxf_processor.py

@@ -0,0 +1,871 @@
+# -*- coding: utf-8 -*-
+"""
+향상된 DXF 파일 처리 모듈
+ezdxf 라이브러리를 사용하여 DXF 파일에서 도곽 정보, 텍스트 엔티티 및 모든 Block Reference/Attribute Reference를 추출
+"""
+
+import os
+import json
+import logging
+from typing import Dict, List, Optional, Tuple, Any
+from dataclasses import dataclass, asdict, field
+
+try:
+    import ezdxf
+    from ezdxf.document import Drawing
+    from ezdxf.entities import Insert, Attrib, AttDef, Text, MText
+    from ezdxf.layouts import BlockLayout, Modelspace
+    from ezdxf import bbox, disassemble
+    EZDXF_AVAILABLE = True
+except ImportError:
+    EZDXF_AVAILABLE = False
+    logging.warning("ezdxf 라이브러리가 설치되지 않았습니다. DXF 기능이 비활성화됩니다.")
+
+from config import Config
+
+
+@dataclass
+class BoundingBox:
+    """바운딩 박스 정보를 담는 데이터 클래스"""
+    min_x: float
+    min_y: float
+    max_x: float
+    max_y: float
+    
+    @property
+    def width(self) -> float:
+        return self.max_x - self.min_x
+    
+    @property
+    def height(self) -> float:
+        return self.max_y - self.min_y
+    
+    @property
+    def center(self) -> Tuple[float, float]:
+        return ((self.min_x + self.max_x) / 2, (self.min_y + self.max_y) / 2)
+    
+    def merge(self, other: 'BoundingBox') -> 'BoundingBox':
+        """다른 바운딩 박스와 병합하여 가장 큰 외곽 박스 반환"""
+        return BoundingBox(
+            min_x=min(self.min_x, other.min_x),
+            min_y=min(self.min_y, other.min_y),
+            max_x=max(self.max_x, other.max_x),
+            max_y=max(self.max_y, other.max_y)
+        )
+
+
+@dataclass
+class TextInfo:
+    """텍스트 엔티티 정보를 담는 데이터 클래스"""
+    entity_type: str  # TEXT, MTEXT, ATTRIB
+    text: str
+    position: Tuple[float, float, float]
+    height: float
+    rotation: float
+    layer: str
+    bounding_box: Optional[BoundingBox] = None
+    entity_handle: Optional[str] = None
+    style: Optional[str] = None
+    color: Optional[int] = None
+
+
+@dataclass
+class AttributeInfo:
+    """속성 정보를 담는 데이터 클래스 - 모든 DXF 속성 포함"""
+    tag: str
+    text: str
+    position: Tuple[float, float, float]  # insert point (x, y, z)
+    height: float
+    width: float
+    rotation: float
+    layer: str
+    bounding_box: Optional[BoundingBox] = None
+    
+    # 추가 DXF 속성들
+    prompt: Optional[str] = None
+    style: Optional[str] = None
+    invisible: bool = False
+    const: bool = False
+    verify: bool = False
+    preset: bool = False
+    align_point: Optional[Tuple[float, float, float]] = None
+    halign: int = 0
+    valign: int = 0
+    text_generation_flag: int = 0
+    oblique_angle: float = 0.0
+    width_factor: float = 1.0
+    color: Optional[int] = None
+    linetype: Optional[str] = None
+    lineweight: Optional[int] = None
+    
+    # 좌표 정보
+    insert_x: float = 0.0
+    insert_y: float = 0.0
+    insert_z: float = 0.0
+    
+    # 계산된 정보
+    estimated_width: float = 0.0
+    entity_handle: Optional[str] = None
+
+
+@dataclass
+class BlockInfo:
+    """블록 정보를 담는 데이터 클래스"""
+    name: str
+    position: Tuple[float, float, float]
+    scale: Tuple[float, float, float]
+    rotation: float
+    layer: str
+    attributes: List[AttributeInfo]
+    bounding_box: Optional[BoundingBox] = None
+
+
+@dataclass
+class TitleBlockInfo:
+    """도곽 정보를 담는 데이터 클래스"""
+    drawing_name: Optional[str] = None
+    drawing_number: Optional[str] = None
+    construction_field: Optional[str] = None
+    construction_stage: Optional[str] = None
+    scale: Optional[str] = None
+    project_name: Optional[str] = None
+    designer: Optional[str] = None
+    date: Optional[str] = None
+    revision: Optional[str] = None
+    location: Optional[str] = None
+    bounding_box: Optional[BoundingBox] = None
+    block_name: Optional[str] = None
+    
+    # 모든 attributes 정보 저장
+    all_attributes: List[AttributeInfo] = field(default_factory=list)
+    attributes_count: int = 0
+    
+    # 추가 메타데이터
+    block_position: Optional[Tuple[float, float, float]] = None
+    block_scale: Optional[Tuple[float, float, float]] = None
+    block_rotation: float = 0.0
+    block_layer: Optional[str] = None
+    
+    def __post_init__(self):
+        """초기화 후 처리"""
+        self.attributes_count = len(self.all_attributes)
+
+
+@dataclass
+class ComprehensiveExtractionResult:
+    """종합적인 추출 결과를 담는 데이터 클래스"""
+    text_entities: List[TextInfo] = field(default_factory=list)
+    all_block_references: List[BlockInfo] = field(default_factory=list)
+    title_block: Optional[TitleBlockInfo] = None
+    overall_bounding_box: Optional[BoundingBox] = None
+    summary: Dict[str, Any] = field(default_factory=dict)
+
+
+class EnhancedDXFProcessor:
+    """향상된 DXF 파일 처리 클래스"""
+    
+    # 도곽 식별을 위한 키워드 정의
+    TITLE_BLOCK_KEYWORDS = {
+        '건설분야': ['construction_field', 'field', '분야', '공사', 'category'],
+        '건설단계': ['construction_stage', 'stage', '단계', 'phase'],
+        '도면명': ['drawing_name', 'title', '제목', 'name', '명'],
+        '축척': ['scale', '축척', 'ratio', '비율'],
+        '도면번호': ['drawing_number', 'number', '번호', 'no', 'dwg'],
+        '설계자': ['designer', '설계', 'design', 'drawn'],
+        '프로젝트': ['project', '사업', '공사명'],
+        '날짜': ['date', '일자', '작성일'],
+        '리비전': ['revision', 'rev', '개정'],
+        '위치': ['location', '위치', '지역']
+    }
+    
+    def __init__(self):
+        """DXF 처리기 초기화"""
+        self.logger = logging.getLogger(__name__)
+        
+        if not EZDXF_AVAILABLE:
+            raise ImportError("ezdxf 라이브러리가 필요합니다. 'pip install ezdxf'로 설치하세요.")
+    
+    def validate_dxf_file(self, file_path: str) -> bool:
+        """DXF 파일 유효성 검사"""
+        try:
+            if not os.path.exists(file_path):
+                self.logger.error(f"파일이 존재하지 않습니다: {file_path}")
+                return False
+            
+            if not file_path.lower().endswith('.dxf'):
+                self.logger.error(f"DXF 파일이 아닙니다: {file_path}")
+                return False
+            
+            # ezdxf로 파일 읽기 시도
+            doc = ezdxf.readfile(file_path)
+            if doc is None:
+                return False
+                
+            self.logger.info(f"DXF 파일 유효성 검사 성공: {file_path}")
+            return True
+            
+        except ezdxf.DXFStructureError as e:
+            self.logger.error(f"DXF 구조 오류: {e}")
+            return False
+        except Exception as e:
+            self.logger.error(f"DXF 파일 검증 중 오류: {e}")
+            return False
+    
+    def load_dxf_document(self, file_path: str) -> Optional[Drawing]:
+        """DXF 문서 로드"""
+        try:
+            doc = ezdxf.readfile(file_path)
+            self.logger.info(f"DXF 문서 로드 성공: {file_path}")
+            return doc
+        except Exception as e:
+            self.logger.error(f"DXF 문서 로드 실패: {e}")
+            return None
+    
+    def _is_empty_text(self, text: str) -> bool:
+        """텍스트가 비어있는지 확인 (공백 문자만 있거나 완전히 비어있는 경우)"""
+        return not text or text.strip() == ""
+    
+    def calculate_comprehensive_bounding_box(self, doc: Drawing) -> Optional[BoundingBox]:
+        """전체 문서의 종합적인 바운딩 박스 계산 (ezdxf.bbox 사용)"""
+        try:
+            msp = doc.modelspace()
+            
+            # ezdxf의 bbox 모듈을 사용하여 전체 바운딩 박스 계산
+            cache = bbox.Cache()
+            overall_bbox = bbox.extents(msp, cache=cache)
+            
+            if overall_bbox:
+                self.logger.info(f"전체 바운딩 박스: {overall_bbox}")
+                return BoundingBox(
+                    min_x=overall_bbox.extmin.x,
+                    min_y=overall_bbox.extmin.y,
+                    max_x=overall_bbox.extmax.x,
+                    max_y=overall_bbox.extmax.y
+                )
+            else:
+                self.logger.warning("바운딩 박스 계산 실패")
+                return None
+                
+        except Exception as e:
+            self.logger.warning(f"바운딩 박스 계산 중 오류: {e}")
+            return None
+    
+    def extract_all_text_entities(self, doc: Drawing) -> List[TextInfo]:
+        """모든 텍스트 엔티티 추출 (TEXT, MTEXT, DBTEXT)"""
+        text_entities = []
+        
+        try:
+            msp = doc.modelspace()
+            
+            # TEXT 엔티티 추출
+            for text_entity in msp.query('TEXT'):
+                text_content = getattr(text_entity.dxf, 'text', '')
+                if not self._is_empty_text(text_content):
+                    text_info = self._extract_text_info(text_entity, 'TEXT')
+                    if text_info:
+                        text_entities.append(text_info)
+            
+            # MTEXT 엔티티 추출
+            for mtext_entity in msp.query('MTEXT'):
+                # MTEXT는 .text 속성 사용
+                text_content = getattr(mtext_entity, 'text', '') or getattr(mtext_entity.dxf, 'text', '')
+                if not self._is_empty_text(text_content):
+                    text_info = self._extract_text_info(mtext_entity, 'MTEXT')
+                    if text_info:
+                        text_entities.append(text_info)
+            
+            # ATTRIB 엔티티 추출 (블록 외부의 독립적인 속성)
+            for attrib_entity in msp.query('ATTRIB'):
+                text_content = getattr(attrib_entity.dxf, 'text', '')
+                if not self._is_empty_text(text_content):
+                    text_info = self._extract_text_info(attrib_entity, 'ATTRIB')
+                    if text_info:
+                        text_entities.append(text_info)
+            
+            # 페이퍼스페이스도 확인
+            for layout_name in doc.layout_names_in_taborder():
+                if layout_name.startswith('*'):  # 모델스페이스 제외
+                    continue
+                try:
+                    layout = doc.paperspace(layout_name)
+                    
+                    # TEXT, MTEXT, ATTRIB 추출
+                    for entity_type in ['TEXT', 'MTEXT', 'ATTRIB']:
+                        for entity in layout.query(entity_type):
+                            if entity_type == 'MTEXT':
+                                text_content = getattr(entity, 'text', '') or getattr(entity.dxf, 'text', '')
+                            else:
+                                text_content = getattr(entity.dxf, 'text', '')
+                            
+                            if not self._is_empty_text(text_content):
+                                text_info = self._extract_text_info(entity, entity_type)
+                                if text_info:
+                                    text_entities.append(text_info)
+                                    
+                except Exception as e:
+                    self.logger.warning(f"레이아웃 {layout_name} 처리 중 오류: {e}")
+            
+            self.logger.info(f"총 {len(text_entities)}개의 텍스트 엔티티를 찾았습니다.")
+            return text_entities
+            
+        except Exception as e:
+            self.logger.error(f"텍스트 엔티티 추출 중 오류: {e}")
+            return []
+    
+    def _extract_text_info(self, entity, entity_type: str) -> Optional[TextInfo]:
+        """텍스트 엔티티에서 정보 추출"""
+        try:
+            # 텍스트 내용 추출
+            if entity_type == 'MTEXT':
+                text_content = getattr(entity, 'text', '') or getattr(entity.dxf, 'text', '')
+            else:
+                text_content = getattr(entity.dxf, 'text', '')
+            
+            # 위치 정보
+            insert_point = getattr(entity.dxf, 'insert', (0, 0, 0))
+            position = (
+                insert_point.x if hasattr(insert_point, 'x') else insert_point[0],
+                insert_point.y if hasattr(insert_point, 'y') else insert_point[1],
+                insert_point.z if hasattr(insert_point, 'z') else insert_point[2]
+            )
+            
+            # 기본 속성
+            height = getattr(entity.dxf, 'height', 1.0)
+            rotation = getattr(entity.dxf, 'rotation', 0.0)
+            layer = getattr(entity.dxf, 'layer', '0')
+            entity_handle = getattr(entity.dxf, 'handle', None)
+            style = getattr(entity.dxf, 'style', None)
+            color = getattr(entity.dxf, 'color', None)
+            
+            # 바운딩 박스 계산
+            bounding_box = self._calculate_text_bounding_box(entity)
+            
+            return TextInfo(
+                entity_type=entity_type,
+                text=text_content,
+                position=position,
+                height=height,
+                rotation=rotation,
+                layer=layer,
+                bounding_box=bounding_box,
+                entity_handle=entity_handle,
+                style=style,
+                color=color
+            )
+            
+        except Exception as e:
+            self.logger.warning(f"텍스트 정보 추출 중 오류: {e}")
+            return None
+    
+    def _calculate_text_bounding_box(self, entity) -> Optional[BoundingBox]:
+        """텍스트 엔티티의 바운딩 박스 계산"""
+        try:
+            # ezdxf bbox 모듈 사용
+            entity_bbox = bbox.extents([entity])
+            if entity_bbox:
+                return BoundingBox(
+                    min_x=entity_bbox.extmin.x,
+                    min_y=entity_bbox.extmin.y,
+                    max_x=entity_bbox.extmax.x,
+                    max_y=entity_bbox.extmax.y
+                )
+        except Exception as e:
+            self.logger.debug(f"바운딩 박스 계산 실패, 추정값 사용: {e}")
+            
+        # 대안: 추정 계산
+        try:
+            if hasattr(entity, 'dxf'):
+                insert_point = getattr(entity.dxf, 'insert', (0, 0, 0))
+                height = getattr(entity.dxf, 'height', 1.0)
+                
+                # 텍스트 내용 길이 추정
+                if hasattr(entity, 'text'):
+                    text_content = entity.text
+                elif hasattr(entity.dxf, 'text'):
+                    text_content = entity.dxf.text
+                else:
+                    text_content = ""
+                
+                # 텍스트 너비 추정 (높이의 0.6배 * 글자 수)
+                estimated_width = len(text_content) * height * 0.6
+                
+                x, y = insert_point[0], insert_point[1]
+                
+                return BoundingBox(
+                    min_x=x,
+                    min_y=y,
+                    max_x=x + estimated_width,
+                    max_y=y + height
+                )
+        except Exception as e:
+            self.logger.warning(f"텍스트 바운딩 박스 계산 실패: {e}")
+            return None
+    
+    def extract_all_block_references(self, doc: Drawing) -> List[BlockInfo]:
+        """모든 Block Reference 추출 (재귀적으로 중첩된 블록도 포함)"""
+        block_refs = []
+        
+        try:
+            # 모델스페이스에서 INSERT 엔티티 찾기
+            msp = doc.modelspace()
+            
+            for insert in msp.query('INSERT'):
+                block_info = self._process_block_reference(doc, insert)
+                if block_info:
+                    block_refs.append(block_info)
+            
+            # 페이퍼스페이스도 확인
+            for layout_name in doc.layout_names_in_taborder():
+                if layout_name.startswith('*'):  # 모델스페이스 제외
+                    continue
+                try:
+                    layout = doc.paperspace(layout_name)
+                    for insert in layout.query('INSERT'):
+                        block_info = self._process_block_reference(doc, insert)
+                        if block_info:
+                            block_refs.append(block_info)
+                except Exception as e:
+                    self.logger.warning(f"레이아웃 {layout_name} 처리 중 오류: {e}")
+            
+            # 블록 정의 내부도 재귀적으로 검사
+            for block_layout in doc.blocks:
+                if not block_layout.name.startswith('*'):  # 시스템 블록 제외
+                    for insert in block_layout.query('INSERT'):
+                        block_info = self._process_block_reference(doc, insert)
+                        if block_info:
+                            block_refs.append(block_info)
+            
+            self.logger.info(f"총 {len(block_refs)}개의 블록 참조를 찾았습니다.")
+            return block_refs
+            
+        except Exception as e:
+            self.logger.error(f"블록 참조 추출 중 오류: {e}")
+            return []
+    
+    def _process_block_reference(self, doc: Drawing, insert: Insert) -> Optional[BlockInfo]:
+        """개별 Block Reference 처리 - ATTDEF 정보도 함께 수집"""
+        try:
+            # 블록 정보 추출
+            block_name = insert.dxf.name
+            position = (insert.dxf.insert.x, insert.dxf.insert.y, insert.dxf.insert.z)
+            scale = (
+                getattr(insert.dxf, 'xscale', 1.0),
+                getattr(insert.dxf, 'yscale', 1.0), 
+                getattr(insert.dxf, 'zscale', 1.0)
+            )
+            rotation = getattr(insert.dxf, 'rotation', 0.0)
+            layer = getattr(insert.dxf, 'layer', '0')
+            
+            # ATTDEF 정보 수집 (프롬프트 정보 포함)
+            attdef_info = {}
+            try:
+                block_layout = doc.blocks.get(block_name)
+                if block_layout:
+                    for attdef in block_layout.query('ATTDEF'):
+                        tag = getattr(attdef.dxf, 'tag', '')
+                        prompt = getattr(attdef.dxf, 'prompt', '')
+                        if tag:
+                            attdef_info[tag] = {
+                                'prompt': prompt,
+                                'default_text': getattr(attdef.dxf, 'text', ''),
+                                'position': (attdef.dxf.insert.x, attdef.dxf.insert.y, attdef.dxf.insert.z),
+                                'height': getattr(attdef.dxf, 'height', 1.0),
+                                'style': getattr(attdef.dxf, 'style', 'Standard'),
+                                'invisible': getattr(attdef.dxf, 'invisible', False),
+                                'const': getattr(attdef.dxf, 'const', False),
+                                'verify': getattr(attdef.dxf, 'verify', False),
+                                'preset': getattr(attdef.dxf, 'preset', False)
+                            }
+            except Exception as e:
+                self.logger.debug(f"ATTDEF 정보 수집 실패: {e}")
+            
+            # ATTRIB 속성 추출 및 ATTDEF 정보와 결합 (빈 텍스트 제외)
+            attributes = []
+            for attrib in insert.attribs:
+                attr_info = self._extract_attribute_info(attrib)
+                if attr_info and not self._is_empty_text(attr_info.text):
+                    # ATTDEF에서 프롬프트 정보 추가
+                    if attr_info.tag in attdef_info:
+                        attr_info.prompt = attdef_info[attr_info.tag]['prompt']
+                    attributes.append(attr_info)
+            
+            # 블록 바운딩 박스 계산
+            block_bbox = self._calculate_block_bounding_box(insert)
+            
+            return BlockInfo(
+                name=block_name,
+                position=position,
+                scale=scale,
+                rotation=rotation,
+                layer=layer,
+                attributes=attributes,
+                bounding_box=block_bbox
+            )
+            
+        except Exception as e:
+            self.logger.warning(f"블록 참조 처리 중 오류: {e}")
+            return None
+    
+    def _calculate_block_bounding_box(self, insert: Insert) -> Optional[BoundingBox]:
+        """블록의 바운딩 박스 계산"""
+        try:
+            # ezdxf bbox 모듈 사용
+            block_bbox = bbox.extents([insert])
+            if block_bbox:
+                return BoundingBox(
+                    min_x=block_bbox.extmin.x,
+                    min_y=block_bbox.extmin.y,
+                    max_x=block_bbox.extmax.x,
+                    max_y=block_bbox.extmax.y
+                )
+        except Exception as e:
+            self.logger.debug(f"블록 바운딩 박스 계산 실패: {e}")
+            
+        return None
+    
+    def _extract_attribute_info(self, attrib: Attrib) -> Optional[AttributeInfo]:
+        """Attribute Reference에서 모든 정보 추출 (빈 텍스트 포함)"""
+        try:
+            # 기본 속성
+            tag = getattr(attrib.dxf, 'tag', '')
+            text = getattr(attrib.dxf, 'text', '')
+            
+            # 위치 정보
+            insert_point = getattr(attrib.dxf, 'insert', (0, 0, 0))
+            position = (insert_point.x if hasattr(insert_point, 'x') else insert_point[0],
+                       insert_point.y if hasattr(insert_point, 'y') else insert_point[1],
+                       insert_point.z if hasattr(insert_point, 'z') else insert_point[2])
+            
+            # 텍스트 속성
+            height = getattr(attrib.dxf, 'height', 1.0)
+            width = getattr(attrib.dxf, 'width', 1.0)
+            rotation = getattr(attrib.dxf, 'rotation', 0.0)
+            
+            # 레이어 및 스타일
+            layer = getattr(attrib.dxf, 'layer', '0')
+            style = getattr(attrib.dxf, 'style', 'Standard')
+            
+            # 속성 플래그
+            invisible = getattr(attrib.dxf, 'invisible', False)
+            const = getattr(attrib.dxf, 'const', False)
+            verify = getattr(attrib.dxf, 'verify', False)
+            preset = getattr(attrib.dxf, 'preset', False)
+            
+            # 정렬 정보
+            align_point_data = getattr(attrib.dxf, 'align_point', None)
+            align_point = None
+            if align_point_data:
+                align_point = (align_point_data.x if hasattr(align_point_data, 'x') else align_point_data[0],
+                             align_point_data.y if hasattr(align_point_data, 'y') else align_point_data[1],
+                             align_point_data.z if hasattr(align_point_data, 'z') else align_point_data[2])
+            
+            halign = getattr(attrib.dxf, 'halign', 0)
+            valign = getattr(attrib.dxf, 'valign', 0)
+            
+            # 텍스트 형식
+            text_generation_flag = getattr(attrib.dxf, 'text_generation_flag', 0)
+            oblique_angle = getattr(attrib.dxf, 'oblique_angle', 0.0)
+            width_factor = getattr(attrib.dxf, 'width_factor', 1.0)
+            
+            # 시각적 속성
+            color = getattr(attrib.dxf, 'color', None)
+            linetype = getattr(attrib.dxf, 'linetype', None)
+            lineweight = getattr(attrib.dxf, 'lineweight', None)
+            
+            # 엔티티 핸들
+            entity_handle = getattr(attrib.dxf, 'handle', None)
+            
+            # 텍스트 폭 추정
+            estimated_width = len(text) * height * 0.6 * width_factor
+            
+            # 바운딩 박스 계산
+            bounding_box = self._calculate_text_bounding_box(attrib)
+            
+            return AttributeInfo(
+                tag=tag,
+                text=text,
+                position=position,
+                height=height,
+                width=width,
+                rotation=rotation,
+                layer=layer,
+                bounding_box=bounding_box,
+                prompt=None,  # 나중에 ATTDEF에서 설정
+                style=style,
+                invisible=invisible,
+                const=const,
+                verify=verify,
+                preset=preset,
+                align_point=align_point,
+                halign=halign,
+                valign=valign,
+                text_generation_flag=text_generation_flag,
+                oblique_angle=oblique_angle,
+                width_factor=width_factor,
+                color=color,
+                linetype=linetype,
+                lineweight=lineweight,
+                insert_x=position[0],
+                insert_y=position[1],
+                insert_z=position[2],
+                estimated_width=estimated_width,
+                entity_handle=entity_handle
+            )
+            
+        except Exception as e:
+            self.logger.warning(f"속성 정보 추출 중 오류: {e}")
+            return None
+    
+    def identify_title_block(self, block_refs: List[BlockInfo]) -> Optional[TitleBlockInfo]:
+        """블록 참조들 중에서 도곽을 식별하고 정보 추출"""
+        title_block_candidates = []
+        
+        for block_ref in block_refs:
+            # 도곽 키워드를 포함한 속성이 있는지 확인
+            keyword_matches = 0
+            
+            for attr in block_ref.attributes:
+                for keyword_group in self.TITLE_BLOCK_KEYWORDS.keys():
+                    if self._contains_keyword(attr.tag, keyword_group) or \
+                       self._contains_keyword(attr.text, keyword_group):
+                        keyword_matches += 1
+                        break
+            
+            # 충분한 키워드가 매칭되면 도곽 후보로 추가
+            if keyword_matches >= 2:  # 최소 2개 이상의 키워드 매칭
+                title_block_candidates.append((block_ref, keyword_matches))
+        
+        if not title_block_candidates:
+            self.logger.warning("도곽 블록을 찾을 수 없습니다.")
+            return None
+        
+        # 가장 많은 키워드를 포함한 블록을 도곽으로 선택
+        title_block_candidates.sort(key=lambda x: x[1], reverse=True)
+        best_candidate = title_block_candidates[0][0]
+        
+        self.logger.info(f"도곽 블록 발견: {best_candidate.name} (키워드 매칭: {title_block_candidates[0][1]})")
+        
+        return self._extract_title_block_info(best_candidate)
+    
+    def _contains_keyword(self, text: str, keyword_group: str) -> bool:
+        """텍스트에 특정 키워드 그룹의 단어가 포함되어 있는지 확인"""
+        if not text:
+            return False
+        
+        text_lower = text.lower()
+        keywords = self.TITLE_BLOCK_KEYWORDS.get(keyword_group, [])
+        
+        return any(keyword.lower() in text_lower for keyword in keywords)
+    
+    def _extract_title_block_info(self, block_ref: BlockInfo) -> TitleBlockInfo:
+        """도곽 블록에서 상세 정보 추출"""
+        # TitleBlockInfo 객체 생성
+        title_block = TitleBlockInfo(
+            block_name=block_ref.name,
+            all_attributes=block_ref.attributes.copy(),
+            block_position=block_ref.position,
+            block_scale=block_ref.scale,
+            block_rotation=block_ref.rotation,
+            block_layer=block_ref.layer
+        )
+        
+        # 속성들을 분석하여 도곽 정보 매핑
+        for attr in block_ref.attributes:
+            text_value = attr.text.strip()
+            
+            if not text_value:
+                continue
+            
+            # 각 키워드 그룹별로 매칭 시도
+            if self._contains_keyword(attr.tag, '도면명') or self._contains_keyword(attr.text, '도면명'):
+                title_block.drawing_name = text_value
+            elif self._contains_keyword(attr.tag, '도면번호') or self._contains_keyword(attr.text, '도면번호'):
+                title_block.drawing_number = text_value
+            elif self._contains_keyword(attr.tag, '건설분야') or self._contains_keyword(attr.text, '건설분야'):
+                title_block.construction_field = text_value
+            elif self._contains_keyword(attr.tag, '건설단계') or self._contains_keyword(attr.text, '건설단계'):
+                title_block.construction_stage = text_value
+            elif self._contains_keyword(attr.tag, '축척') or self._contains_keyword(attr.text, '축척'):
+                title_block.scale = text_value
+            elif self._contains_keyword(attr.tag, '설계자') or self._contains_keyword(attr.text, '설계자'):
+                title_block.designer = text_value
+            elif self._contains_keyword(attr.tag, '프로젝트') or self._contains_keyword(attr.text, '프로젝트'):
+                title_block.project_name = text_value
+            elif self._contains_keyword(attr.tag, '날짜') or self._contains_keyword(attr.text, '날짜'):
+                title_block.date = text_value
+            elif self._contains_keyword(attr.tag, '리비전') or self._contains_keyword(attr.text, '리비전'):
+                title_block.revision = text_value
+            elif self._contains_keyword(attr.tag, '위치') or self._contains_keyword(attr.text, '위치'):
+                title_block.location = text_value
+        
+        # 도곽 바운딩 박스는 블록의 바운딩 박스 사용
+        title_block.bounding_box = block_ref.bounding_box
+        
+        # 속성 개수 업데이트
+        title_block.attributes_count = len(title_block.all_attributes)
+        
+        self.logger.info(f"도곽 '{block_ref.name}'에서 {title_block.attributes_count}개의 속성 추출 완료")
+        
+        return title_block
+    
+    def process_dxf_file_comprehensive(self, file_path: str) -> Dict[str, Any]:
+        """DXF 파일 종합적인 처리"""
+        result = {
+            'success': False,
+            'error': None,
+            'file_path': file_path,
+            'comprehensive_result': None,
+            'summary': {}
+        }
+        
+        try:
+            # 파일 유효성 검사
+            if not self.validate_dxf_file(file_path):
+                result['error'] = "유효하지 않은 DXF 파일입니다."
+                return result
+            
+            # DXF 문서 로드
+            doc = self.load_dxf_document(file_path)
+            if not doc:
+                result['error'] = "DXF 문서를 로드할 수 없습니다."
+                return result
+            
+            # 종합적인 추출 시작
+            comprehensive_result = ComprehensiveExtractionResult()
+            
+            # 1. 모든 텍스트 엔티티 추출
+            self.logger.info("텍스트 엔티티 추출 중...")
+            comprehensive_result.text_entities = self.extract_all_text_entities(doc)
+            
+            # 2. 모든 블록 참조 추출
+            self.logger.info("블록 참조 추출 중...")
+            comprehensive_result.all_block_references = self.extract_all_block_references(doc)
+            
+            # 3. 도곽 정보 추출
+            self.logger.info("도곽 정보 추출 중...")
+            comprehensive_result.title_block = self.identify_title_block(comprehensive_result.all_block_references)
+            
+            # 4. 전체 바운딩 박스 계산
+            self.logger.info("전체 바운딩 박스 계산 중...")
+            comprehensive_result.overall_bounding_box = self.calculate_comprehensive_bounding_box(doc)
+            
+            # 5. 요약 정보 생성
+            comprehensive_result.summary = {
+                'total_text_entities': len(comprehensive_result.text_entities),
+                'total_block_references': len(comprehensive_result.all_block_references),
+                'title_block_found': comprehensive_result.title_block is not None,
+                'title_block_name': comprehensive_result.title_block.block_name if comprehensive_result.title_block else None,
+                'total_attributes': sum(len(br.attributes) for br in comprehensive_result.all_block_references),
+                'non_empty_attributes': sum(len([attr for attr in br.attributes if not self._is_empty_text(attr.text)]) 
+                                          for br in comprehensive_result.all_block_references),
+                'overall_bounding_box': comprehensive_result.overall_bounding_box.__dict__ if comprehensive_result.overall_bounding_box else None
+            }
+            
+            # 결과 저장
+            result['comprehensive_result'] = asdict(comprehensive_result)
+            result['summary'] = comprehensive_result.summary
+            result['success'] = True
+            
+            self.logger.info(f"DXF 파일 종합 처리 완료: {file_path}")
+            self.logger.info(f"추출 요약: 텍스트 엔티티 {comprehensive_result.summary['total_text_entities']}개, "
+                           f"블록 참조 {comprehensive_result.summary['total_block_references']}개, "
+                           f"비어있지 않은 속성 {comprehensive_result.summary['non_empty_attributes']}개")
+            
+        except Exception as e:
+            self.logger.error(f"DXF 파일 처리 중 오류: {e}")
+            result['error'] = str(e)
+        
+        return result
+    
+    def save_analysis_result(self, result: Dict[str, Any], output_file: str) -> bool:
+        """분석 결과를 JSON 파일로 저장"""
+        try:
+            os.makedirs(Config.RESULTS_FOLDER, exist_ok=True)
+            output_path = os.path.join(Config.RESULTS_FOLDER, output_file)
+            
+            with open(output_path, 'w', encoding='utf-8') as f:
+                json.dump(result, f, ensure_ascii=False, indent=2, default=str)
+            
+            self.logger.info(f"분석 결과 저장 완료: {output_path}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"분석 결과 저장 실패: {e}")
+            return False
+
+
+# 기존 클래스명과의 호환성을 위한 별칭
+DXFProcessor = EnhancedDXFProcessor
+
+
+def main():
+    """테스트용 메인 함수"""
+    logging.basicConfig(level=logging.INFO)
+    
+    if not EZDXF_AVAILABLE:
+        print("ezdxf 라이브러리가 설치되지 않았습니다.")
+        return
+    
+    processor = EnhancedDXFProcessor()
+    
+    # 테스트 파일 경로 (실제 파일 경로로 변경 필요)
+    test_file = "test_drawing.dxf"
+    
+    if os.path.exists(test_file):
+        result = processor.process_dxf_file_comprehensive(test_file)
+        
+        if result['success']:
+            print("DXF 파일 종합 처리 성공!")
+            summary = result['summary']
+            print(f"텍스트 엔티티: {summary['total_text_entities']}")
+            print(f"블록 참조: {summary['total_block_references']}")
+            print(f"도곽 발견: {summary['title_block_found']}")
+            print(f"비어있지 않은 속성: {summary['non_empty_attributes']}")
+            
+            if summary['overall_bounding_box']:
+                bbox_info = summary['overall_bounding_box']
+                print(f"전체 바운딩 박스: ({bbox_info['min_x']:.2f}, {bbox_info['min_y']:.2f}) ~ "
+                      f"({bbox_info['max_x']:.2f}, {bbox_info['max_y']:.2f})")
+        else:
+            print(f"처리 실패: {result['error']}")
+    else:
+        print(f"테스트 파일을 찾을 수 없습니다: {test_file}")
+
+
+    def process_dxf_file(self, file_path: str) -> Dict[str, Any]:
+        """
+        기존 코드와의 호환성을 위한 메서드
+        process_dxf_file_comprehensive를 호출하고 기존 형식으로 변환
+        """
+        try:
+            # 새로운 종합 처리 메서드 호출
+            comprehensive_result = self.process_dxf_file_comprehensive(file_path)
+            
+            if not comprehensive_result['success']:
+                return comprehensive_result
+            
+            # 기존 형식으로 변환
+            comp_data = comprehensive_result['comprehensive_result']
+            
+            # 기존 형식으로 데이터 재구성
+            result = {
+                'success': True,
+                'error': None,
+                'file_path': file_path,
+                'title_block': comp_data.get('title_block'),
+                'block_references': comp_data.get('all_block_references', []),
+                'summary': comp_data.get('summary', {})
+            }
+            
+            return result
+            
+        except Exception as e:
+            self.logger.error(f"DXF 파일 처리 중 오류: {e}")
+            return {
+                'success': False,
+                'error': str(e),
+                'file_path': file_path,
+                'title_block': None,
+                'block_references': [],
+                'summary': {}
+            }

fletimageanalysis/gemini_analyzer.py

@@ -0,0 +1,271 @@
+"""
+Gemini API 연동 모듈 (좌표 추출 기능 추가)
+Google Gemini API를 사용하여 이미지와 텍스트 좌표를 함께 분석합니다.
+"""
+
+import base64
+import logging
+import json
+from google import genai
+from google.genai import types
+from typing import Optional, Dict, Any, List
+
+from config import Config
+
+# 로깅 설정
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# --- 새로운 스키마 정의 ---
+
+# 좌표를 포함하는 값을 위한 재사용 가능한 스키마
+ValueWithCoords = types.Schema(
+    type=types.Type.OBJECT,
+    properties={
+        "value": types.Schema(type=types.Type.STRING, description="추출된 텍스트 값"),
+        "x": types.Schema(type=types.Type.NUMBER, description="텍스트의 시작 x 좌표"),
+        "y": types.Schema(type=types.Type.NUMBER, description="텍스트의 시작 y 좌표"),
+    },
+    required=["value", "x", "y"]
+)
+
+# 모든 필드가 ValueWithCoords를 사용하도록 스키마 업데이트
+SCHEMA_EXPRESSWAY = types.Schema(
+    type=types.Type.OBJECT,
+    properties={
+        "도면명_line0": ValueWithCoords,
+        "도면명_line1": ValueWithCoords,
+        "도면명_line2": ValueWithCoords,
+        "편철번호": ValueWithCoords,
+        "도면번호": ValueWithCoords,
+        "Main_Title": ValueWithCoords,
+        "Sub_Title": ValueWithCoords,
+        "수평_도면_축척": ValueWithCoords,
+        "수직_도면_축척": ValueWithCoords,
+        "적용표준버전": ValueWithCoords,
+        "사업명_top": ValueWithCoords,
+        "사업명_bot": ValueWithCoords,
+        "시설_공구": ValueWithCoords,
+        "설계공구_공구명": ValueWithCoords,
+        "설계공구_범위": ValueWithCoords,
+        "시공공구_공구명": ValueWithCoords,
+        "시공공구_범위": ValueWithCoords,
+        "건설분야": ValueWithCoords,
+        "건설단계": ValueWithCoords,
+        "설계사": ValueWithCoords,
+        "시공사": ValueWithCoords,
+        "노선이정": ValueWithCoords,
+        "개정번호_1": ValueWithCoords,
+        "개정날짜_1": ValueWithCoords,
+        "개정내용_1": ValueWithCoords,
+        "작성자_1": ValueWithCoords,
+        "검토자_1": ValueWithCoords,
+        "확인자_1": ValueWithCoords
+    },
+)
+
+SCHEMA_TRANSPORTATION = types.Schema(
+    type=types.Type.OBJECT,
+    properties={
+        "도면명": ValueWithCoords,
+        "편철번호": ValueWithCoords,
+        "도면번호": ValueWithCoords,
+        "Main Title": ValueWithCoords,
+        "Sub Title": ValueWithCoords,
+        "수평축척": ValueWithCoords,
+        "수직축척": ValueWithCoords,
+        "적용표준": ValueWithCoords,
+        "사업명": ValueWithCoords,
+        "시설_공구": ValueWithCoords,
+        "건설분야": ValueWithCoords,
+        "건설단계": ValueWithCoords,
+        "개정차수": ValueWithCoords,
+        "개정일자": ValueWithCoords,
+        "과업책임자": ValueWithCoords,
+        "분야별책임자": ValueWithCoords,
+        "설계자": ValueWithCoords,
+        "위치정보": ValueWithCoords
+    },
+)
+
+
+class GeminiAnalyzer:
+    """Gemini API 이미지 및 텍스트 분석 클래스"""
+
+    def __init__(self, api_key: Optional[str] = None, model: Optional[str] = None):
+        self.api_key = api_key or Config.GEMINI_API_KEY
+        self.model = model or Config.GEMINI_MODEL
+        self.default_prompt = Config.DEFAULT_PROMPT
+
+        if not self.api_key:
+            raise ValueError("Gemini API 키가 설정되지 않았습니다.")
+
+        try:
+            self.client = genai.Client(api_key=self.api_key)
+            logger.info(f"Gemini 클라이언트 초기화 완료 (모델: {self.model})")
+        except Exception as e:
+            logger.error(f"Gemini 클라이언트 초기화 실패: {e}")
+            raise
+
+    def _get_schema(self, organization_type: str) -> types.Schema:
+        """조직 유형에 따른 스키마를 반환합니다."""
+        return SCHEMA_EXPRESSWAY if organization_type == "한국도로공사" else SCHEMA_TRANSPORTATION
+
+    def analyze_pdf_page(
+        self,
+        base64_data: str,
+        text_blocks: List[Dict[str, Any]],
+        prompt: Optional[str] = None,
+        mime_type: str = "image/png",
+        organization_type: str = "transportation"
+    ) -> Optional[str]:
+        """
+        Base64 이미지와 추출된 텍스트 좌표를 함께 분석합니다.
+
+        Args:
+            base64_data: Base64로 인코딩된 이미지 데이터.
+            text_blocks: PDF에서 추출된 텍스트와 좌표 정보 리스트.
+            prompt: 분석 요청 텍스트 (None인 경우 기본값 사용).
+            mime_type: 이미지 MIME 타입.
+            organization_type: 조직 유형 ("transportation" 또는 "expressway").
+
+        Returns:
+            분석 결과 JSON 문자열 또는 None (실패 시).
+        """
+        try:
+            # 텍스트 블록 정보를 JSON 문자열로 변환하여 프롬프트에 추가
+            text_context = "\n".join([
+                f"- text: '{block['text']}', bbox: ({block['bbox'][0]:.0f}, {block['bbox'][1]:.0f})"
+                for block in text_blocks
+            ])
+            
+            analysis_prompt = (
+                (prompt or self.default_prompt) +
+                "\n\n--- 추출된 텍스트와 좌표 정보 ---\n" +
+                text_context +
+                "\n\n--- 지시사항 ---\n"
+                "위 텍스트와 좌표 정보를 바탕으로, 이미지의 내용을 분석하여 JSON 스키마를 채워주세요."
+                "각 필드에 해당하는 텍스트를 찾고, 해당 텍스트의 'value'와 시작 'x', 'y' 좌표를 JSON에 기입하세요."
+                "top은 주로 문서 상단에, bot은 주로 문서 하단입니다. "
+                "특히 설계공구과 시공공구의 경우, 여러 개의 컬럼(공구명, 범위)으로 나누어진 경우가 있습니다. "
+                "설계공구 | 설계공구_공구명 | 설계공구_범위"
+                "시공공구 | 시공공구_공구명 | 시공공구_범위"
+                "와 같은 구조입니다. 구분자 색은 항상 black이 아닐 수 있음에 주의하세요"
+                "Given an image with a row like '설계공구 | 제2-1공구 | 12780.00-15860.00', the output should be:"
+"설계공구_공구명: '제2-1공구'"
+"설계공구_범위: '12780.00-15860.00'"
+                "도면명_line{n}은 도면명에 해당하는 값 여러 줄을 위에서부터 0, 1, 2, ...라고 정의합니다."
+                "도면명에 해당하는 값이 두 줄인 경우 line0이 생략된 경우입니다."
+                "{ }_Title은 중앙 상단의 비교적 큰 폰트입니다. "
+                "사업명_top에 해당하는 텍스트 아랫줄은 '시설_공구' 항목입니다."
+                "개정번호_{n}의 n은 삼각형 내부의 숫자입니다."
+                "각각의 컬럼에 해당하는 값을 개별적으로 추출해주세요."
+                "해당하는 값이 없으면 빈 문자열을 사용하세요."
+            )
+
+            contents = [
+                types.Content(
+                    role="user",
+                    parts=[
+                        types.Part.from_bytes(
+                            mime_type=mime_type,
+                            data=base64.b64decode(base64_data),
+                        ),
+                        types.Part.from_text(text=analysis_prompt),
+                    ],
+                )
+            ]
+
+            selected_schema = self._get_schema(organization_type)
+
+            generate_content_config = types.GenerateContentConfig(
+                temperature=0,
+                top_p=0.05,
+                response_mime_type="application/json",
+                response_schema=selected_schema
+            )
+
+            logger.info("Gemini API 분석 요청 시작 (텍스트 좌표 포함)...")
+
+            response = self.client.models.generate_content(
+                model=self.model,
+                contents=contents,
+                config=generate_content_config,
+            )
+
+            if response and hasattr(response, 'text'):
+                result = response.text
+                # JSON 응답을 파싱하여 다시 직렬화 (일관된 포맷팅)
+                parsed_json = json.loads(result)
+                
+                # 디버깅: Gemini 응답 내용 로깅
+                logger.info(f"=== Gemini 응답 디버깅 ===")
+                logger.info(f"조직 유형: {organization_type}")
+                logger.info(f"응답 필드 수: {len(parsed_json) if isinstance(parsed_json, dict) else 'N/A'}")
+                
+                if isinstance(parsed_json, dict):
+                    # 새로운 필드들이 응답에 포함되었는지 확인
+                    new_fields = ["설계공구_Station_col1", "설계공구_Station_col2", "시공공구_Station_col1", "시공공구_Station_col2"]
+                    old_fields = ["설계공구_Station", "시공공구_Station"]
+                    
+                    logger.info("=== 새 필드 확인 ===")
+                    for field in new_fields:
+                        if field in parsed_json:
+                            field_data = parsed_json[field]
+                            if isinstance(field_data, dict) and field_data.get('value'):
+                                logger.info(f"✅ {field}: '{field_data.get('value')}' at ({field_data.get('x', 'N/A')}, {field_data.get('y', 'N/A')})")
+                            else:
+                                logger.info(f"⚠️ {field}: 빈 값 또는 잘못된 형식 - {field_data}")
+                        else:
+                            logger.info(f"❌ {field}: 응답에 없음")
+                    
+                    logger.info("=== 기존 필드 확인 ===")
+                    for field in old_fields:
+                        if field in parsed_json:
+                            field_data = parsed_json[field]
+                            if isinstance(field_data, dict) and field_data.get('value'):
+                                logger.info(f"⚠️ {field}: '{field_data.get('value')}' (기존 필드가 여전히 존재)")
+                            else:
+                                logger.info(f"⚠️ {field}: 빈 값 - {field_data}")
+                        else:
+                            logger.info(f"✅ {field}: 응답에 없음 (예상됨)")
+                    
+                    logger.info("=== 전체 응답 필드 목록 ===")
+                    for key in parsed_json.keys():
+                        value = parsed_json[key]
+                        if isinstance(value, dict) and 'value' in value:
+                            logger.info(f"필드: {key} = '{value.get('value', '')}' at ({value.get('x', 'N/A')}, {value.get('y', 'N/A')})")
+                        else:
+                            logger.info(f"필드: {key} = {type(value).__name__}")
+                
+                logger.info("=== 디버깅 끝 ===")
+                
+                pretty_result = json.dumps(parsed_json, ensure_ascii=False, indent=2)
+                logger.info(f"분석 완료: {len(pretty_result)} 문자")
+                return pretty_result
+            else:
+                logger.error("API 응답에서 텍스트를 찾을 수 없습니다.")
+                return None
+
+        except Exception as e:
+            logger.error(f"이미지 및 텍스트 분석 중 오류 발생: {e}")
+            return None
+
+    # --- 기존 다른 메서드들은 필요에 따라 수정 또는 유지 ---
+    # analyze_image_stream_from_base64, analyze_pdf_images 등은
+    # 새로운 analyze_pdf_page 메서드와 호환되도록 수정 필요.
+    # 지금은 핵심 기능에 집중.
+
+    def validate_api_connection(self) -> bool:
+        """API 연결 상태를 확인합니다."""
+        try:
+            test_response = self.client.models.generate_content("안녕하세요")
+            if test_response and hasattr(test_response, 'text'):
+                logger.info("Gemini API 연결 테스트 성공")
+                return True
+            else:
+                logger.error("Gemini API 연결 테스트 실패")
+                return False
+        except Exception as e:
+            logger.error(f"Gemini API 연결 테스트 중 오류: {e}")
+            return False

fletimageanalysis/mapping_table_json.json

@@ -0,0 +1,199 @@
+{
+  "mapping_table": {
+    "ailabel_to_systems": {
+      "도면명_line0": {
+        "molit": "",
+        "expressway": "TD_DNAME_TOP",
+        "railway": "",
+        "docaikey": "DNAME_TOP"
+      },
+      "도면명_line1": {
+        "molit": "DI_TITLE",
+        "expressway": "TD_DNAME_MAIN",
+        "railway": "TD_DNAME_MAIN",
+        "docaikey": "DNAME_MAIN"
+      },
+      "도면명_line2": {
+        "molit": "DI_SUBTITLE",
+        "expressway": "TD_DNAME_BOT",
+        "railway": "TD_DNAME_BOT",
+        "docaikey": "DNAME_BOT"
+      },
+      "편철번호": {
+        "molit": "DA_PAGENO",
+        "expressway": "TD_DWGNO",
+        "railway": "TD_DWGNO",
+        "docaikey": "DWGNO"
+      },
+      "도면번호": {
+        "molit": "DI_DRWNO",
+        "expressway": "TD_DWGCODE",
+        "railway": "TD_DWGCODE",
+        "docaikey": "DWGCODE"
+      },
+      "Main_Title": {
+        "molit": "UD_TITLE",
+        "expressway": "TB_MTITIL",
+        "railway": "TB_MTITIL",
+        "docaikey": "MTITIL"
+      },
+      "Sub_Title": {
+        "molit": "UD_SUBTITLE",
+        "expressway": "TB_STITL",
+        "railway": "TB_STITL",
+        "docaikey": "STITL"
+      },
+      "수평_도면_축척": {
+        "molit": "DA_HSCALE",
+        "expressway": "TD_HSCAL",
+        "railway": "",
+        "docaikey": "HSCAL"
+      },
+      "수직_도면_축척": {
+        "molit": "DA_VSCALE",
+        "expressway": "TD_VSCAL",
+        "railway": "",
+        "docaikey": "VSCAL"
+      },
+      "적용표준버전": {
+        "molit": "DA_STDVER",
+        "expressway": "TD_VERSION",
+        "railway": "TD_VERSION",
+        "docaikey": "VERSION"
+      },
+      "사업명_top": {
+        "molit": "PI_CNAME",
+        "expressway": "TB_CNAME",
+        "railway": "",
+        "docaikey": "TBCNAME"
+      },
+      "시설_공구": {
+        "molit": "UD_CDNAME",
+        "expressway": "TB_CSCOP",
+        "railway": "",
+        "docaikey": "CSCOP"
+      },
+      "사업명_bot": {
+        "molit": "",
+        "expressway": "TD_CNAME",
+        "railway": "TD_CNAME",
+        "docaikey": "TDCNAME"
+      },
+      "설계공구_공구명": {
+        "molit": "",
+        "expressway": "TD_DSECT",
+        "railway": "",
+        "docaikey": "DSECT"
+      },
+      "시공공구_공구명": {
+        "molit": "",
+        "expressway": "TD_CSECT",
+        "railway": "",
+        "docaikey": "CSECT"
+      },
+      "건설분야": {
+        "molit": "PA_CCLASS",
+        "expressway": "TD_FIELD",
+        "railway": "TD_FIELD",
+        "docaikey": "FIELD"
+      },
+      "건설단계": {
+        "molit": "PI_STAGE",
+        "expressway": "TD_CSTEP",
+        "railway": "TD_CSTEP",
+        "docaikey": "CSTEP"
+      },
+      "설계사": {
+        "molit": "",
+        "expressway": "TD_DCOMP",
+        "railway": "TD_DCOMP",
+        "docaikey": "DCOMP"
+      },
+      "시공사": {
+        "molit": "",
+        "expressway": "TD_CCOMP",
+        "railway": "TD_CCOMP",
+        "docaikey": "CCOMP"
+      },
+      "노선이정": {
+        "molit": "",
+        "expressway": "TD_LNDST",
+        "railway": "",
+        "docaikey": "LNDST"
+      },
+      "설계공구_범위": {
+        "molit": "",
+        "expressway": "TD_DDIST",
+        "railway": "",
+        "docaikey": "DDIST"
+      },
+      "시공공구_범위": {
+        "molit": "",
+        "expressway": "TD_CDIST",
+        "railway": "",
+        "docaikey": "CDIST"
+      },
+      "개정번호_1": {
+        "molit": "DC_RNUM1",
+        "expressway": "TR_RNUM1",
+        "railway": "TR_RNUM1",
+        "docaikey": "RNUM1"
+      },
+      "개정날짜_1": {
+        "molit": "DC_RDATE1",
+        "expressway": "TR_RDAT1",
+        "railway": "TR_RDAT1",
+        "docaikey": "RDAT1"
+      },
+      "개정내용_1": {
+        "molit": "DC_RDES1",
+        "expressway": "TR_RCON1",
+        "railway": "TR_RCON1",
+        "docaikey": "RCON1"
+      },
+      "작성자_1": {
+        "molit": "DC_RDGN1",
+        "expressway": "TR_DGN1",
+        "railway": "TR_DGN1",
+        "docaikey": "DGN1"
+      },
+      "검토자_1": {
+        "molit": "DC_RCHK1",
+        "expressway": "TR_CHK1",
+        "railway": "TR_CHK1",
+        "docaikey": "CHK1"
+      },
+      "확인자_1": {
+        "molit": "DC_RAPP1",
+        "expressway": "TR_APP1",
+        "railway": "TR_APP1",
+        "docaikey": "APP1"
+      }
+    },
+    "system_mappings": {
+      "expressway_to_transportation": {
+        "TD_DNAME_MAIN": "DNAME_MAIN",
+        "TD_DNAME_BOT": "DNAME_BOT",
+        "TD_DWGNO": "DWGNO",
+        "TD_DWGCODE": "DWGCODE",
+        "TB_MTITIL": "MTITIL",
+        "TB_STITL": "STITL",
+        "TD_DWGCODE_PREV": "DWGCODE_PREV",
+        "TD_HSCAL": "HSCAL",
+        "TD_VERSION": "VERSION",
+        "TB_CNAME": "TBCNAME",
+        "TB_CSCOP": "CSCOP",
+        "TD_FIELD": "FIELD",
+        "TD_CSTEP": "CSTEP",
+        "TD_DCOMP": "DCOMP",
+        "TD_CCOMP": "CCOMP",
+        "TR_RNUM1": "RNUM1",
+        "TR_RDAT1": "RDAT1",
+        "TR_RCON1": "RCON1",
+        "TR_DGN1": "DGN1",
+        "TR_CHK1": "CHK1",
+        "TR_APP1": "APP1"
+      }
+    }
+  }
+}

fletimageanalysis/multi_file_processor.py

@@ -0,0 +1,588 @@
+"""
+다중 파일 처리 모듈
+여러 PDF/DXF 파일을 배치로 처리하고 결과를 CSV로 저장하는 기능을 제공합니다.
+
+Author: Claude Assistant
+Created: 2025-07-14
+Version: 1.0.0
+"""
+
+import asyncio
+import os
+import pandas as pd
+from datetime import datetime
+from typing import List, Dict, Any, Optional, Callable
+from dataclasses import dataclass
+import logging
+
+from pdf_processor import PDFProcessor
+from dxf_processor import EnhancedDXFProcessor
+from gemini_analyzer import GeminiAnalyzer
+from csv_exporter import TitleBlockCSVExporter
+import json # Added import
+
+# 로깅 설정
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class FileProcessingResult:
+    """단일 파일 처리 결과"""
+    file_path: str
+    file_name: str
+    file_type: str
+    file_size: int
+    processing_time: float
+    success: bool
+    error_message: Optional[str] = None
+    
+    # PDF 분석 결과
+    pdf_analysis_result: Optional[str] = None
+    
+    # DXF 분석 결과
+    dxf_title_blocks: Optional[List[Dict]] = None
+    dxf_total_attributes: Optional[int] = None
+    dxf_total_text_entities: Optional[int] = None
+    
+    # 공통 메타데이터
+    processed_at: Optional[str] = None
+
+
+@dataclass
+class BatchProcessingConfig:
+    """배치 처리 설정"""
+    organization_type: str = "한국도로공사"
+    enable_gemini_batch_mode: bool = False
+    max_concurrent_files: int = 3
+    save_intermediate_results: bool = True
+    output_csv_path: Optional[str] = None
+    include_error_files: bool = True
+
+
+class MultiFileProcessor:
+    """다중 파일 처리기"""
+    
+    def __init__(self, gemini_api_key: str):
+        """
+        다중 파일 처리기 초기화
+        
+        Args:
+            gemini_api_key: Gemini API 키
+        """
+        self.gemini_api_key = gemini_api_key
+        self.pdf_processor = PDFProcessor()
+        self.dxf_processor = EnhancedDXFProcessor()
+        self.gemini_analyzer = GeminiAnalyzer(gemini_api_key)
+        self.csv_exporter = TitleBlockCSVExporter()  # CSV 내보내기 추가
+        
+        self.processing_results: List[FileProcessingResult] = []
+        self.current_progress = 0
+        self.total_files = 0
+        
+    async def process_multiple_files(
+        self,
+        file_paths: List[str],
+        config: BatchProcessingConfig,
+        progress_callback: Optional[Callable[[int, int, str], None]] = None
+    ) -> List[FileProcessingResult]:
+        """
+        여러 파일을 배치로 처리
+        
+        Args:
+            file_paths: 처리할 파일 경로 리스트
+            config: 배치 처리 설정
+            progress_callback: 진행률 콜백 함수 (current, total, status)
+            
+        Returns:
+            처리 결과 리스트
+        """
+        self.processing_results = []
+        self.total_files = len(file_paths)
+        self.current_progress = 0
+        
+        logger.info(f"배치 처리 시작: {self.total_files}개 파일")
+        
+        # 동시 처리 제한을 위한 세마포어
+        semaphore = asyncio.Semaphore(config.max_concurrent_files)
+        
+        # 각 파일에 대한 처리 태스크 생성
+        tasks = []
+        for i, file_path in enumerate(file_paths):
+            task = self._process_single_file_with_semaphore(
+                semaphore, file_path, config, progress_callback, i + 1
+            )
+            tasks.append(task)
+        
+        # 모든 파일 처리 완료까지 대기
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # 예외 발생한 결과 처리
+        for i, result in enumerate(results):
+            if isinstance(result, Exception):
+                error_result = FileProcessingResult(
+                    file_path=file_paths[i],
+                    file_name=os.path.basename(file_paths[i]),
+                    file_type="unknown",
+                    file_size=0,
+                    processing_time=0,
+                    success=False,
+                    error_message=str(result),
+                    processed_at=datetime.now().isoformat()
+                )
+                self.processing_results.append(error_result)
+        
+        logger.info(f"배치 처리 완료: {len(self.processing_results)}개 결과")
+        
+        # CSV 저장
+        if config.output_csv_path:
+            await self.save_results_to_csv(config.output_csv_path)
+            
+            # JSON 출력도 함께 생성 (좌표 정보 포함)
+            json_output_path = config.output_csv_path.replace('.csv', '.json')
+            await self.save_results_to_json(json_output_path)
+        
+        return self.processing_results
+    
+    async def _process_single_file_with_semaphore(
+        self,
+        semaphore: asyncio.Semaphore,
+        file_path: str,
+        config: BatchProcessingConfig,
+        progress_callback: Optional[Callable[[int, int, str], None]],
+        file_number: int
+    ) -> None:
+        """세마포어를 사용하여 단일 파일 처리"""
+        async with semaphore:
+            result = await self._process_single_file(file_path, config)
+            self.processing_results.append(result)
+            
+            self.current_progress += 1
+            if progress_callback:
+                status = f"처리 완료: {result.file_name}"
+                if not result.success:
+                    status = f"처리 실패: {result.file_name} - {result.error_message}"
+                progress_callback(self.current_progress, self.total_files, status)
+    
+    async def _process_single_file(
+        self,
+        file_path: str,
+        config: BatchProcessingConfig
+    ) -> FileProcessingResult:
+        """
+        단일 파일 처리
+        
+        Args:
+            file_path: 파일 경로
+            config: 처리 설정
+            
+        Returns:
+            처리 결과
+        """
+        start_time = asyncio.get_event_loop().time()
+        file_name = os.path.basename(file_path)
+        
+        try:
+            # 파일 정보 수집
+            file_size = os.path.getsize(file_path)
+            file_type = self._detect_file_type(file_path)
+            
+            logger.info(f"파일 처리 시작: {file_name} ({file_type})")
+            
+            result = FileProcessingResult(
+                file_path=file_path,
+                file_name=file_name,
+                file_type=file_type,
+                file_size=file_size,
+                processing_time=0,
+                success=False,
+                processed_at=datetime.now().isoformat()
+            )
+            
+            # 파일 유형에 따른 처리
+            if file_type.lower() == 'pdf':
+                await self._process_pdf_file(file_path, result, config)
+            elif file_type.lower() == 'dxf':
+                await self._process_dxf_file(file_path, result, config)
+            else:
+                raise ValueError(f"지원하지 않는 파일 형식: {file_type}")
+            
+            result.success = True
+            
+        except Exception as e:
+            logger.error(f"파일 처리 오류 ({file_name}): {str(e)}")
+            result.success = False
+            result.error_message = str(e)
+        
+        finally:
+            # 처리 시간 계산
+            end_time = asyncio.get_event_loop().time()
+            result.processing_time = round(end_time - start_time, 2)
+            
+        return result
+    
+    async def _process_pdf_file(
+        self,
+        file_path: str,
+        result: FileProcessingResult,
+        config: BatchProcessingConfig
+    ) -> None:
+        """PDF 파일 처리"""
+        # PDF 이미지 변환
+        images = self.pdf_processor.convert_to_images(file_path)
+        if not images:
+            raise ValueError("PDF를 이미지로 변환할 수 없습니다")
+        
+        # 첫 번째 페이지만 분석 (다중 페이지 처리는 향후 개선)
+        first_page = images[0]
+        base64_image = self.pdf_processor.image_to_base64(first_page)
+        
+        # PDF에서 텍스트 블록 추출
+        text_blocks = self.pdf_processor.extract_text_with_coordinates(file_path, 0)
+        
+        # Gemini API로 분석
+        # 실제 구현에서는 batch mode 사용 가능
+        analysis_result = await self._analyze_with_gemini(
+            base64_image, text_blocks, config.organization_type
+        )
+        
+        result.pdf_analysis_result = analysis_result
+    
+    async def _process_dxf_file(
+        self,
+        file_path: str,
+        result: FileProcessingResult,
+        config: BatchProcessingConfig
+    ) -> None:
+        """DXF 파일 처리"""
+        # DXF 파일 분석
+        extraction_result = self.dxf_processor.extract_comprehensive_data(file_path)
+        
+        # 타이틀 블록 정보를 딕셔너리 리스트로 변환
+        title_blocks = []
+        for tb_info in extraction_result.title_blocks:
+            tb_dict = {
+                'block_name': tb_info.block_name,
+                'block_position': f"{tb_info.block_position[0]:.2f}, {tb_info.block_position[1]:.2f}",
+                'attributes_count': tb_info.attributes_count,
+                'attributes': [
+                    {
+                        'tag': attr.tag,
+                        'text': attr.text,
+                        'prompt': attr.prompt,
+                        'insert_x': attr.insert_x,
+                        'insert_y': attr.insert_y
+                    }
+                    for attr in tb_info.all_attributes
+                ]
+            }
+            title_blocks.append(tb_dict)
+        
+        result.dxf_title_blocks = title_blocks
+        result.dxf_total_attributes = sum(tb['attributes_count'] for tb in title_blocks)
+        result.dxf_total_text_entities = len(extraction_result.text_entities)
+        
+        # 상세한 title block attributes CSV 생성
+        if extraction_result.title_blocks:
+            await self._save_detailed_dxf_csv(file_path, extraction_result)
+    
+    async def _analyze_with_gemini(
+        self,
+        base64_image: str,
+        text_blocks: list,
+        organization_type: str
+    ) -> str:
+        """Gemini API로 이미지 분석"""
+        try:
+            # 비동기 처리를 위해 동기 함수를 태스크로 실행
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(
+                None,
+                self.gemini_analyzer.analyze_pdf_page,
+                base64_image,
+                text_blocks,
+                None,  # prompt (default 사용)
+                "image/png",  # mime_type
+                organization_type
+            )
+            return result
+        except Exception as e:
+            logger.error(f"Gemini 분석 오류: {str(e)}")
+            return f"분석 실패: {str(e)}"
+    
+    async def _save_detailed_dxf_csv(
+        self,
+        file_path: str,
+        extraction_result
+    ) -> None:
+        """상세한 DXF title block attributes CSV 저장"""
+        try:
+            # 파일명에서 확장자 제거
+            file_name = os.path.splitext(os.path.basename(file_path))[0]
+            
+            # 출력 디렉토리 확인 및 생성
+            output_dir = os.path.join(os.path.dirname(file_path), '..', 'results')
+            os.makedirs(output_dir, exist_ok=True)
+            
+            # CSV 파일명 생성
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            csv_filename = f"detailed_title_blocks_{file_name}_{timestamp}.csv"
+            csv_path = os.path.join(output_dir, csv_filename)
+            
+            # TitleBlockCSVExporter를 사용하여 CSV 생성
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(
+                None,
+                self.csv_exporter.save_title_block_info_to_csv,
+                extraction_result.title_blocks,
+                csv_path
+            )
+            
+            logger.info(f"상세 DXF CSV 저장 완료: {csv_path}")
+            
+        except Exception as e:
+            logger.error(f"상세 DXF CSV 저장 오류: {str(e)}")
+    
+    def _detect_file_type(self, file_path: str) -> str:
+        """파일 확장자로 파일 유형 검출"""
+        _, ext = os.path.splitext(file_path.lower())
+        if ext == '.pdf':
+            return 'PDF'
+        elif ext == '.dxf':
+            return 'DXF'
+        else:
+            return ext.upper().lstrip('.')
+    
+    async def save_results_to_csv(self, output_path: str) -> None:
+        """
+        처리 결과를 CSV 파일로 저장
+        
+        Args:
+            output_path: 출력 CSV 파일 경로
+        """
+        try:
+            # 결과를 DataFrame으로 변환
+            data_rows = []
+            
+            for result in self.processing_results:
+                # 기본 정보
+                row = {
+                    'file_name': result.file_name,
+                    'file_path': result.file_path,
+                    'file_type': result.file_type,
+                    'file_size_bytes': result.file_size,
+                    'file_size_mb': round(result.file_size / (1024 * 1024), 2),
+                    'processing_time_seconds': result.processing_time,
+                    'success': result.success,
+                    'error_message': result.error_message or '',
+                    'processed_at': result.processed_at
+                }
+                
+                # PDF 분석 결과
+                if result.file_type.lower() == 'pdf':
+                    row['pdf_analysis_result'] = result.pdf_analysis_result or ''
+                    row['dxf_total_attributes'] = ''
+                    row['dxf_total_text_entities'] = ''
+                    row['dxf_title_blocks_summary'] = ''
+                
+                # DXF 분석 결과
+                elif result.file_type.lower() == 'dxf':
+                    row['pdf_analysis_result'] = ''
+                    row['dxf_total_attributes'] = result.dxf_total_attributes or 0
+                    row['dxf_total_text_entities'] = result.dxf_total_text_entities or 0
+                    
+                    # 타이틀 블록 요약
+                    if result.dxf_title_blocks:
+                        summary = f"{len(result.dxf_title_blocks)}개 타이틀블록"
+                        for tb in result.dxf_title_blocks[:3]:  # 처음 3개만 표시
+                            summary += f" | {tb['block_name']}({tb['attributes_count']}속성)"
+                        if len(result.dxf_title_blocks) > 3:
+                            summary += f" | ...외 {len(result.dxf_title_blocks)-3}개"
+                        row['dxf_title_blocks_summary'] = summary
+                    else:
+                        row['dxf_title_blocks_summary'] = '타이틀블록 없음'
+                
+                data_rows.append(row)
+            
+            # DataFrame 생성 및 CSV 저장
+            df = pd.DataFrame(data_rows)
+
+            # pdf_analysis_result 컬럼 평탄화
+            if 'pdf_analysis_result' in df.columns:
+                # JSON 문자열을 딕셔너리로 변환 (이미 딕셔너리인 경우도 처리)
+                df['pdf_analysis_result'] = df['pdf_analysis_result'].apply(lambda x: json.loads(x) if isinstance(x, str) and x.strip() else {}).fillna({})
+                
+                # 평탄화된 데이터를 새로운 DataFrame으로 생성
+                # errors='ignore'를 사용하여 JSON이 아닌 값은 무시
+                # record_prefix를 사용하여 컬럼 이름에 접두사 추가
+                pdf_analysis_df = pd.json_normalize(df['pdf_analysis_result'], errors='ignore', record_prefix='pdf_analysis_result_')
+                
+                # 원본 df에서 pdf_analysis_result 컬럼 제거
+                df = df.drop(columns=['pdf_analysis_result'])
+                
+                # 원본 df와 평탄화된 DataFrame을 병합
+                df = pd.concat([df, pdf_analysis_df], axis=1)
+
+            # 컬럼 순서 정렬을 위한 기본 순서 정의
+            column_order = [
+                'file_name', 'file_type', 'file_size_mb', 'processing_time_seconds',
+                'success', 'error_message', 'processed_at', 'file_path', 'file_size_bytes',
+                'dxf_total_attributes', 'dxf_total_text_entities', 'dxf_title_blocks_summary'
+            ]
+
+            # 기존 컬럼 순서를 유지하면서 새로운 컬럼을 추가
+            existing_columns = [col for col in column_order if col in df.columns]
+            new_columns = [col for col in df.columns if col not in existing_columns]
+            df = df[existing_columns + sorted(new_columns)]
+            
+            # UTF-8 BOM으로 저장 (한글 호환성)
+            df.to_csv(output_path, index=False, encoding='utf-8-sig')
+            
+            logger.info(f"CSV 저장 완료: {output_path}")
+            logger.info(f"총 {len(data_rows)}개 파일 결과 저장")
+            
+        except Exception as e:
+            logger.error(f"CSV 저장 오류: {str(e)}")
+            raise
+    
+    async def save_results_to_json(self, output_path: str) -> None:
+        """
+        처리 결과를 JSON 파일로 저장 (좌표 정보 포함)
+        
+        Args:
+            output_path: 출력 JSON 파일 경로
+        """
+        try:
+            # 결과를 JSON 구조로 변환
+            json_data = {
+                "metadata": {
+                    "total_files": len(self.processing_results),
+                    "success_files": sum(1 for r in self.processing_results if r.success),
+                    "failed_files": sum(1 for r in self.processing_results if not r.success),
+                    "generated_at": datetime.now().isoformat(),
+                    "format_version": "1.0"
+                },
+                "results": []
+            }
+            
+            for result in self.processing_results:
+                # 기본 정보
+                result_data = {
+                    "file_info": {
+                        "name": result.file_name,
+                        "path": result.file_path,
+                        "type": result.file_type,
+                        "size_bytes": result.file_size,
+                        "size_mb": round(result.file_size / (1024 * 1024), 2)
+                    },
+                    "processing_info": {
+                        "success": result.success,
+                        "processing_time_seconds": result.processing_time,
+                        "processed_at": result.processed_at,
+                        "error_message": result.error_message
+                    }
+                }
+                
+                # PDF 분석 결과 (좌표 정보 포함)
+                if result.file_type.lower() == 'pdf' and result.pdf_analysis_result:
+                    try:
+                        # JSON 문자열을 딕셔너리로 변환 (이미 딕셔너리인 경우도 처리)
+                        if isinstance(result.pdf_analysis_result, str):
+                            analysis_data = json.loads(result.pdf_analysis_result)
+                        else:
+                            analysis_data = result.pdf_analysis_result
+                        
+                        result_data["pdf_analysis"] = analysis_data
+                        
+                    except (json.JSONDecodeError, TypeError) as e:
+                        logger.warning(f"PDF 분석 결과 JSON 파싱 오류: {e}")
+                        result_data["pdf_analysis"] = {"error": "JSON 파싱 실패", "raw_data": str(result.pdf_analysis_result)}
+                
+                # DXF 분석 결과
+                elif result.file_type.lower() == 'dxf':
+                    result_data["dxf_analysis"] = {
+                        "total_attributes": result.dxf_total_attributes or 0,
+                        "total_text_entities": result.dxf_total_text_entities or 0,
+                        "title_blocks": result.dxf_title_blocks or []
+                    }
+                
+                json_data["results"].append(result_data)
+            
+            # JSON 파일 저장 (예쁜 포맷팅과 한글 지원)
+            with open(output_path, 'w', encoding='utf-8') as f:
+                json.dump(json_data, f, ensure_ascii=False, indent=2, default=str)
+            
+            logger.info(f"JSON 저장 완료: {output_path}")
+            logger.info(f"총 {len(json_data['results'])}개 파일 결과 저장 (좌표 정보 포함)")
+            
+        except Exception as e:
+            logger.error(f"JSON 저장 오류: {str(e)}")
+            raise
+    
+    def get_processing_summary(self) -> Dict[str, Any]:
+        """처리 결과 요약 정보 반환"""
+        if not self.processing_results:
+            return {}
+        
+        total_files = len(self.processing_results)
+        success_files = sum(1 for r in self.processing_results if r.success)
+        failed_files = total_files - success_files
+        
+        pdf_files = sum(1 for r in self.processing_results if r.file_type.lower() == 'pdf')
+        dxf_files = sum(1 for r in self.processing_results if r.file_type.lower() == 'dxf')
+        
+        total_processing_time = sum(r.processing_time for r in self.processing_results)
+        avg_processing_time = total_processing_time / total_files if total_files > 0 else 0
+        
+        total_file_size = sum(r.file_size for r in self.processing_results)
+        
+        return {
+            'total_files': total_files,
+            'success_files': success_files,
+            'failed_files': failed_files,
+            'pdf_files': pdf_files,
+            'dxf_files': dxf_files,
+            'total_processing_time': round(total_processing_time, 2),
+            'avg_processing_time': round(avg_processing_time, 2),
+            'total_file_size_mb': round(total_file_size / (1024 * 1024), 2),
+            'success_rate': round((success_files / total_files) * 100, 1) if total_files > 0 else 0
+        }
+
+
+def generate_default_csv_filename() -> str:
+    """기본 CSV 파일명 생성"""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return f"batch_analysis_results_{timestamp}.csv"
+
+
+# 사용 예시
+if __name__ == "__main__":
+    async def main():
+        # 테스트용 예시
+        processor = MultiFileProcessor("your-gemini-api-key")
+        
+        config = BatchProcessingConfig(
+            organization_type="한국도로공사",
+            max_concurrent_files=2,
+            output_csv_path="test_results.csv"
+        )
+        
+        # 진행률 콜백 함수
+        def progress_callback(current: int, total: int, status: str):
+            print(f"진행률: {current}/{total} ({current/total*100:.1f}%) - {status}")
+        
+        # 파일 경로 리스트 (실제 파일 경로로 교체 필요)
+        file_paths = [
+            "sample1.pdf",
+            "sample2.dxf",
+            "sample3.pdf"
+        ]
+        
+        results = await processor.process_multiple_files(
+            file_paths, config, progress_callback
+        )
+        
+        summary = processor.get_processing_summary()
+        print("처리 요약:", summary)
+    
+    # asyncio.run(main())

fletimageanalysis/pdf_processor.py

@@ -0,0 +1,322 @@
+"""
+PDF 처리 모듈
+PDF 파일을 이미지로 변환하고 base64로 인코딩하는 기능을 제공합니다.
+"""
+
+import base64
+import io
+import fitz  # PyMuPDF
+from PIL import Image
+from typing import List, Optional, Tuple, Dict, Any
+import logging
+from pathlib import Path
+
+# 로깅 설정
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class PDFProcessor:
+    """PDF 파일 처리 클래스"""
+    
+    def __init__(self):
+        self.supported_formats = ['pdf']
+        
+    def validate_pdf_file(self, file_path: str) -> bool:
+        """PDF 파일 유효성 검사"""
+        try:
+            path = Path(file_path)
+            
+            # 파일 존재 여부 확인
+            if not path.exists():
+                logger.error(f"파일이 존재하지 않습니다: {file_path}")
+                return False
+                
+            # 파일 확장자 확인
+            if path.suffix.lower() != '.pdf':
+                logger.error(f"지원하지 않는 파일 형식입니다: {path.suffix}")
+                return False
+                
+            # PDF 파일 열기 테스트
+            doc = fitz.open(file_path)
+            page_count = len(doc)
+            doc.close()
+            
+            if page_count == 0:
+                logger.error("PDF 파일에 페이지가 없습니다.")
+                return False
+                
+            logger.info(f"PDF 검증 완료: {page_count}페이지")
+            return True
+            
+        except Exception as e:
+            logger.error(f"PDF 파일 검증 중 오류 발생: {e}")
+            return False
+    
+    def get_pdf_info(self, file_path: str) -> Optional[dict]:
+        """PDF 파일 정보 조회"""
+        try:
+            doc = fitz.open(file_path)
+            info = {
+                'page_count': len(doc),
+                'metadata': doc.metadata,
+                'file_size': Path(file_path).stat().st_size,
+                'filename': Path(file_path).name
+            }
+            doc.close()
+            return info
+            
+        except Exception as e:
+            logger.error(f"PDF 정보 조회 중 오류 발생: {e}")
+            return None
+    
+    def convert_pdf_page_to_image(
+        self, 
+        file_path: str, 
+        page_number: int = 0,
+        zoom: float = 2.0,
+        image_format: str = "PNG"
+    ) -> Optional[Image.Image]:
+        """PDF 페이지를 PIL Image로 변환"""
+        try:
+            doc = fitz.open(file_path)
+            
+            if page_number >= len(doc):
+                logger.error(f"페이지 번호가 범위를 벗어남: {page_number}")
+                doc.close()
+                return None
+                
+            # 페이지 로드
+            page = doc.load_page(page_number)
+            
+            # 이미지 변환을 위한 매트릭스 설정 (확대/축소)
+            mat = fitz.Matrix(zoom, zoom)
+            pix = page.get_pixmap(matrix=mat)
+            
+            # PIL Image로 변환
+            img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+            
+            doc.close()
+            logger.info(f"페이지 {page_number + 1} 이미지 변환 완료: {img.size}")
+            return img
+            
+        except Exception as e:
+            logger.error(f"PDF 페이지 이미지 변환 중 오류 발생: {e}")
+            return None
+    
+    def convert_pdf_to_images(
+        self, 
+        file_path: str,
+        max_pages: Optional[int] = None,
+        zoom: float = 2.0
+    ) -> List[Image.Image]:
+        """PDF의 모든 페이지를 이미지로 변환"""
+        images = []
+        
+        try:
+            doc = fitz.open(file_path)
+            total_pages = len(doc)
+            
+            # 최대 페이지 수 제한
+            if max_pages:
+                total_pages = min(total_pages, max_pages)
+            
+            for page_num in range(total_pages):
+                img = self.convert_pdf_page_to_image(file_path, page_num, zoom)
+                if img:
+                    images.append(img)
+                    
+            doc.close()
+            logger.info(f"총 {len(images)}개 페이지 이미지 변환 완료")
+            
+        except Exception as e:
+            logger.error(f"PDF 전체 페이지 변환 중 오류 발생: {e}")
+            
+        return images
+    
+    def image_to_base64(
+        self, 
+        image: Image.Image, 
+        format: str = "PNG",
+        quality: int = 95
+    ) -> Optional[str]:
+        """PIL Image를 base64 문자열로 변환"""
+        try:
+            buffer = io.BytesIO()
+            
+            # JPEG 형식인 경우 품질 설정
+            if format.upper() == "JPEG":
+                image.save(buffer, format=format, quality=quality)
+            else:
+                image.save(buffer, format=format)
+                
+            buffer.seek(0)
+            base64_string = base64.b64encode(buffer.getvalue()).decode('utf-8')
+            
+            logger.info(f"이미지를 base64로 변환 완료 (크기: {len(base64_string)} 문자)")
+            return base64_string
+            
+        except Exception as e:
+            logger.error(f"이미지 base64 변환 중 오류 발생: {e}")
+            return None
+    
+    def pdf_page_to_base64(
+        self, 
+        file_path: str, 
+        page_number: int = 0,
+        zoom: float = 2.0,
+        format: str = "PNG"
+    ) -> Optional[str]:
+        """PDF 페이지를 직접 base64로 변환"""
+        img = self.convert_pdf_page_to_image(file_path, page_number, zoom)
+        if img:
+            return self.image_to_base64(img, format)
+        return None
+    
+    def pdf_page_to_image_bytes(
+        self, 
+        file_path: str, 
+        page_number: int = 0,
+        zoom: float = 2.0,
+        format: str = "PNG"
+    ) -> Optional[bytes]:
+        """PDF 페이지를 이미지 바이트로 변환 (Flet 이미지 표시용)"""
+        try:
+            img = self.convert_pdf_page_to_image(file_path, page_number, zoom)
+            if img:
+                buffer = io.BytesIO()
+                img.save(buffer, format=format)
+                buffer.seek(0)
+                image_bytes = buffer.getvalue()
+                
+                logger.info(f"페이지 {page_number + 1} 이미지 바이트 변환 완료 (크기: {len(image_bytes)} 바이트)")
+                return image_bytes
+            return None
+            
+        except Exception as e:
+            logger.error(f"PDF 페이지 이미지 바이트 변환 중 오류 발생: {e}")
+            return None
+    
+    def get_optimal_zoom_for_size(self, target_size: Tuple[int, int]) -> float:
+        """목표 크기에 맞는 최적 줌 비율 계산"""
+        # 기본 PDF 페이지 크기 (A4: 595x842 points)
+        default_width, default_height = 595, 842
+        target_width, target_height = target_size
+        
+        # 비율 계산
+        width_ratio = target_width / default_width
+        height_ratio = target_height / default_height
+        
+        # 작은 비율을 선택하여 전체 페이지가 들어가도록 함
+        zoom = min(width_ratio, height_ratio)
+        
+        logger.info(f"최적 줌 비율 계산: {zoom:.2f}")
+        return zoom
+
+    def extract_text_with_coordinates(self, file_path: str, page_number: int = 0) -> List[Dict[str, Any]]:
+        """PDF 페이지에서 텍스트와 좌표를 추출합니다."""
+        text_blocks = []
+        try:
+            doc = fitz.open(file_path)
+            if page_number >= len(doc):
+                logger.error(f"페이지 번호가 범위를 벗어남: {page_number}")
+                doc.close()
+                return []
+
+            page = doc.load_page(page_number)
+            # 'dict' 옵션은 블록, 라인, 스팬에 대한 상세 정보를 제공합니다.
+            blocks = page.get_text("dict")["blocks"]
+            for b in blocks:  # 블록 반복
+                if b['type'] == 0:  # 텍스트 블록
+                    for l in b["lines"]:  # 라인 반복
+                        for s in l["spans"]:  # 스팬(텍스트 조각) 반복
+                            text_blocks.append({
+                                "text": s["text"],
+                                "bbox": s["bbox"], # (x0, y0, x1, y1)
+                                "font": s["font"],
+                                "size": s["size"]
+                            })
+            
+            doc.close()
+            logger.info(f"페이지 {page_number + 1}에서 {len(text_blocks)}개의 텍스트 블록 추출 완료")
+            return text_blocks
+
+        except Exception as e:
+            logger.error(f"PDF 텍스트 및 좌표 추출 중 오류 발생: {e}")
+            return []
+    
+    def convert_to_images(
+        self, 
+        file_path: str, 
+        zoom: float = 2.0,
+        max_pages: int = 10
+    ) -> List[Image.Image]:
+        """PDF의 모든 페이지(또는 지정된 수까지)를 PIL Image 리스트로 변환"""
+        images = []
+        try:
+            doc = fitz.open(file_path)
+            page_count = min(len(doc), max_pages)  # 최대 페이지 수 제한
+            
+            logger.info(f"PDF 변환 시작: {page_count}페이지")
+            
+            for page_num in range(page_count):
+                page = doc.load_page(page_num)
+                
+                # 이미지 변환을 위한 매트릭스 설정
+                mat = fitz.Matrix(zoom, zoom)
+                pix = page.get_pixmap(matrix=mat)
+                
+                # PIL Image로 변환
+                img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+                images.append(img)
+                
+                logger.info(f"페이지 {page_num + 1}/{page_count} 변환 완료: {img.size}")
+            
+            doc.close()
+            logger.info(f"PDF 전체 변환 완료: {len(images)}개 이미지")
+            return images
+            
+        except Exception as e:
+            logger.error(f"PDF 다중 페이지 변환 중 오류 발생: {e}")
+            return []
+    
+    def image_to_bytes(self, image: Image.Image, format: str = 'PNG') -> bytes:
+        """
+        PIL Image를 바이트 데이터로 변환합니다.
+        
+        Args:
+            image: PIL Image 객체
+            format: 이미지 포맷 ('PNG', 'JPEG' 등)
+            
+        Returns:
+            이미지 바이트 데이터
+        """
+        try:
+            buffer = io.BytesIO()
+            image.save(buffer, format=format)
+            image_bytes = buffer.getvalue()
+            buffer.close()
+            
+            logger.info(f"이미지를 {format} 바이트로 변환: {len(image_bytes)} bytes")
+            return image_bytes
+            
+        except Exception as e:
+            logger.error(f"이미지 바이트 변환 중 오류 발생: {e}")
+            return b''
+
+# 사용 예시
+if __name__ == "__main__":
+    processor = PDFProcessor()
+    
+    # 테스트용 코드 (실제 PDF 파일 경로로 변경 필요)
+    test_pdf = "test.pdf"
+    
+    if processor.validate_pdf_file(test_pdf):
+        info = processor.get_pdf_info(test_pdf)
+        print(f"PDF 정보: {info}")
+        
+        # 첫 번째 페이지를 base64로 변환
+        base64_data = processor.pdf_page_to_base64(test_pdf, 0)
+        if base64_data:
+            print(f"Base64 변환 성공: {len(base64_data)} 문자")
+    else:
+        print("PDF 파일 검증 실패")

fletimageanalysis/requirements-cli.txt

@@ -0,0 +1,9 @@
+# Essential packages for CLI batch processing only
+PyMuPDF>=1.26.3
+google-genai>=1.0.0
+Pillow>=10.0.0
+ezdxf>=1.4.2
+numpy>=1.24.0
+python-dotenv>=1.0.0
+pandas>=2.0.0
+requests>=2.31.0 

fletimageanalysis/requirements.txt

@@ -0,0 +1,38 @@
+# Flet 기반 PDF 이미지 분석기 - 필수 라이브러리
+
+# UI 프레임워크
+flet>=0.25.1
+
+# Google Generative AI SDK
+google-genai>=1.0.0
+
+# PDF 처리 라이브러리 (둘 중 하나 선택)
+PyMuPDF>=1.26.3
+pdf2image>=1.17.0
+
+# 이미지 처리
+Pillow>=10.0.0
+
+# DXF 파일 처리 (NEW)
+ezdxf>=1.4.2
+
+# 수치 계산 (NEW)
+numpy>=1.24.0
+
+# 환경 변수 관리
+python-dotenv>=1.0.0
+
+# 추가 유틸리티
+requests>=2.31.0
+
+# 데이터 처리 (NEW - 다중 파일 CSV 출력용)
+pandas>=2.0.0
+
+# Flet Material Design (선택 사항)
+flet-material>=0.3.3
+
+# 개발 도구 (선택 사항)
+# black>=23.0.0
+# flake8>=6.0.0
+# pytest>=7.0.0
+# mypy>=1.0.0