transitive-js/dist/graph/edge.d.ts

A tool for generating dynamic stylized transit maps that are easy to understand.

export default class Edge {
    /**
     * Initialize a new edge
     * @constructor
     * @param {Point[]} pointArray - the internal Points for this Edge
     * @param {Vertex} fromVertex
     * @param {Vertex} toVertex
     */
    constructor(pointArray: any[], fromVertex: any, toVertex: any);
    id: number;
    pointArray: any[];
    fromVertex: any;
    toVertex: any;
    pathSegments: any[];
    renderedEdges: any[];
    getId(): number;
    /**
     *
     */
    getLength(): number;
    getWorldLength(): number | undefined;
    getWorldMidpoint(): {
        x: any;
        y: any;
    } | undefined;
    calculateWorldLengthAndMidpoint(): void;
    worldLength: number | undefined;
    worldMidpoint: {
        x: any;
        y: any;
    } | undefined;
    pointsBeforeMidpoint: number | undefined;
    pointsAfterMidpoint: number | undefined;
    /**
     *
     */
    isAxial(): boolean;
    /**
     *
     */
    hasCurvature(): boolean;
    /**
     *
     */
    replaceVertex(oldVertex: any, newVertex: any): void;
    /**
     *  Add a path segment that traverses this edge
     */
    addPathSegment(segment: any): void;
    copyPathSegments(baseEdge: any): void;
    getPathSegmentIds(baseEdge: any): string;
    /**
     *
     */
    addRenderedEdge(rEdge: any): void;
    /** internal geometry functions **/
    calculateGeometry(cellSize: any, angleConstraint: any): void;
    angleConstraintR: number | undefined;
    fx: any;
    fy: any;
    tx: any;
    ty: any;
    constrainedFromAngle: number | undefined;
    fvx: number | undefined;
    fvy: number | undefined;
    constrainedToAngle: number | undefined;
    tvx: number | undefined;
    tvy: number | undefined;
    elbow: {
        x: any;
        y: any;
    } | undefined;
    fromAngle: number | undefined;
    toAngle: number | undefined;
    /**
     *  Adjust the 'to' endpoint angle by rotating it increments of angleConstraintR
     *  until a valid intersection between the from and to endpoint rays is achieved.
     */
    adjustToAngle(): void;
    /**
     *  Adjust the 'from' endpoint angle by rotating it increments of angleConstraintR
     *  until a valid intersection between the from and to endpoint rays is achieved.
     */
    adjustFromAngle(): void;
    computeEndpointIntersection(): {
        intersect: boolean;
        u: number;
        v: number;
    };
    calculateVectors(fromAngle: any, toAngle: any): void;
    fromVector: {
        x: number;
        y: number;
    } | undefined;
    fromleftVector: {
        x: number;
        y: number;
    } | undefined;
    fromRightVector: {
        x: number;
        y: number;
    } | undefined;
    toVector: {
        x: number;
        y: number;
    } | undefined;
    toleftVector: {
        x: number;
        y: number;
    } | undefined;
    toRightVector: {
        x: number;
        y: number;
    } | undefined;
    /**
     *  Compute the 'alignment id', a string that uniquely identifies a line in
     *  2D space given a point and angle relative to the x-axis.
     */
    calculateAlignmentId(x: any, y: any, angle: any): string;
    calculateAlignmentIds(): void;
    fromAlignmentId: string | undefined;
    toAlignmentId: string | undefined;
    hasTransit(cellSize: any): boolean;
    getFromAlignmentId(): string | undefined;
    getToAlignmentId(): string | undefined;
    getAlignmentRange(alignmentId: any): {
        max: number;
        min: number;
    } | null;
    align(vertex: any, vector: any): void;
    curveAngle: any;
    aligned: boolean | undefined;
    getGeometricCoords(fromOffsetPx: any, toOffsetPx: any, display: any, forward: any): any[];
    /**
     * Get render coords for the provided offsets (0 values for offsets imply base
     * render coordinates).
     */
    getRenderCoords(fromOffsetPx: any, toOffsetPx: any, display: any, forward: any): ({
        x: any;
        y: number;
        arc?: undefined;
        ex?: undefined;
        ey?: undefined;
        len?: undefined;
        radius?: undefined;
    } | {
        arc: number;
        ex: any;
        ey: number;
        len: number;
        radius: number;
        x: any;
        y: number;
    } | {
        len: number;
        x: any;
        y: number;
        arc?: undefined;
        ex?: undefined;
        ey?: undefined;
        radius?: undefined;
    } | {
        arc: number;
        len: number;
        radius: number;
        x: number;
        y: number;
        ex?: undefined;
        ey?: undefined;
    })[];
    ccw: number | undefined;
    calculateBaseRenderCoords(display: any): void;
    baseRenderCoords: ({
        x: any;
        y: number;
        arc?: undefined;
        ex?: undefined;
        ey?: undefined;
        len?: undefined;
        radius?: undefined;
    } | {
        arc: number;
        ex: any;
        ey: number;
        len: number;
        radius: number;
        x: any;
        y: number;
    } | {
        len: number;
        x: any;
        y: number;
        arc?: undefined;
        ex?: undefined;
        ey?: undefined;
        radius?: undefined;
    } | {
        arc: number;
        len: number;
        radius: number;
        x: number;
        y: number;
        ex?: undefined;
        ey?: undefined;
    })[] | null | undefined;
    isStraight(): boolean;
    getBaseRadiusPx(): number;
    getElbowAngle(): number;
    getRenderLength(display: any): number;
    renderLength: number | null | undefined;
    /**
     * Retrieve the coordinate located at a defined percentage along an Edge's length.
     * @param {Number} t - a value between 0 and 1 representing the location of the
     *   point to be computed
     * @param {Object[]} coords - the offset coordinates computed for this edge.
     * @param {Display} display
     * @returns {Object} - the coordinate as an {x,y} Object
     */
    coordAlongEdge(t: number, coords: Object[], display: any): Object;
    /**
     * Get coordinate along "offset edge."
     * @param {[type]} t - a value between 0 and 1 representing the location of the
     *   point to be computed
     * @param {Object[]} coords - the offset coordinates computed for this edge.
     * @returns {Object} - the coordinate as an {x,y} Object
     */
    coordAlongOffsetEdge(t: [any], coords: Object[]): Object;
    /**
     * Iterate over reference coordinates (which default to input coords) to find
     * the coordinate along the edge at distance along edge.
     * @param  {[type]} targetDistance - target distance along edge's base geometry
     * @param  {[type]} coords - coordinates for edge
     * @param  {[type]} [refCoordinates=coords] - reference coordinates to use for
     *                                            distance. Defaults to coords.
     * @returns {Object} - the coordinate as an {x,y} Object
     */
    coordAlongRefEdge(targetDistance: [any], coords: [any], refCoordinates?: [any] | undefined): Object;
    clearRenderData(): void;
    getVector(vertex: any): {
        x: number;
        y: number;
    } | undefined;
    /**
     *  Gets the vertex opposite another vertex on an edge
     */
    oppositeVertex(vertex: any): any;
    commonVertex(edge: any): any;
    /**
     *
     */
    setPointLabelPosition(pos: any, skip: any): void;
    /**
     *  Determines if this edge is part of a standalone, non-transit path
     *  (e.g. a walk/bike/drive-only journey)
     */
    isNonTransitPath(): boolean;
    /**
     *
     */
    toString(): string;
}