거리 측정값이 바퀴 명령이 되기까지
- 입력주변까지의 거리 측정
거리 float[180] + 측정 지점 float[180,3]이상적인 물리 거리 센서로 충돌체를 감지합니다. 계획기에 물체 이름이나 좌표를 넘기지 않습니다.
- 처리관측으로 경로 계산
5cm 점유 격자 → 0.43m 확장 → A*평평한 시험 구역 경계와 로봇의 현재 위치는 알고 있다고 가정합니다. 초당 10번 경로를 계산합니다.
- 출력주행 후 다시 측정
경로 → v, ω → 바퀴 드라이브 → 다음 스캔센서 데이터가 없으면 정지합니다. 상자 배치가 바뀌면 우회 경로도 달라집니다.
앞선 로봇은 우리가 지정한 경유점을 따라갔습니다. 이번에는 목적지 [1.3, 0]만 지정합니다. Isaac Sim 6.2의 Physics Raycast Sensor로 주변까지의 거리를 읽고, 측정값으로 점유 격자를 만듭니다. 로봇이 들어갈 여유를 확보한 뒤 A*로 경로를 찾아 바퀴를 제어합니다. 실제 움직임과 접촉은 PhysX가 계산합니다.
1. 센서에서 어떤 데이터가 나올까요?
센서는 몸체 좌표계에서 0.25m 위, 바닥에서는 약 0.48m 높이에 놓았습니다. 수평으로 360°를 2° 간격으로 나눈 광선 180개를 쏘며, 최대 측정 거리는 2.5m입니다. 센서는 물리 스텝에 맞춰 측정하고, 제어기는 6스텝마다 한 프레임을 읽습니다. 물리 계산이 초당 60스텝이면 제어에 사용하는 스캔은 초당 10개입니다.
Isaac Sim의 isaacsim.sensors.experimental.physics.RaycastSensor가 광선별 거리와 충돌 지점을 돌려줍니다. 이상적인 물리 거리 센서이며, 회전형 RTX LiDAR나 카메라를 사용한 예제는 아닙니다. NVIDIA 센서 설명
angles: float[180] 로봇 수평면에서의 방향, 단위 rad
ranges: float[180] 광선별 거리, 단위 m
hit_positions: float[180,3] 월드 좌표계에서 측정한 XYZ 지점
pose: [x, y, yaw] 몸체의 위치와 바라보는 방향
로봇이 [-1.3, 0] 부근에 있을 때 90번 광선은 정면인 +X 방향을 가리킵니다. 중앙 상자 배치에서 기록한 첫 스캔을 반올림하면 다음과 같습니다.
{
"ray_index": 90,
"angle_degrees": 0,
"range_m": 1.075,
"hit_position_world": [-0.225, 0.0, 0.48]
}
정면 1.075m 앞에 광선과 만나는 표면이 있다는 뜻입니다. 이것만으로 물체의 이름이 ‘상자’라고 알 수는 없습니다. 시험 상자의 앞면이 X=-0.225m에 있어서 이 지점이 측정된 것입니다. 옆 광선들은 앞면의 다른 부분을 읽습니다. 부딪힌 곳이 없으면 최대 거리인 2.5m가 나오며, 이 값은 장애물로 지도에 넣지 않습니다.

2. 왜 장애물을 실제보다 크게 표시할까요?
경로 탐색에는 한 칸이 5cm인 격자를 씁니다. 측정한 충돌 지점을 장애물 칸으로 표시하고, 그 주변을 0.43m만큼 넓힙니다. 바퀴까지 포함한 로봇의 외접 반경 약 0.36m에 추종 오차를 위한 여유를 더한 값입니다. 로봇의 중심이 이 영역 밖으로 지나가야 몸체도 부딪히지 않습니다. 점 하나는 통과할 수 있는 틈이라도 실제 로봇에는 좁을 수 있습니다.
시작할 때 장애물 지도는 비어 있습니다. 평평한 5×4m 시험 바닥의 경계는 알고 있다고 가정하고, 그 안에서 아직 관측하지 않은 칸은 통행 가능으로 취급합니다. 센서가 읽은 지점을 누적하고 초당 10번 경로를 다시 계산합니다. 정적인 장애물용 예제라 이전 장애물 관측을 지우지는 않습니다. 움직이는 사람이나 상자를 추적하는 기능은 별도입니다.
A*는 주변 칸을 후보로 살펴봅니다. 지금까지 이동할 거리와 목적지까지 남은 거리의 추정치를 함께 비교해 다음 후보를 고릅니다. 이 예제는 주변 8칸을 확인하며, 막힌 모서리를 대각선으로 가로지르는 이동은 제외합니다. 목적지 칸까지 찾으면 앞서 거쳐 온 칸들을 역순으로 연결해 경로를 만듭니다.
S . . # # # . . G
. . . # # # . . .
. . . # # # . . .
. . . . . . . . .
이 설명용 격자에서 S는 로봇, G는 목적지, #은 로봇 크기까지 고려해 넓힌 장애물, .은 통과 가능한 칸입니다. 막힌 칸을 피해 돌아가야 합니다. 결과는 칸 중심의 XY 좌표를 순서대로 담은 float[N,2] 배열입니다. 중앙 상자 실험의 첫 경로는 53개 지점이었고, [[-1.30, 0.00], [-1.25, -0.05], …]로 시작했습니다. 이 좌표들은 스캔을 읽은 뒤 계산한 결과이며, 앞선 제어처럼 실행 전에 입력해 둔 경유점이 아닙니다.
3. 계산한 경로가 어떻게 주행으로 이어질까요?
계산한 경로에서 가까운 진행 목표점을 고르고, 로봇이 바라보는 방향과 얼마나 차이가 나는지 구합니다. 그 차이로 전진 속도와 회전 속도를 정해 좌우 바퀴에 전달합니다. 화면의 청록색 선은 센서 관측으로 그때 계산한 경로입니다. 파란 선은 실제로 표면에 닿은 광선입니다. 선을 따라 몸체 좌표를 강제로 옮기지는 않습니다.
광선 180개의 거리 + 현재 로봇 위치
→ 장애물 칸 표시 → 로봇 크기만큼 확장 → A* 경로
→ 가까운 진행 목표점 → 전진 속도 v / 회전 속도 ω
→ 좌우 바퀴 속도 → PhysX가 계산한 움직임
→ 다음 센서 프레임 → 경로 재계산
최대 전진 속도는 앞선 예제와 같은 0.32m/s입니다. 정면 측정값이 0.46m보다 작으면 전진 명령을 멈추는 보조 조건도 넣었습니다. 센서 데이터가 없거나 오래됐을 때, 통과할 경로를 찾지 못했을 때도 정지합니다. 학습용 정지 조건이며 실제 로봇의 안전 인증 기능을 대신하지 않습니다.
로봇의 현재 위치는 시뮬레이터에서 직접 읽습니다. SLAM이나 실제 바퀴 오도메트리를 구현한 것은 아닙니다. WorldGen 공간은 겉모습을 담당하고, 바닥·상자는 따로 설정한 충돌체입니다. 센서 높이보다 낮은 물체, 계단, 생성한 공간의 임의의 가구까지 감지한다고 볼 수는 없습니다.
처음이면 실습 파일부터 받기
GPU 실습은 Isaac Sim을 실행할 머신에서 터미널을 엽니다. CPU 실습은 지금 쓰는 컴퓨터에서 해도 됩니다. 아래 명령은 한 줄씩 입력하고 Enter를 누르세요. 여러 줄짜리 명령 블록은 통째로 복사해도 됩니다.
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. 생성한 실험실 준비하기
NVIDIA Linux 환경 설정과 WorldGen 공간 가져오기를 먼저 확인하세요. NVIDIA GPU가 있는 호환 Linux 머신의 터미널에서 저장소 루트로 이동한 뒤 입력합니다.
nvidia-smi
mkdir -p runs/worldgen-navigation
cp -R labs/worldgen-isaac/assets runs/worldgen-navigation/assets
export WORLDGEN_DATA_ROOT="$PWD/runs/worldgen-navigation"
준비된 장면을 사용하므로 FLUX 가중치를 받거나 공간을 새로 생성할 필요가 없습니다. NVIDIA Omniverse 약관에 동의한 뒤, 본인의 동의를 나타내는 환경 변수를 설정합니다.
export ACCEPT_EULA=Y
bash labs/worldgen-navigation/run.sh sensor --layout center
Isaac Sim GUI가 열리고 측정 광선과 계산한 경로가 보입니다. 실행을 마치면 결과를 저장하고 닫힙니다. runs/worldgen-navigation/sensor/result.json과 scans.json을 확인하세요. scene.usdc는 시작 장면이며, 파일을 열고 Play만 눌렀을 때 제어기까지 실행되지는 않습니다. 제어는 Python 실행 스크립트가 담당합니다.
2. 기존 경유점 경로를 막아 보기
lower 배치는 기존에 지정한 −Y 방향 우회로에 상자를 하나 더 놓습니다. 경유점 목록은 그대로 둡니다. 두 방식은 시작점·목적지·로봇·충돌체·최대 속도가 같습니다. 센서 제어기에 배치 이름이나 상자의 좌표를 전달하지 않습니다.
bash labs/worldgen-navigation/run.sh scripted --layout lower \
--output /work/scripted-lower --max-seconds 20
bash labs/worldgen-navigation/run.sh sensor --layout lower \
--output /work/sensor-lower
bash labs/worldgen-navigation/run.sh sensor --layout upper \
--output /work/sensor-upper
컨테이너의 /work는 앞서 지정한 WORLDGEN_DATA_ROOT입니다. upper는 추가 상자를 반대편에 놓습니다. 관측에 맞춰 계획한다면 우회 방향도 다시 바뀌어야 합니다. 세 가지 통제된 배치의 동작 확인이며, 일반적인 자율주행 성능을 평가한 벤치마크는 아닙니다. 실제 접촉 기록, 몸체 위치, 계산한 경로를 결과 파일에서 비교해 보세요.
3. 센서 데이터를 일부러 끊어 보기
bash labs/worldgen-navigation/run.sh sensor --sensor-off \
--output /work/sensor-off --max-seconds 3
로봇은 움직이지 않아야 합니다. 거리 프레임을 못 받는데도 숨겨진 경로를 따라 주행하지 않는지 확인하는 실험입니다.
4. 실제 GUI 녹화하기
X11 데스크톱에서 xwininfo와 x11grab을 지원하는 ffmpeg를 준비합니다. 녹화할 때는 새 출력 폴더를 사용하세요.
mkdir -p runs/worldgen-navigation-film
cp -R labs/worldgen-isaac/assets runs/worldgen-navigation-film/assets
python3 labs/worldgen-navigation/record_gui.py \
--work "$PWD/runs/worldgen-navigation-film" --scenario sensor \
--layout lower --max-seconds 30 --ffmpeg /path/to/ffmpeg
실제 뷰포트 프레임이 준비되면 녹화를 시작하고 로봇을 움직입니다. 원본 창 녹화, 로그, 거리 배열, 주행 기록을 함께 남깁니다. package.py로 뷰포트 영상과 비교 영상을 만들 수 있으며, 배속을 바꿨다면 편집 메타데이터에 기록합니다. 시뮬레이션 시간과 실제 녹화 시간도 각각 저장합니다.
GPU 없이 기록을 검사합니다
녹색 선은 센서 제어로 실제 이동한 몸체 위치입니다. 빨간 점선은 상자에 막힌 기존 제어의 기록입니다. 센서 측정점도 함께 표시했습니다. 실행 후 저장 데이터로 그린 그래프이며, GUI 녹화와 구분해 보세요.
| 실행 | 도착 여부 | 도착까지의 시뮬레이션 시간 | 장애물 접촉 보고 수 |
|---|---|---|---|
| 기존 제어, 아래쪽 통로 막힘 | 실패 | — (20초 실행) | 638 |
| 센서 제어, 중앙 상자 | 성공 | 12.08초 | 0 |
| 센서 제어, 아래쪽 통로 막힘 | 성공 | 12.08초 | 0 |
| 센서 제어, 위쪽 통로 막힘 | 성공 | 12.08초 | 0 |
| 센서 데이터 차단 | 정지 유지 | — (3초 검사) | 0 |
638은 한동안 이어진 접촉에서 발생한 보고 수이며, 별개의 충돌 638회를 뜻하지 않습니다. 성공 영상은 도착 후 약 3초 동안 정지하는 모습까지 담았습니다. 좌우 대칭 배치에서 이동 시간이 거의 같았으며, 여러 회차의 평균이나 성능 벤치마크 결과는 아닙니다.
아래쪽 통로 배치의 시작 USD 장면 다운로드. assets/와 sensor/를 나란히 두고 sensor/scene.usdc를 여세요. 경로를 계산하는 Python 제어기는 소스 코드로 제공합니다.
python3 labs/worldgen-navigation/test_navigation.py
python3 labs/worldgen-navigation/check.py
첫 명령은 관측에 따라 경로가 달라지는지와 정지 조건을 검사합니다. 두 번째는 GPU 머신에서 실제 실행한 데이터로 거리 배열의 크기와 시각, 우회 방향, 접촉, 도착 위치, 영상 해시를 확인합니다. 직접 실행한 결과도 검사할 수 있습니다.
python3 labs/worldgen-navigation/check.py --run runs/worldgen-navigation/sensor-lower
실행 영상과 기록
실습 소스 코드
navigation.py
GitHub에서 파일 보기"""Small, inspectable scan-to-grid planner; no simulator or scene access.
Inputs are robot pose, a goal, and measured range endpoints. Unknown cells are
optimistically traversable inside a known, flat test boundary. No SLAM is done.
"""
import heapq
import math
class Navigator:
resolution = .05
radius = .43 # Circumscribed robot footprint plus tracking margin.
bounds = (-2.5, -2., 2.5, 2.)
def __init__(self, goal=(1.3, 0.)):
self.goal = tuple(goal)
self.hits = set()
self.path = []
self.replans = 0
self.blocked = set()
self.last_time = None
def cell(self, point):
return tuple(int(round((point[i] - self.bounds[i]) / self.resolution)) for i in (0, 1))
def point(self, cell):
return tuple(self.bounds[i] + cell[i] * self.resolution for i in (0, 1))
def allowed(self, cell):
x, y = self.point(cell)
return (self.bounds[0] + self.radius <= x <= self.bounds[2] - self.radius
and self.bounds[1] + self.radius <= y <= self.bounds[3] - self.radius
and cell not in self.blocked)
def line_free(self, start, end):
n = max(1, math.ceil(math.dist(start, end) / (self.resolution / 2)))
return all(self.allowed(self.cell([start[j] + (end[j] - start[j]) * i / n for j in (0, 1)]))
for i in range(n + 1))
def update(self, pose, depths, endpoints, sim_time):
"""Only measured endpoints within range become occupied cells."""
if not depths or len(depths) != len(endpoints):
self.path = []
return False
if self.last_time is not None and sim_time <= self.last_time:
self.path = []
return False
self.last_time = sim_time
for distance, point in zip(depths, endpoints):
if math.isfinite(distance) and .05 <= distance < 2.499 and all(math.isfinite(q) for q in point[:2]):
self.hits.add(self.cell(point))
n = math.ceil(self.radius / self.resolution)
offsets = [(i, j) for i in range(-n, n+1) for j in range(-n, n+1)
if math.hypot(i, j) * self.resolution <= self.radius + self.resolution / 2]
self.blocked = {(x+i, y+j) for x, y in self.hits for i, j in offsets}
self.path = self.plan(pose[:2])
self.replans += 1
return bool(self.path)
def plan(self, start):
source, goal = self.cell(start), self.cell(self.goal)
if not self.allowed(source) or not self.allowed(goal):
return []
queue = [(math.dist(source, goal), 0., source)]
costs, parents = {source: 0.}, {}
while queue:
_, cost, node = heapq.heappop(queue)
if cost > costs[node]:
continue
if node == goal:
route = [node]
while route[-1] != source:
route.append(parents[route[-1]])
return [self.point(c) for c in reversed(route)]
for dx, dy in ((1, -1), (1, 0), (1, 1), (0, -1), (0, 1), (-1, -1), (-1, 0), (-1, 1)):
neighbor = (node[0]+dx, node[1]+dy)
if not self.allowed(neighbor):
continue
if dx and dy and (not self.allowed((node[0]+dx, node[1])) or not self.allowed((node[0], node[1]+dy))):
continue
candidate = cost + math.hypot(dx, dy)
if candidate < costs.get(neighbor, float('inf')):
costs[neighbor] = candidate
parents[neighbor] = node
heapq.heappush(queue, (candidate + math.dist(neighbor, goal), candidate, neighbor))
return []
def command(self, pose, front_min, sensor_age):
x, y, yaw = pose
distance = math.dist((x, y), self.goal)
if distance < .12:
return 0., 0., 'goal'
if sensor_age > .25 or not self.path:
return 0., 0., 'sensor-stop' if sensor_age > .25 else 'no-path'
target = self.path[0]
for point in self.path:
if math.dist((x, y), point) <= .40 and self.line_free((x, y), point):
target = point
error = math.atan2(math.sin(math.atan2(target[1]-y, target[0]-x)-yaw),
math.cos(math.atan2(target[1]-y, target[0]-x)-yaw))
omega = max(-1.1, min(1.1, 2.8*error))
speed = min(.32, .9*distance) * max(0., math.cos(error)) if abs(error) < .65 else 0.
if front_min < .46:
speed = 0.
return speed, omega, 'follow-scan-path'
run.sh
GitHub에서 파일 보기#!/usr/bin/env bash
# Start an isolated Isaac Sim 6.2 container. ACCEPT_EULA must be supplied by the user.
set -euo pipefail
: "${ACCEPT_EULA:?Set ACCEPT_EULA=Y only after accepting the NVIDIA Omniverse agreement.}"
[[ "$ACCEPT_EULA" == Y ]] || { echo "ACCEPT_EULA must be Y after your own acceptance." >&2; exit 1; }
worldgen_lab_root="$(cd "$(dirname "$0")" && pwd)"
worldgen_data_root="${WORLDGEN_DATA_ROOT:-$worldgen_lab_root}"
mkdir -p "$worldgen_data_root/cache"
worldgen_scenario="${1:-sensor}"
shift || true
worldgen_xauth="${XAUTHORITY:-/run/user/$(id -u)/gdm/Xauthority}"
worldgen_display="${DISPLAY:-:1}"
worldgen_desktop_args=()
worldgen_headless=false
for worldgen_arg in "$@"; do
[[ "$worldgen_arg" == --headless ]] && worldgen_headless=true
done
if ! "$worldgen_headless"; then
[[ -f "$worldgen_xauth" ]] || { echo "Set XAUTHORITY to your X11 desktop authority file for GUI use." >&2; exit 1; }
worldgen_desktop_args=(-e "DISPLAY=$worldgen_display" -e XAUTHORITY=/tmp/isaac-xauthority
-v "$worldgen_xauth:/tmp/isaac-xauthority:ro" -v /tmp/.X11-unix:/tmp/.X11-unix:rw)
fi
exec docker run --rm --user 0:0 --gpus all --shm-size=2g \
-e ACCEPT_EULA="$ACCEPT_EULA" -e PRIVACY_CONSENT=N -e NVIDIA_DRIVER_CAPABILITIES=all \
"${worldgen_desktop_args[@]}" \
-v "$worldgen_data_root/cache:/root/.cache:rw" \
-v "$worldgen_lab_root:/lab:ro" -v "$worldgen_data_root:/work:rw" \
--entrypoint /isaac-sim/python.sh nvcr.io/nvidia/isaac-sim:6.2.0 \
/lab/run.py --assets /work/assets --output "/work/$worldgen_scenario" --scenario "$worldgen_scenario" \
--allow-root --/omni/client/omniverse/use_omnihub=false --/renderer/multiGpu/enabled=false --/rtx/hydra/supportMultiTickRate=false "$@"
run.py
GitHub에서 파일 보기"""Sensor navigation in the WorldGen scene.
Scene setup derives from the frozen worldgen-isaac lab (commit f035e0e).
The Navigator receives scan endpoints and ego pose, never obstacle transforms.
Run inside Isaac Sim 6.2, outside the WorldGen Python environment.
The visual shell is not a collider. The test floor and crate are explicit proxies.
"""
import argparse,json,math,os,time,traceback
from pathlib import Path
from importlib.metadata import version, PackageNotFoundError
p=argparse.ArgumentParser()
p.add_argument('--assets',type=Path,required=True);p.add_argument('--output',type=Path,required=True)
p.add_argument('--scenario',choices=['sensor','scripted'],default='sensor')
p.add_argument('--room-emission',type=float,default=400.);p.add_argument('--headless',action='store_true');p.add_argument('--collision-view',action='store_true')
p.add_argument('--raw-collider',action='store_true');p.add_argument('--no-floor',action='store_true');p.add_argument('--record-handshake',action='store_true')
p.add_argument('--layout',choices=['center','lower','upper'],default='center')
p.add_argument('--sensor-off',action='store_true')
p.add_argument('--max-seconds',type=float,default=30.)
p.add_argument('--hold-seconds',type=float,default=3.)
a,kit_args=p.parse_known_args();a.assets=a.assets.resolve();a.output=a.output.resolve();a.output.mkdir(parents=True,exist_ok=True)
(a.output/'FAILED').unlink(missing_ok=True)
from isaacsim import SimulationApp
app=SimulationApp({'headless':a.headless,'width':1280,'height':720,'window_width':1440,'window_height':900,
'renderer':'RaytracedLighting','anti_aliasing':2,'fast_shutdown':True})
failed=True
try:
import numpy as np
import carb,omni.usd,omni.physx
from pxr import Gf,Sdf,UsdGeom,UsdShade,UsdLux,UsdPhysics,PhysxSchema,PhysicsSchemaTools
from isaacsim.core.simulation_manager import SimulationManager
import isaacsim.core.experimental.utils.stage as stage_utils
from isaacsim.core.rendering_manager import RenderingManager, ViewportManager
from omni.kit.viewport.utility import get_active_viewport
settings=carb.settings.get_settings()
settings.set_bool('/physics/updateToUsd',True)
settings.set_bool('/rtx/hydra/readTransformsFromFabricInRenderDelegate',False)
settings.set_bool('/persistent/app/viewport/Viewport/Viewport0/scene/cameras/visible',False)
stage_utils.create_new_stage()
class SimulationLoop:
@property
def current_time(self):return SimulationManager.get_simulation_time()
def initialize(self):
SimulationManager.setup_simulation(dt=1/60)
SimulationManager.initialize_physics()
RenderingManager.set_dt(1/60)
def step(self,render=True):
SimulationManager.step()
if render:RenderingManager.render()
simulation=SimulationLoop()
stage=omni.usd.get_context().get_stage();UsdGeom.SetStageUpAxis(stage,'Z');UsdGeom.SetStageMetersPerUnit(stage,1.)
root=UsdGeom.Xform.Define(stage,'/World');stage.SetDefaultPrim(root.GetPrim())
manifest=json.loads((a.assets/'calibration.json').read_text())
config=manifest['physics_proxy'];robot_cfg=manifest['robot']
def xform(path,pos):
obj=UsdGeom.Xform.Define(stage,path);obj.AddTranslateOp().Set(Gf.Vec3d(*pos));return obj
def material(name,rgb,emission=0):
mat=UsdShade.Material.Define(stage,'/World/Looks/'+name);shader=UsdShade.Shader.Define(stage,mat.GetPath().AppendChild('Surface'))
shader.CreateIdAttr('UsdPreviewSurface');shader.CreateInput('diffuseColor',Sdf.ValueTypeNames.Color3f).Set(Gf.Vec3f(*rgb))
shader.CreateInput('roughness',Sdf.ValueTypeNames.Float).Set(.65)
shader.CreateInput('emissiveColor',Sdf.ValueTypeNames.Color3f).Set(Gf.Vec3f(*(np.array(rgb)*emission)))
mat.CreateSurfaceOutput().ConnectToSource(shader.ConnectableAPI(),'surface');return mat
def bind(obj,mat):UsdShade.MaterialBindingAPI.Apply(obj.GetPrim()).Bind(mat)
green=material('RobotGreen',(.30,.65,.025),.15);dark=material('Rubber',(.045,.05,.055),.05)
steel=material('Steel',(.35,.39,.42));orange=material('TestCrate',(.96,.34,.025),.1);gray=material('ProxyFloor',(.33,.40,.42),.1)
blue=material('Probe',(.03,.35,.95),.2);white=material('Ruler',(.94,.94,.85),.3)
def physics_material(name,friction):
mat=UsdShade.Material.Define(stage,'/World/Looks/'+name);api=UsdPhysics.MaterialAPI.Apply(mat.GetPrim())
api.CreateStaticFrictionAttr(friction);api.CreateDynamicFrictionAttr(friction);api.CreateRestitutionAttr(0.)
return mat
traction=physics_material('Traction',.9);caster_mat=physics_material('Caster',.015)
def box(path,pos,size,mat,collision=False):
o=UsdGeom.Cube.Define(stage,path);o.CreateSizeAttr(1.);o.AddTranslateOp().Set(Gf.Vec3d(*pos));o.AddScaleOp().Set(Gf.Vec3d(*size));bind(o,mat)
if collision:UsdPhysics.CollisionAPI.Apply(o.GetPrim())
return o
def rigid(obj,mass):
UsdPhysics.RigidBodyAPI.Apply(obj.GetPrim());UsdPhysics.MassAPI.Apply(obj.GetPrim()).CreateMassAttr(mass)
# The render mesh is a decimation of the generated RGB-distance shell.
mesh_data=np.load(a.assets/'room-mesh.npz');mesh=UsdGeom.Mesh.Define(stage,'/World/GeneratedRoom')
mesh.CreatePointsAttr(mesh_data['points']);mesh.CreateFaceVertexCountsAttr([3]*len(mesh_data['indices']));mesh.CreateFaceVertexIndicesAttr(mesh_data['indices'].reshape(-1))
mesh.CreateSubdivisionSchemeAttr('none');mesh.CreateDoubleSidedAttr(True)
UsdGeom.PrimvarsAPI(mesh).CreatePrimvar('st',Sdf.ValueTypeNames.TexCoord2fArray,UsdGeom.Tokens.vertex).Set(mesh_data['uv'])
mesh.CreateExtentAttr([Gf.Vec3f(*mesh_data['points'].min(0).tolist()),Gf.Vec3f(*mesh_data['points'].max(0).tolist())])
# Native OmniPBR avoids the PreviewSurface texture-graph translation on RTX.
room_mat=UsdShade.Material.Define(stage,'/World/Looks/Room')
room_shader=UsdShade.Shader.Define(stage,'/World/Looks/Room/Shader')
room_shader.CreateIdAttr('OmniPBR')
room_shader.GetImplementationSourceAttr().Set(UsdShade.Tokens.sourceAsset)
room_shader.SetSourceAsset(Sdf.AssetPath('OmniPBR.mdl'),'mdl')
room_shader.SetSourceAssetSubIdentifier('OmniPBR','mdl')
out=room_shader.CreateOutput('out',Sdf.ValueTypeNames.Token)
room_mat.CreateSurfaceOutput('mdl').ConnectToSource(out)
for name in ['diffuse_texture','emissive_color_texture']:
room_shader.CreateInput(name,Sdf.ValueTypeNames.Asset).Set(Sdf.AssetPath(str(a.assets/'panorama.jpg')))
room_shader.CreateInput('project_uvw',Sdf.ValueTypeNames.Bool).Set(False)
room_shader.CreateInput('texture_scale',Sdf.ValueTypeNames.Float2).Set(Gf.Vec2f(1,1))
room_shader.CreateInput('diffuse_color_constant',Sdf.ValueTypeNames.Color3f).Set(Gf.Vec3f(1))
room_shader.CreateInput('reflection_roughness_constant',Sdf.ValueTypeNames.Float).Set(1.)
room_shader.CreateInput('enable_emission',Sdf.ValueTypeNames.Bool).Set(True)
room_shader.CreateInput('emissive_color',Sdf.ValueTypeNames.Color3f).Set(Gf.Vec3f(1))
room_shader.CreateInput('emissive_intensity',Sdf.ValueTypeNames.Float).Set(a.room_emission)
bind(mesh,room_mat)
if a.raw_collider:
UsdPhysics.CollisionAPI.Apply(mesh.GetPrim())
UsdPhysics.MeshCollisionAPI.Apply(mesh.GetPrim()).CreateApproximationAttr('none')
if a.collision_view:mesh.CreateVisibilityAttr('invisible')
if not a.no_floor:
floor=box('/World/ProxyFloor',config['floor_center'],config['floor_size'],gray,True)
UsdShade.MaterialBindingAPI.Apply(floor.GetPrim()).Bind(traction,materialPurpose='physics')
if not a.collision_view:floor.CreateVisibilityAttr('invisible')
obstacle_paths=['/World/TestCrate']
if a.layout!='center':
extra=box('/World/ExtraCrate',(0,-.95 if a.layout=='lower' else .95,.3),(.45,.60,.6),orange,True)
obstacle_paths.append('/World/ExtraCrate')
crate=box('/World/TestCrate',config['obstacle_center'],config['obstacle_size'],orange,True)
# One metre, in the chosen simulation scale, rather than a claim about the generated simulation.
box('/World/OneMetreBar',(0,.95,.06),(1,.015,.01),white)
for x in np.linspace(-.5,.5,11):box(f'/World/Tick{int(round((x+.5)*10))}',(float(x),.95,.065),(.01,.06 if abs(x)>.49 else .035,.01),white)
paths=[];drives=[]
if a.scenario=='probes':
for i,(x,y) in enumerate([(-1,-.7),(-1,.7),(1,-.7),(1,.7)]):
obj=xform(f'/World/Probe{i}',(x,y,.75));rigid(obj,.1)
if not a.headless:PhysxSchema.PhysxRigidBodyAPI.Apply(obj.GetPrim()).CreateDisableGravityAttr(True)
box(str(obj.GetPath())+'/Geometry',(0,0,0),(.1,.1,.1),blue,True);paths.append(str(obj.GetPath()))
else:
robot=xform('/World/Robot',(0,0,0));UsdPhysics.ArticulationRootAPI.Apply(robot.GetPrim())
PhysxSchema.PhysxArticulationAPI.Apply(robot.GetPrim()).CreateEnabledSelfCollisionsAttr(False)
start=np.array(manifest['route']['start']);chassis=xform('/World/Robot/Chassis',start);rigid(chassis,8.)
PhysxSchema.PhysxContactReportAPI.Apply(chassis.GetPrim()).CreateThresholdAttr(0)
box('/World/Robot/Chassis/Body',(0,0,0),robot_cfg['body_size'],green,True)
box('/World/Robot/Chassis/Top',(0,0,.13),(.38,.30,.08),steel)
box('/World/Robot/Chassis/Front',(.28,0,.035),(.012,.22,.04),white)
caster=UsdGeom.Sphere.Define(stage,'/World/Robot/Chassis/Caster');caster.CreateRadiusAttr(.05);caster.AddTranslateOp().Set(Gf.Vec3d(-.21,0,-.18));bind(caster,dark)
UsdPhysics.CollisionAPI.Apply(caster.GetPrim());UsdShade.MaterialBindingAPI.Apply(caster.GetPrim()).Bind(caster_mat,materialPurpose='physics')
for i,y in enumerate([.26,-.26]):
path=f'/World/Robot/Wheel{i}';local=np.array([.10,y,-.12]);wheel=xform(path,start+local);rigid(wheel,.3);PhysxSchema.PhysxContactReportAPI.Apply(wheel.GetPrim()).CreateThresholdAttr(0)
cylinder=UsdGeom.Cylinder.Define(stage,path+'/Tyre');cylinder.CreateAxisAttr('Y');cylinder.CreateRadiusAttr(.11);cylinder.CreateHeightAttr(.06);bind(cylinder,dark)
UsdPhysics.CollisionAPI.Apply(cylinder.GetPrim());UsdShade.MaterialBindingAPI.Apply(cylinder.GetPrim()).Bind(traction,materialPurpose='physics')
for j in range(3):
spoke=box(path+f'/Spoke{j}',(0,(-.031 if y<0 else .031),0),(.16,.006,.015),white)
spoke.AddRotateYOp().Set(j*60.)
joint=UsdPhysics.RevoluteJoint.Define(stage,f'/World/Robot/Joint{i}');joint.CreateAxisAttr('Y')
joint.CreateBody0Rel().SetTargets([chassis.GetPath()]);joint.CreateBody1Rel().SetTargets([wheel.GetPath()])
joint.CreateLocalPos0Attr(Gf.Vec3f(*local));joint.CreateLocalPos1Attr(Gf.Vec3f(0))
drive=UsdPhysics.DriveAPI.Apply(joint.GetPrim(),'angular');drive.CreateTypeAttr('force');drive.CreateStiffnessAttr(0);drive.CreateDampingAttr(20);drive.CreateMaxForceAttr(6);drive.CreateTargetVelocityAttr(0)
drives.append(drive)
paths=['/World/Robot/Chassis']
from isaacsim.sensors.experimental.physics import Raycast,RaycastSensor
from navigation import Navigator
angles=np.linspace(-math.pi,math.pi,180,endpoint=False)
scanner=RaycastSensor(Raycast.create('/World/Robot/Chassis/RangeSensor',
ray_origins=[[0.,0.,0.]]*len(angles),ray_directions=[[math.cos(t),math.sin(t),0.] for t in angles],
min_range=.05,max_range=2.5,output_frame='WORLD',translations=[[0.,0.,.25]]))
cap=UsdGeom.Cylinder.Define(stage,'/World/Robot/Chassis/SensorCap');cap.CreateAxisAttr('Z');cap.CreateRadiusAttr(.06);cap.CreateHeightAttr(.04);cap.AddTranslateOp().Set(Gf.Vec3d(0,0,.24));bind(cap,blue)
cyan=material('LiveSensor',(.015,.8,.85),.7)
def curve(path,mat,width):
c=UsdGeom.BasisCurves.Define(stage,path);c.CreateTypeAttr('linear');c.CreateWidthsAttr([width]);c.SetWidthsInterpolation('constant');bind(c,mat);return c
scan_lines=curve('/World/LiveScan',blue,.006);path_line=curve('/World/PlannedPath',cyan,.012)
goal_marker=UsdGeom.Cylinder.Define(stage,'/World/Goal');goal_marker.CreateRadiusAttr(.12);goal_marker.CreateHeightAttr(.015);goal_marker.AddTranslateOp().Set(Gf.Vec3d(1.3,0,.055));bind(goal_marker,green)
if a.scenario=='scripted':
scan_lines.CreateVisibilityAttr('invisible');path_line.CreateVisibilityAttr('invisible')
timing={'sensor_s':0.,'planner_s':0.,'draw_s':0.,'step_s':0.}
navigator=Navigator();scan_log=[];last_scan_time=-1e9;front_min=2.5
# Save the source scene before stepping. The exported state can be inspected in the GUI.
def aim(camera,eye,target):
matrix=Gf.Matrix4d(1).SetLookAt(Gf.Vec3d(*eye),Gf.Vec3d(*target),Gf.Vec3d(0,0,1)).GetInverse()
UsdGeom.Xformable(camera).AddTransformOp().Set(matrix)
camera=UsdGeom.Camera.Define(stage,'/World/FilmCamera');camera.GetPrim().ApplyAPI('OmniSensorAPI');aim(camera,(0,-1.8,1.35),(0,.6,.45));camera.CreateFocalLengthAttr(11);camera.CreateHorizontalApertureAttr(36);camera.CreateClippingRangeAttr(Gf.Vec2f(.03,120))
dome=UsdLux.DomeLight.Define(stage,'/World/Dome');dome.CreateIntensityAttr(450)
key=UsdLux.SphereLight.Define(stage,'/World/Light');key.AddTranslateOp().Set(Gf.Vec3d(-.3,-.5,2.1));key.CreateIntensityAttr(1800);key.CreateRadiusAttr(.7)
stage.Export(str(a.output/'scene.usdc'))
portable=Sdf.Layer.FindOrOpen(str(a.output/'scene.usdc'))
for name in ['diffuse_texture','emissive_color_texture']:
portable.GetAttributeAtPath('/World/Looks/Room/Shader.inputs:'+name).default=Sdf.AssetPath(os.path.relpath(a.assets/'panorama.jpg',a.output))
portable.Save()
simulation.initialize()
if not a.headless:
viewport=get_active_viewport();ViewportManager.set_camera(camera)
import asyncio
from omni.kit.viewport.utility import capture_viewport_to_file
from PIL import Image
for _ in range(8):
simulation.step()
capture=capture_viewport_to_file(viewport,str(a.output/'initial-rgb.png'))
async def wait_for_frame():
return await asyncio.wait_for(capture.wait_for_result(),timeout=120)
app.run_coroutine(wait_for_frame())
image_deadline=time.monotonic()+10
while True:
try:
with Image.open(a.output/'initial-rgb.png') as frame:
pixels=np.array(frame)
break
except (FileNotFoundError,OSError):
if time.monotonic()>image_deadline:raise
RenderingManager.render();time.sleep(.02)
(a.output/'initial-rgb.png').chmod(0o644)
assert pixels.ndim==3 and pixels[:,:,:3].mean()>5,'Native viewport remained black'
print('RENDER_CHECK',pixels.shape,float(pixels[:,:,:3].mean()),flush=True)
if a.scenario=='probes':
for _ in range(40):RenderingManager.render()
else:
for _ in range(40):simulation.step(render=True)
inspector=omni.physx.get_physx_interface()
def pose(path):
v=inspector.get_rigidbody_transformation(path);assert v['ret_val'],path
return list(v['position']),list(v['rotation'])
raycasts={}
for name,xy in [('floor_left',[-1,-1]),('floor_right',[1,-1]),('crate',[0,0])]:
hit=omni.physx.get_physx_scene_query_interface().raycast_closest((xy[0],xy[1],2.),(0.,0.,-1.),5.)
raycasts[name]={'hit':bool(hit['hit']),'collider':str(hit.get('collision','')),'position':list(hit.get('position',[]))}
contacts=[]
def on_contact(headers,data):
for header in headers:
actor0=str(PhysicsSchemaTools.intToSdfPath(header.actor0));actor1=str(PhysicsSchemaTools.intToSdfPath(header.actor1))
if any(path in actor0+actor1 for path in obstacle_paths) and 'Robot' in actor0+actor1:
contacts.append({'actor0':actor0,'actor1':actor1,'type':int(header.type),'time':simulation.current_time})
subscription=omni.physx.get_physx_simulation_interface().subscribe_contact_report_events(on_contact)
if a.record_handshake:
(a.output/'ready.json').write_text(json.dumps({'camera':str(camera.GetPath()),'application':'Isaac Sim 6.2 native window'}))
deadline=time.monotonic()+60
while not (a.output/'record-go').exists():
if time.monotonic()>deadline:raise TimeoutError('Native recorder did not start')
RenderingManager.render()
if a.scenario!='probes':
for _ in range(45):simulation.step(render=True)
print('NATIVE_GUI_RECORDING_STARTED',flush=True)
if a.scenario=='probes' and not a.headless:
for path in paths:PhysxSchema.PhysxRigidBodyAPI.Get(stage,path).GetDisableGravityAttr().Set(False)
samples=[];waypoints=manifest['route']['detour_waypoints'];waypoint=0
steps=int(a.max_seconds*60)
start_wall=time.monotonic();start_sim=simulation.current_time;reached=False;goal_time=None;phase='starting'
for step in range(steps):
position,rotation=pose(paths[0]);x,y,z=position;qx,qy,qz,qw=rotation
yaw=math.atan2(2*(qw*qz+qx*qy),1-2*(qy*qy+qz*qz))
elapsed=simulation.current_time-start_sim
if step%6==0 and not a.sensor_off:
tick=time.perf_counter()
frame=scanner.get_data()
depths=np.asarray(frame['depths']).reshape(-1).astype(float).tolist()
endpoints=np.asarray(frame['hit_positions']).reshape(-1,3).astype(float).tolist()
reading_time=float(frame['time'])
assert len(depths)==180 and all(math.isfinite(q) for q in depths),'Invalid range scan'
last_scan_time=simulation.current_time
# hit prim paths and scene objects are deliberately not passed to the planner.
timing['sensor_s']+=time.perf_counter()-tick;tick=time.perf_counter()
navigator.update((x,y,yaw),depths,endpoints,reading_time)
timing['planner_s']+=time.perf_counter()-tick;tick=time.perf_counter()
forward=[d for t,d in zip(angles,depths) if abs(t)<math.radians(25)]
front_min=min(forward)
scan_log.append({'sim_time_s':elapsed,'sensor_time_s':reading_time,'pose_xyyaw':[x,y,yaw],
'depths_m':depths,'hit_positions_world':endpoints,'front_min_m':front_min,
'planned_path_xy':navigator.path,'occupied_cells':len(navigator.hits)})
sensor_origin=[x,y,z+.25]
line_points=[]
for d,pt in zip(depths,endpoints):
if .05<=d<2.499:line_points.extend([sensor_origin,pt])
scan_lines.CreatePointsAttr([Gf.Vec3f(*pt) for pt in line_points]);scan_lines.CreateCurveVertexCountsAttr([2]*(len(line_points)//2))
path_points=[Gf.Vec3f(q[0],q[1],.075) for q in navigator.path]
path_line.CreatePointsAttr(path_points);path_line.CreateCurveVertexCountsAttr([len(path_points)] if len(path_points)>1 else [])
timing['draw_s']+=time.perf_counter()-tick
v=omega=0.
if a.scenario=='sensor':
v,omega,phase=navigator.command((x,y,yaw),front_min,simulation.current_time-last_scan_time)
reached=phase=='goal'
else:
distance=math.dist(waypoints[waypoint],(x,y))
if distance<.12:
if waypoint<len(waypoints)-1:waypoint+=1
else:reached=True
if not reached:
target=waypoints[waypoint];error=math.atan2(math.sin(math.atan2(target[1]-y,target[0]-x)-yaw),math.cos(math.atan2(target[1]-y,target[0]-x)-yaw))
omega=max(-1.1,min(1.1,2.8*error));v=min(.32,.9*distance)*max(0.,math.cos(error)) if abs(error)<.65 else 0.
phase='fixed-waypoints'
for drive,speed in zip(drives,[(v-.26*omega)/.11,(v+.26*omega)/.11]):
drive.GetTargetVelocityAttr().Set(math.degrees(speed))
tick=time.perf_counter();simulation.step(render=True);timing['step_s']+=time.perf_counter()-tick
if step%60==0:print('SIM_STEP',step,phase,front_min,position,flush=True)
if step%6==0:
samples.append({'step':step,'sim_time_s':simulation.current_time-start_sim,'wall_s':time.monotonic()-start_wall,
'poses':{path:pose(path) for path in paths},'command':[v,omega],'waypoint':waypoint if a.scenario=='scripted' else None,
'phase':phase,'front_min_m':front_min,'sensor_age_s':simulation.current_time-last_scan_time if last_scan_time>0 else None})
if reached:
if goal_time is None:goal_time=elapsed
if elapsed-goal_time>=a.hold_seconds:break
if not a.headless:time.sleep(max(0,(step+1)/60-(time.monotonic()-start_wall)))
for drive in drives:drive.GetTargetVelocityAttr().Set(0)
try: sim_version=version('isaacsim')
except PackageNotFoundError:
from isaacsim.core.version import get_version
sim_version=get_version()[0]
result={'status':'complete','scenario':a.scenario,'layout':a.layout,'sensor_off':a.sensor_off,'collision_view':a.collision_view,'no_floor':a.no_floor,'raw_collider':a.raw_collider,
'isaacsim_version':sim_version,'physics':'live PhysX; joint velocity drives; not a USD trajectory replay',
'control':'measured physics raycast scan → endpoint occupancy → inflation → A* → pose-feedback wheel control' if a.scenario=='sensor' else 'frozen detour waypoints',
'timing':timing,'sensor':{'class':'isaacsim.sensors.experimental.physics.RaycastSensor','rays':180,'max_range_m':2.5,'height_above_chassis_m':.25,'controller_read_hz':10,'scan_frames':len(scan_log),'replans':navigator.replans},
'navigation':{'obstacle_transforms_as_input':False,'known_floor_bounds':navigator.bounds,'inflation_radius_m':navigator.radius,'grid_resolution_m':navigator.resolution,'goal_xy':navigator.goal,'pose_source':'simulator ground truth; not SLAM or wheel odometry'},
'goal_reached_s':goal_time,'start_sim_s':start_sim,'duration_sim_s':simulation.current_time-start_sim,'duration_wall_s':time.monotonic()-start_wall,'reached_goal':reached,
'stage':{'up_axis':str(UsdGeom.GetStageUpAxis(stage)),'meters_per_unit':UsdGeom.GetStageMetersPerUnit(stage),'render_mesh_collision':mesh.GetPrim().HasAPI(UsdPhysics.CollisionAPI),'multitick_rendering':settings.get_as_bool('/rtx/hydra/supportMultiTickRate'),'room_emission_display_setting':a.room_emission,'proxy_floor':not a.no_floor},'raycasts':raycasts,'crate_contact_events':contacts,'samples':samples,'final_poses':{path:pose(path) for path in paths}}
(a.output/'scans.json').write_text(json.dumps(scan_log,separators=(',',':'))+'\n')
(a.output/'result.json').write_text(json.dumps(result,indent=2)+'\n')
print('RUN_RESULT',json.dumps({k:v for k,v in result.items() if k not in ['samples','crate_contact_events']}),flush=True)
failed=False
except BaseException:
traceback.print_exc()
finally:
if failed:(a.output/'FAILED').touch()
app.close()
if failed:raise SystemExit(1)
record_gui.py
GitHub에서 파일 보기"""Record the real native Isaac Sim window while run.py performs live physics."""
import argparse,json,os,signal,subprocess,time
from pathlib import Path
p=argparse.ArgumentParser();p.add_argument('--work',type=Path,required=True)
p.add_argument('--scenario',choices=['sensor','scripted'],default='sensor')
p.add_argument('--ffmpeg',type=Path,required=True);p.add_argument('--collision-view',action='store_true')
p.add_argument('--layout',choices=['center','lower','upper'],default='center');p.add_argument('--max-seconds',default='40')
a=p.parse_args();root=Path(__file__).resolve().parent;a.work=a.work.resolve()
output=a.work/a.scenario;output.mkdir(parents=True,exist_ok=True)
assert not (output/'ready.json').exists(),'Use a new output folder for a fresh recording'
env=dict(os.environ,WORLDGEN_DATA_ROOT=str(a.work),DISPLAY=os.environ.get('DISPLAY',':1'),XAUTHORITY=os.environ.get('XAUTHORITY',f'/run/user/{os.getuid()}/gdm/Xauthority'))
command=['bash',str(root/'run.sh'),a.scenario,'--record-handshake','--layout',a.layout,'--max-seconds',a.max_seconds]+(['--collision-view'] if a.collision_view else [])
recorder=None
with (output/'simulator.log').open('w') as log:
process=subprocess.Popen(command,env=env,stdout=log,stderr=subprocess.STDOUT)
try:
deadline=time.monotonic()+240
while not (output/'ready.json').exists():
if process.poll() is not None:raise RuntimeError('Isaac Sim stopped before the viewport was ready; see simulator.log')
if time.monotonic()>deadline:raise TimeoutError('Isaac Sim startup timed out')
time.sleep(.3)
listing=subprocess.check_output(['xwininfo','-root','-tree'],env=env,text=True)
window=next(row.split()[0] for row in listing.splitlines() if ('"Isaac Sim' in row or '"Isaac-Sim' in row) and 'mutter-x11-frames' not in row)
metadata=subprocess.check_output(['xwininfo','-id',window],env=env,text=True)
(output/'window.txt').write_text(metadata)
with (output/'recorder.log').open('w') as recordlog:
recorder=subprocess.Popen([str(a.ffmpeg),'-nostdin','-hide_banner','-loglevel','warning','-y','-f','x11grab','-draw_mouse','0','-framerate','30','-window_id',str(int(window,16)),'-i',env['DISPLAY']+'.0','-an','-vf','scale=trunc(iw/2)*2:trunc(ih/2)*2','-c:v','libx264','-preset','ultrafast','-crf','18','-pix_fmt','yuv420p','-movflags','+faststart',str(output/'native-gui.mp4')],env=env,stdout=recordlog,stderr=subprocess.STDOUT)
time.sleep(.5);assert recorder.poll() is None,'X11 recorder could not start'
(output/'record-go').touch()
process.wait(timeout=300)
if (output/'FAILED').exists() or not (output/'result.json').exists():raise RuntimeError('Simulation failed; keep the logs for diagnosis')
finally:
if recorder and recorder.poll() is None:
recorder.send_signal(signal.SIGINT);recorder.wait(timeout=15)
if process.poll() is None:process.terminate()
print('Native GUI recording:',output/'native-gui.mp4')
package.py
GitHub에서 파일 보기"""Package native GUI crops and an honest sequential controller comparison.
Requires ffmpeg and Pillow on the editing machine. All footage stays at 1×.
"""
import argparse,hashlib,json,subprocess,tempfile
from pathlib import Path
from PIL import Image,ImageDraw,ImageFont
p=argparse.ArgumentParser();p.add_argument('--source',type=Path,required=True);p.add_argument('--output',type=Path,required=True)
p.add_argument('--ffmpeg',default='ffmpeg');p.add_argument('--font',required=True);p.add_argument('--font-ko',required=True)
a=p.parse_args();a.output.mkdir(parents=True,exist_ok=True)
def ff(*args):subprocess.run([a.ffmpeg,'-hide_banner','-loglevel','error','-y',*map(str,args)],check=True)
def digest(path):return hashlib.sha256(path.read_bytes()).hexdigest()
records={}
for label,scenario,stem in [('lower','sensor','worldgen-navigation-lower'),('baseline','scripted','worldgen-navigation-fixed'),('upper','sensor','worldgen-navigation-upper'),('center','sensor','worldgen-navigation-center')]:
folder=a.source/label/scenario
assert 'Width: 1440' in (folder/'window.txt').read_text() and 'Height: 900' in (folder/'window.txt').read_text()
r=json.loads((folder/'result.json').read_text());duration=r['duration_wall_s']+.95
output=a.output/(stem+'.mp4')
ff('-ss','0.4','-i',folder/'native-gui.mp4','-t',duration,'-an','-vf','crop=952:536:50:64,scale=960:540',
'-c:v','libx264','-preset','slow','-crf','23','-pix_fmt','yuv420p','-movflags','+faststart',output)
ff('-ss','5','-i',output,'-frames:v','1',a.output/(stem+'.jpg'))
records[stem]={'source_native_sha256':digest(folder/'native-gui.mp4'),'crop_xywh':[50,64,952,536],
'trim_start_s':.4,'speed':1.,'duration_limit_s':duration,'simulation_s':r['duration_sim_s'],
'simulation_wall_s':r['duration_wall_s'],'goal_reached_s':r['goal_reached_s'],'published_sha256':digest(output)}
# The complete sensor take is shown after a 10 s excerpt of the fixed controller.
# A hard cut and persistent labels distinguish separate real simulator runs.
with tempfile.TemporaryDirectory() as directory:
temp=Path(directory)
for lang in ['en','ko']:
font=ImageFont.truetype(a.font if lang=='en' else a.font_ko,25)
labels=['Fixed waypoints | New box blocks the route','Range sensor + A* | Replans from measurements'] if lang=='en' else ['기존 경유점 제어 | 추가 상자에 막힘','거리 센서 + A* | 측정값으로 경로 재계산']
parts=[]
for i,(name,text) in enumerate(zip(['worldgen-navigation-fixed','worldgen-navigation-lower'],labels)):
badge=Image.new('RGBA',(960,48),(247,249,250,235));draw=ImageDraw.Draw(badge)
draw.rectangle((0,0,5,48),fill='#76b900');draw.text((17,9),text,font=font,fill='#1b252b')
png=temp/f'label-{lang}-{i}.png';badge.save(png)
part=temp/f'part-{lang}-{i}.mp4';parts.append(part)
options=['-i',a.output/(name+'.mp4'),'-i',png,'-filter_complex','[0:v][1:v]overlay=0:0:format=auto,format=yuv420p']
if i==0:options+=['-t','10']
ff(*options,'-an','-c:v','libx264','-preset','slow','-crf','23',part)
listing=temp/f'concat-{lang}.txt';listing.write_text(''.join(f"file '{part}'\n" for part in parts))
stem='worldgen-navigation' if lang=='en' else 'worldgen-navigation-ko'
output=a.output/(stem+'.mp4')
ff('-f','concat','-safe','0','-i',listing,'-c','copy','-movflags','+faststart',output)
ff('-ss','13','-i',output,'-frames:v','1',a.output/(stem+'.jpg'))
records[stem]={'edit':'10 s fixed-route excerpt, then complete sensor-lower viewport take; labeled hard cut',
'sources':['worldgen-navigation-fixed','worldgen-navigation-lower'],'speed':1.,'published_sha256':digest(output)}
(a.output/'navigation-edit.json').write_text(json.dumps(records,indent=2)+'\n')
print('Native crops and bilingual sequential comparison packaged at 1× speed.')
plot.py
GitHub에서 파일 보기"""Visualize actual poses and measured hits after the run; no rendered footage."""
import argparse,json
from pathlib import Path
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from matplotlib.patches import Rectangle
from matplotlib.font_manager import FontProperties
p=argparse.ArgumentParser();p.add_argument('--evidence',type=Path,required=True);p.add_argument('--output',type=Path,required=True);p.add_argument('--font');a=p.parse_args();a.output.mkdir(parents=True,exist_ok=True)
if a.font:plt.rcParams['font.family']=FontProperties(fname=a.font).get_name()
plt.rcParams.update({'svg.fonttype':'path','axes.unicode_minus':False,'font.size':10})
for lang in ['en','ko']:
fig,axes=plt.subplots(1,3,figsize=(12,4.4),layout='constrained');fig.patch.set_facecolor('#f5f7f8')
for ax,case,label in zip(axes,['center','lower','upper'],['Central box','Lower route blocked','Upper route blocked'] if lang=='en' else ['중앙 상자','아래쪽 통로 막힘','위쪽 통로 막힘']):
folder=a.evidence/case;r=json.loads((folder/'result.json').read_text());scans=json.loads((folder/'scans.json').read_text())
ax.add_patch(Rectangle((-.225,-.4),.45,.8,color='#eba146',alpha=.8))
if case!='center':ax.add_patch(Rectangle((-.225,-1.25 if case=='lower' else .65),.45,.6,color='#eba146',alpha=.8))
hits=[pt for scan in scans[::10] for d,pt in zip(scan['depths_m'],scan['hit_positions_world']) if d<2.499]
ax.scatter([p[0] for p in hits],[p[1] for p in hits],s=7,c='#5295b7',label='Sensor hits' if lang=='en' else '센서 측정')
points=[s['poses']['/World/Robot/Chassis'][0] for s in r['samples']]
ax.plot([p[0] for p in points],[p[1] for p in points],c='#659f00',lw=2.6,label='Measured robot path' if lang=='en' else '실제 이동 경로')
if case=='lower':
old=json.loads((a.evidence/'baseline/result.json').read_text());points=[s['poses']['/World/Robot/Chassis'][0] for s in old['samples']]
ax.plot([p[0] for p in points],[p[1] for p in points],'--',c='#bc4f38',lw=2,label='Fixed route' if lang=='en' else '기존 제어')
ax.scatter([-1.3,1.3],[0,0],c=['#3b6d8e','#659f00'],s=30)
ax.set(xlim=(-1.75,1.75),ylim=(-1.6,1.6),title=label,xlabel='X (m)');ax.set_aspect('equal');ax.grid(alpha=.17)
for spine in ax.spines.values():spine.set_edgecolor('#d0d5da')
axes[0].set_ylabel('Y (m)');axes[1].legend(loc='lower center',fontsize=8)
fig.suptitle('Recorded sensor hits and physical chassis motion' if lang=='en' else '실제 센서 측정점과 몸체 이동 기록',fontsize=14)
path=a.output/f'paths.{lang}.svg';fig.savefig(path);plt.close(fig)
path.write_text('\n'.join(line.rstrip() for line in path.read_text().splitlines())+'\n')
test_navigation.py
GitHub에서 파일 보기"""Behavior checks for planning from observations, independent of Isaac Sim."""
import math
import unittest
from navigation import Navigator
def observations(lower=False, upper=False):
# A dense synthetic scan of facing surfaces; scene geometry is never an API input.
points = [[-.225, y/100, .48] for y in range(-40, 41, 2)]
if lower:
points += [[-.225, y/100, .48] for y in range(-125, -64, 2)]
if upper:
points += [[-.225, y/100, .48] for y in range(65, 126, 2)]
return [math.dist((-1.3, 0), p[:2]) for p in points], points
class ScanPlanning(unittest.TestCase):
def test_new_observation_changes_route_without_waypoints(self):
nav = Navigator()
nav.update((-1.3, 0, 0), [2.5], [[1.2, 0, .48]], 1.)
self.assertTrue(all(abs(p[1]) < .01 for p in nav.path))
nav.update((-1.3, 0, 0), *observations(), 2.)
self.assertTrue(max(abs(p[1]) for p in nav.path) > .8)
self.assertTrue(all(nav.allowed(nav.cell(p)) for p in nav.path))
def test_side_is_determined_by_measured_obstruction(self):
lower, upper = Navigator(), Navigator()
lower.update((-1.3, 0, 0), *observations(lower=True), 1.)
upper.update((-1.3, 0, 0), *observations(upper=True), 1.)
self.assertGreater(max(p[1] for p in lower.path), .8)
self.assertLess(min(p[1] for p in upper.path), -.8)
def test_missing_or_stale_scan_stops(self):
nav = Navigator()
self.assertEqual(nav.command((-1.3, 0, 0), 2.5, 1.)[:2], (0., 0.))
nav.update((-1.3, 0, 0), [2.5], [[1.2, 0, .48]], 1.)
self.assertEqual(nav.command((-1.3, 0, 0), 2.5, .26)[:2], (0., 0.))
def test_complete_barrier_does_not_produce_a_path(self):
nav = Navigator()
points = [[-.225, y/100, .48] for y in range(-200, 201, 2)]
nav.update((-1.3, 0, 0), [1.]*len(points), points, 1.)
self.assertFalse(nav.path)
self.assertEqual(nav.command((-1.3, 0, 0), 1., 0.)[:2], (0., 0.))
if __name__ == '__main__':
unittest.main()
check.py
GitHub에서 파일 보기"""Validate recorded sensor navigation without NumPy, CUDA or Isaac Sim."""
import argparse
import hashlib
import json
import math
from pathlib import Path
def check_run(folder):
r = json.loads((folder / 'result.json').read_text())
scans = json.loads((folder / 'scans.json').read_text())
assert r['status'] == 'complete' and r['isaacsim_version'].startswith('6.2')
assert r['stage']['meters_per_unit'] == 1 and r['stage']['up_axis'] == 'Z'
assert not r['stage']['render_mesh_collision'] and r['stage']['proxy_floor']
assert r['navigation']['obstacle_transforms_as_input'] is False
samples = r['samples']
path = '/World/Robot/Chassis'
positions = [s['poses'][path][0] for s in samples]
assert all(all(math.isfinite(v) for v in p) and .20 < p[2] < .28 for p in positions)
assert all(abs(p[0]) < 2.1 and abs(p[1]) < 1.6 for p in positions)
assert r['sensor']['scan_frames'] == len(scans)
for previous, current in zip(scans, scans[1:]):
assert current['sensor_time_s'] > previous['sensor_time_s']
assert abs(current['sim_time_s'] - previous['sim_time_s'] - .1) < 1e-5
for frame in scans:
assert len(frame['depths_m']) == len(frame['hit_positions_world']) == 180
assert all(math.isfinite(v) and .05 <= v <= 2.50001 for v in frame['depths_m'])
assert all(len(p) == 3 and all(math.isfinite(v) for v in p) for p in frame['hit_positions_world'])
final = r['final_poses'][path][0]
if r['sensor_off']:
assert not scans and not r['reached_goal']
assert max(math.dist(p[:2], positions[0][:2]) for p in positions) < .01
assert all(s['command'] == [0., 0.] for s in samples)
elif r['scenario'] == 'sensor':
assert len(scans) > 30 and r['reached_goal'] and not r['crate_contact_events']
assert math.dist(final[:2], (1.3, 0)) < .13
assert min(scans[0]['depths_m']) < 1.1
if r['layout'] == 'lower':
assert max(p[1] for p in positions) > .8 and min(p[1] for p in positions) > -.2
else:
assert min(p[1] for p in positions) < -.8
else:
assert r['layout'] == 'lower' and not r['reached_goal'] and r['crate_contact_events']
assert -.6 < final[0] < -.4 and final[1] < -.6
print(folder.name, r['scenario'], r['layout'], 'verified')
return r
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--run', type=Path)
args = parser.parse_args()
if args.run:
check_run(args.run)
return
folder = Path(__file__).resolve().parent
record = json.loads((folder / 'recorded.json').read_text())
for case in record['runs']:
check_run(folder / 'evidence' / case)
root = folder.parents[1]
for name, expected in record['files'].items():
data = (root / name).read_bytes()
assert len(data) == expected['bytes'] and hashlib.sha256(data).hexdigest() == expected['sha256'], name
print('Actual scans, route adaptation, contacts, sensor-off stop and media verified.')
if __name__ == '__main__':
main()




