운전자 시점으로 네 가지 도로 환경 달려 보기

CARLA에서 도심·폭우·젖은 주택가·안개를 직접 촬영했습니다. 규칙 기반 Traffic Manager의 주행이며 AI 정책 성능을 평가한 영상은 아닙니다.

  • CARLA 0.9.16
  • Unreal Engine 4.26
  • Traffic Manager
운전자 시점으로 보는 네 도로 환경
실행 영상실행 영상과 기록

자동차와 카메라는 각각 무엇을 할까요?

데이터는 어떻게 흐를까요?
  1. 입력환경 고르기Town10HD · Town03 · Town02 · Town04와 날씨

    CARLA가 맵·차량·물리·센서를 시뮬레이션합니다.

  2. 처리운전 명령으로 한 스텝 진행Traffic Manager 제어 → 0.05초

    규칙 기반 제어기는 차량·도로 상태를 읽습니다. RGB 영상을 입력으로 쓰지는 않습니다.

  3. 출력관측 기록하기960×540 RGB + 프레임 번호 + XYZ + 속도

    운전자·추적 카메라를 같은 스텝에 찍습니다. 공개 개별 영상은 768×432로 줄였습니다.

다음 차량 상태를 Traffic Manager가 읽어 새 제어 명령을 정합니다.

먼저 아래의 4분할 영상을 보세요. CARLA 0.9.16의 실제 RGB 센서로 촬영한 화면입니다. Isaac Sim에서 경로를 재생한 영상과 달리 Unreal Engine이 도로와 교통을 렌더링합니다. 도심, 폭우가 내리는 교차로, 해 질 무렵의 젖은 주택가, 안개 낀 고속도로에 서로 다른 맵을 사용했습니다. 화면 아래에 보이는 보닛으로 카메라의 위치를 가늠할 수 있습니다.

입력과 출력의 흐름

운전하는 프로그램과 영상을 찍는 센서를 구분해 봅시다

CARLA의 Traffic Manager는 가상 차량과 도로 정보를 읽고 가속·조향·제동을 정하는 규칙 기반 제어기입니다. RGB 카메라는 그 차에서 보이는 풍경을 기록합니다. Traffic Manager가 이 카메라 영상을 보고 운전하는 것은 아닙니다. 다양한 센서·환경을 시험하는 예제이며, 학습한 자율주행 모델의 성능을 검증한 결과는 아닙니다. Traffic Manager 공식 설명

한 스텝마다 가상 시간이 0.05초씩 흐릅니다. 차량 기준 (0.3, 0, 1.45)m에 운전자 카메라를, (-6, 0, 3)m에 뒤따라가는 카메라를 달아 같은 스텝을 촬영합니다. 원본 센서 버퍼는 [540, 960, 4] 모양의 uint8 배열입니다. BGRA 순서이므로 알파를 빼고 BGR을 RGB로 바꾼 뒤 영상에 씁니다. 프레임 번호로 그 순간의 차량 위치·속도와 연결합니다.

텍스트
도로 + 현재 차량 상태 → Traffic Manager → 가속·조향·제동 명령
                                            ↓
                               CARLA 물리 계산 → 다음 차량 상태
                                            ↓
                             RGB 카메라 + 차량 자세 → 저장할 샘플

네 화면에서 볼 것

위치 환경 살펴볼 부분
왼쪽 위 Town10HD / 맑은 낮 차선, 주변 차량, 건물과 운전자 시야
오른쪽 위 Town03 / 폭우 젖은 노면과 교차로 시야
왼쪽 아래 Town02 / 젖은 노면·일몰 주택가 도로와 빛의 변화
오른쪽 아래 Town04 / 안개 먼 물체가 보이기 시작하는 거리

경로가 서로 다르므로 같은 도로의 날씨만 바꾼 성능 비교는 아닙니다. 각 영상은 20 FPS로 찍은 320프레임을 원래 속도로 재생합니다. 날씨에 따른 화면 차이를 보여주며, 이 실험에서 타이어 마찰 변화까지 확인한 것은 아닙니다.

처음이면 실습 파일부터 받기

GPU 실습은 Isaac Sim을 실행할 머신에서 터미널을 엽니다. CPU 실습은 지금 쓰는 컴퓨터에서 해도 됩니다. 아래 명령은 한 줄씩 입력하고 Enter를 누르세요. 여러 줄짜리 명령 블록은 통째로 복사해도 됩니다.

Shell
cd "$HOME"
git clone https://github.com/james-joobs/awesome-nvidia-physical-ai.git
cd awesome-nvidia-physical-ai
pwd

홈 폴더에 받는 예입니다. 이미 내려받았다면 git clone은 건너뛰고 내 실습 폴더로 이동합니다. 새 터미널을 열 때마다 pwd의 출력 끝이 awesome-nvidia-physical-ai인지 확인하세요. 그래야 labs/로 시작하는 파일을 찾을 수 있습니다.

내 환경에서 운전자 카메라로 촬영하기

1. 별도 CARLA 서버 띄우기

NVIDIA 그래픽 드라이버, Docker, NVIDIA Container Toolkit이 있는 Linux를 사용합니다. 먼저 nvidia-smi를 입력해 GPU가 보이는지 확인하세요. 이 단계에서 GPU가 보이지 않으면 환경 설정 가이드부터 따라갑니다. 서버와 Python 클라이언트는 모두 0.9.16으로 맞춥니다. 저장소의 최신 개발 브랜치와 이번에 사용한 배포판은 Unreal 버전이 다릅니다.

저장소 폴더에서 터미널 A를 열고 입력하세요.

Shell
docker pull carlasim/carla:0.9.16
docker run --rm --name physical-ai-carla --gpus all --shm-size=2g \
  -e NVIDIA_DRIVER_CAPABILITIES=all \
  -p 127.0.0.1:24000-24002:24000-24002 \
  carlasim/carla:0.9.16 /bin/bash CarlaUE4.sh \
  -RenderOffScreen -nosound -carla-rpc-port=24000 -quality-level=Epic

이 터미널은 켜 둡니다. -RenderOffScreen은 창을 띄우지 않고 실제 카메라를 렌더링하는 옵션입니다. 포트는 내 컴퓨터에서만 연결할 수 있습니다. 다른 시뮬레이터와 GPU를 동시에 점유하지 않도록 여유 있는 GPU에서 실행하세요.

2. 카메라를 달고 촬영하기

같은 저장소 폴더에서 터미널 B를 새로 엽니다.

Shell
python3 -m venv .venv-carla
source .venv-carla/bin/activate
python -m pip install carla==0.9.16 numpy pillow imageio imageio-ffmpeg
python labs/carla-ego/capture.py --output runs/carla-ego

환경마다 synchronized frames 메시지가 나올 때까지 기다리세요. 코드가 맵을 불러오고 차량·카메라를 만든 뒤 한 스텝씩 진행합니다. 결과 폴더에는 운전자·후방 추적 시점 MP4와 result.json이 생깁니다. JSON에는 프레임별 위치(m)와 속도(m/s)가 들어갑니다. 거의 움직이지 않은 경우에는 오류로 알려주므로 신호 대기, 교통, 출발 위치를 먼저 확인할 수 있습니다. 종료할 때는 이 코드가 만든 차량과 센서만 정리합니다.

3. 비교 영상으로 묶기

FFmpeg가 설치된 환경에서 실행합니다.

Shell
python labs/carla-ego/package.py --input runs/carla-ego --output runs/carla-web
python3 labs/carla-ego/check.py

플랫폼·맵 이름을 붙이고 용량을 줄인 개별 영상과 4분할 영상을 만듭니다. 촬영을 마치면 다른 터미널에서 docker stop physical-ai-carla로 직접 띄운 서버를 종료합니다.

결과를 검사하고 다음 실습으로 이어 가기

GPU가 없어도 영상과 촬영 기록을 보거나 check.py를 실행할 수 있습니다. 프레임 수, 시간 간격, 좌표의 유효성, 이동 거리와 공개 영상 해시를 검사합니다. 주행 안전성이나 정책 성능을 판정하는 검사는 아닙니다.

CARLA → fVDB 복원 실습에서는 여러 시점의 영상으로 실제 3DGS 공간을 만듭니다. 학습 모델의 출력은 Alpamayo 실습에서, 필요한 장면 접근 권한을 갖춘 정책 평가는 AlpaSim 가이드에서 이어 갈 수 있습니다. 서로 독립된 실행 경로입니다.

출처·이용 조건: CARLA 0.9.16 코드는 MIT, CARLA 자체 에셋은 CC-BY입니다. README에는 CC-BY의 버전이 명시되어 있지 않습니다. Unreal Engine과 통합 구성요소에는 별도 조건이 적용됩니다. 공개 영상은 크기를 줄이고 설명을 덧붙였습니다. 미디어 출처에서 확인할 수 있습니다.

실행 영상과 기록

맑은 도심

CARLA 차량에 단 RGB 센서를 원래 속도로 재생합니다. 실습에서 설치·카메라 위치·프레임별 기록을 확인할 수 있습니다.

폭우가 내리는 교차로

CARLA 차량에 단 RGB 센서를 원래 속도로 재생합니다. 실습에서 설치·카메라 위치·프레임별 기록을 확인할 수 있습니다.

해 질 무렵의 젖은 주택가

CARLA 차량에 단 RGB 센서를 원래 속도로 재생합니다. 실습에서 설치·카메라 위치·프레임별 기록을 확인할 수 있습니다.

안개 낀 고속도로

CARLA 차량에 단 RGB 센서를 원래 속도로 재생합니다. 실습에서 설치·카메라 위치·프레임별 기록을 확인할 수 있습니다.

실습 소스 코드

capture.pyGitHub에서 파일 보기
Python
"""Record real CARLA RGB sensors; Traffic Manager is a rule-based driver, not an AI policy.

Run against a dedicated CARLA 0.9.16 server. Only actors created here are destroyed.
"""
import argparse
import hashlib
import json
import math
import queue
from pathlib import Path

import carla
import imageio.v2 as imageio
import numpy as np
from PIL import Image

CASES = [
    ("city-clear", "Town10HD_Opt", "ClearNoon", 1),
    ("junction-rain", "Town03", "HardRainNoon", 8),
    ("suburb-sunset", "Town02", "WetSunset", 0),
    ("highway-fog", "Town04_Opt", "CloudyNoon", 20),
]


def image_for_frame(q, frame):
    while True:
        image = q.get(timeout=30)
        if image.frame == frame:
            return np.frombuffer(image.raw_data, dtype=np.uint8).reshape(image.height, image.width, 4)[:, :, :3][:, :, ::-1].copy()
        if image.frame > frame:
            raise RuntimeError(f"Missed sensor frame {frame}; received {image.frame}")


def record(client, case, output, fps, seconds, width, height):
    name, map_name, weather_name, spawn_index = case
    print(f"Loading {name}: {map_name}, {weather_name}", flush=True)
    world = client.load_world(map_name)
    previous = world.get_settings()
    settings = world.get_settings()
    settings.synchronous_mode = True
    settings.fixed_delta_seconds = 1 / fps
    world.apply_settings(settings)
    weather = getattr(carla.WeatherParameters, weather_name)
    if name == "highway-fog":
        weather.fog_density = 55
        weather.fog_distance = 8
        weather.fog_falloff = 1.0
    world.set_weather(weather)
    tm = client.get_trafficmanager(24005)
    tm.set_synchronous_mode(True)
    tm.set_random_device_seed(42)
    tm.global_percentage_speed_difference(20)
    actors = []
    writers = []
    try:
        blueprints = world.get_blueprint_library()
        points = world.get_map().get_spawn_points()
        bp = blueprints.find("vehicle.tesla.model3")
        bp.set_attribute("role_name", "hero")
        ego = world.spawn_actor(bp, points[spawn_index])
        actors.append(ego)
        for index in range(3, min(len(points), 75), 4):
            other = world.try_spawn_actor(bp, points[index])
            if other:
                actors.append(other)
                other.set_autopilot(True, 24005)
        ego.set_autopilot(True, 24005)
        tm.ignore_lights_percentage(ego, 0)
        tm.distance_to_leading_vehicle(ego, 3)
        streams = []
        folder = output / name
        folder.mkdir(parents=True, exist_ok=True)
        for view, transform in [
            ("ego", carla.Transform(carla.Location(x=0.3, z=1.45))),
            ("chase", carla.Transform(carla.Location(x=-6, z=3), carla.Rotation(pitch=-12))),
        ]:
            camera_bp = blueprints.find("sensor.camera.rgb")
            for key, value in {"image_size_x": width, "image_size_y": height, "fov": 90, "sensor_tick": 0}.items():
                camera_bp.set_attribute(key, str(value))
            camera_bp.set_attribute("motion_blur_intensity", "0")
            camera = world.spawn_actor(camera_bp, transform, attach_to=ego)
            actors.append(camera)
            q = queue.Queue()
            camera.listen(q.put)
            path = folder / f"{view}.mp4"
            writer = imageio.get_writer(path, fps=fps, codec="libx264", quality=None,
                pixelformat="yuv420p", macro_block_size=None,
                output_params=["-crf", "23", "-preset", "fast", "-movflags", "+faststart"])
            writers.append(writer)
            streams.append((view, q, writer, path))
        samples = []
        for i in range(round((seconds + 2) * fps)):
            frame = world.tick()
            images = [(view, image_for_frame(q, frame), writer, path) for view, q, writer, path in streams]
            if i < 2 * fps:
                continue
            for view, rgb, writer, path in images:
                writer.append_data(rgb)
                if i == 5 * fps:
                    Image.fromarray(rgb).save(folder / f"{view}.jpg", quality=92)
            transform, velocity = ego.get_transform(), ego.get_velocity()
            samples.append({"frame": frame, "simulation_seconds": round((i - 2*fps)/fps, 3),
                "position_m": [transform.location.x, transform.location.y, transform.location.z],
                "rotation_deg": [transform.rotation.pitch, transform.rotation.yaw, transform.rotation.roll],
                "speed_mps": math.sqrt(velocity.x**2 + velocity.y**2 + velocity.z**2)})
        for writer in writers:
            writer.close()
        writers.clear()
        displacement = math.dist(samples[0]["position_m"], samples[-1]["position_m"])
        distance = sum(math.dist(a["position_m"], b["position_m"]) for a,b in zip(samples, samples[1:]))
        report = {"id": name, "map": world.get_map().name, "weather": weather_name,
            "fog_density": weather.fog_density, "controller": "CARLA Traffic Manager (rule-based)",
            "npc_vehicles": len(actors)-3, "fps": fps, "frames": len(samples), "resolution": [width, height],
            "displacement_m": round(displacement, 3), "distance_m": round(distance, 3), "trajectory": samples,
            "videos": [{"view": view, "file": str(path.relative_to(output)),
                "sha256": hashlib.sha256(path.read_bytes()).hexdigest()} for view,_,_,path in streams]}
        (folder / "result.json").write_text(json.dumps(report, indent=2)+"\n")
        print(f"{name}: {len(samples)} synchronized frames, {distance:.1f}m travelled", flush=True)
        if distance < 5:
            raise RuntimeError(f"{name}: ego did not travel enough; review the spawn and traffic")
        return report
    finally:
        for writer in writers:
            writer.close()
        for actor in reversed(actors):
            if actor.is_alive:
                if actor.type_id.startswith("sensor."):
                    actor.stop()
                actor.destroy()
        tm.set_synchronous_mode(False)
        world.apply_settings(previous)


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--host", default="127.0.0.1")
    parser.add_argument("--port", type=int, default=24000)
    parser.add_argument("--output", type=Path, required=True)
    parser.add_argument("--case", choices=[c[0] for c in CASES], action="append")
    parser.add_argument("--seconds", type=float, default=16)
    parser.add_argument("--fps", type=int, default=20)
    parser.add_argument("--width", type=int, default=960)
    parser.add_argument("--height", type=int, default=540)
    args = parser.parse_args()
    client = carla.Client(args.host, args.port)
    client.set_timeout(90)
    assert client.get_server_version() == "0.9.16", "Use the pinned CARLA server and client"
    cases = [c for c in CASES if not args.case or c[0] in args.case]
    results = [record(client, c, args.output, args.fps, args.seconds, args.width, args.height) for c in cases]
    (args.output / "result.json").write_text(json.dumps({"server_version": client.get_server_version(),
        "client_version": client.get_client_version(), "seed": 42, "cases": results}, indent=2)+"\n")


if __name__ == "__main__":
    main()
package.pyGitHub에서 파일 보기
Python
"""Make labeled, lightweight web videos from the four original CARLA sensor takes."""
import argparse
import hashlib
import json
import subprocess
from pathlib import Path

from PIL import Image, ImageDraw, ImageFont

CASES=[("city-clear","Town10HD / clear city"),("junction-rain","Town03 / heavy rain"),
       ("suburb-sunset","Town02 / wet sunset"),("highway-fog","Town04 / fog")]


def main():
    parser=argparse.ArgumentParser()
    parser.add_argument("--input",type=Path,required=True)
    parser.add_argument("--output",type=Path,required=True)
    parser.add_argument("--ffmpeg",default="ffmpeg")
    args=parser.parse_args();args.output.mkdir(parents=True,exist_ok=True)
    font_path=next(Path(p) for p in ["/System/Library/Fonts/Supplemental/Arial.ttf","/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf"] if Path(p).exists())
    font=ImageFont.truetype(str(font_path),18)
    reports=[]
    for name,label in CASES:
        overlay=Image.new("RGBA",(768,432))
        draw=ImageDraw.Draw(overlay)
        draw.rectangle((0,0,768,34),fill=(0,0,0,180))
        draw.text((12,7),f"CARLA 0.9.16  |  Ego RGB  |  {label}",font=font,fill="white")
        png=args.output/f"carla-{name}-label.png";overlay.save(png)
        target=args.output/f"carla-{name}.mp4"
        subprocess.run([args.ffmpeg,"-hide_banner","-loglevel","error","-y","-i",str(args.input/name/"ego.mp4"),"-i",str(png),
            "-filter_complex","[0:v]scale=768:432[v];[v][1:v]overlay=0:0", "-an","-c:v","libx264","-crf","26","-pix_fmt","yuv420p","-movflags","+faststart",str(target)],check=True)
        subprocess.run([args.ffmpeg,"-hide_banner","-loglevel","error","-y","-ss","4","-i",str(target),"-frames:v","1",str(target.with_suffix(".jpg"))],check=True)
        report=json.loads((args.input/name/"result.json").read_text())
        report["published"]={"file":target.name,"sha256":hashlib.sha256(target.read_bytes()).hexdigest(),"resolution":[768,432],"edit":"20 fps / original speed; label overlay; resize and H.264 CRF26"}
        reports.append(report)
        png.unlink()
    inputs=[]
    for name,_ in CASES:
        inputs.extend(["-i",str(args.output/f"carla-{name}.mp4")])
    grid=args.output/"carla-ego.mp4"
    filters=";".join(f"[{i}:v]scale=640:360[v{i}]" for i in range(4))+";[v0][v1][v2][v3]xstack=inputs=4:layout=0_0|640_0|0_360|640_360[out]"
    subprocess.run([args.ffmpeg,"-hide_banner","-loglevel","error","-y",*inputs,"-filter_complex",filters,"-map","[out]","-an","-c:v","libx264","-crf","25","-pix_fmt","yuv420p","-movflags","+faststart",str(grid)],check=True)
    subprocess.run([args.ffmpeg,"-hide_banner","-loglevel","error","-y","-ss","4","-i",str(grid),"-frames:v","1",str(grid.with_suffix(".jpg"))],check=True)
    (args.output/"carla-recorded.json").write_text(json.dumps({"date":"2026-11-20","server_version":"0.9.16","seed":42,
        "controller":"Traffic Manager; rule-based closed-loop simulation, not a learned driving policy",
        "grid_order":[c[0] for c in CASES],"cases":reports,
        "grid":{"file":grid.name,"sha256":hashlib.sha256(grid.read_bytes()).hexdigest(),"frames":320,"fps":20,"resolution":[1280,720]}},indent=2)+"\n")


if __name__=="__main__":
    main()
check.pyGitHub에서 파일 보기
Python
"""CPU-only checks of our recorded CARLA trajectories and published sensor videos."""
import hashlib
import json
import math
from pathlib import Path


def main():
    root=Path(__file__).resolve().parents[2]
    data=json.loads((root/"labs/carla-ego/recorded.json").read_text())
    assert data["server_version"]=="0.9.16" and len(data["cases"])==4
    for case in data["cases"]:
        rows=case["trajectory"]
        assert len(rows)==case["frames"]==320 and case["fps"]==20
        assert all(b["frame"]-a["frame"]==1 and math.isclose(b["simulation_seconds"]-a["simulation_seconds"],.05,abs_tol=1e-6) for a,b in zip(rows,rows[1:]))
        assert all(all(math.isfinite(n) for n in row["position_m"]) and 0<=row["speed_mps"]<50 for row in rows)
        distance=sum(math.dist(a["position_m"],b["position_m"]) for a,b in zip(rows,rows[1:]))
        assert math.isclose(distance,case["distance_m"],abs_tol=.001) and distance>5
        video=root/"site/public/showcase"/case["published"]["file"]
        assert hashlib.sha256(video.read_bytes()).hexdigest()==case["published"]["sha256"]
        print(f'{case["id"]}: {len(rows)} frames, {distance:.1f}m, video hash OK')
    grid=data["grid"]
    assert hashlib.sha256((root/"site/public/showcase"/grid["file"]).read_bytes()).hexdigest()==grid["sha256"]
    print("Four CARLA sensor runs verified. This is not a learned-policy safety evaluation.")


if __name__=="__main__":
    main()