(대표님) 20250611 21시 15분 OCR 등

2 files changed, 544 insertions, 650 deletions

diff --git a/app/api/ocr/utils/imageRotation.ts b/app/api/ocr/utils/imageRotation.ts
index fe9cf840..6d59dace 100644
--- a/app/api/ocr/utils/imageRotation.ts
+++ b/app/api/ocr/utils/imageRotation.ts
@@ -1,244 +1,427 @@
+// ============================================================================
 // app/api/ocr/utils/imageRotation.ts
-// Sharp을 사용한 서버 사이드 이미지 회전
+// PDF 페이지 처리 기능이 추가된 이미지 회전 유틸리티
+// ============================================================================
 
 import sharp from 'sharp';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { randomUUID } from 'crypto';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { tmpdir } from 'os';
+
+const exec = promisify(execFile);
 
 /**
- * 서버 사이드에서 이미지를 회전시킵니다
- * @param base64 - base64 인코딩된 이미지 데이터
- * @param degrees - 회전 각도 (0, 90, 180, 270)
- * @returns Promise<string> - 회전된 이미지의 base64 데이터
+ * PDF 페이지 수를 확인하는 함수
  */
-export async function rotateImageBase64(base64: string, degrees: number): Promise<string> {
+export async function getPDFPageCount(pdfBuffer: Buffer): Promise<number> {
+  const tmp = tmpdir();
+  const id = randomUUID();
+  const pdfPath = path.join(tmp, `${id}.pdf`);
+  
   try {
-    console.log(`🔄 Rotating image by ${degrees} degrees...`);
+    await fs.writeFile(pdfPath, pdfBuffer);
     
-    // base64를 Buffer로 변환
-    const inputBuffer = Buffer.from(base64, 'base64');
+    // pdfinfo 명령어로 페이지 수 확인
+    const { stdout } = await exec('pdfinfo', [pdfPath]);
+    const pageMatch = stdout.match(/Pages:\s+(\d+)/);
+    const pageCount = pageMatch ? parseInt(pageMatch[1]) : 1;
     
-    // 회전 각도에 따른 처리
-    let rotatedBuffer: Buffer;
-    
-    switch (degrees) {
-      case 0:
-        // 회전 없음
-        rotatedBuffer = inputBuffer;
-        break;
-        
-      case 90:
-        rotatedBuffer = await sharp(inputBuffer)
-          .rotate(90)
-          .jpeg({ 
-            quality: 90,
-            progressive: true 
-          })
-          .toBuffer();
-        break;
-        
-      case 180:
-        rotatedBuffer = await sharp(inputBuffer)
-          .rotate(180)
-          .jpeg({ 
-            quality: 90,
-            progressive: true 
-          })
-          .toBuffer();
-        break;
-        
-      case 270:
-        rotatedBuffer = await sharp(inputBuffer)
-          .rotate(270)
-          .jpeg({ 
-            quality: 90,
-            progressive: true 
-          })
-          .toBuffer();
-        break;
-        
-      default:
-        console.warn(`⚠️ Unsupported rotation angle: ${degrees}°. Using original image.`);
-        rotatedBuffer = inputBuffer;
-    }
-    
-    // Buffer를 다시 base64로 변환
-    const rotatedBase64 = rotatedBuffer.toString('base64');
-    
-    console.log(`✅ Image rotated successfully (${degrees}°)`);
-    return rotatedBase64;
+    console.log(`📄 PDF has ${pageCount} pages`);
+    return pageCount;
     
   } catch (error) {
-    console.error(`❌ Error rotating image by ${degrees}°:`, error);
-    console.warn('Using original image due to rotation error');
-    return base64; // 실패시 원본 반환
+    console.warn('❌ Could not get PDF page count, trying alternative method:', error);
+    
+    // pdfinfo가 실패하면 pdftoppm으로 테스트
+    try {
+      await exec('pdftoppm', ['-l', '1', '-null', pdfPath]);
+      return 1; // 최소 1페이지는 있음
+    } catch {
+      console.warn('⚠️ Could not determine page count, assuming 1 page');
+      return 1;
+    }
+  } finally {
+    await fs.rm(pdfPath, { force: true }).catch(() => {});
   }
 }
 
 /**
- * 이미지 품질을 개선합니다
- * @param base64 - base64 인코딩된 이미지 데이터
- * @returns Promise<string> - 개선된 이미지의 base64 데이터
+ * base64 데이터 유효성 검증
  */
-export async function enhanceImageQuality(base64: string): Promise<string> {
-  try {
-    console.log('🎨 Enhancing image quality...');
-    
-    const inputBuffer = Buffer.from(base64, 'base64');
-    
-    const enhancedBuffer = await sharp(inputBuffer)
-      .resize(2000, 2000, { 
-        fit: 'inside',
-        withoutEnlargement: true 
-      })
-      // 개별 매개변수 방식으로 수정
-      .sharpen(1, 1, 2)  // sigma, m1(flat), m2(jagged)
-      .normalize() // 히스토그램 정규화
-      .gamma(1.1)  // 약간의 감마 보정
-      .jpeg({ 
-        quality: 95,
-        progressive: true,
-        mozjpeg: true
-      })
-      .toBuffer();
-    
-    const enhancedBase64 = enhancedBuffer.toString('base64');
-    
-    console.log('✅ Image quality enhanced');
-    return enhancedBase64;
-    
-  } catch (error) {
-    console.error('❌ Error enhancing image:', error);
-    return base64;
-  }
+export function validateBase64Image(base64: string): { isValid: boolean; error?: string; size?: number } {
+    try {
+        if (!base64 || typeof base64 !== 'string') {
+            return { isValid: false, error: 'Base64 data is empty or invalid type' };
+        }
+
+        const cleanBase64 = base64.replace(/^data:image\/[a-z]+;base64,/, '');
+
+        if (!/^[A-Za-z0-9+/]*={0,2}$/.test(cleanBase64)) {
+            return { isValid: false, error: 'Invalid base64 format' };
+        }
+
+        if (cleanBase64.length < 100) {
+            return { isValid: false, error: `Base64 too short: ${cleanBase64.length} characters` };
+        }
+
+        const buffer = Buffer.from(cleanBase64, 'base64');
+        const bufferSize = buffer.length;
+
+        if (bufferSize < 1) {
+            return { isValid: false, error: `Buffer too small: ${bufferSize} bytes` };
+        }
+
+        if (bufferSize > 52428800) { // 50MB
+            return { isValid: false, error: `Buffer too large: ${bufferSize} bytes (max: 50MB)` };
+        }
+
+        return { isValid: true, size: bufferSize };
+
+    } catch (error) {
+        return {
+            isValid: false,
+            error: `Base64 validation failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+        };
+    }
 }
 
 /**
- * PDF를 고품질 이미지로 변환합니다
- * @param pdfBuffer - PDF Buffer 데이터
- * @param pageIndex - 변환할 페이지 인덱스 (0부터 시작)
- * @returns Promise<string> - 변환된 이미지의 base64 데이터
+ * 서버 사이드에서 이미지를 회전시킵니다
  */
-export async function convertPDFToImage(pdfBuffer: Buffer, pageIndex: number = 0): Promise<string> {
-  try {
-    console.log(`📄 Converting PDF page ${pageIndex + 1} to image...`);
-    
-    // pdf2pic 라이브러리 사용
-    const pdf2pic = require('pdf2pic');
-    
-    const convert = pdf2pic.fromBuffer(pdfBuffer, {
-      density: 300,           // 300 DPI for high quality
-      saveFilename: "page",
-      savePath: "/tmp",       // 임시 경로
-      format: "jpeg",
-      width: 2480,           // A4 크기 @ 300 DPI
-      height: 3508,
-      quality: 100
-    });
-    
-    const result = await convert(pageIndex + 1, { responseType: "buffer" });
-    const base64 = result.buffer.toString('base64');
-    
-    console.log('✅ PDF converted to image successfully');
-    return base64;
-    
-  } catch (error) {
-    console.error('❌ Error converting PDF to image:', error);
-    throw new Error('Failed to convert PDF to image');
-  }
+export async function rotateImageBase64(base64: string, degrees: number): Promise<string> {
+    try {
+        console.log(`🔄 === ROTATING IMAGE BY ${degrees}° ===`);
+
+        const validation = validateBase64Image(base64);
+        if (!validation.isValid) {
+            throw new Error(`Invalid input base64: ${validation.error}`);
+        }
+
+        console.log(`✅ Input validation passed - size: ${validation.size} bytes`);
+
+        const cleanBase64 = base64.replace(/^data:image\/[a-z]+;base64,/, '');
+        const inputBuffer = Buffer.from(cleanBase64, 'base64');
+
+        console.log(`📊 Input buffer created: ${inputBuffer.length} bytes`);
+
+        const normalizedDegrees = ((degrees % 360) + 360) % 360;
+        console.log(`📐 Normalized rotation: ${normalizedDegrees}°`);
+
+        let rotatedBuffer: Buffer;
+
+        if (normalizedDegrees === 0) {
+            console.log('  ↻ No rotation needed, applying quality enhancement...');
+            rotatedBuffer = await sharp(inputBuffer)
+                .jpeg({
+                    quality: 90,
+                    progressive: true,
+                    mozjpeg: true
+                })
+                .toBuffer();
+        } else {
+            console.log(`  🔄 Applying ${normalizedDegrees}° rotation...`);
+
+            const sharpInstance = sharp(inputBuffer);
+            const metadata = await sharpInstance.metadata();
+            console.log(`  📏 Original image: ${metadata.width}x${metadata.height}, format: ${metadata.format}`);
+
+            rotatedBuffer = await sharpInstance
+                .rotate(normalizedDegrees)
+                .jpeg({
+                    quality: 90,
+                    progressive: true,
+                    mozjpeg: true
+                })
+                .toBuffer();
+        }
+
+        console.log(`📊 Output buffer created: ${rotatedBuffer.length} bytes`);
+
+        if (rotatedBuffer.length === 0) {
+            throw new Error('Rotation resulted in empty buffer');
+        }
+
+        if (rotatedBuffer.length > 52428800) {
+            throw new Error(`Rotated image too large: ${rotatedBuffer.length} bytes`);
+        }
+
+        const rotatedBase64 = rotatedBuffer.toString('base64');
+
+        const outputValidation = validateBase64Image(rotatedBase64);
+        if (!outputValidation.isValid) {
+            throw new Error(`Invalid output base64: ${outputValidation.error}`);
+        }
+
+        console.log(`✅ Image rotated successfully: ${outputValidation.size} bytes`);
+        console.log(`📈 Size change: ${inputBuffer.length} → ${outputValidation.size} bytes`);
+
+        return rotatedBase64;
+
+    } catch (error) {
+        console.error(`❌ Error rotating image by ${degrees}°:`, error);
+
+        if (error instanceof Error) {
+            if (error.message.includes('Input buffer contains unsupported image format')) {
+                console.error('  🖼️ Unsupported image format - try converting to JPEG first');
+            } else if (error.message.includes('Input image exceeds pixel limit')) {
+                console.error('  📏 Image too large for processing');
+            } else if (error.message.includes('premature close')) {
+                console.error('  🔧 Corrupted image data');
+            }
+        }
+
+        const originalValidation = validateBase64Image(base64);
+        if (originalValidation.isValid) {
+            console.warn('  ↩️ Using original image due to rotation error');
+            return base64;
+        } else {
+            throw new Error(`Rotation failed and original image is invalid: ${originalValidation.error}`);
+        }
+    }
 }
 
 /**
- * 이미지에서 텍스트 방향을 감지합니다
- * @param base64 - base64 인코딩된 이미지 데이터
- * @returns Promise<number> - 감지된 올바른 회전 각도
+ * 이미지 품질을 개선합니다
  */
-export async function detectTextOrientation(base64: string): Promise<number> {
-  // 이 함수는 간단한 방향 감지를 시뮬레이션합니다
-  // 실제로는 더 정교한 알고리즘이 필요할 수 있습니다
-  
-  console.log('🧭 Detecting text orientation...');
-  
-  const rotations = [0, 90, 180, 270];
-  const scores: { rotation: number; score: number }[] = [];
-  
-  for (const rotation of rotations) {
+export async function enhanceImageQuality(base64: string): Promise<string> {
     try {
-      const rotatedBase64 = await rotateImageBase64(base64, rotation);
-      
-      // 간단한 품질 측정 (실제로는 OCR API 호출이나 다른 방법 사용)
-      const score = await estimateTextQuality(rotatedBase64);
-      scores.push({ rotation, score });
-      
-      console.log(`  ${rotation}°: quality score = ${score.toFixed(3)}`);
-      
+        console.log('🎨 === ENHANCING IMAGE QUALITY ===');
+
+        const validation = validateBase64Image(base64);
+        if (!validation.isValid) {
+            console.warn(`⚠️ Invalid input for enhancement: ${validation.error}`);
+            return base64;
+        }
+
+        console.log(`✅ Enhancement input valid: ${validation.size} bytes`);
+
+        const cleanBase64 = base64.replace(/^data:image\/[a-z]+;base64,/, '');
+        const inputBuffer = Buffer.from(cleanBase64, 'base64');
+
+        const sharpInstance = sharp(inputBuffer);
+        const metadata = await sharpInstance.metadata();
+
+        console.log(`📏 Original: ${metadata.width}x${metadata.height}, ${metadata.format}`);
+
+        const maxDimension = 2000;
+        let needsResize = false;
+
+        if (metadata.width && metadata.height) {
+            needsResize = metadata.width > maxDimension || metadata.height > maxDimension;
+        }
+
+        let enhancedBuffer: Buffer;
+
+        if (needsResize) {
+            console.log(`📐 Resizing to fit ${maxDimension}px...`);
+            enhancedBuffer = await sharpInstance
+                .resize(maxDimension, maxDimension, {
+                    fit: 'inside',
+                    withoutEnlargement: true
+                })
+                .sharpen(0.5, 1, 2)
+                .normalize()
+                .gamma(1.1)
+                .jpeg({
+                    quality: 95,
+                    progressive: true,
+                    mozjpeg: true
+                })
+                .toBuffer();
+        } else {
+            console.log('📐 No resize needed, applying enhancement only...');
+            enhancedBuffer = await sharpInstance
+                .sharpen(0.5, 1, 2)
+                .normalize()
+                .gamma(1.1)
+                .jpeg({
+                    quality: 95,
+                    progressive: true,
+                    mozjpeg: true
+                })
+                .toBuffer();
+        }
+
+        const enhancedBase64 = enhancedBuffer.toString('base64');
+
+        const outputValidation = validateBase64Image(enhancedBase64);
+        if (!outputValidation.isValid) {
+            console.warn(`⚠️ Enhancement resulted in invalid image: ${outputValidation.error}`);
+            return base64;
+        }
+
+        console.log(`✅ Image enhanced: ${validation.size} → ${outputValidation.size} bytes`);
+        return enhancedBase64;
+
     } catch (error) {
-      console.warn(`  ${rotation}°: Failed to test orientation`);
-      scores.push({ rotation, score: 0 });
+        console.error('❌ Error enhancing image:', error);
+        return base64;
     }
-  }
-  
-  const bestOrientation = scores.reduce((best, current) => 
-    current.score > best.score ? current : best
-  );
-  
-  console.log(`🎯 Best orientation detected: ${bestOrientation.rotation}°`);
-  return bestOrientation.rotation;
 }
 
 /**
- * 이미지의 텍스트 품질을 추정합니다 (간단한 버전)
+ * PDF를 이미지로 변환합니다 (개선된 버전)
  */
-async function estimateTextQuality(base64: string): Promise<number> {
+export async function convertPDFToImage(
+  pdfBuffer: Buffer,
+  pageIndex = 0,
+  dpi = 300,
+): Promise<string> {
+  const tmp = tmpdir();
+  const id = randomUUID();
+  const pdfPath = path.join(tmp, `${id}.pdf`);
+  const outPrefix = path.join(tmp, id);
+  const jpgPath = `${outPrefix}.jpg`;
+
   try {
-    const buffer = Buffer.from(base64, 'base64');
+    console.log(`📄 Converting PDF page ${pageIndex + 1} to image (${dpi} DPI)...`);
     
-    // Sharp을 사용해 이미지 통계 분석
-    const stats = await sharp(buffer)
-      .greyscale()
-      .stats();
-    
-    // 간단한 품질 지표 계산
-    // 실제로는 더 복잡한 알고리즘이 필요합니다
-    const contrast = stats.channels[0].max - stats.channels[0].min;
-    const sharpness = stats.channels[0].stdev;
+    // 1) PDF 임시 저장
+    await fs.writeFile(pdfPath, pdfBuffer);
+
+    // 2) pdftoppm 실행
+    const page = pageIndex + 1; // pdftoppm은 1-based
+    await exec('pdftoppm', [
+      '-jpeg',
+      '-singlefile',
+      '-r', dpi.toString(),
+      '-f', page.toString(),
+      '-l', page.toString(),
+      pdfPath,
+      outPrefix,
+    ], { maxBuffer: 1024 * 1024 * 50 }); // 50MB 버퍼
+
+    // 3) 결과 읽어 base64 변환
+    const img = await fs.readFile(jpgPath);
+    const base64 = img.toString('base64');
     
-    return (contrast + sharpness) / 510; // 0-1 범위로 정규화
+    console.log(`✅ PDF page ${pageIndex + 1} converted successfully: ${img.length} bytes`);
     
+    return base64;
+
   } catch (error) {
-    return 0;
+    console.error(`❌ Error converting PDF page ${pageIndex + 1}:`, error);
+    throw new Error(`Failed to convert PDF page ${pageIndex + 1}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+  } finally {
+    // 4) 임시 파일 정리
+    await fs.rm(pdfPath, { force: true }).catch(() => {});
+    await fs.rm(jpgPath, { force: true }).catch(() => {});
   }
 }
 
 /**
- * 이미지가 회전이 필요한지 빠르게 체크합니다
- * @param base64 - base64 인코딩된 이미지 데이터
- * @returns Promise<boolean> - 회전이 필요하면 true
+ * 파일 형식을 JPEG로 정규화
  */
-export async function needsRotation(base64: string): Promise<boolean> {
-  try {
-    const buffer = Buffer.from(base64, 'base64');
-    
-    // 이미지 메타데이터 확인
-    const metadata = await sharp(buffer).metadata();
-    
-    // EXIF 방향 정보가 있으면 회전 필요
-    if (metadata.orientation && metadata.orientation > 1) {
-      console.log(`📐 EXIF orientation detected: ${metadata.orientation}`);
-      return true;
+export async function normalizeImageFormat(base64: string): Promise<string> {
+    try {
+        console.log('🔄 Normalizing image format to JPEG...');
+
+        const validation = validateBase64Image(base64);
+        if (!validation.isValid) {
+            throw new Error(`Cannot normalize invalid image: ${validation.error}`);
+        }
+
+        const cleanBase64 = base64.replace(/^data:image\/[a-z]+;base64,/, '');
+        const inputBuffer = Buffer.from(cleanBase64, 'base64');
+
+        const normalizedBuffer = await sharp(inputBuffer)
+            .jpeg({
+                quality: 90,
+                progressive: true
+            })
+            .toBuffer();
+
+        const normalizedBase64 = normalizedBuffer.toString('base64');
+
+        const outputValidation = validateBase64Image(normalizedBase64);
+        if (!outputValidation.isValid) {
+            throw new Error(`Normalization failed: ${outputValidation.error}`);
+        }
+
+        console.log(`✅ Format normalized: ${validation.size} → ${outputValidation.size} bytes`);
+        return normalizedBase64;
+
+    } catch (error) {
+        console.error('❌ Error normalizing image format:', error);
+        throw error;
     }
-    
-    // 가로/세로 비율 체크 (일반적으로 문서는 세로가 더 긺)
-    if (metadata.width && metadata.height) {
-      const aspectRatio = metadata.width / metadata.height;
-      if (aspectRatio > 1.5) {
-        console.log(`📐 Wide aspect ratio detected: ${aspectRatio.toFixed(2)}`);
-        return true; // 너무 가로로 긴 이미지는 회전 필요할 가능성
-      }
+}
+
+// 기존 함수들
+export async function detectTextOrientation(base64: string): Promise<number> {
+    console.log('🧭 Detecting text orientation...');
+
+    const rotations = [0, 90, 180, 270];
+    const scores: { rotation: number; score: number }[] = [];
+
+    for (const rotation of rotations) {
+        try {
+            const rotatedBase64 = await rotateImageBase64(base64, rotation);
+            const score = await estimateTextQuality(rotatedBase64);
+            scores.push({ rotation, score });
+
+            console.log(`  ${rotation}°: quality score = ${score.toFixed(3)}`);
+
+        } catch (error) {
+            console.warn(`  ${rotation}°: Failed to test orientation`);
+            scores.push({ rotation, score: 0 });
+        }
+    }
+
+    const bestOrientation = scores.reduce((best, current) =>
+        current.score > best.score ? current : best
+    );
+
+    console.log(`🎯 Best orientation detected: ${bestOrientation.rotation}°`);
+    return bestOrientation.rotation;
+}
+
+async function estimateTextQuality(base64: string): Promise<number> {
+    try {
+        const cleanBase64 = base64.replace(/^data:image\/[a-z]+;base64,/, '');
+        const buffer = Buffer.from(cleanBase64, 'base64');
+
+        const stats = await sharp(buffer)
+            .greyscale()
+            .stats();
+
+        const contrast = stats.channels[0].max - stats.channels[0].min;
+        const sharpness = stats.channels[0].stdev;
+
+        return (contrast + sharpness) / 510;
+
+    } catch (error) {
+        return 0;
+    }
+}
+
+export async function needsRotation(base64: string): Promise<boolean> {
+    try {
+        const cleanBase64 = base64.replace(/^data:image\/[a-z]+;base64,/, '');
+        const buffer = Buffer.from(cleanBase64, 'base64');
+
+        const metadata = await sharp(buffer).metadata();
+
+        if (metadata.orientation && metadata.orientation > 1) {
+            console.log(`📐 EXIF orientation detected: ${metadata.orientation}`);
+            return true;
+        }
+
+        if (metadata.width && metadata.height) {
+            const aspectRatio = metadata.width / metadata.height;
+            if (aspectRatio > 1.5) {
+                console.log(`📐 Wide aspect ratio detected: ${aspectRatio.toFixed(2)}`);
+                return true;
+            }
+        }
+
+        return false;
+
+    } catch (error) {
+        console.warn('Error checking if rotation needed:', error);
+        return false;
     }
-    
-    return false;
-    
-  } catch (error) {
-    console.warn('Error checking if rotation needed:', error);
-    return false;
-  }
 }
\ No newline at end of file
diff --git a/app/api/ocr/utils/tableExtraction.ts b/app/api/ocr/utils/tableExtraction.ts
index ea543f8e..720e5a5f 100644
--- a/app/api/ocr/utils/tableExtraction.ts
+++ b/app/api/ocr/utils/tableExtraction.ts
@@ -1,7 +1,11 @@
 // app/api/ocr/utils/tableExtraction.ts
-// 완전한 테이블 추출 로직 구현
+// 개선된 완전 테이블 추출 로직 – Format‑1 식별번호 파싱 보강 & 중복 행 제거
 
-interface ExtractedRow {
+/* -------------------------------------------------------------------------- */
+/* 타입                                                                   */
+/* -------------------------------------------------------------------------- */
+
+export interface ExtractedRow {
   no: string;
   identificationNo: string;
   tagNo: string;
@@ -41,516 +45,223 @@ interface ColumnMapping {
   weldingDate: number;
 }
 
-// 메인 테이블 추출 함수
-export async function extractTablesFromOCR(ocrResult: any): Promise<ExtractedRow[][]> {
-  const extractedTables: ExtractedRow[][] = [];
-  const warnings: string[] = [];
+/* -------------------------------------------------------------------------- */
+/* 메인                                                                   */
+/* -------------------------------------------------------------------------- */
 
-  if (!ocrResult || !ocrResult.images) {
-    console.warn('No OCR images found in result');
-    return [];
-  }
+export async function extractTablesFromOCR (ocrResult: any): Promise<ExtractedRow[][]> {
+  const tables: ExtractedRow[][] = [];
+  if (!ocrResult?.images) return tables;
 
-  for (let imageIndex = 0; imageIndex < ocrResult.images.length; imageIndex++) {
-    const image = ocrResult.images[imageIndex];
-    
-    if (!image.tables || image.tables.length === 0) {
-      console.warn(`No tables found in image ${imageIndex}`);
-      continue;
-    }
+  ocrResult.images.forEach((image: any, imgIdx: number) => {
+    image.tables?.forEach((table: OCRTable, tblIdx: number) => {
+      if (!isRelevantTable(table)) return;
+      const rows = extractTableData(table, imgIdx, tblIdx);
+      if (rows.length) tables.push(rows);
+    });
+  });
+  return tables;
+}
 
-    for (let tableIndex = 0; tableIndex < image.tables.length; tableIndex++) {
-      const table = image.tables[tableIndex];
-      
-      try {
-        if (isRelevantTable(table)) {
-          const extractedRows = extractTableData(table, imageIndex, tableIndex);
-          
-          if (extractedRows.length > 0) {
-            extractedTables.push(extractedRows);
-            console.log(`Successfully extracted ${extractedRows.length} rows from table ${tableIndex + 1} in image ${imageIndex + 1}`);
-          } else {
-            console.warn(`Table ${tableIndex + 1} in image ${imageIndex + 1} was identified as relevant but no data could be extracted`);
-          }
-        } else {
-          console.log(`Table ${tableIndex + 1} in image ${imageIndex + 1} is not relevant (no required headers found)`);
-        }
-      } catch (error) {
-        console.error(`Error processing table ${tableIndex + 1} in image ${imageIndex + 1}:`, error);
-      }
-    }
-  }
+/* -------------------------------------------------------------------------- */
+/* 관련 테이블 판별                                                       */
+/* -------------------------------------------------------------------------- */
 
-  console.log(`Total extracted tables: ${extractedTables.length}`);
-  return extractedTables;
+function isRelevantTable (table: OCRTable): boolean {
+  const headers = table.cells.filter(c => c.rowIndex < 3).map(getCellText).join(' ').toLowerCase();
+  return /\bno\b|번호/.test(headers) && /identification|식별|ident|id/.test(headers);
 }
 
-// 관련 테이블인지 확인
-function isRelevantTable(table: OCRTable): boolean {
-  if (!table.cells || table.cells.length === 0) {
-    return false;
-  }
+/* -------------------------------------------------------------------------- */
+/* 표 해석                                                                 */
+/* -------------------------------------------------------------------------- */
 
-  // 첫 3행에서 헤더 찾기
-  const headerCells = table.cells.filter(cell => cell.rowIndex <= 2);
-  const headerTexts = headerCells
-    .map(cell => getCellText(cell).toLowerCase())
-    .filter(text => text.length > 0);
-
-  console.log('Header texts found:', headerTexts);
-
-  // 필수 키워드 확인
-  const hasNo = headerTexts.some(text => 
-    text.includes('no.') || 
-    text === 'no' || 
-    text.includes('번호') ||
-    text.match(/^no\.?$/i)
-  );
-  
-  const hasIdentification = headerTexts.some(text => 
-    text.includes('identification') || 
-    text.includes('식별') || 
-    text.includes('ident') ||
-    text.includes('id')
-  );
-
-  // 테이블 품질 확인
-  const hasMinimumCells = table.cells.length >= 6; // 최소 헤더 + 데이터
-  const hasReasonableConfidence = table.inferConfidence >= 0.5; // 신뢰도 기준 완화
-
-  const isRelevant = hasNo && hasIdentification && hasMinimumCells && hasReasonableConfidence;
-  
-  console.log(`Table relevance check: hasNo=${hasNo}, hasIdentification=${hasIdentification}, minCells=${hasMinimumCells}, confidence=${hasReasonableConfidence} => ${isRelevant}`);
-  
-  return isRelevant;
-}
+function extractTableData (table: OCRTable, imgIdx: number, tblIdx: number): ExtractedRow[] {
+  const grid = buildGrid(table);
+  const headerRowIdx = findHeaderRow(grid);
+  if (headerRowIdx === -1) return [];
 
-// 테이블 데이터 추출
-function extractTableData(table: OCRTable, imageIndex: number, tableIndex: number): ExtractedRow[] {
-  console.log(`Processing table ${tableIndex + 1} in image ${imageIndex + 1}`);
-  
-  // 테이블 그리드 구축
-  const tableGrid = buildTableGrid(table);
-  
-  if (tableGrid.length < 2) {
-    console.warn('Table has less than 2 rows (need header + data)');
-    return [];
-  }
+  const format   = detectFormat(grid[headerRowIdx]);
+  const mapping  = mapColumns(grid[headerRowIdx]);
 
-  console.log(`Table grid built: ${tableGrid.length} rows, ${tableGrid[0]?.length || 0} columns`);
+  const seen = new Set<string>();
+  const data: ExtractedRow[] = [];
 
-  // 헤더 행 찾기
-  const headerRowIndex = findHeaderRow(tableGrid);
-  if (headerRowIndex === -1) {
-    console.warn('No header row found');
-    return [];
-  }
+  for (let r = headerRowIdx + 1; r < grid.length; r++) {
+    const row = grid[r];
+    if (isBlankRow(row)) continue;
 
-  console.log(`Header row found at index: ${headerRowIndex}`);
-
-  // 테이블 형식 결정
-  const headerRow = tableGrid[headerRowIndex];
-  const tableFormat = determineTableFormat(headerRow);
-  console.log(`Table format detected: ${tableFormat}`);
-  
-  // 컬럼 매핑 찾기
-  const columnMapping = findColumnMapping(headerRow, tableFormat);
-  console.log('Column mapping:', columnMapping);
-  
-  // 데이터 행 추출
-  const dataRows: ExtractedRow[] = [];
-  
-  for (let i = headerRowIndex + 1; i < tableGrid.length; i++) {
-    const row = tableGrid[i];
-    
-    if (row && row.length > 0 && !isEmptyRow(row)) {
-      try {
-        const extractedRow = extractRowData(row, tableFormat, columnMapping, imageIndex, tableIndex, i);
-        if (extractedRow && isValidRow(extractedRow)) {
-          dataRows.push(extractedRow);
-        }
-      } catch (error) {
-        console.warn(`Error processing row ${i}:`, error);
-      }
-    }
+    const parsed = buildRow(row, format, mapping, tblIdx, r);
+    if (!parsed || !isValidRow(parsed)) continue;
+
+    const key = `${parsed.no}-${parsed.identificationNo}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+
+    data.push(parsed);
   }
-  
-  console.log(`Extracted ${dataRows.length} valid rows from table`);
-  return dataRows;
+  return data;
 }
 
-// 테이블 그리드 구축
-function buildTableGrid(table: OCRTable): string[][] {
-  if (!table.cells || table.cells.length === 0) {
-    return [];
-  }
+/* -------------------------------------------------------------------------- */
+/* Grid & Header                                                             */
+/* -------------------------------------------------------------------------- */
+
+function buildGrid (table: OCRTable): string[][] {
+  const maxR = Math.max(...table.cells.map(c => c.rowIndex + c.rowSpan - 1));
+  const maxC = Math.max(...table.cells.map(c => c.columnIndex + c.columnSpan - 1));
+  const grid = Array.from({ length: maxR + 1 }, () => Array(maxC + 1).fill(''));
 
-  const maxRow = Math.max(...table.cells.map(cell => cell.rowIndex + cell.rowSpan - 1)) + 1;
-  const maxCol = Math.max(...table.cells.map(cell => cell.columnIndex + cell.columnSpan - 1)) + 1;
-  
-  const grid: string[][] = Array(maxRow).fill(null).map(() => Array(maxCol).fill(''));
-  
-  // 셀 내용으로 그리드 채우기
   table.cells.forEach(cell => {
-    const text = getCellText(cell);
-    
+    const txt = getCellText(cell);
     for (let r = cell.rowIndex; r < cell.rowIndex + cell.rowSpan; r++) {
       for (let c = cell.columnIndex; c < cell.columnIndex + cell.columnSpan; c++) {
-        if (grid[r] && grid[r][c] !== undefined) {
-          // 기존 텍스트가 있으면 결합
-          grid[r][c] = grid[r][c] ? `${grid[r][c]} ${text}`.trim() : text;
-        }
+        grid[r][c] = grid[r][c] ? `${grid[r][c]} ${txt}` : txt;
       }
     }
   });
-  
   return grid;
 }
 
-// 셀 텍스트 추출
-function getCellText(cell: TableCell): string {
-  if (!cell.cellTextLines || cell.cellTextLines.length === 0) {
-    return '';
-  }
-
-  return cell.cellTextLines
-    .map(line => 
-      line.cellWords
-        .map(word => word.inferText || '')
-        .join(' ')
-    )
-    .join('\n')
-    .trim();
+function getCellText (cell: TableCell): string {
+  return cell.cellTextLines?.flatMap(l => l.cellWords.map(w => w.inferText.trim())).filter(Boolean).join(' ') ?? '';
 }
 
-// 헤더 행 찾기
-function findHeaderRow(tableGrid: string[][]): number {
-  for (let i = 0; i < Math.min(3, tableGrid.length); i++) {
-    const row = tableGrid[i];
-    const rowText = row.join(' ').toLowerCase();
-    
-    console.log(`Checking row ${i}: "${rowText}"`);
-    
-    const hasNo = rowText.includes('no.') || rowText.includes('번호') || /\bno\b/.test(rowText);
-    const hasIdent = rowText.includes('identification') || rowText.includes('식별') || rowText.includes('ident');
-    
-    if (hasNo && hasIdent) {
-      console.log(`Header row found at ${i}`);
-      return i;
-    }
+function findHeaderRow (grid: string[][]): number {
+  for (let i = 0; i < Math.min(3, grid.length); i++) {
+    const t = grid[i].join(' ').toLowerCase();
+    if (/\bno\b|번호/.test(t) && /identification|식별|ident/.test(t)) return i;
   }
   return -1;
 }
 
-// 테이블 형식 결정
-function determineTableFormat(headerRow: string[]): 'format1' | 'format2' {
-  const headerText = headerRow.join(' ').toLowerCase();
-  
-  // Format 2: Tag No와 Joint No가 분리된 컬럼
-  const hasTagNoColumn = headerText.includes('tag') && headerText.includes('no');
-  const hasJointNoColumn = headerText.includes('joint') && headerText.includes('no');
-  
-  if (hasTagNoColumn && hasJointNoColumn) {
-    return 'format2';
-  }
-  
-  // Format 1: Identification No에 통합
-  return 'format1';
-}
+/* -------------------------------------------------------------------------- */
+/* Column Mapping                                                            */
+/* -------------------------------------------------------------------------- */
 
-// 컬럼 매핑 찾기
-function findColumnMapping(headerRow: string[], format: 'format1' | 'format2'): ColumnMapping {
-  const mapping: ColumnMapping = {
-    no: -1,
-    identification: -1,
-    tagNo: -1,
-    jointNo: -1,
-    jointType: -1,
-    weldingDate: -1
-  };
+function detectFormat (header: string[]): 'format1' | 'format2' {
+  const h = header.join(' ').toLowerCase();
+  return h.includes('tag') && h.includes('joint') ? 'format2' : 'format1';
+}
 
-  headerRow.forEach((header, index) => {
-    const lowerHeader = header.toLowerCase().trim();
-    
-    console.log(`Column ${index}: "${header}" -> "${lowerHeader}"`);
-    
-    if ((lowerHeader.includes('no.') || lowerHeader === 'no') && 
-        !lowerHeader.includes('identification') && 
-        !lowerHeader.includes('tag') && 
-        !lowerHeader.includes('joint')) {
-      mapping.no = index;
-      console.log(`  -> Mapped to 'no'`);
-    } else if (lowerHeader.includes('identification') || lowerHeader.includes('ident')) {
-      mapping.identification = index;
-      console.log(`  -> Mapped to 'identification'`);
-    } else if (lowerHeader.includes('tag') && lowerHeader.includes('no')) {
-      mapping.tagNo = index;
-      console.log(`  -> Mapped to 'tagNo'`);
-    } else if (lowerHeader.includes('joint') && lowerHeader.includes('no')) {
-      mapping.jointNo = index;
-      console.log(`  -> Mapped to 'jointNo'`);
-    } else if (lowerHeader.includes('joint') && lowerHeader.includes('type')) {
-      mapping.jointType = index;
-      console.log(`  -> Mapped to 'jointType'`);
-    } else if (lowerHeader.includes('type') && !lowerHeader.includes('joint')) {
-      mapping.jointType = index;
-      console.log(`  -> Mapped to 'jointType'`);
-    } else if (lowerHeader.includes('welding') || lowerHeader.includes('date')) {
-      mapping.weldingDate = index;
-      console.log(`  -> Mapped to 'weldingDate'`);
-    }
+function mapColumns (header: string[]): ColumnMapping {
+  const mp: ColumnMapping = { no: -1, identification: -1, tagNo: -1, jointNo: -1, jointType: -1, weldingDate: -1 };
+
+  header.forEach((h, i) => {
+    const t = h.toLowerCase();
+    if (/^no\.?$/.test(t) && !/ident|tag|joint/.test(t)) mp.no = i;
+    else if (/identification|ident/.test(t)) mp.identification = i;
+    else if (/tag.*no/.test(t)) mp.tagNo = i;
+    else if (/joint.*no/.test(t)) mp.jointNo = i;
+    else if (/joint.*type/.test(t) || (/^type$/.test(t) && mp.jointType === -1)) mp.jointType = i;
+    else if (/welding|date/.test(t)) mp.weldingDate = i;
   });
-
-  console.log('Final column mapping:', mapping);
-  return mapping;
+  return mp;
 }
 
-// 행 데이터 추출
-function extractRowData(
-  row: string[], 
-  format: 'format1' | 'format2', 
-  columnMapping: ColumnMapping,
-  imageIndex: number,
-  tableIndex: number,
-  rowIndex: number
+/* -------------------------------------------------------------------------- */
+/* Row Extraction                                                            */
+/* -------------------------------------------------------------------------- */
+
+function buildRow (
+  row: string[],
+  format: 'format1' | 'format2',
+  mp: ColumnMapping,
+  tblIdx: number,
+  rowIdx: number
 ): ExtractedRow | null {
-  
-  const extractedRow: ExtractedRow = {
-    no: '',
+  const out: ExtractedRow = {
+    no: mp.no >= 0 ? clean(row[mp.no]) : '',
     identificationNo: '',
     tagNo: '',
     jointNo: '',
-    jointType: '',
+    jointType: mp.jointType >= 0 ? clean(row[mp.jointType]) : '',
     weldingDate: '',
     confidence: 0,
-    sourceTable: tableIndex,
-    sourceRow: rowIndex
+    sourceTable: tblIdx,
+    sourceRow: rowIdx,
   };
 
-  console.log(`Processing row ${rowIndex}: [${row.map(cell => `"${cell}"`).join(', ')}]`);
-
-  // No. 추출
-  if (columnMapping.no >= 0 && columnMapping.no < row.length) {
-    extractedRow.no = cleanText(row[columnMapping.no]);
+  if (mp.weldingDate >= 0) out.weldingDate = clean(row[mp.weldingDate]);
+  else {
+    const idx = row.findIndex(col => /\d{4}[.\-/]\d{1,2}[.\-/]\d{1,2}/.test(col));
+    if (idx >= 0) out.weldingDate = clean(row[idx]);
   }
 
-  if (format === 'format1') {
-    // Format 1: 통합된 identification 데이터
-    if (columnMapping.identification >= 0 && columnMapping.identification < row.length) {
-      const combinedText = row[columnMapping.identification];
-      const parsedData = parseIdentificationData(combinedText);
-      extractedRow.identificationNo = parsedData.identificationNo;
-      extractedRow.tagNo = parsedData.tagNo;
-      extractedRow.jointNo = parsedData.jointNo;
-      
-      console.log(`  Parsed identification: "${combinedText}" -> `, parsedData);
-    }
+  if (format === 'format2') {
+    if (mp.identification >= 0) out.identificationNo = clean(row[mp.identification]);
+    if (mp.jointNo >= 0) out.jointNo = clean(row[mp.jointNo]);
+    if (mp.tagNo >= 0) out.tagNo = clean(row[mp.tagNo]);
   } else {
-    // Format 2: 분리된 컬럼들
-    if (columnMapping.identification >= 0 && columnMapping.identification < row.length) {
-      extractedRow.identificationNo = cleanText(row[columnMapping.identification]);
-    }
-    if (columnMapping.tagNo >= 0 && columnMapping.tagNo < row.length) {
-      extractedRow.tagNo = cleanText(row[columnMapping.tagNo]);
-    }
-    if (columnMapping.jointNo >= 0 && columnMapping.jointNo < row.length) {
-      extractedRow.jointNo = cleanText(row[columnMapping.jointNo]);
-    }
+    const combined = mp.identification >= 0 ? row[mp.identification] : '';
+    const parsed = parseIdentificationData(combined);
+    out.identificationNo = parsed.identificationNo;
+    out.jointNo         = parsed.jointNo;
+    out.tagNo           = parsed.tagNo;
   }
 
-  // Joint Type 추출
-  if (columnMapping.jointType >= 0 && columnMapping.jointType < row.length) {
-    extractedRow.jointType = cleanText(row[columnMapping.jointType]);
-  }
-
-  // Welding Date 추출 (컬럼 매핑이 있으면 사용, 없으면 날짜 패턴으로 찾기)
-  if (columnMapping.weldingDate >= 0 && columnMapping.weldingDate < row.length) {
-    extractedRow.weldingDate = cleanText(row[columnMapping.weldingDate]);
-  } else {
-    const dateIndex = findDateColumn(row);
-    if (dateIndex >= 0) {
-      extractedRow.weldingDate = cleanText(row[dateIndex]);
-    }
-  }
-
-  // 신뢰도 계산
-  extractedRow.confidence = calculateRowConfidence(extractedRow);
-
-  console.log(`  Extracted row:`, extractedRow);
-
-  return extractedRow;
+  out.confidence = scoreRow(out);
+  return out;
 }
 
-// Identification 데이터 파싱 (Format 1용)
-function parseIdentificationData(combinedText: string): {
-  identificationNo: string;
-  tagNo: string;
-  jointNo: string;
-} {
-  const cleanedText = cleanText(combinedText);
-  
-  console.log(`Parsing identification data: "${cleanedText}"`);
-  
-  // 줄바꿈으로 먼저 분리
-  const lines = cleanedText.split(/[\r\n]+/).map(line => line.trim()).filter(line => line.length > 0);
-  
-  const allParts: string[] = [];
-  lines.forEach(line => {
-    // 공백과 특수문자로 분리
-    const parts = line.split(/[\s\-_]+/).filter(part => part.length > 0);
-    allParts.push(...parts);
-  });
+/* -------------------------------------------------------------------------- */
+/* Format‑1 셀 파싱                                                         */
+/* -------------------------------------------------------------------------- */
 
-  console.log(`  Split into parts:`, allParts);
+function parseIdentificationData (txt: string): { identificationNo: string; jointNo: string; tagNo: string } {
+  const cleaned = clean(txt);
+  if (!cleaned) return { identificationNo: '', jointNo: '', tagNo: '' };
 
-  if (allParts.length === 0) {
-    return { identificationNo: cleanedText, tagNo: '', jointNo: '' };
-  }
+  const tokens = cleaned.split(/\s+/).map(clean).filter(Boolean);
 
-  if (allParts.length === 1) {
-    return { identificationNo: allParts[0], tagNo: '', jointNo: '' };
-  }
+  // Identification 후보: 하이픈이 2개 이상 포함된 토큰 가운데 가장 긴 것
+  const idCand = tokens.filter(t => t.split('-').length >= 3).sort((a, b) => b.length - a.length);
+  const identificationNo = idCand[0] || '';
 
-  // 길이별로 정렬하여 식별
-  const sortedParts = [...allParts].sort((a, b) => b.length - a.length);
-  
-  const identificationNo = sortedParts[0]; // 가장 긴 것
-  const jointNo = allParts.find(part => part.length <= 3 && /^[A-Z0-9]+$/i.test(part)) || 
-                 sortedParts[sortedParts.length - 1]; // 3글자 이하 영숫자 또는 가장 짧은 것
-  const tagNo = allParts.find(part => part !== identificationNo && part !== jointNo) || '';
-  
-  const result = { identificationNo, tagNo, jointNo };
-  console.log(`  Parsed result:`, result);
-  
-  return result;
-}
+  const residual = tokens.filter(t => t !== identificationNo);
+  if (!residual.length) return { identificationNo, jointNo: '', tagNo: '' };
 
-// 날짜 컬럼 찾기
-function findDateColumn(row: string[]): number {
-  const datePattern = /\d{4}[.\-\/]\d{1,2}[.\-\/]\d{1,2}/;
-  
-  for (let i = 0; i < row.length; i++) {
-    if (datePattern.test(row[i])) {
-      console.log(`  Found date in column ${i}: "${row[i]}"`);
-      return i;
-    }
-  }
-  
-  return -1;
-}
+  residual.sort((a, b) => a.length - b.length);
+  const jointNo = residual[0] || '';
+  const tagNo   = residual[residual.length - 1] || '';
 
-// 텍스트 정리
-function cleanText(text: string): string {
-  return text
-    .replace(/[\r\n\t]+/g, ' ')
-    .replace(/\s+/g, ' ')
-    .trim();
+  return { identificationNo, jointNo, tagNo };
 }
 
-// 빈 행 확인
-function isEmptyRow(row: string[]): boolean {
-  return row.every(cell => !cell || cell.trim().length === 0);
+/* -------------------------------------------------------------------------- */
+/* Helpers                                                                   */
+/* -------------------------------------------------------------------------- */
+
+const clean = (s: string = '') => s.replace(/[\r\n\t]+/g, ' ').replace(/\s+/g, ' ').trim();
+const isBlankRow = (row: string[]) => row.every(c => !clean(c));
+const isValidRow = (r: ExtractedRow) => !!(r.no || r.identificationNo);
+
+function scoreRow (r: ExtractedRow): number {
+  const w: Record<keyof ExtractedRow, number> = {
+    no: 1, identificationNo: 3, tagNo: 2, jointNo: 2, jointType: 1, weldingDate: 1,
+    confidence: 0, sourceTable: 0, sourceRow: 0,
+  } as any;
+  let s = 0, t = 0;
+  (Object.keys(w) as (keyof ExtractedRow)[]).forEach(k => { t += w[k]; if ((r[k] as string)?.length) s += w[k]; });
+  return t ? s / t : 0;
 }
 
-// 유효한 행 확인
-function isValidRow(row: ExtractedRow): boolean {
-  // 번호나 식별번호 중 하나라도 있으면 유효
-  const hasBasicData = !!(row.no || row.identificationNo);
-  
-  // 너무 짧은 데이터는 제외 (오인식 방지)
-  const hasReasonableLength = (row.identificationNo?.length || 0) >= 3 || 
-                             (row.no?.length || 0) >= 1;
-  
-  return hasBasicData && hasReasonableLength;
-}
+/* -------------------------------------------------------------------------- */
+/* OCR 품질 분석 (기존 로직 유지)                                            */
+/* -------------------------------------------------------------------------- */
 
-// 행 신뢰도 계산
-function calculateRowConfidence(row: ExtractedRow): number {
-  let score = 0;
-  let maxScore = 0;
-
-  // 각 필드별 가중치
-  const weights = {
-    no: 1,
-    identificationNo: 3, // 가장 중요
-    tagNo: 2,
-    jointNo: 2,
-    jointType: 1,
-    weldingDate: 1
-  };
+export function analyzeOCRQuality (ocrResult: any) {
+  let conf = 0, cnt = 0, tbl = 0, kw = 0;
+  const keys = ['no.', 'identification', 'joint', 'tag', 'type', 'weld', 'date'];
 
-  Object.entries(weights).forEach(([field, weight]) => {
-    maxScore += weight;
-    const value = row[field as keyof ExtractedRow] as string;
-    
-    if (value && value.length > 0) {
-      // 기본 점수
-      score += weight * 0.5;
-      
-      // 길이 보너스
-      if (field === 'identificationNo' && value.length > 10) {
-        score += weight * 0.3;
-      } else if (field === 'no' && /^\d+$/.test(value)) {
-        score += weight * 0.3;
-      } else if (field === 'weldingDate' && /\d{4}[.\-\/]\d{1,2}[.\-\/]\d{1,2}/.test(value)) {
-        score += weight * 0.3;
-      } else if (value.length > 2) {
-        score += weight * 0.2;
-      }
-    }
+  ocrResult.images?.forEach((img: any) => {
+    tbl += img.tables?.length || 0;
+    img.fields?.forEach((f: any) => {
+      conf += f.inferConfidence || 0; cnt++;
+      const t = (f.inferText || '').toLowerCase();
+      keys.forEach(k => { if (t.includes(k)) kw++; });
+    });
   });
 
-  return maxScore > 0 ? Math.min(score / maxScore, 1) : 0;
+  return { confidence: cnt ? conf / cnt : 0, tablesFound: tbl, textQuality: cnt ? kw / cnt : 0, keywordCount: kw };
 }
-
-// 유틸리티: OCR 결과 품질 분석
-export function analyzeOCRQuality(ocrResult: any): { 
-  confidence: number; 
-  tablesFound: number; 
-  textQuality: number;
-  keywordCount: number;
-} {
-  let totalConfidence = 0;
-  let totalFields = 0;
-  let tablesFound = 0;
-  let relevantKeywords = 0;
-
-  const keywords = ['no.', 'identification', 'joint', 'tag', 'type', 'weld', 'date'];
-
-  if (ocrResult.images) {
-    ocrResult.images.forEach((image: any) => {
-      // 테이블 분석
-      if (image.tables) {
-        tablesFound += image.tables.length;
-      }
-
-      // 필드 신뢰도 분석
-      if (image.fields) {
-        image.fields.forEach((field: any) => {
-          const confidence = field.inferConfidence || 0;
-          const text = (field.inferText || '').toLowerCase();
-          
-          totalConfidence += confidence;
-          totalFields++;
-
-          // 관련 키워드 확인
-          keywords.forEach(keyword => {
-            if (text.includes(keyword)) {
-              relevantKeywords++;
-            }
-          });
-        });
-      }
-    });
-  }
-
-  const avgConfidence = totalFields > 0 ? totalConfidence / totalFields : 0;
-  const textQuality = totalFields > 0 ? relevantKeywords / totalFields : 0;
-
-  return {
-    confidence: avgConfidence,
-    tablesFound,
-    textQuality,
-    keywordCount: relevantKeywords
-  };
-}
\ No newline at end of file