libavoided-js

Deterministic orthogonal edge router with obstacle avoidance. Zero dependencies.

Install

npm install libavoided-js

Quick Example

import { routeEdges } from 'libavoided-js';

const result = routeEdges({
  obstacles: [
    { id: 'A', x: 0, y: 0, width: 100, height: 60 },
    { id: 'B', x: 300, y: 0, width: 100, height: 60 },
  ],
  edges: [{
    id: 'e1',
    sourceId: 'A',
    targetId: 'B',
    sourcePoint: { x: 100, y: 30 },
    targetPoint: { x: 300, y: 30 },
  }],
}, {
  obstacleMargin: 10,
  bendPenalty: 50,
});

const section = result.edges[0].sections[0];
// section.startPoint, section.bendPoints, section.endPoint

Compat API

An OOP adapter matching libavoid's class names and method signatures is available at libavoided-js/compat.

import {
  Router, ShapeRef, ConnRef, ConnEnd,
  Rectangle, RouterFlag, ConnDirFlag, RoutingParameter,
} from 'libavoided-js/compat';

const router = new Router(RouterFlag.OrthogonalRouting);
router.setRoutingParameter(RoutingParameter.shapeBufferDistance, 10);

const s1 = new ShapeRef(router, new Rectangle({ x: 0, y: 0 }, { x: 100, y: 60 }));
const s2 = new ShapeRef(router, new Rectangle({ x: 300, y: 0 }, { x: 400, y: 60 }));

const conn = new ConnRef(
  router,
  new ConnEnd({ x: 100, y: 30 }, ConnDirFlag.Right),
  new ConnEnd({ x: 300, y: 30 }, ConnDirFlag.Left),
);

router.processTransaction();

const route = conn.route(); // PolyLine
// route.ps → [{x, y}, ...]

API Reference

Core (libavoided-js)

routeEdges(input, options?)

Routes all edges, returning orthogonal paths that avoid obstacles.

• input — { obstacles: Obstacle[], edges: EdgeRequest[] }
• options — RouterOptions (all optional)
• returns — { edges: RoutedEdge[] }

routeEdgesIncremental(input, previousInput, previousOutput, options?)

Incremental routing that reuses unchanged edges from a previous result.

Types

| Type | Fields | |------|--------| | Obstacle | id, x, y, width, height | | EdgeRequest | id, sourceId, targetId, sourcePoint, targetPoint, sourceDirection?, targetDirection?, pinnedWaypoints?, previousPath? | | RoutedEdge | id, sections[] — each with startPoint, endPoint, bendPoints[], incomingShape, outgoingShape | | CardinalDirection | 'up' \| 'down' \| 'left' \| 'right' |

RouterOptions

| Option | Default | Description | |--------|---------|-------------| | obstacleMargin | 10 | Buffer around obstacles | | edgeSpacing | 8 | Space between parallel segments | | bendPenalty | 50 | Cost per direction change | | crossingPenalty | 200 | Cost per edge crossing | | lengthPenalty | 1 | Cost multiplier for segment length |

Compat (libavoided-js/compat)

OOP facade with libavoid-compatible class names.

| Class | Description | |-------|-------------| | Router(flag) | Main router. Call processTransaction() to route. | | ShapeRef(router, polygon) | Obstacle shape. Auto-registers with router. | | ConnRef(router, srcEnd, dstEnd) | Connector. Call route() after processing. | | ConnEnd(point, directions?) | Connection endpoint with optional direction constraint. | | Rectangle(topLeft, bottomRight) | Axis-aligned rectangle. | | Polygon(points?) | Arbitrary polygon (bounding box used for routing). | | PolyLine(points?) | Routed path result. |

| Enum | Values | |------|--------| | RouterFlag | OrthogonalRouting = 2 | | ConnDirFlag | None, Up, Down, Left, Right, All | | RoutingParameter | segmentPenalty, crossingPenalty, shapeBufferDistance, idealNudgingDistance, ... |

License

MIT