라이다 (LiDAR)

핵심 인사이트 (3줄 요약)

레이저 펄스를 송출하고 반사되어 돌아오는 시간(ToF)을 측정하여 거리와 형상을 파악하는 원격 탐사 기술이다. 3D 포인트 클라우드를 생성하여 자율주행, 지도 제작, 로봇의 핵심 센서로 활용된다. 높은 정확도와 주야간 사용 가능이 장점이다.

I. 개요

개념: LiDAR(Light Detection and Ranging)는 레이저 광선을 송출하고 반사되어 돌아오는 시간(Time of Flight)을 측정하여 거리와 3차원 형상을 파악하는 원격 탐사 기술이다.

비유: "레이저 눈" - 어둠 속에서도 3D로 세상을 볼 수 있는 눈. 박쥐가 초음파로 사물을 감지하듯, 라이다는 레이저로 3D 지도를 만든다.

등장 배경:

1. 기존 문제점: 카메라는 조도에 따라 성능이 달라졌고, 거리 정보를 직접 얻을 수 없었다. 레이더는 거리 측정은 가능하지만 해상도가 낮았다. 야간, 안개, 비 등 악조건에서 환경 인식이 어려웠다.

2. 기술적 필요성: 자율주행, 드론, 로봇 등에서 고해상도 3D 환경 인식이 필수가 되었다. 주야간, 악천후에도 작동하는 신뢰성 높은 센서가 필요했다.

3. 시장/산업 요구: 자율주행차 시장 성장, 디지털 트윈/3D 매핑 수요 증가, 산업 자동화에서 정밀 거리 측정 필요성이 급증했다.

핵심 목적: 고해상도 3D 공간 정보를 실시간으로 획득하여 자율주행, 로봇 내비게이션, 지형 측량 등에 활용하는 것이다.

II. 구성 요소 및 핵심 원리

구성 요소:

구조 다이어그램:

┌─────────────────────────────────────────────────────────────────┐
│                    LiDAR 시스템 구조                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   ┌────────────────────────────────────────────────────────┐    │
│   │                    LiDAR 센서                          │    │
│   │  ┌──────────┐   ┌──────────┐   ┌──────────┐           │    │
│   │  │ 레이저   │   │ 광학계   │   │ 수광부   │           │    │
│   │  │ 송출부   │──→│ (미러)   │──→│ (검출기) │           │    │
│   │  │ 905nm    │   │ 스캐닝   │   │ APD/SPAD │           │    │
│   │  └──────────┘   └────┬─────┘   └────┬─────┘           │    │
│   │                      │              │                  │    │
│   │                      ↓              ↑                  │    │
│   │               ┌─────────────────────────┐              │    │
│   │               │    타이밍/처리 회로      │              │    │
│   │               │  • ToF 계산             │              │    │
│   │               │  • 포인트 클라우드 생성  │              │    │
│   │               └─────────────────────────┘              │    │
│   └────────────────────────────────────────────────────────┘    │
│                              ↓                                   │
│   ┌────────────────────────────────────────────────────────┐    │
│   │                   3D 포인트 클라우드                    │    │
│   │        ·  ·  ·      ·  ·                               │    │
│   │          ·  ·  ·  ·  ·  ·    ← 수십만~수백만 점        │    │
│   │        ·  ·  ·  ·  ·  ·  ·                            │    │
│   │          ·  ·  ·  ·  ·                                │    │
│   │        ·  ·  ·  ·  ·  ·                               │    │
│   │        (X, Y, Z, 반사강도)                             │    │
│   └────────────────────────────────────────────────────────┘    │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

동작 원리:

① 레이저 발사 → ② 타겟 반사 → ③ 반사광 수신 → ④ ToF 측정 → ⑤ 거리 계산 → ⑥ 포인트 생성

• 1단계 (레이저 발사): 레이저 다이오드에서 짧은 펄스(나노초 단위)를 발사한다.
• 2단계 (타겟 반사): 레이저가 타겟에 도달하여 반사된다.
• 3단계 (반사광 수신): 수광 센서(APD, SPAD)가 반사된 광자를 검출한다.
• 4단계 (ToF 측정): 발사 시점부터 수신 시점까지의 시간을 측정한다.
• 5단계 (거리 계산): ToF로부터 거리를 계산한다.
• 6단계 (포인트 생성): 거리 + 스캔 각도로 3D 좌표(X, Y, Z)를 생성한다.

핵심 알고리즘/공식:

Time of Flight 거리 계산:

거리 d = (c × t) / 2
c = 3 × 10^8 m/s (빛의 속도)
t = 왕복 비행 시간 (초)

예: t = 100ns → d = (3×10^8 × 100×10^-9) / 2 = 15m

거리 해상도:

Δd = c × Δt / 2
Δt: 타이밍 해상도

예: Δt = 100ps → Δd = 1.5cm

코드 예시:

import numpy as np
from dataclasses import dataclass
from typing import List, Tuple
import math

@dataclass
class Point3D:
    """3D 포인트"""
    x: float
    y: float
    z: float
    intensity: float  # 반사 강도 (0-255)

class LiDARSimulator:
    """LiDAR 시뮬레이터"""

    def __init__(self, num_channels: int = 32,
                 horizontal_resolution: float = 0.2,  # 도
                 max_range: float = 200.0):  # 미터
        self.num_channels = num_channels
        self.h_resolution = math.radians(horizontal_resolution)
        self.max_range = max_range
        self.c = 3e8  # 빛의 속도 (m/s)

        # 수직 시야각 설정 (VLP-16 기준)
        self.vertical_angles = np.linspace(-15, 15, num_channels)

    def calculate_distance(self, time_of_flight: float) -> float:
        """ToF로 거리 계산"""
        return (self.c * time_of_flight) / 2

    def calculate_tof(self, distance: float) -> float:
        """거리로 ToF 계산"""
        return (2 * distance) / self.c

    def spherical_to_cartesian(self, distance: float,
                                azimuth: float,
                                elevation: float) -> Tuple[float, float, float]:
        """구면 좌표 → 직교 좌표"""
        x = distance * math.cos(elevation) * math.cos(azimuth)
        y = distance * math.cos(elevation) * math.sin(azimuth)
        z = distance * math.sin(elevation)
        return x, y, z

    def generate_point_cloud(self,
                             distance_matrix: np.ndarray,
                             azimuth_angles: np.ndarray) -> List[Point3D]:
        """거리 행렬로 포인트 클라우드 생성"""
        points = []

        for ch in range(self.num_channels):
            elevation = math.radians(self.vertical_angles[ch])

            for i, azimuth in enumerate(azimuth_angles):
                distance = distance_matrix[ch, i]

                if distance > 0 and distance <= self.max_range:
                    x, y, z = self.spherical_to_cartesian(
                        distance, azimuth, elevation
                    )

                    # 반사 강도 시뮬레이션 (거리에 반비례)
                    intensity = max(0, min(255, 255 * (1 - distance/self.max_range)))

                    points.append(Point3D(x, y, z, intensity))

        return points

    def detect_ground_plane(self, points: List[Point3D],
                            z_threshold: float = -1.5) -> List[Point3D]:
        """지면 포인트 분리"""
        ground = []
        non_ground = []

        for p in points:
            if p.z < z_threshold:
                ground.append(p)
            else:
                non_ground.append(p)

        return ground, non_ground

    def cluster_objects(self, points: List[Point3D],
                        distance_threshold: float = 0.5) -> List[List[Point3D]]:
        """객체 클러스터링 (간소화된 DBSCAN)"""
        if not points:
            return []

        clusters = []
        visited = set()
        points_array = np.array([[p.x, p.y, p.z] for p in points])

        for i, point in enumerate(points):
            if i in visited:
                continue

            # 이웃 찾기
            distances = np.linalg.norm(points_array - points_array[i], axis=1)
            neighbors = np.where(distances < distance_threshold)[0]

            if len(neighbors) >= 3:  # 최소 포인트 수
                cluster = [points[j] for j in neighbors]
                clusters.append(cluster)
                visited.update(neighbors)

        return clusters

# 사용 예시
if __name__ == "__main__":
    lidar = LiDARSimulator(num_channels=16, horizontal_resolution=0.2)

    # 시뮬레이션 데이터 생성
    num_scans = 1800  # 360도 / 0.2도
    azimuth_angles = np.linspace(0, 2*np.pi, num_scans)

    # 거리 행렬 (시뮬레이션)
    np.random.seed(42)
    distance_matrix = np.random.uniform(5, 100, (16, num_scans))

    # 일부 포인트는 물체 없음 (0)
    distance_matrix[np.random.random(distance_matrix.shape) < 0.3] = 0

    # 포인트 클라우드 생성
    point_cloud = lidar.generate_point_cloud(distance_matrix, azimuth_angles)
    print(f"생성된 포인트 수: {len(point_cloud)}")

    # 지면 분리
    ground, objects = lidar.detect_ground_plane(point_cloud)
    print(f"지면 포인트: {len(ground)}, 객체 포인트: {len(objects)}")

    # 클러스터링
    clusters = lidar.cluster_objects(objects[:1000])  # 속도를 위해 일부만
    print(f"감지된 객체 수: {len(clusters)}")

III. 기술 비교 분석

장단점 분석:

대안 기술 비교:

선택 기준: 고정밀 3D 매핑은 기계식, 양산 자동차는 MEMS/Solid-State, 저비용 단거리는 Flash, 악천후 보완은 레이더 융합을 선택한다.

기술 진화 계보:

기계식 회전 → MEMS 미러 → OPA(위상배열) → FMCW → 4D LiDAR

IV. 실무 적용 방안

기술사적 판단:

실제 도입 사례:

• 사례 1: 웨이모 (Waymo) - 5세대 Driver에 커스텀 LiDAR 5개 탑재. 300m 감지 거리, 360° 커버리지. 주야간, 비 올 때도 자율주행 가능.

• 사례 2: 벨로다인 (Velodyne) - VLS-128 128채널 LiDAR. 초당 240만 포인트 생성. 자율주행, 매핑, 산업용으로 전 세계 300개 이상 고객.

• 사례 3: 아이비오 (Ibeo) - LUX 4D Solid-State LiDAR. 0.1° 해상도, 객체 분류 기능 내장. 아우디와 협력하여 양산차 탑재.

도입 시 고려사항:

1. 기술적: 파장 선택(905nm vs 1550nm), 스캔 방식, 처리 파이프라인
2. 운영적: 캘리브레이션, 청소/유지보수, 환경 적응성
3. 보안적: 레이저 안전(Class 1), 데이터 보안, 간섭 방지
4. 경제적: 비용-성능 트레이드오프, 양산 가능성

주의사항 / 흔한 실수:

• 악천후 무시: 비, 눈, 안개에서 성능 저하. 레이더/카메라 융합 필요.
• 반사율 과신: 검은색, 반사 표면에서 거리 오차. 반사율 보정 필요.
• 간섭 문제: 다수 LiDAR 동시 사용 시 간섭. 파장/타이밍 분리 필요.

관련 개념 / 확장 학습:

V. 기대 효과 및 결론

정량적 기대 효과:

미래 전망:

1. 기술 발전 방향: Solid-State 저비용화, FMCW(속도 측정), 4D LiDAR, AI 내장형으로 진화.
2. 시장 트렌드: 자율주행 양산 가속화로 LiDAR 가격 하락. 2027년 시장 규모 50억 달러 전망.
3. 후속 기술: 양자 LiDAR, 광자 카운팅, Meta-material 렌즈.

결론: LiDAR는 자율주행과 3D 매핑의 핵심 센서로, 높은 정확도와 3D 인식 능력이 장점이다. 비용 절감과 Solid-State화가 대중화의 열쇠다.

참고 표준: IEC 60825-1(레이저 안전), SAE J2944(LiDAR 성능), IEEE P2851(자율주행 센서), ISO/SAE 21434(사이버보안)

어린이를 위한 종합 설명

라이다는 마치 "레이저 눈" 같아요!

박쥐가 "초음파"로 사물을 감지하잖아요? 라이다도 비슷해요. 대신 초음파 대신 "레이저"를 써요. 레이저를 쏘았다가 반사돼서 돌아오는 시간을 재는 거예요.

예를 들어, 레이저를 쐈는데 0.0000001초 만에 돌아오면, 빛의 속도로 계산해서 "15미터 앞에 뭔가 있구나!"라고 알 수 있어요. 이걸 수백만 번 반복하면 3D 지도를 만들 수 있죠!

자율주행차에 라이다가 있어요. 차 위에 돌아가는 물체가 보인 적 있나요? 그게 라이다예요. 360도로 돌아가면서 레이저를 쏴서 주변에 차, 사람, 신호등이 어디 있는지 3D로 그려요. 그래서 밤에도, 비가 와도 주변을 잘 볼 수 있어요!