@grafloria/element 0.3.20 → 0.3.22

package/src/libs/engine/src/routing/algorithms/ElkRouter.d.ts

@@ -1,34 +0,0 @@
-import type { IRouter, RouteRequest, RoutedPath } from '../types';
-/**
- * ElkRouter uses the ELK (Eclipse Layout Kernel) library for intelligent
- * orthogonal edge routing. This provides the same sophisticated routing
- * as React Flow's ELK.js example.
- *
- * Features:
- * - Automatic bend point calculation to avoid nodes
- * - Optimized orthogonal routing
- * - Handles complex graph layouts
- *
- * License: EPL-2.0 (Eclipse Public License 2.0)
- */
-export declare class ElkRouter implements IRouter {
-    private elk?;
-    getName(): string;
-    route(request: RouteRequest): Promise<RoutedPath | null>;
-    /**
-     * Map our direction format to ELK port sides
-     */
-    private mapDirectionToElkSide;
-    /**
-     * Create a simple direct path as fallback
-     */
-    private createDirectPath;
-    /**
-     * Calculate total path length
-     */
-    private calculatePathLength;
-    /**
-     * Calculate path segments
-     */
-    private calculateSegments;
-}

package/src/libs/engine/src/routing/algorithms/ElkRouter.js

@@ -1,210 +0,0 @@
-"use strict";
-// ElkRouter - Uses ELK.js for intelligent orthogonal routing with obstacle avoidance
-// Based on Eclipse Layout Kernel - handles complex graph layouts automatically
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ElkRouter = void 0;
-const tslib_1 = require("tslib");
-const elk_loader_1 = require("../../layout/elk-loader");
-/**
- * ElkRouter uses the ELK (Eclipse Layout Kernel) library for intelligent
- * orthogonal edge routing. This provides the same sophisticated routing
- * as React Flow's ELK.js example.
- *
- * Features:
- * - Automatic bend point calculation to avoid nodes
- * - Optimized orthogonal routing
- * - Handles complex graph layouts
- *
- * License: EPL-2.0 (Eclipse Public License 2.0)
- */
-class ElkRouter {
-    getName() {
-        return 'elk';
-    }
-    route(request) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const { start, end, sourceDirection, targetDirection, obstacles = [] } = request;
-            // Handle same start and end point
-            if (start.x === end.x && start.y === end.y) {
-                return {
-                    points: [{ x: start.x, y: start.y }],
-                    totalLength: 0,
-                    bendCount: 0,
-                    cost: 0,
-                    segments: [],
-                };
-            }
-            try {
-                // CRITICAL: We only want edge routing, not node layout!
-                // Don't pass obstacles as children - ELK will reposition them
-                // Instead, we need a different approach for obstacle avoidance
-                // For now, create a simple graph with just source and target
-                // Future: Use ELK's libavoid algorithm or custom obstacle constraints
-                const sourceNode = {
-                    id: 'source',
-                    x: start.x - 10,
-                    y: start.y - 10,
-                    width: 20,
-                    height: 20,
-                    ports: [{
-                            id: 'source-port',
-                            x: 10,
-                            y: 10,
-                        }],
-                };
-                const targetNode = {
-                    id: 'target',
-                    x: end.x - 10,
-                    y: end.y - 10,
-                    width: 20,
-                    height: 20,
-                    ports: [{
-                            id: 'target-port',
-                            x: 10,
-                            y: 10,
-                        }],
-                };
-                // Create minimal ELK graph for edge routing only
-                const graph = {
-                    id: 'root',
-                    layoutOptions: {
-                        'elk.algorithm': 'fixed', // Use fixed to prevent node repositioning
-                        'elk.edgeRouting': 'ORTHOGONAL',
-                    },
-                    children: [sourceNode, targetNode],
-                    edges: [{
-                            id: 'edge-1',
-                            sources: ['source-port'],
-                            targets: ['target-port'],
-                        }],
-                };
-                // Let ELK calculate the layout (module + instance load lazily on first use)
-                (_a = this.elk) !== null && _a !== void 0 ? _a : (this.elk = new (yield (0, elk_loader_1.loadElk)()).default());
-                const layouted = yield this.elk.layout(graph);
-                // Debug: Log the ELK result
-                console.log('ELK layout result:', JSON.stringify(layouted, null, 2));
-                // Extract edge routing points
-                const edge = (_b = layouted.edges) === null || _b === void 0 ? void 0 : _b[0];
-                if (!edge || !edge.sections || edge.sections.length === 0) {
-                    // Fallback to direct routing
-                    console.warn('ELK did not return edge sections, using fallback');
-                    console.warn('Edge object:', edge);
-                    return this.createDirectPath(start, end);
-                }
-                console.log('ELK edge sections:', edge.sections);
-                // Convert ELK edge sections to our point format
-                // ELK sections contain: startPoint, bendPoints (optional), endPoint
-                const points = [];
-                for (const section of edge.sections) {
-                    // Add section start point
-                    if (section.startPoint) {
-                        points.push({ x: section.startPoint.x, y: section.startPoint.y });
-                    }
-                    // Add all bend points in this section
-                    if (section.bendPoints) {
-                        for (const bendPoint of section.bendPoints) {
-                            points.push({ x: bendPoint.x, y: bendPoint.y });
-                        }
-                    }
-                    // Add section end point (will be start of next section if there are multiple)
-                    if (section.endPoint) {
-                        points.push({ x: section.endPoint.x, y: section.endPoint.y });
-                    }
-                }
-                // Calculate metrics
-                const totalLength = this.calculatePathLength(points);
-                const bendCount = points.length - 2;
-                const result = {
-                    points,
-                    totalLength,
-                    bendCount: Math.max(0, bendCount),
-                    cost: totalLength + bendCount * 10,
-                    segments: this.calculateSegments(points),
-                };
-                console.log('ELK routing result:', result);
-                console.log('Points:', points.map(p => `(${p.x.toFixed(1)}, ${p.y.toFixed(1)})`).join(' -> '));
-                return result;
-            }
-            catch (error) {
-                console.error('ELK routing failed:', error);
-                // Fallback to direct path
-                return this.createDirectPath(start, end);
-            }
-        });
-    }
-    /**
-     * Map our direction format to ELK port sides
-     */
-    mapDirectionToElkSide(direction) {
-        switch (direction) {
-            case 'top':
-                return 'NORTH';
-            case 'bottom':
-                return 'SOUTH';
-            case 'left':
-                return 'WEST';
-            case 'right':
-                return 'EAST';
-            default:
-                return 'EAST';
-        }
-    }
-    /**
-     * Create a simple direct path as fallback
-     */
-    createDirectPath(start, end) {
-        const points = [start, end];
-        const totalLength = this.calculatePathLength(points);
-        const dx = end.x - start.x;
-        const dy = end.y - start.y;
-        const angle = (Math.atan2(dy, dx) * 180) / Math.PI;
-        return {
-            points,
-            totalLength,
-            bendCount: 0,
-            cost: totalLength,
-            segments: [{
-                    start,
-                    end,
-                    length: totalLength,
-                    angle,
-                }],
-        };
-    }
-    /**
-     * Calculate total path length
-     */
-    calculatePathLength(points) {
-        let length = 0;
-        for (let i = 1; i < points.length; i++) {
-            const dx = points[i].x - points[i - 1].x;
-            const dy = points[i].y - points[i - 1].y;
-            length += Math.sqrt(dx * dx + dy * dy);
-        }
-        return length;
-    }
-    /**
-     * Calculate path segments
-     */
-    calculateSegments(points) {
-        const segments = [];
-        for (let i = 1; i < points.length; i++) {
-            const start = points[i - 1];
-            const end = points[i];
-            const dx = end.x - start.x;
-            const dy = end.y - start.y;
-            const length = Math.sqrt(dx * dx + dy * dy);
-            const angle = (Math.atan2(dy, dx) * 180) / Math.PI;
-            segments.push({
-                start,
-                end,
-                length,
-                angle,
-            });
-        }
-        return segments;
-    }
-}
-exports.ElkRouter = ElkRouter;
-//# sourceMappingURL=ElkRouter.js.map

package/src/libs/engine/src/routing/algorithms/ManhattanRouter.d.ts

@@ -1,18 +0,0 @@
-import type { IRouter, RouteRequest, RoutedPath } from '../types';
-export declare class ManhattanRouter implements IRouter {
-    getName(): string;
-    route(request: RouteRequest): RoutedPath | null;
-    private search;
-    private blocked;
-    private inflate;
-    /**
-     * Orthogonal connection between two (possibly off-grid vs on-grid) points.
-     * Returns the INTERIOR joint(s) only — the endpoints themselves are already
-     * in the path. Prefers continuing along `preferSide`'s axis first so the join
-     * doesn't immediately break the stub's perpendicularity.
-     */
-    private orthogonalJoin;
-    private cleanup;
-    private pathLength;
-    private segments;
-}

package/src/libs/engine/src/routing/algorithms/ManhattanRouter.js

@@ -1,224 +0,0 @@
-"use strict";
-// Wave 5 (Edge routing) — Card 3: Manhattan router with JointJS+-parity knobs.
-//
-// A first-class GRID router: A* over grid cells where the search state carries
-// the entry DIRECTION, so turns are explicit moves — they cost extra (the bend
-// penalty), U-turns are forbidden outright, and every produced path is
-// orthogonal BY CONSTRUCTION rather than by post-rectification.
-//
-// The knobs, mapped onto the existing RoutingOptions vocabulary so callers
-// don't learn a second config language:
-//
-//   step                  → options.gridSize        (default 20)
-//   obstacle padding      → options.obstacleMargin  (default 10)
-//   maximumLoops          → options.maxIterations   (default 10000 expansions)
-//   turn penalty          → options.costs.bends     (default 10)
-//   perpendicular ends    → options.jetty           (default = step; Manhattan
-//                           ALWAYS stubs — that is what makes it Manhattan)
-//
-// Exhausting the loop cap returns null — the caller's fallback chain (the
-// renderer falls back to the plain orthogonal route) handles it, which is the
-// same contract JointJS+'s fallbackRoute serves.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManhattanRouter = void 0;
-const OrthogonalRouter_1 = require("./OrthogonalRouter");
-const DIR_VECTORS = {
-    left: { x: -1, y: 0 },
-    right: { x: 1, y: 0 },
-    top: { x: 0, y: -1 },
-    bottom: { x: 0, y: 1 },
-};
-/** The four grid moves, indexed so opposites are (i + 2) % 4 — the U-turn test. */
-const MOVES = [
-    { dx: 1, dy: 0, side: 'right' },
-    { dx: 0, dy: 1, side: 'bottom' },
-    { dx: -1, dy: 0, side: 'left' },
-    { dx: 0, dy: -1, side: 'top' },
-];
-class ManhattanRouter {
-    getName() {
-        return 'manhattan';
-    }
-    route(request) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-        const { start, end, sourceDirection, targetDirection } = request;
-        const obstacles = (_a = request.obstacles) !== null && _a !== void 0 ? _a : [];
-        const options = (_b = request.options) !== null && _b !== void 0 ? _b : {};
-        const step = Math.max(1, (_c = options.gridSize) !== null && _c !== void 0 ? _c : 20);
-        const padding = (_d = options.obstacleMargin) !== null && _d !== void 0 ? _d : 10;
-        const maxLoops = (_e = options.maxIterations) !== null && _e !== void 0 ? _e : 10000;
-        const bendCost = (_g = (_f = options.costs) === null || _f === void 0 ? void 0 : _f.bends) !== null && _g !== void 0 ? _g : 10;
-        // Manhattan ALWAYS leaves perpendicular: an unset jetty defaults to one step.
-        const jetty = (_h = options.jetty) !== null && _h !== void 0 ? _h : step;
-        const srcSide = sourceDirection !== null && sourceDirection !== void 0 ? sourceDirection : OrthogonalRouter_1.OrthogonalRouter.deriveExitSide(start, end);
-        const tgtSide = targetDirection !== null && targetDirection !== void 0 ? targetDirection : OrthogonalRouter_1.OrthogonalRouter.deriveExitSide(end, start);
-        // Stub points: the search runs between them; the anchors join at the end.
-        const sv = DIR_VECTORS[srcSide];
-        const tv = DIR_VECTORS[tgtSide];
-        const sStub = { x: start.x + sv.x * jetty, y: start.y + sv.y * jetty };
-        const tStub = { x: end.x + tv.x * jetty, y: end.y + tv.y * jetty };
-        const inflated = obstacles.map((o) => this.inflate(o, padding));
-        // Card 6: soft containment — steps OUTSIDE the container cost extra, so a
-        // sibling edge stays inside its group when an inside route exists, without
-        // making escape impossible when obstacles force it.
-        const container = options.container;
-        const containerPenalty = (_j = options.containerPenalty) !== null && _j !== void 0 ? _j : 2 * step;
-        const gridPath = this.search(sStub, tStub, srcSide, inflated, step, bendCost, maxLoops, container, containerPenalty);
-        if (!gridPath)
-            return null;
-        // anchor → stub → (orthogonal joins) grid path (orthogonal joins) → stub → anchor
-        const pts = [
-            Object.assign({}, start),
-            sStub,
-            ...this.orthogonalJoin(sStub, gridPath[0], srcSide),
-            ...gridPath,
-            ...this.orthogonalJoin(gridPath[gridPath.length - 1], tStub, undefined),
-            tStub,
-            Object.assign({}, end),
-        ];
-        const cleaned = this.cleanup(pts);
-        const totalLength = this.pathLength(cleaned);
-        const bendCount = Math.max(0, cleaned.length - 2);
-        return {
-            points: cleaned,
-            totalLength,
-            bendCount,
-            cost: totalLength + bendCount * bendCost,
-            segments: this.segments(cleaned),
-        };
-    }
-    // ------------------------------------------------------------------ search
-    search(from, to, startSide, obstacles, step, bendCost, maxLoops, container, containerPenalty = 0) {
-        const sx = Math.round(from.x / step);
-        const sy = Math.round(from.y / step);
-        const tx = Math.round(to.x / step);
-        const ty = Math.round(to.y / step);
-        const startMove = MOVES.findIndex((m) => m.side === startSide);
-        const h = (x, y) => (Math.abs(x - tx) + Math.abs(y - ty)) * step;
-        const open = [
-            { x: sx, y: sy, move: startMove, g: 0, f: h(sx, sy), parent: null },
-        ];
-        // best g seen per (cell, entry-direction) — direction is part of the state,
-        // which is exactly what makes turns first-class.
-        const best = new Map();
-        best.set(`${sx},${sy},${startMove}`, 0);
-        let expansions = 0;
-        while (open.length > 0) {
-            if (++expansions > maxLoops)
-                return null; // maximumLoops: give up honestly
-            // extract-min (open sets stay small at these grid sizes; a heap would be
-            // an optimisation, not a correctness change)
-            let bi = 0;
-            for (let i = 1; i < open.length; i++)
-                if (open[i].f < open[bi].f)
-                    bi = i;
-            const node = open.splice(bi, 1)[0];
-            if (node.x === tx && node.y === ty) {
-                const cells = [];
-                let cur = node;
-                while (cur) {
-                    cells.push({ x: cur.x * step, y: cur.y * step });
-                    cur = cur.parent;
-                }
-                return cells.reverse();
-            }
-            for (let mi = 0; mi < MOVES.length; mi++) {
-                // U-turns are forbidden: a 180° flip is never a legal Manhattan move.
-                if (node.move >= 0 && mi === (node.move + 2) % 4)
-                    continue;
-                const m = MOVES[mi];
-                const nx = node.x + m.dx;
-                const ny = node.y + m.dy;
-                const wx = nx * step;
-                const wy = ny * step;
-                // the TARGET cell is always enterable (ports sit at node edges whose
-                // inflated obstacle covers them); everything else respects obstacles
-                if (!(nx === tx && ny === ty) && this.blocked(wx, wy, obstacles))
-                    continue;
-                const turn = node.move >= 0 && mi !== node.move ? bendCost : 0;
-                // Card 6: leaving the container is allowed but costs.
-                const outside = container !== undefined &&
-                    (wx < container.x || wx > container.x + container.width ||
-                        wy < container.y || wy > container.y + container.height)
-                    ? containerPenalty
-                    : 0;
-                const g = node.g + step + turn + outside;
-                const key = `${nx},${ny},${mi}`;
-                const known = best.get(key);
-                if (known !== undefined && known <= g)
-                    continue;
-                best.set(key, g);
-                open.push({ x: nx, y: ny, move: mi, g, f: g + h(nx, ny), parent: node });
-            }
-        }
-        return null;
-    }
-    blocked(x, y, obstacles) {
-        for (const o of obstacles) {
-            if (x >= o.x && x <= o.x + o.width && y >= o.y && y <= o.y + o.height)
-                return true;
-        }
-        return false;
-    }
-    inflate(o, padding) {
-        var _a;
-        const m = padding + ((_a = o.margin) !== null && _a !== void 0 ? _a : 0);
-        return { id: o.id, x: o.x - m, y: o.y - m, width: o.width + 2 * m, height: o.height + 2 * m };
-    }
-    // ------------------------------------------------------------------ joins
-    /**
-     * Orthogonal connection between two (possibly off-grid vs on-grid) points.
-     * Returns the INTERIOR joint(s) only — the endpoints themselves are already
-     * in the path. Prefers continuing along `preferSide`'s axis first so the join
-     * doesn't immediately break the stub's perpendicularity.
-     */
-    orthogonalJoin(a, b, preferSide) {
-        if (a.x === b.x || a.y === b.y)
-            return [];
-        const preferHorizontalFirst = preferSide === 'left' || preferSide === 'right';
-        return preferHorizontalFirst ? [{ x: b.x, y: a.y }] : [{ x: a.x, y: b.y }];
-    }
-    cleanup(pts) {
-        // dedupe
-        const dedup = [];
-        for (const p of pts) {
-            const last = dedup[dedup.length - 1];
-            if (!last || last.x !== p.x || last.y !== p.y)
-                dedup.push(Object.assign({}, p));
-        }
-        // merge collinear runs (also swallows out-and-back retraces on the same line)
-        const out = [];
-        for (const p of dedup) {
-            while (out.length >= 2) {
-                const a = out[out.length - 2];
-                const b = out[out.length - 1];
-                const collinear = (a.x === b.x && b.x === p.x) || (a.y === b.y && b.y === p.y);
-                if (collinear)
-                    out.pop();
-                else
-                    break;
-            }
-            out.push(p);
-        }
-        return out;
-    }
-    pathLength(pts) {
-        let len = 0;
-        for (let i = 1; i < pts.length; i++) {
-            len += Math.abs(pts[i].x - pts[i - 1].x) + Math.abs(pts[i].y - pts[i - 1].y);
-        }
-        return len;
-    }
-    segments(pts) {
-        const segs = [];
-        for (let i = 1; i < pts.length; i++) {
-            const s = pts[i - 1];
-            const e = pts[i];
-            const length = Math.hypot(e.x - s.x, e.y - s.y);
-            segs.push({ start: s, end: e, length, angle: (Math.atan2(e.y - s.y, e.x - s.x) * 180) / Math.PI });
-        }
-        return segs;
-    }
-}
-exports.ManhattanRouter = ManhattanRouter;
-//# sourceMappingURL=ManhattanRouter.js.map

package/src/libs/engine/src/routing/algorithms/OrthogonalRouter.d.ts

@@ -1,173 +0,0 @@
-import type { IRouter, RouteRequest, RoutedPath } from '../types';
-import type { Point } from '../../types';
-/**
- * OrthogonalRouter creates paths with only 90-degree angles
- * Supports obstacle avoidance using A* on a grid
- */
-export declare class OrthogonalRouter implements IRouter {
-    /**
-     * Wave 8 — Card 6: indexes memoised on the obstacle ARRAY's identity, so the
-     * whole frame's links share one index instead of rebuilding it per link.
-     * Weak, so an obstacle set dies with the frame that made it.
-     */
-    private static readonly indexCache;
-    /**
-     * The index for this obstacle set: the caller's if it prepared one (the
-     * engine does), otherwise ours. Returns null for a set small enough that
-     * scanning it is genuinely cheaper.
-     */
-    private static indexFor;
-    getName(): string;
-    route(request: RouteRequest): RoutedPath | null;
-    /**
-     * Card 1: the exit side a FLOATING anchor should use, derived from where the
-     * other endpoint is — dominant axis first, ties break horizontal (matching
-     * the midline fallback's own axis choice, so the derived route agrees with
-     * what the undirected route would have preferred).
-     */
-    static deriveExitSide(from: Point, toward: Point): 'left' | 'right' | 'top' | 'bottom';
-    /**
-     * Card 1: guarantee the route leaves/enters PERPENDICULAR to the port side
-     * for at least `jetty` px before the first/after the last bend.
-     *
-     * The simple route's gap logic shrinks stubs on short links (its gapOffset
-     * clamp), and the A* grid can snap the first elbow closer than the stub — so
-     * the guarantee is enforced as a post-pass: if the first segment along the
-     * port direction is shorter than the jetty (or points the wrong way), a stub
-     * point is inserted at start + dir·jetty and the joint is re-orthogonalised
-     * by routing the old interior through the stub's far ordinate. Same for the
-     * target end, mirrored.
-     */
-    private enforceJetty;
-    /**
-     * Simple orthogonal route - exact implementation of React Flow's getSmoothStepPath
-     * Based on React Flow's smoothstep-edge.ts getPoints() function
-     * Handles all edge cases: opposite ports, same ports, mixed ports
-     *
-     * CRITICAL: The offset determines how far the line moves away from the port
-     * before making turns. A larger offset creates more spacing from nodes.
-     */
-    private simpleOrthogonalRoute;
-    /**
-     * Merge collinear consecutive points. Because the kept path lies on the
-     * same line the removed points did, this also collapses out-and-back
-     * excursions (backtracking stubs) without changing route coverage.
-     */
-    private mergeCollinearPoints;
-    /**
-     * Check if we can use a direct straight line between ports
-     * This happens when ports are aligned and facing each other directly
-     */
-    private canUseDirectLine;
-    /**
-     * Simplify orthogonal path by removing redundant collinear points
-     * ONLY removes points that are on the same straight line (horizontal or vertical)
-     * This preserves proper orthogonal (right-angle) routing
-     */
-    private simplifyOrthogonalPath;
-    /**
-     * Apply gap offset in the direction the port points
-     */
-    private applyGapOffset;
-    /**
-     * Get direction vector for a port direction (React Flow style)
-     */
-    private getDirectionVector;
-    /**
-     * Determine routing direction based on source/target positions (React Flow logic)
-     */
-    private getRoutingDirection;
-    /**
-     * Determine if we need Z-shape routing (vs L-shape)
-     * Z-shape is needed when ports point toward each other or in same direction
-     */
-    private needsZShape;
-    /**
-     * Calculate L-shape midpoint (one bend)
-     */
-    private calculateLShapeMidpoint;
-    /**
-     * Calculate Z-shape midpoints (two bends)
-     */
-    private calculateZShapeMidpoints;
-    /**
-     * Orthogonal routing with obstacle avoidance using A*
-     */
-    private avoidObstaclesRoute;
-    /**
-     * A* pathfinding on a grid with improved obstacle avoidance
-     */
-    private aStarPathfinding;
-    /**
-     * Reconstruct path from A* came-from map
-     */
-    private reconstructPath;
-    /**
-     * Manhattan distance heuristic
-     */
-    private heuristic;
-    /**
-     * Get 4-directional orthogonal neighbors
-     */
-    private getOrthogonalNeighbors;
-    /**
-     * Check if point collides with any obstacle
-     * FIXED: Use inclusive bounds to prevent paths grazing obstacle edges
-     */
-    private collidesWithObstacles;
-    /**
-     * Check if any segment of the path intersects with obstacles
-     * This determines if we need to use A* pathfinding
-     */
-    private pathIntersectsObstacles;
-    /**
-     * Check if a line segment intersects with a rectangle
-     */
-    private lineIntersectsRectangle;
-    /**
-     * Check if a point is inside a rectangle
-     */
-    private pointInRectangle;
-    /**
-     * Check if two line segments intersect
-     * Using the cross product method
-     */
-    private lineSegmentsIntersect;
-    /**
-     * Snap point to grid
-     */
-    private snapToGrid;
-    /**
-     * Find nearest valid point outside obstacles
-     * Searches outward from point in the given direction until finding a valid position
-     */
-    private findNearestValidPoint;
-    /**
-     * Convert point to map key
-     */
-    private pointToKey;
-    /**
-     * Convert map key to point
-     */
-    private keyToPoint;
-    /**
-     * Calculate total path length
-     */
-    private calculatePathLength;
-    /**
-     * Count bends in path
-     */
-    private countBends;
-    /**
-     * Get direction between two points ('h' or 'v')
-     */
-    private getDirection;
-    /**
-     * Remove duplicate consecutive points
-     */
-    private removeDuplicatePoints;
-    /**
-     * Calculate segments from points
-     */
-    private calculateSegments;
-}