car_hybrid_astar — GRAPH path op

• 데이터 종류: image2d × matrix → table

• 호출: import fullseye as fs; fs.ledger.car_hybrid_astar(occupancy, poses, radius=1.0, cell=1.0, step=None, n_theta=72, allow_reverse=True, footprint=None, clearance=0.0, reverse_penalty=0.0, switch_penalty=0.0, steer_penalty=0.0, shot_every=None, max_expansions=200000, return_tree=False)(구현을 직접 호출하려면 import carpath; carpath.car_hybrid_astar(occupancy, poses, radius=1.0, cell=1.0, step=None, n_theta=72, allow_reverse=True, footprint=None, clearance=0.0, reverse_penalty=0.0, switch_penalty=0.0, steer_penalty=0.0, shot_every=None, max_expansions=200000, return_tree=False), 원장에서 가져오려면 opsgraph.get("car_hybrid_astar"))

사용법

> 이 연산자의 설명은 아직 번역이 없습니다. 원문을 그대로 싣습니다.

Hybrid A* (Dolgov, Thrun, Montemerlo and Diebel 2010): a car's path through an occupancy grid.

`occupancy is a 2-D grid (> 0.5 = obstacle); cell (row, col)` covers metres

`x in [col*cell, (col+1)*cell), y in [row*cell, (row+1)*cell). poses` is

`[[x, y, theta], [x', y', theta']]` (start, goal) in metres/radians. The car has minimum turning

radius `radius; footprint=(length, width, rear_offset)` is a rectangle in rear-axle coordinates

(`None = point car with clearance` metres kept from obstacles). Motion primitives are

{left, straight, right} × {forward, reverse if `allow_reverse} arcs of step` metres (default

`1.01·sqrt(2)·cell`, so each primitive leaves its cell); states are pruned per discrete cell

`(col, row, theta bin of 2π/n_theta). Cost = path length + reverse_penalty`·(reversed length)

+ `switch_penalty per gear change + steer_penalty` per steering change (all default 0, so the

cost is the geometric length). The heuristic is the obstacle-free Reeds–Shepp length (Dubins when

reversing is disallowed), admissible because every penalty is non-negative. At the start node, and then

every `shot_every expansions (default None = adaptive: a node with cost-to-go h` tries when the

expansion count is a multiple of `ceil(h / step)`, so nodes near the goal try every time, as in the

paper), the shortest analytic path from the node to the goal is collision-checked, and the search ends

when that shot is free. On an obstacle-free grid the first shot succeeds and the result equals the

Reeds–Shepp (Dubins) length exactly; with obstacles the result is never below it (`lower_bound`).

Cell pruning makes Hybrid A* an approximation of the optimum among all feasible paths, as in the paper.

Returns `points (N, 3)` poses along the path (start, tree part, analytic shot to the goal),

`length (metres), cost, lower_bound` (Reeds–Shepp/Dubins length start→goal),

`segments [(kind, gear, length)] of the whole path, n_expanded, n_generated`,

`closed_by_shot (True when the analytic expansion ended the search; False` when the goal cell

itself was popped), `shot_from (pose where the shot started), tree ((K, 3)` expanded poses,

only when `return_tree`).

Raises `ValueError: grid not 2-D or empty; poses not (2, 3)` finite, outside the grid or in

collision; `radius/cell/step not positive, n_theta < 4`, negative penalties; the goal is

unreachable (open set exhausted) or `max_expansions` was hit (reported, never a partial path).

참고(샘플 데이터·문헌)

• 샘플 데이터 카탈로그(DL URL / 라이선스) —— 2-D 는 skimage.data(BSD/public)+ 합성, 3-D 는 실데이터 소스(Stanford/PDS 등)의 DL URL.

• 연산자의 내력·참고문헌 —— 이 연산자 족의 바탕이 된 연구/기법의 출처.

• 알고리즘의 정전(저자·연도)과 용도는 위의 패밀리 사용 가이드에 적혀 있습니다.

실행 가능한 예제(이 연산자를 실제로 호출하는 검증된 샘플)

• poc_car_parking — py -3.11 examples/poc_car_parking.py

• poc_driving_school — py -3.11 examples/poc_driving_school.py

타입이 이어지는 다음 연산자(table 를 입력으로 받는 것)

graph_edge_consensus · graph_core_persistence · tree_morphometry · tree_sholl · tree_run_length

같은 카테고리(path)

car_dubins_path · car_reeds_shepp_path


*Provenance: carpath.py — GRAPH 연산자 레지스트리. 이 op 노트는 tools/opdocs.py md 가 자동 생성합니다(직접 편집하지 마세요).*

© 2026 Kazufumi Furuse — Fullseye operator documentation. Licensed under Apache-2.0.