@things-factory/board-import 10.0.0-beta.108

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@things-factory/board-import",
+  "version": "10.0.0-beta.108",
+  "main": "dist-server/index.js",
+  "things-factory": true,
+  "author": "heartyoh",
+  "description": "도면(CAD/이미지/IFC) → Operato Board (2D + 3D) → 데이터 바인딩 통합 import 파이프라인 (백엔드 코어)",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "@things-factory:registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hatiolab/things-factory.git",
+    "directory": "packages/board-import"
+  },
+  "scripts": {
+    "build": "npm run clean:server && tsc --p tsconfig.json",
+    "build:server": "npm run clean:server && tsc",
+    "clean:server": "rm -rf dist-server",
+    "clean": "npm run clean:server"
+  },
+  "dependencies": {
+    "@operato/graphql": "^10.0.0-beta.1",
+    "@things-factory/ai-client-base": "^10.0.0-beta.92",
+    "@things-factory/attachment-base": "^10.0.0-beta.108",
+    "@things-factory/auth-base": "^10.0.0-beta.108",
+    "@things-factory/board-service": "^10.0.0-beta.108",
+    "@things-factory/env": "^10.0.0-beta.92",
+    "@things-factory/shell": "^10.0.0-beta.108",
+    "dxf-parser": "^1.1.2"
+  },
+  "gitHead": "7de47925ebd3f39dc232d4dbfa43f9687f3603c4"
+}

package/probe/gcp-vision-probe.mjs

@@ -0,0 +1,114 @@
+/**
+ * GCP Cloud Vision 프로브 — 도면 이미지에서 객체검출(박스) + OCR(라벨+박스) 추출.
+ *
+ * 목적: board 생성 레이아웃 추출에 GCP Vision 이 실제로 무엇을 주는지 *기준선* 측정.
+ *   - OBJECT_LOCALIZATION : common-object(가구 등) + normalized 박스 → 위치 후보
+ *   - DOCUMENT_TEXT_DETECTION : 라벨 텍스트 + 위치 → 식별/앵커
+ *   - LABEL_DETECTION : 장면 라벨(맥락)
+ * 기하(벽/선/사각)는 Vision 이 안 줌 — 그건 OpenCV 영역(별도). 본 프로브는 Vision 의 몫만 확인.
+ *
+ * 사전 준비 (사용자 환경 — 키는 직접 발급):
+ *   1) GCP 콘솔에서 프로젝트 선택 → "Cloud Vision API" 사용 설정(Enable).
+ *   2) APIs & Services → Credentials → "API key" 생성 (Vision API 로 제한 권장).
+ *   3) export GOOGLE_VISION_API_KEY="발급키"
+ *
+ * 실행 (Node 18+ — 내장 fetch 사용, npm install 불필요):
+ *   node packages/board-import/probe/gcp-vision-probe.mjs [이미지경로]
+ *   기본 경로: /Users/super/Downloads/download.jpg
+ *
+ * 출력: 콘솔 요약(객체/텍스트/라벨) + 원본응답 JSON(<이미지>.vision.json).
+ */
+import { readFileSync, writeFileSync } from 'node:fs'
+
+const imgPath = process.argv[2] || '/Users/super/Downloads/download.jpg'
+const apiKey = process.env.GOOGLE_VISION_API_KEY || process.env.GCP_API_KEY
+
+if (!apiKey) {
+  console.error('✗ GOOGLE_VISION_API_KEY (또는 GCP_API_KEY) 환경변수가 필요합니다.')
+  console.error('  예: export GOOGLE_VISION_API_KEY="AIza..."')
+  process.exit(1)
+}
+
+let content
+try {
+  content = readFileSync(imgPath).toString('base64')
+} catch (e) {
+  console.error(`✗ 이미지를 읽을 수 없습니다: ${imgPath}\n  ${e.message}`)
+  process.exit(1)
+}
+
+const body = {
+  requests: [
+    {
+      image: { content },
+      features: [
+        { type: 'OBJECT_LOCALIZATION', maxResults: 50 },
+        { type: 'DOCUMENT_TEXT_DETECTION' },
+        { type: 'LABEL_DETECTION', maxResults: 20 }
+      ]
+    }
+  ]
+}
+
+console.log(`▶ Vision 호출: ${imgPath} (${Math.round(content.length / 1365)} KB base64)\n`)
+
+const res = await fetch(`https://vision.googleapis.com/v1/images:annotate?key=${apiKey}`, {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify(body)
+})
+
+const json = await res.json()
+const apiErr = json.error || json.responses?.[0]?.error
+if (!res.ok || apiErr) {
+  console.error('✗ API 에러:', JSON.stringify(apiErr || json, null, 2))
+  console.error('  (Vision API 미사용설정 / 키 제한 / 결제 미설정 등을 확인하세요.)')
+  process.exit(1)
+}
+
+const r = json.responses[0]
+const bbox = v => {
+  const pts = v || []
+  const xs = pts.map(p => p.x ?? 0)
+  const ys = pts.map(p => p.y ?? 0)
+  return pts.length
+    ? `[${Math.min(...xs)},${Math.min(...ys)} → ${Math.max(...xs)},${Math.max(...ys)}]`
+    : '[?]'
+}
+
+// 1) 객체 검출 — 위치 후보 (normalized 0..1)
+const objs = r.localizedObjectAnnotations || []
+console.log(`=== OBJECT_LOCALIZATION (${objs.length}) — normalized 0..1 ===`)
+for (const o of objs.sort((a, b) => b.score - a.score)) {
+  console.log(`  ${String(o.name).padEnd(18)} score=${o.score.toFixed(2)}  ${bbox(o.boundingPoly?.normalizedVertices)}`)
+}
+if (!objs.length) console.log('  (객체 검출 없음 — 저해상도/추상 도면이면 흔함)')
+
+// 2) OCR — 라벨 텍스트 + 위치
+console.log(`\n=== DOCUMENT_TEXT_DETECTION ===`)
+const fullText = r.fullTextAnnotation?.text?.trim()
+console.log(fullText ? `  전체텍스트:\n${fullText.split('\n').map(l => '    ' + l).join('\n')}` : '  (텍스트 없음)')
+const words = []
+for (const page of r.fullTextAnnotation?.pages || [])
+  for (const block of page.blocks || [])
+    for (const para of block.paragraphs || [])
+      for (const word of para.words || []) {
+        const t = (word.symbols || []).map(s => s.text).join('')
+        words.push({ t, box: word.boundingBox?.normalizedVertices || word.boundingBox?.vertices })
+      }
+console.log(`  단어 수: ${words.length}`)
+for (const w of words.slice(0, 40)) console.log(`    "${w.t}"  ${bbox(w.box)}`)
+
+// 3) 라벨 — 맥락
+const labels = r.labelAnnotations || []
+console.log(`\n=== LABELS (${labels.length}) ===`)
+for (const l of labels) console.log(`  ${l.description} (${l.score.toFixed(2)})`)
+
+// 원본 응답 저장
+const out = imgPath.replace(/\.[^.]+$/, '') + '.vision.json'
+writeFileSync(out, JSON.stringify(json, null, 2))
+console.log(`\n✓ raw 응답 → ${out}`)
+console.log('\n해석 가이드:')
+console.log('  - 객체 박스가 가구/설비를 잡으면 → 위치 후보로 활용 (VLM 좌표추정 대체).')
+console.log('  - 텍스트+박스가 있으면 → 컴포넌트 식별/앵커 (산업도면 ID 에서 진가).')
+console.log('  - 벽/선/사각 기하는 여기 안 나옴 → OpenCV 로 별도 추출해야 함.')

package/probe/opencv-geometry-probe.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+"""
+OpenCV 기하 프로브 — 도면 이미지에서 *벽/선·사각·객체 footprint* 를 추출.
+
+목적: 레이아웃의 핵심(기하)을 VLM 좌표추정이 아니라 CV 로 얼마나 뽑을 수 있는지 *기준선* 측정.
+GCP Vision(객체/OCR) 이 못 주는 부분 — 선·사각·연결성분 — 을 담당. 둘을 합쳐 하이브리드.
+
+로컬 실행, 외부 전송/키 없음 (프라이버시 안전).
+
+사전 준비:
+    pip install opencv-python numpy
+
+실행:
+    python packages/board-import/probe/opencv-geometry-probe.py [이미지경로]
+    기본 경로: /Users/super/Downloads/download.jpg
+
+출력:
+    - 콘솔 요약(이미지 크기 / 선 수 / 사각 후보 수 + 상위 박스 좌표)
+    - 시각 오버레이 PNG(<이미지>_cv_overlay.png) — 검출 선(초록)·사각(빨강)을 원본 위에 그림.
+      ★ 이 오버레이를 눈으로 보고 "CV 가 이 도면에서 기하를 의미있게 잡는지" 판단.
+"""
+import sys
+import os
+
+try:
+    import cv2
+    import numpy as np
+except ImportError:
+    sys.exit("✗ opencv-python / numpy 가 필요합니다:  pip install opencv-python numpy")
+
+img_path = sys.argv[1] if len(sys.argv) > 1 else "/Users/super/Downloads/download.jpg"
+img = cv2.imread(img_path)
+if img is None:
+    sys.exit(f"✗ 이미지를 읽을 수 없습니다: {img_path}")
+
+h0, w0 = img.shape[:2]
+print(f"▶ 입력: {img_path}  ({w0}x{h0})")
+
+# 저해상도면 검출이 어렵다 — 업스케일(보간)로 선을 살림. (배율은 가독 위해 ~900px 목표.)
+scale = max(1, round(900 / max(w0, h0)))
+if scale > 1:
+    img = cv2.resize(img, (w0 * scale, h0 * scale), interpolation=cv2.INTER_CUBIC)
+    print(f"  저해상도 → {scale}x 업스케일 ({img.shape[1]}x{img.shape[0]})")
+h, w = img.shape[:2]
+
+gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+# ── 1. 선(벽/경로) 검출 — Canny + 확률적 Hough ───────────────────────────────
+edges = cv2.Canny(gray, 40, 120, apertureSize=3)
+min_len = max(20, w // 25)
+lines = cv2.HoughLinesP(edges, 1, np.pi / 180, threshold=50,
+                        minLineLength=min_len, maxLineGap=8)
+lines = lines if lines is not None else []
+print(f"\n=== 선(LINES) — {len(lines)} 개 (minLen={min_len}) ===")
+
+# ── 2. 사각/객체 footprint — 임계 + 윤곽 → bounding rect ──────────────────────
+# 청사진(밝은 선/짙은 배경)·일반 도면 모두 커버하도록 Otsu 양방향 시도 후 더 풍부한 쪽 선택.
+def contours_from(bin_img):
+    cnts, _ = cv2.findContours(bin_img, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
+    return cnts
+
+_, th = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+cands_a = contours_from(th)
+cands_b = contours_from(cv2.bitwise_not(th))
+cnts = cands_a if len(cands_a) >= len(cands_b) else cands_b
+
+area_min = (w * h) * 0.0008   # 너무 작은 잡음 제거
+area_max = (w * h) * 0.5      # 전체 프레임 같은 거대 윤곽 제거
+rects = []
+for c in cnts:
+    a = cv2.contourArea(c)
+    if a < area_min or a > area_max:
+        continue
+    x, y, ww, hh = cv2.boundingRect(c)
+    rects.append((x, y, ww, hh, a))
+rects.sort(key=lambda r: -r[4])
+print(f"\n=== 사각 후보(RECTS) — {len(rects)} 개 (area {area_min:.0f}~{area_max:.0f}px²) ===")
+for x, y, ww, hh, a in rects[:25]:
+    # 원본 좌표계로 환산해 보고
+    print(f"  x={x//scale:4d} y={y//scale:4d}  w={ww//scale:4d} h={hh//scale:4d}  (area={a/scale/scale:.0f})")
+
+# ── 3. 시각 오버레이 저장 ──────────────────────────────────────────────────────
+overlay = img.copy()
+for ln in lines:
+    x1, y1, x2, y2 = ln[0]
+    cv2.line(overlay, (x1, y1), (x2, y2), (0, 200, 0), 1)
+for x, y, ww, hh, a in rects:
+    cv2.rectangle(overlay, (x, y), (x + ww, y + hh), (0, 0, 255), 1)
+
+base, _ = os.path.splitext(img_path)
+out = base + "_cv_overlay.png"
+cv2.imwrite(out, overlay)
+print(f"\n✓ 오버레이 → {out}")
+print("\n해석 가이드:")
+print("  - 초록 선이 벽/경로를 따라가면 → Hough 로 구조선 추출 가능.")
+print("  - 빨강 사각이 방/가구/설비 footprint 에 맞으면 → 위치·크기 후보로 활용.")
+print("  - 어수선하면(저해상도/스타일) → 전처리 강화 또는 고해상도 입력 필요.")
+print("  - 이 기하 + GCP Vision(객체/OCR 라벨) + VLM(의미) = 하이브리드.")

package/server/index.ts

@@ -0,0 +1,7 @@
+/**
+ * @things-factory/board-import — 도면(CAD/이미지/IFC) → Board Model 백엔드 코어.
+ *
+ * Phase 1: DXF 결정적 파이프라인 (AI 미사용).
+ * Phase 2+: GraphQL/REST 엔드포인트, AI 통합.
+ */
+export * from './service/index'

package/server/service/adapters/dxf-adapter.ts

@@ -0,0 +1,230 @@
+/**
+ * DXF Format Adapter — DXF 텍스트 파일을 UniversalEntity 목록으로 정규화.
+ *
+ * 백엔드 환경(Node.js)에서 동작. 입력은 string / Buffer / ArrayBuffer / Uint8Array 모두 허용.
+ *
+ * 구현 범위 (Phase 1):
+ *   - INSERT (블록 참조) → kind='shape', attribs.name 추출
+ *   - LWPOLYLINE / POLYLINE → kind='path'
+ *   - CIRCLE → kind='shape', attribs.shape='circle'
+ *   - LINE → kind='path' (단일 선분)
+ *   - TEXT / MTEXT → kind='text'
+ *   - 레이어, 좌표, 회전 추출
+ *   - $INSUNITS 단위 추출
+ *
+ * 보류 (Phase 2+):
+ *   - HATCH, SPLINE, ELLIPSE 의 정밀 변환
+ *   - 블록 정의 안의 entities 깊이 펼치기
+ *   - 외부 참조 (XREF)
+ */
+import DxfParser from 'dxf-parser'
+
+import type {
+  AdapterCapabilities,
+  AdapterInput,
+  BoundingBox,
+  FormatAdapter,
+  ParseOptions,
+  ParseResult,
+  UniversalEntity
+} from '../types/index'
+
+const DXF_INSUNITS_TO_UNITS: Record<number, ParseResult['units']> = {
+  0: 'unknown',
+  1: 'inch',
+  4: 'mm',
+  5: 'cm',
+  6: 'm'
+}
+
+export class DxfAdapter implements FormatAdapter {
+  readonly format = 'dxf'
+  readonly supportedExtensions = ['.dxf']
+  readonly capabilities: AdapterCapabilities = {
+    has2D: true,
+    has3D: false,
+    hasSemanticLabels: false,
+    hasTextLabels: true,
+    hasAttributes: true
+  }
+
+  async detect(file: AdapterInput, filename?: string): Promise<boolean> {
+    if (filename) {
+      const lower = filename.toLowerCase()
+      if (lower.endsWith('.dxf')) return true
+      // 명백한 non-DXF 확장자는 content peek 자체를 시도하지 않음.
+      // 잘못된 입력 타입(Promise/Stream 등) 이 흘러도 detect 가 throw 하지 않게 가드.
+      if (/\.(jpe?g|png|gif|webp|bmp|svg|pdf|ifc|gltf|glb|json|xml|csv|xlsx?|docx?)$/.test(lower)) {
+        return false
+      }
+    }
+    try {
+      const head = readHead(file, 256)
+      return /\b0\s*\n\s*SECTION\b/.test(head) || /^\s*999/.test(head)
+    } catch {
+      // 입력 타입을 텍스트로 못 읽으면 DXF 가 아니다 — false 로 흘려보내 다음 어댑터에 양보.
+      return false
+    }
+  }
+
+  async parse(file: AdapterInput, options: ParseOptions = {}): Promise<ParseResult> {
+    const text = readText(file)
+    const parser = new DxfParser()
+    const dxf = parser.parseSync(text)
+
+    if (!dxf) throw new Error('DXF 파싱 실패')
+
+    const entities: UniversalEntity[] = []
+    let uidCounter = 0
+    const nextUid = () => `dxf-${++uidCounter}`
+
+    const excludeLayers = new Set((options.excludeLayers || []).map(l => l.toLowerCase()))
+    const maxEntities = options.maxEntities ?? 100000
+
+    for (const e of dxf.entities || []) {
+      if (entities.length >= maxEntities) break
+
+      const layer = (e as any).layer || ''
+      if (excludeLayers.has(layer.toLowerCase())) continue
+
+      const ue = entityToUniversal(e, layer, nextUid())
+      if (ue) entities.push(ue)
+    }
+
+    const bbox = computeBoundingBox(entities)
+    const units = DXF_INSUNITS_TO_UNITS[(dxf.header as any)?.$INSUNITS ?? 0]
+
+    return {
+      entities,
+      metadata: {
+        format: 'dxf',
+        formatVersion: (dxf.header as any)?.$ACADVER,
+        ...((dxf.header as any) || {})
+      },
+      bbox,
+      units
+    }
+  }
+}
+
+// ── DXF entity → UniversalEntity ─────────────────────────────────────
+
+function entityToUniversal(e: any, layer: string, uid: string): UniversalEntity | null {
+  const type = e.type as string
+
+  switch (type) {
+    case 'INSERT': {
+      const x = e.position?.x ?? 0
+      const y = e.position?.y ?? 0
+      const width = (e.xScale ?? 1) * 1
+      const height = (e.yScale ?? 1) * 1
+      return {
+        uid,
+        kind: 'shape',
+        position: { x, y },
+        size: { width, height },
+        rotation: e.rotation ?? 0,
+        bbox: { min: { x, y }, max: { x: x + width, y: y + height } },
+        attribs: {
+          name: e.name,
+          layer,
+          shape: 'rect'
+        }
+      }
+    }
+
+    case 'CIRCLE': {
+      const cx = e.center?.x ?? 0
+      const cy = e.center?.y ?? 0
+      const r = e.radius ?? 0
+      return {
+        uid,
+        kind: 'shape',
+        position: { x: cx - r, y: cy - r },
+        size: { width: 2 * r, height: 2 * r },
+        bbox: { min: { x: cx - r, y: cy - r }, max: { x: cx + r, y: cy + r } },
+        attribs: { layer, shape: 'circle' }
+      }
+    }
+
+    case 'LWPOLYLINE':
+    case 'POLYLINE': {
+      const verts: { x: number; y: number }[] = (e.vertices || []).map((v: any) => ({ x: v.x, y: v.y }))
+      if (verts.length === 0) return null
+      const xs = verts.map(v => v.x)
+      const ys = verts.map(v => v.y)
+      const min = { x: Math.min(...xs), y: Math.min(...ys) }
+      const max = { x: Math.max(...xs), y: Math.max(...ys) }
+      return {
+        uid,
+        kind: 'path',
+        position: { x: min.x, y: min.y },
+        size: { width: max.x - min.x, height: max.y - min.y },
+        bbox: { min, max },
+        attribs: { layer, shape: 'polyline', vertices: verts, closed: !!e.shape }
+      }
+    }
+
+    case 'LINE': {
+      const x1 = e.vertices?.[0]?.x ?? 0
+      const y1 = e.vertices?.[0]?.y ?? 0
+      const x2 = e.vertices?.[1]?.x ?? 0
+      const y2 = e.vertices?.[1]?.y ?? 0
+      const min = { x: Math.min(x1, x2), y: Math.min(y1, y2) }
+      const max = { x: Math.max(x1, x2), y: Math.max(y1, y2) }
+      return {
+        uid,
+        kind: 'path',
+        position: { x: min.x, y: min.y },
+        size: { width: max.x - min.x, height: max.y - min.y },
+        bbox: { min, max },
+        attribs: { layer, shape: 'polyline', vertices: [{ x: x1, y: y1 }, { x: x2, y: y2 }] }
+      }
+    }
+
+    case 'TEXT':
+    case 'MTEXT': {
+      const x = e.position?.x ?? e.startPoint?.x ?? 0
+      const y = e.position?.y ?? e.startPoint?.y ?? 0
+      const text = e.text ?? e.string ?? ''
+      const h = e.textHeight ?? e.height ?? 1
+      return {
+        uid,
+        kind: 'text',
+        position: { x, y },
+        bbox: { min: { x, y }, max: { x: x + h * (text.length || 1), y: y + h } },
+        attribs: { layer, text }
+      }
+    }
+
+    default:
+      return null
+  }
+}
+
+// ── 유틸 ─────────────────────────────────────────────────────────────
+
+function computeBoundingBox(entities: UniversalEntity[]): BoundingBox {
+  if (entities.length === 0) return { min: { x: 0, y: 0 }, max: { x: 0, y: 0 } }
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity
+  for (const e of entities) {
+    if (e.bbox.min.x < minX) minX = e.bbox.min.x
+    if (e.bbox.min.y < minY) minY = e.bbox.min.y
+    if (e.bbox.max.x > maxX) maxX = e.bbox.max.x
+    if (e.bbox.max.y > maxY) maxY = e.bbox.max.y
+  }
+  return { min: { x: minX, y: minY }, max: { x: maxX, y: maxY } }
+}
+
+function readText(file: AdapterInput): string {
+  if (typeof file === 'string') return file
+  if (Buffer.isBuffer(file)) return file.toString('utf-8')
+  if (file instanceof Uint8Array) return Buffer.from(file).toString('utf-8')
+  if (file instanceof ArrayBuffer) return Buffer.from(new Uint8Array(file)).toString('utf-8')
+  throw new Error('Unsupported DXF input type')
+}
+
+function readHead(file: AdapterInput, maxBytes: number): string {
+  const text = readText(file)
+  return text.substring(0, maxBytes)
+}