쉬운 비유:

  현실 세계                          컴퓨터 세계
  +-----------+                     +-----------+
  | 공을 던지면 |  --- Bullet --->  | 공이 포물선을 |
  | 바닥에 튕긴다|  Physics가 계산   | 그리며 튕긴다  |
  +-----------+                     +-----------+

  즉, "가상 세계의 물리 법칙"을 만들어주는 엔진이다.

Erwin Coumans의 경력 타임라인:

  2003         2010         2014         2022         현재
  |------------|------------|------------|------------|
  Sony CEA     AMD          Google       NVIDIA
  (Bullet 개발  (GPU 물리    (TensorFlow  (로봇/AI
   시작)        가속 연구)    PyBullet)    물리 연구)

+--------------------------------------------------+
|              Bullet Physics 활용 분야              |
+--------------------------------------------------+
|                                                    |
|  [게임]          [영화/VFX]       [로봇공학]        |
|  GTA IV/V        Megamind         PyBullet         |
|  Red Dead         Shrek 4         강화학습          |
|  Redemption      Hollywood VFX    로봇 시뮬레이션   |
|                                                    |
|  [VR/AR]         [과학/공학]      [교육/연구]       |
|  가상현실         구조 해석         대학교 연구      |
|  시뮬레이션       충돌 분석         물리 교육        |
|                                                    |
|  [3D 소프트웨어]  [AI/ML]                           |
|  Maya, Blender   강화학습 환경                      |
|  Cinema 4D       OpenAI Gym                        |
|                                                    |
+--------------------------------------------------+

비유: "대형 음식점에서 주문 처리하기"

  1단계 Broadphase: "어느 테이블 손님이 주문했지?" (대략적 파악)
  2단계 Narrowphase: "정확히 뭘 주문했지?" (정밀 확인)
  3단계 Dispatch:    "요리사에게 전달!" (적절한 처리기로 연결)

예시: 물체가 100개 있을 때

  모든 쌍을 비교하면: 100 x 99 / 2 = 4,950번 검사 (너무 많다!)
  Broadphase 적용 후:  실제 근처에 있는 ~50쌍만 검사 (빠르다!)

DBVT = Dynamic Bounding Volume Hierarchy Tree

  각 물체를 AABB(축 정렬 경계 상자)로 감싸고,
  이진 트리 구조로 계층화한다.

              [전체 영역 AABB]
              /              \
     [왼쪽 그룹 AABB]    [오른쪽 그룹 AABB]
      /        \            /          \
   [A의 AABB] [B의 AABB] [C의 AABB] [D의 AABB]  <-- 리프 노드(실제 물체)

  장점: 물체가 움직여도 트리를 빠르게 업데이트할 수 있다.
        두 개의 트리를 운영한다:
        - 정적 물체용 트리 (한번 구성, 업데이트 거의 없음)
        - 동적 물체용 트리 (매 프레임 업데이트)

GJK = "두 물체 사이에 종이를 끼울 수 있는가?"

  +-------+     +-------+
  |   A   |     |   B   |
  |       |     |       |
  +-------+     +-------+
       <---종이--->
  종이를 끼울 수 있다 = 충돌 안 함 (분리됨)

  +-------+
  |   A +-------+
  |     | B     |
  +-----+       |
        +-------+
  종이를 끼울 수 없다 = 충돌함 (겹침)

  GJK는 이것을 "민코프스키 차" 공간에서
  원점이 내부에 있는지 확인하는 방식으로 판단한다.

형상 조합별 알고리즘 선택 (Dispatch Table):

  +-----------+--------+---------+----------+-----------+
  |           | Sphere | Box     | Convex   | Triangle  |
  +-----------+--------+---------+----------+-----------+
  | Sphere    | S-S    | S-Box   | GJK      | S-Tri     |
  | Box       |        | SAT     | GJK      | GJK       |
  | Convex    |        |         | GJK+EPA  | GJK       |
  | Triangle  |        |         |          | GJK       |
  +-----------+--------+---------+----------+-----------+

  S-S: 구-구 충돌 (거리 비교만으로 가능, 가장 빠름)
  SAT: 분리축 정리 (박스 간 최적화)
  GJK+EPA: 범용 볼록 도형 충돌 + 관통 깊이

강체의 속성:

  +------------------+
  | btRigidBody      |
  +------------------+
  | - mass (질량)     |  <-- 0이면 정적 물체(바닥 등)
  | - position (위치) |
  | - rotation (회전) |
  | - velocity (속도) |
  | - angular vel.   |  <-- 회전 속도
  | - friction (마찰) |
  | - restitution    |  <-- 탄성 (0=찰흙, 1=완벽한 공)
  | - inertia (관성)  |
  +------------------+

매 프레임(1/60초)마다:

  1. 외력 적용 (중력, 사용자 힘 등)
         F = m * a  (뉴턴 제2법칙)
         |
         v
  2. 속도 갱신
         v_new = v_old + a * dt
         |
         v
  3. 충돌 감지 (Broadphase -> Narrowphase)
         "누구랑 부딪혔지?"
         |
         v
  4. 제약 조건 풀기 (Constraint Solver)
         "겹침을 어떻게 해결하지?"
         |
         v
  5. 위치 갱신
         pos_new = pos_old + v * dt
         |
         v
  6. 화면에 그리기

연체의 구조 (Position Based Dynamics):

  노드(Node) = 점 질량
  링크(Link) = 노드 간 연결 (스프링처럼 작동)
  면(Face)   = 세 노드로 구성된 삼각형

       o-------o-------o
      / \     / \     / \
     /   \   /   \   /   \
    o-----o-o-----o-o-----o     <-- 메쉬처럼 연결된 점들
     \   / \ \   / \ \   /
      \ /   \ \ /   \ \ /
       o-------o-------o

  각 노드(o)는 독립적으로 움직이며,
  링크(-)가 너무 늘어나면 당기고,
  너무 줄어들면 밀어낸다.
  -> 이것이 말랑한 물체의 행동을 만든다.

Bullet이 지원하는 제약 조건 종류:

  1. Point-to-Point (볼 조인트)
     o----o    두 점이 연결됨 (팔의 어깨 관절)

  2. Hinge (경첩)
     |    |
     o====o    한 축으로만 회전 (문의 경첩)
     |    |

  3. Slider (슬라이더)
     o========o    한 축으로만 이동 (서랍)

  4. ConeTwist (원뿔 비틀림)
       /|\
      / | \
     o--+--o    제한된 각도로 회전 (목 관절)

  5. Generic 6DOF (6자유도)
     X/Y/Z 이동 + X/Y/Z 회전 = 6개 축 각각 제한 가능
     (가장 범용적, 위의 모든 조인트를 흉내낼 수 있음)

  6. Fixed (고정)
     두 물체를 완전히 붙여놓기 (용접)

쉬운 비유: "만원 지하철에서 사람들이 자리 잡기"

  상황: 사람들이 너무 많아서 서로 겹쳐 있다.
  해결: 각 사람이 옆 사람을 조금씩 밀어낸다.
        이것을 여러 번 반복하면 결국 모두가 적절한 자리를 찾는다.

  Sequential Impulse = "한 쌍씩 순서대로, 살짝 밀어내기를 반복"

Sequential Impulse Solver 동작 흐름:

  입력: 충돌 접촉점들의 목록 (contact manifold)
  |
  v
  각 접촉점마다:
  +------------------------------------------+
  | 1. 비관통 제약 (Non-penetration)          |
  |    "물체가 서로 뚫고 들어가면 안 된다"     |
  |                                          |
  | 2. 마찰 제약 (Friction) x 2              |
  |    "미끄러지지 않게 하는 힘" (접선 방향 2개)|
  +------------------------------------------+
  |
  v
  반복 (iterations, 기본 10회):
  +------------------------------------------+
  | for each contact:                         |
  |   - 현재 상대 속도 계산                    |
  |   - 필요한 충격량(impulse) 계산            |
  |   - 충격량 적용 (속도 변경)                |
  |   - 충격량 클램핑 (음수 방지)              |
  +------------------------------------------+
  |
  v
  수렴: 반복할수록 정확한 해에 수렴

Bullet이 지원하는 충돌 형상 (Collision Shapes):

  기본 도형 (Primitive):
  +----------+   +----+   +------+   +---------+
  | Sphere   |   | Box|   |Cylind|   | Capsule |
  |    O     |   |    |   |  ||  |   |   ()    |
  |          |   |    |   |  ||  |   |   ||    |
  +----------+   +----+   +------+   +---------+

  볼록 도형 (Convex):
  +----------------+   +------------------+
  | ConvexHull     |   | MultiSphere      |
  |   /\           |   |  O O             |
  |  /  \          |   |   O              |
  | /____\         |   |  O O             |
  +----------------+   +------------------+

  오목/복합 도형 (Concave / Compound):
  +------------------+   +------------------+
  | TriangleMesh     |   | CompoundShape    |
  | /\/\/\/\         |   |  [Box]+[Sphere]  |
  | \/\/\/\/         |   |  복합 형상 조합   |
  +------------------+   +------------------+

  특수 도형:
  +------------------+   +------------------+
  | StaticPlane      |   | HeightfieldTerrain|
  | ________________ |   | /\/\_/\/\        |
  | (무한 평면)      |   | (지형)            |
  +------------------+   +------------------+

PyBullet의 주요 기능:

  +-------------------------------------------------+
  | PyBullet                                         |
  +-------------------------------------------------+
  | - URDF/SDF/MJCF 로봇 모델 로딩                   |
  | - 순방향/역방향 운동학 (FK/IK)                    |
  | - 순방향/역방향 동역학                            |
  | - 충돌 감지 및 광선 교차 쿼리                     |
  | - OpenGL 기반 실시간 시각화                       |
  | - OpenAI Gym 호환 강화학습 환경                   |
  | - TensorFlow/PyTorch 연동 가능                   |
  | - 멀티바디 시뮬레이션                             |
  +-------------------------------------------------+

  설치: pip install pybullet

주요 특징:
- GJK 기반 볼록 형상 충돌 감지
- AABB 트리 기반 브로드페이즈
- 강체/연체/차량 시뮬레이션
- Python (PyBullet), C++ API 제공
- 로봇공학, 게임, VR/AR에 널리 사용

- 구(Sphere), 박스(Box), 원통(Cylinder), 원뿔(Cone)
- 볼록 껍질(ConvexHull) - GJK 기반
- 삼각 메쉬(TriangleMesh) - 정적 형상
- 복합 형상(CompoundShape) - 여러 형상 조합

+---------------------------------------------------------------------+
|             물리 엔진 비교 (Bullet vs PhysX vs Havok vs ODE)         |
+---------------------------------------------------------------------+

  라이선스:
  Bullet   [===== zlib (완전 자유) =====]
  PhysX    [===== BSD-3 (오픈소스) =====]   (2018년 오픈소스 전환)
  Havok    [=== 상용 (유료) ===]
  ODE      [===== BSD/LGPL (자유) =====]

  성능 (일반적 평가):
  Bullet   [========]  좋음
  PhysX    [==========] 매우 좋음 (GPU 가속 최적화)
  Havok    [==========] 매우 좋음 (AAA 최적화)
  ODE      [======]    보통

  사용 편의성:
  Bullet   [======]    보통 (문서 부족)
  PhysX    [========]  좋음 (Unity/Unreal 내장)
  Havok    [========]  좋음 (전문 도구 제공)
  ODE      [=====]     보통

  커뮤니티/지원:
  Bullet   [========]  활발한 오픈소스 커뮤니티
  PhysX    [==========] NVIDIA 공식 지원
  Havok    [========]  Microsoft 공식 지원 (유료)
  ODE      [====]      소규모 커뮤니티

쉬운 비유: "두 사람이 겹쳐서 서 있을 때"

  겹침 전:           겹친 상태:            MTV로 해결:
  +---+   +---+     +---+                +---+   +---+
  | A |   | B |     | A-+-B |            | A | ->| B |
  +---+   +---+     +---+                +---+   +---+
                     <-d->                     <-MTV->
                     관통 깊이               최소 이동 벡터

  MTV = 방향(normal) x 깊이(depth)
  방향: A에서 B를 향하는 방향
  깊이: 얼마나 겹쳤는지의 크기

3D 공간에서 두 박스의 충돌과 MTV:

  Y축
  ^
  |     +-------+
  |     |       |
  |     |   B   |
  |     |   +---+---+
  |     +---+-+ |   |
  |         | A |   |
  |         |   +---+
  |         +-------+
  +-------------------------> X축

  접촉점(Contact Point)에서의 정보:
  - contactNormal (n): B 표면의 법선 방향 (화살표 방향)
  - penetrationDepth (d): 겹침 깊이 (음수 값)

  MTV 계산:
  MTV = contactNormal * (-penetrationDepth)
      = n * |d|

  적용:
  B의 새 위치 = B의 현재 위치 + MTV
  (또는 A와 B 각각 MTV/2씩 반대 방향으로 이동)

더 구체적인 예시 (2D 단면):

  충돌 전:
       +------+      +------+
       |  A   |      |  B   |
       | (0,0)|      | (3,0)|
       +------+      +------+
         2x2           2x2

  충돌 상태 (B가 왼쪽으로 이동):
       +------+
       |  A +------+
       |    | B    |
       +----+      |
            +------+
       A(0,0)  B(1.5,0)
       겹침 = 0.5

  Contact Point 정보:
       normal  = (1, 0, 0)   -- X축 양의 방향 (A->B)
       depth   = -0.5        -- 음수 = 관통 중

  MTV 계산:
       MTV = normal * (-depth) = (1,0,0) * 0.5 = (0.5, 0, 0)

  해결 후:
       B의 새 위치 = (1.5, 0, 0) + (0.5, 0, 0) = (2.0, 0, 0)
       -> 겹침 해소!

MTV = m_normalWorldOnB * (-getDistance())

비유: "눌린 스프링이 원래대로 돌아가는 것"

  상황: 두 물체가 겹쳐 있다.

  1. 겹침 감지
     +----+----+
     | A  | B  |    "어, 이 둘이 겹쳐 있네!"
     +----+----+

  2. 스프링처럼 밀어내기 (충격량/Impulse 적용)
     +----+ -> <- +----+
     | A  |       | B  |    "살짝 밀어내자!"
     +----+       +----+

  3. 반복 (여러 번)
     +----+   +----+
     | A  |   | B  |    "이제 떨어졌다!"
     +----+   +----+

  핵심: Solver는 각 접촉점에 대해 "충격량(impulse)"을 계산하고,
        물체의 속도를 변경하여 겹침을 해소한다.
        이것을 여러 번 반복(iteration)하여 정확도를 높인다.

더 구체적인 비유: "만원 엘리베이터"

  10명이 엘리베이터에 타려고 하는데 6명만 들어간다.

  1회차: 앞의 2명이 뒤의 2명을 밀어냄
  2회차: 밀려난 2명이 옆의 2명을 밀어냄
  3회차: 옆의 2명이 밖의 2명을 밀어냄
  ...
  N회차: 모든 사람이 적절한 위치를 찾음

  Bullet의 기본 iteration = 10회
  iteration이 많을수록 정확하지만 느려진다.

Contact Constraint의 구성요소:

  각 접촉점(Contact Point)마다 3개의 제약이 생긴다:

  +--------------------------------------------------+
  |  1. 비관통 제약 (Normal Constraint)               |
  |     "법선 방향으로 물체가 겹치지 않게 한다"        |
  |                                                    |
  |        ^  법선 (normal)                            |
  |        |                                           |
  |     ---+--- 접촉면                                 |
  |                                                    |
  +--------------------------------------------------+
  |  2. 마찰 제약 1 (Friction Constraint, 접선 1)     |
  |     "접촉면 위에서 미끄러지지 않게 한다"           |
  |                                                    |
  |     <---> 접선 방향 1                              |
  |     ---+--- 접촉면                                 |
  |                                                    |
  +--------------------------------------------------+
  |  3. 마찰 제약 2 (Friction Constraint, 접선 2)     |
  |     "접촉면 위에서 미끄러지지 않게 한다"           |
  |                                                    |
  |     (접선 방향 2 = 법선과 접선1에 수직)            |
  |                                                    |
  +--------------------------------------------------+

전체 물리 시뮬레이션 스텝 흐름:

  stepSimulation() 호출
         |
         v
  +--------------------------------------------+
  | 1. Broadphase                               |
  |    AABB(축 정렬 경계 상자) 겹침 검사          |
  |    -> 충돌 후보 쌍 목록 생성                  |
  |    예: (A,B), (C,D), (A,E) ...              |
  +--------------------------------------------+
         |
         v
  +--------------------------------------------+
  | 2. Narrowphase                              |
  |    후보 쌍에 대해 정밀 충돌 검사              |
  |    GJK/EPA/SAT 알고리즘 사용                 |
  |    -> 실제 충돌 여부 확정                     |
  |    -> 접촉점(contact point) 생성             |
  +--------------------------------------------+
         |
         v
  +--------------------------------------------+
  | 3. Contact Generation                       |
  |    각 접촉점에 대해:                         |
  |    - 접촉 법선(normal) 계산                  |
  |    - 관통 깊이(penetration depth) 계산       |
  |    - 접촉 위치 계산                          |
  |    -> Contact Manifold에 저장                |
  +--------------------------------------------+
         |
         v
  +--------------------------------------------+
  | 4. Constraint Solving (핵심!)               |
  |    Sequential Impulse Solver가 동작:         |
  |                                              |
  |    for iter = 1 to 10 (기본 반복 횟수):      |
  |      for each contact:                       |
  |        a) 상대 속도 계산                     |
  |        b) 필요한 충격량 계산                  |
  |           (Jacobian, Effective Mass 사용)    |
  |        c) 충격량 적용 (속도 변경)             |
  |        d) 클램핑 (비물리적 결과 방지)         |
  |                                              |
  |    추가: Baumgarte 안정화                    |
  |    -> 위치 오차를 속도로 보상                 |
  |    -> 관통 상태에서 자동 복구                 |
  +--------------------------------------------+
         |
         v
  +--------------------------------------------+
  | 5. Position Update                          |
  |    새로운 속도로 위치 갱신                    |
  |    pos_new = pos_old + velocity * dt        |
  |    -> 물체들이 실제로 이동!                   |
  |    -> 겹침이 해소된 새 위치로 이동            |
  +--------------------------------------------+

Baumgarte 안정화의 쉬운 비유:

  문제: Solver가 속도만 바꾸면, 이미 겹친 위치는 그대로이다.
        다음 프레임에서야 물체가 밀려나기 시작한다.
        -> 물체가 서로 "천천히 빠져나오는" 느낌 (부자연스러움)

  해결: Baumgarte 안정화
        "겹침 깊이에 비례하는 추가 속도"를 부여한다.

        추가_속도 = (ERP / dt) * 관통_깊이

        ERP (Error Reduction Parameter): 0~1 사이 값
        - 0에 가까우면: 천천히 복구 (부드럽지만 느림)
        - 1에 가까우면: 즉시 복구 (빠르지만 불안정할 수 있음)
        - 보통 0.2 정도가 기본값

  비유: 마치 "겹친 정도에 비례하는 스프링"이 달린 것처럼 작동한다.

기존 BIM 간섭 해결 방식:

  1. 모델링 (Revit, AutoCAD 등)
  2. 간섭 감지 (Navisworks Clash Detective)
  3. 수동 해결 (엔지니어가 하나하나 이동/수정)
  4. 재검토

  문제: 3단계에서 수작업이 많고 시간이 오래 걸린다!

Bullet Physics 기반 자동 간섭 해결 개념:

  [기존 BIM 모델]
       |
       v
  [1. IFC/Revit 데이터에서 3D 지오메트리 추출]
       |
       v
  [2. Bullet Physics 세계에 충돌 형상으로 등록]
       |  - 파이프 -> Cylinder 또는 Capsule
       |  - 덕트 -> Box
       |  - 케이블 트레이 -> Box
       |  - 구조물 -> TriangleMesh (정적, 이동 불가)
       |
       v
  [3. 구조물은 Static, MEP는 Dynamic으로 설정]
       |  - 구조물: mass = 0 (정적, 움직이지 않음)
       |  - 벽/바닥/천장: mass = 0 (정적)
       |  - MEP 파이프: mass = 1 (동적, 밀려날 수 있음)
       |  - MEP 덕트: mass = 1 (동적)
       |
       v
  [4. Constraint 설정 (이동 제한)]
       |  - 파이프: Y축/Z축으로만 이동 가능 (경로 유지)
       |  - 덕트: 특정 범위 내에서만 이동 가능
       |  - 연결점: Fixed Constraint (단부 고정)
       |
       v
  [5. stepSimulation() 반복 호출]
       |  Solver가 자동으로:
       |  - 겹친 MEP 요소들을 밀어냄
       |  - 구조물과 겹친 부분을 해소
       |  - Constraint를 만족하면서 최소 이동
       |
       v
  [6. 결과 위치를 BIM 모델에 반영]
       |
       v
  [자동 해결된 BIM 모델]

구체적 적용 예시: 배관과 덕트의 간섭

  간섭 전 (평면도):
  ================================ 천장
         +========+
         | 덕트    |  (좌우로 진행)
  -------+--||----+--------------
            ||                     파이프 (위아래로 진행)
            ||
  ================================ 바닥

  -> 덕트와 파이프가 겹침!

  Bullet Physics 적용 후:
  ================================ 천장
         +========+
         | 덕트    |  (약간 위로 이동)
  -------+---------+--------------
            ||                     파이프 (그대로)
            ||
  ================================ 바닥

  -> Solver가 덕트를 위로 밀어서 간섭 해소!
  -> 파이프는 구조물과 가까우므로 이동하지 않음

[LayoutVLM = 건축가 + 물리학자의 협업]

  VLM (건축가 역할)                  최적화 (물리학자 역할)
  +-------------------------+       +-------------------------+
  | "이 방에는 소파를         |       | "소파가 벽을 뚫고 있어!  |
  |  TV 앞에, 테이블을        | --->  |  벽 안쪽으로 밀어 넣자.  |
  |  소파 옆에 놓으면         |       |  책장이 TV와 겹쳐!      |
  |  좋겠다" (의미 이해)      |       |  0.3m 옮기자" (물리 보정) |
  +-------------------------+       +-------------------------+
         |                                    |
         v                                    v
  초기 배치안 생성                     물리적으로 타당한 최종 배치

LayoutVLM 아키텍처:

자연어 입력: "소파 앞에 테이블을, 창문 옆에 식물을"
     |
     v
VLM (Vision-Language Model)
  - 시각적으로 마킹된 이미지 생성
  - 두 가지 상호보완 표현 추출:
    1. 수치적 자세 추정 (x, y, z, rotation)
    2. 공간 관계 명세 (앞에, 옆에, 위에...)
     |
     v
미분 가능 최적화 (Differentiable Optimization)
  - 수치 추정과 공간 관계를 동시에 만족하는 해 탐색
  - 충돌 페널티 항 포함 (물리적 타당성 보장)
  - 그래디언트 기반 최적화로 수렴
     |
     v
물리적으로 타당한 3D 배치 결과

기존 LLM 기반:
  - 물리적 충돌 무시 (소파와 테이블이 겹침)
  - 공간 관계 부정확 (위치는 맞지만 방향이 틀림)

LayoutVLM:
  - 미분 가능 최적화로 충돌 자동 해소
  - 공간 관계와 수치적 정확성 동시 만족
  - 의미론적 의도와 물리적 타당성의 균형

[미분 가능 최적화 비유 -- 눈 감고 골짜기 찾기]

  높이 (= 배치의 "나쁜 정도")
   ^
   |    *                        * = 현재 위치
   |   / \        *              / = 경사(기울기)
   |  /   \      / \
   | /     \    /   \            발밑 기울기를 느끼고
   |/       \  /     \           아래로 걸어간다
   |         \/       \          (= 경사 하강법)
   |          *
   |       골짜기
   +-------------------------> 가구 위치

  1단계: 발밑이 왼쪽으로 기울어져 있다 --> 왼쪽으로 한 걸음
  2단계: 아직 기울어져 있다 --> 또 한 걸음
  ...
  N단계: 평평하다! --> 최적 위치 도달!

[PGD의 동작]

  반복 1~N: 일반 경사 하강      반복 N: 경계 투영
  +---+---+---+              +---+---+---+
  |   | A |   |              |   | A |   |
  |   +---+   |              |   +---+   |
  |     B-----|---X (벽 밖!)  |     B |   | <-- 벽 안으로 밀어넣기
  |           |              |       |   |
  +-----------+              +-----------+

[이중 표현 -- 비유: 지도 + 길 안내]

  표현 1: 수치적 자세 추정                표현 2: 공간 관계 명세
  (= GPS 좌표)                          (= 길 안내 문장)
  +---------------------------+         +---------------------------+
  | 소파: (2.0, 0, -1.5, 90도) |         | "소파는 TV 앞에 있다"      |
  | TV:   (2.0, 0, 1.5, 270도)|         | "테이블은 소파 왼쪽에 있다"|
  | 테이블: (0.5, 0, -1.5, 0도)|         | "의자는 테이블을 향한다"   |
  +---------------------------+         +---------------------------+
         |                                       |
         |            자기 일관성 검증             |
         |         (Self-Consistent Decoding)     |
         v                    v                   v
  +-------------------------------------------------------+
  | 수치 좌표가 관계 명세와 일치하는 것만 유지              |
  | 예: 소파 좌표가 실제로 TV 앞인지 확인                   |
  |     --> 일치하면 유지, 불일치하면 해당 관계 제거         |
  +-------------------------------------------------------+

[LayoutVLM 처리 파이프라인]

  단계 1: 장면 입력
  +-------------------------------------------+
  | 언어 지시: "교실에 책상 20개, 칠판, 교탁"    |
  | 방 경계: 바닥 꼭짓점 좌표, 벽 높이           |
  | 에셋 정보: 각 가구의 3D 바운딩 박스 크기      |
  +-------------------------------------------+
              |
              v
  단계 2: VLM이 마크 이미지 분석
  +-------------------------------------------+
  | VLM이 방의 조감도(top-down view) 이미지를    |
  | 분석하여 "여기에 무엇을 놓으면 좋겠다"       |
  | 판단 (시각적 마크가 붙은 이미지 활용)        |
  +-------------------------------------------+
              |
              v
  단계 3: 코드 생성 (이중 표현)
  +-------------------------------------------+
  | VLM이 Python 코드를 생성:                   |
  |   - 각 가구의 초기 좌표/회전 (수치적 추정)    |
  |   - 가구 간 관계 규칙 (공간 관계 명세)        |
  +-------------------------------------------+
              |
              v
  단계 4: 자기 일관성 검증
  +-------------------------------------------+
  | 초기 좌표가 관계 규칙을 만족하는지 확인       |
  | 만족하지 않는 관계는 제거                    |
  +-------------------------------------------+
              |
              v
  단계 5: 미분 가능 최적화
  +-------------------------------------------+
  | L_semantic: 관계 규칙을 좌표로 변환한 손실    |
  | L_physics: Distance-IoU 충돌 페널티          |
  | PGD(투영 경사 하강법)로 최적화                |
  +-------------------------------------------+
              |
              v
  단계 6: 최종 layout.json 출력
  +-------------------------------------------+
  | 각 가구의 최종 (x, y, z, rotation) 출력      |
  +-------------------------------------------+

[Distance-IoU 손실 -- 쉬운 설명]

  일반 IoU                          Distance-IoU
  +----------+                      +----------+
  |  A  |    |                      |  A       | ---거리---> B
  |     | B  |  = 겹침 영역 비율     |          |
  +----------+                      +----------+

  IoU만으로는 "겹치지 않지만              DIoU는 겹침 + 거리를
  가까운 경우"를 구분 못함               동시에 고려

L_physics = 합(모든 i,j 쌍) L_DIoU(p_i, p_j, b_i, b_j)

여기서:
  p_i, p_j = 물체 i, j의 자세(위치 + 회전)
  b_i, b_j = 물체 i, j의 3D 바운딩 박스 크기
  L_DIoU = IoU 손실 + 중심점 거리 패널티

+----------------------------------+------------------------------+
| 상황                             | 권장 알고리즘                |
+----------------------------------+------------------------------+
| 두 볼록 형상 간 정밀 충돌 판별  | GJK                          |
| 다각형 메쉬 간 빠른 충돌 판별   | SAT (AABB 먼저, OBB 정밀)    |
| 수천 개 부재 간 충돌 검색       | BVH + GJK/SAT                |
| MEP 경로 자동 생성              | A* (6-연결, 복셀 기반)       |
| 다목적 배치 최적화              | NSGA-II (유전 알고리즘)      |
| 자동 클래시 해결 (상용)         | BAMROC                       |
| 대규모 실시간 BIM 렌더링        | Unity DOTS (ECS+Jobs+Burst)  |
| 자연어 기반 레이아웃 생성       | LLplace / LayoutVLM          |
+----------------------------------+------------------------------+

알고리즘    시간복잡도        공간복잡도    특징
-----------------------------------------------------
GJK         O(k) 반복        O(1)          볼록 형상 필수
SAT         O(n*m) 축 수    O(n+m)        MTV 직접 산출
BVH 빌드    O(n log n)       O(n)          초기 구축 비용
BVH 쿼리    O(log n)         O(1)          쿼리는 매우 빠름
A* (3D)     O(V log V)       O(V)          V=복셀 수
GA          O(g*p*eval)     O(p)          g=세대, p=집단크기