rabbit-ear
Version:
origami design library
886 lines (885 loc) • 112 kB
TypeScript
export default ear;
/**
* @description Rabbit Ear, the main entrypoint into the library methods
*/
declare const ear: {
__types__: () => void;
axiom: {
validateAxiom1And2: (boundary: [number, number][], point1: [number, number], point2: [number, number]) => boolean[];
validateAxiom3: (boundary: [number, number][], solutions: VecLine2[], line1: VecLine2, line2: VecLine2) => boolean[];
validateAxiom4: (boundary: [number, number][], solutions: VecLine2[], line: VecLine2, point: [number, number]) => boolean[];
validateAxiom5: (boundary: [number, number][], solutions: VecLine2[], line: VecLine2, point1: [number, number], point2: [number, number]) => boolean[];
validateAxiom6: (boundary: [number, number][], solutions: VecLine2[], line1: VecLine2, line2: VecLine2, point1: [number, number], point2: [number, number]) => boolean[];
validateAxiom7: (boundary: [number, number][], solutions: VecLine2[], line1: VecLine2, line2: VecLine2, point: [number, number]) => boolean[];
normalAxiom1InPolygon: (polygon: [number, number][], point1: [number, number], point2: [number, number]) => UniqueLine[];
axiom1InPolygon: (polygon: [number, number][], point1: [number, number], point2: [number, number]) => VecLine2[];
normalAxiom2InPolygon: (polygon: [number, number][], point1: [number, number], point2: [number, number]) => UniqueLine[];
axiom2InPolygon: (polygon: [number, number][], point1: [number, number], point2: [number, number]) => VecLine2[];
normalAxiom3InPolygon: (polygon: [number, number][], line1: UniqueLine, line2: UniqueLine) => UniqueLine[];
axiom3InPolygon: (polygon: [number, number][], line1: VecLine2, line2: VecLine2) => VecLine2[];
normalAxiom4InPolygon: (polygon: [number, number][], line: UniqueLine, point: [number, number]) => UniqueLine[];
axiom4InPolygon: (polygon: [number, number][], line: VecLine2, point: [number, number]) => VecLine2[];
normalAxiom5InPolygon: (polygon: [number, number][], line: UniqueLine, point1: [number, number], point2: [number, number]) => UniqueLine[];
axiom5InPolygon: (polygon: [number, number][], line: VecLine2, point1: [number, number], point2: [number, number]) => VecLine2[];
normalAxiom6InPolygon: (polygon: [number, number][], line1: UniqueLine, line2: UniqueLine, point1: [number, number], point2: [number, number]) => UniqueLine[];
axiom6InPolygon: (polygon: [number, number][], line1: VecLine2, line2: VecLine2, point1: [number, number], point2: [number, number]) => VecLine2[];
normalAxiom7InPolygon: (polygon: [number, number][], line1: UniqueLine, line2: UniqueLine, point: [number, number]) => UniqueLine[];
axiom7InPolygon: (polygon: [number, number][], line1: VecLine2, line2: VecLine2, point: [number, number]) => VecLine2[];
normalAxiom1: (point1: [number, number], point2: [number, number]) => [UniqueLine];
axiom1: (point1: [number, number], point2: [number, number]) => [VecLine2];
normalAxiom2: (point1: [number, number], point2: [number, number]) => [UniqueLine];
axiom2: (point1: [number, number], point2: [number, number]) => [VecLine2];
normalAxiom3: (line1: UniqueLine, line2: UniqueLine) => [UniqueLine?, UniqueLine?];
axiom3: (line1: VecLine2, line2: VecLine2) => [VecLine2?, VecLine2?];
normalAxiom4: (line: UniqueLine, point: [number, number]) => [UniqueLine];
axiom4: ({ vector }: VecLine2, point: [number, number]) => [VecLine2];
normalAxiom5: (line: UniqueLine, point1: [number, number], point2: [number, number]) => [UniqueLine?, UniqueLine?];
axiom5: (line: VecLine2, point1: [number, number], point2: [number, number]) => VecLine2[];
normalAxiom6: (line1: UniqueLine, line2: UniqueLine, point1: [number, number], point2: [number, number]) => UniqueLine[];
axiom6: (line1: VecLine2, line2: VecLine2, point1: [number, number], point2: [number, number]) => VecLine2[];
normalAxiom7: (line1: UniqueLine, line2: UniqueLine, point: [number, number]) => [UniqueLine?];
axiom7: (line1: VecLine2, line2: VecLine2, point: [number, number]) => [VecLine2?];
};
convert: {
parseCSSStyleSheet: (sheet: CSSStyleSheet) => any;
parseStyleElement: (style: SVGStyleElement) => any[];
getStylesheetStyle: (key: any, nodeName: any, attributes: any, sheets?: any[]) => any;
lineToSegments: (line: Element) => [number, number, number, number][];
pathToSegments: (path: Element) => [number, number, number, number][];
polygonToSegments: (polygon: Element) => [number, number, number, number][];
polylineToSegments: (polyline: Element) => [number, number, number, number][];
rectToSegments: (rect: Element) => [number, number, number, number][];
facesVerticesPolygon: (graph: any, options: any) => SVGElement[];
facesEdgesPolygon: (graph: any, options: any) => SVGElement[];
drawFaces: (graph: any, options: any) => SVGElement | SVGElement[];
edgesPaths: (graph: FOLD, options?: any) => SVGElement;
edgesLines: (graph: FOLD, options?: any) => SVGElement;
drawEdges: (graph: any, options: any) => SVGElement;
drawVertices: (graph: any, options?: {}) => SVGElement;
drawBoundaries: (graph: any, options?: {}) => SVGElement;
colorToAssignment: (color: any, customAssignments: any) => any;
opacityToFoldAngle: (opacity: any, assignment: any) => number;
getEdgeStroke: (element: any, attributes: any) => string;
getEdgeOpacity: (element: any, attributes: any) => number;
setKeysAndValues: (el: Element, attributes?: any) => void;
boundingBoxToViewBox: (box: Box) => string;
getViewBox: (graph: FOLD) => string;
getNthPercentileEdgeLength: ({ vertices_coords, edges_vertices, edges_length }: FOLD, n?: number) => number;
getStrokeWidth: (graph: FOLD, vmax?: number) => number;
planarizeGraph: (graph: FOLD, epsilon?: number) => FOLD;
findEpsilonInObject: (graph: FOLD, object: any, key?: string) => number;
invertVertical: (vertices_coords: [number, number][] | [number, number, number][]) => undefined;
invisibleParent: (child: any) => any;
foldToObj: (file: string | FOLD) => string;
renderSVG: (graph: FOLD, element: SVGElement, options?: any) => SVGElement;
foldToSvg: (file: string | FOLD, options?: {
string?: boolean;
vertices?: boolean;
edges?: {
mountain: any;
valley: any;
};
faces?: {
front: any;
back: any;
};
boundaries?: any;
viewBox?: boolean;
strokeWidth?: number;
radius?: number;
}) => string | SVGElement;
svgSegments: (svg: string | Element) => {
element: Element;
attributes?: {
[key: string]: string;
};
segment: [number, number][];
data: {
assignment: string;
foldAngle: string;
};
stroke: string;
opacity: number;
}[];
svgEdgeGraph: (svg: string | Element, options: any) => FOLD;
svgToFold: (file: string | SVGElement, options: any) => FOLD;
opxEdgeGraph: (file: string) => FOLD;
opxToFold: (file: string, options: number | {
epsilon?: number;
invertVertical?: boolean;
}) => FOLD;
objToFold: (file: string) => FOLD;
};
diagram: {
diagramReflectPoint: ({ vector, origin }: VecLine2, point: [number, number]) => [number, number];
axiom1Arrows: ({ vertices_coords }: FOLD, point1: [number, number], point2: [number, number], options: {
vmin?: number;
padding?: number;
}) => Arrow[];
axiom2Arrows: ({ vertices_coords }: FOLD, point1: [number, number], point2: [number, number], options: {
vmin?: number;
padding?: number;
}) => Arrow[];
axiom3Arrows: ({ vertices_coords }: FOLD, line1: VecLine2, line2: VecLine2, options: {
vmin?: number;
padding?: number;
}) => Arrow[];
axiom4Arrows: ({ vertices_coords }: FOLD, line: VecLine2, point: [number, number], options: {
vmin?: number;
padding?: number;
}) => Arrow[];
axiom5Arrows: ({ vertices_coords }: FOLD, line: VecLine2, point1: [number, number], point2: [number, number], options: {
vmin?: number;
padding?: number;
}) => Arrow[];
axiom6Arrows: ({ vertices_coords }: FOLD, line1: VecLine2, line2: VecLine2, point1: [number, number], point2: [number, number], options: {
vmin?: number;
padding?: number;
}) => Arrow[];
axiom7Arrows: ({ vertices_coords }: FOLD, line1: VecLine2, line2: VecLine2, point: [number, number], options: {
vmin?: number;
padding?: number;
}) => Arrow[];
arrowFromSegment: (points: [number, number][], options?: {
vmin?: number;
padding?: number;
}) => Arrow;
arrowFromSegmentInPolygon: (polygon: [number, number][], segment: [number, number][], options?: {
vmin?: number;
padding?: number;
}) => Arrow;
arrowFromLine: (polygon: [number, number][], line: VecLine2, options: {
vmin?: number;
padding?: number;
}) => Arrow;
foldLineArrow: ({ vertices_coords }: FOLD, foldLine: VecLine2, options: {
vmin?: number;
padding?: number;
}) => Arrow;
};
general: {
toCamel: (s: string) => string;
toKebab: (s: string) => string;
capitalized: (s: string) => string;
sortPointsAlongVector: (points: number[][], vector: number[]) => number[];
radialSortUnitVectors2: (vectors: [number, number][]) => number[];
radialSortVectors3: (points: [number, number, number][], vector?: [number, number, number], origin?: [number, number, number]) => number[];
cleanNumber: (number: number, places?: number) => number;
clusterSortedGeneric: (elements: any[], comparison: Function) => number[][];
clusterUnsortedIndices: (indices: any[], comparison: Function) => number[][];
clusterScalars: (numbers: number[], epsilon?: number) => number[][];
clusterRanges: (ranges: [number, number][], epsilon?: number) => number[][];
clusterParallelVectors: (vectors: number[][], epsilon?: number) => number[][];
uniqueElements: (array: number[]) => number[];
nonUniqueElements: (array: any[]) => any[];
uniqueSortedNumbers: (array: number[]) => number[];
epsilonUniqueSortedNumbers: (array: number[], epsilon?: number) => number[];
arrayIntersection: (array1: any[], array2: any[]) => any[];
rotateCircularArray: (array: any[], newStartIndex: number) => any[];
splitCircularArray: (array: any[], indices: [number, number]) => [any[], any[]];
chooseTwoPairs: (array: any[]) => [any, any][];
setDifferenceSortedNumbers: (a: number[], b: number[]) => number[];
setDifferenceSortedEpsilonNumbers: (a: number[], b: number[], epsilon?: number) => number[];
arrayMinimumIndex: (array: any[], map?: Function) => number;
arrayMaximumIndex: (array: any[], map?: Function) => number;
mergeArraysWithHoles: (...arrays: any[][]) => any[];
clustersToReflexiveArrays: (clusters: number[][]) => number[][];
arrayArrayToLookupArray: (array_array: number[][]) => boolean[][];
lookupArrayToArrayArray: (lookupArray: boolean[][]) => number[][];
};
graph: Function & {
validate: (graph: FOLD) => string[];
walkSingleFace: ({ vertices_vertices, vertices_sectors }: FOLDExtended, vertex0: number, vertex1: number, walkedEdges?: any) => {
vertices: number[];
edges: string[];
angles?: number[];
};
walkPlanarFaces: ({ vertices_vertices, vertices_sectors }: FOLDExtended) => {
vertices: number[];
edges: string[];
angles?: number[];
}[];
filterWalkedBoundaryFace: (walkedFaces: {
vertices: number[];
edges: string[];
angles?: number[];
}[]) => {
vertices: number[];
edges: string[];
angles?: number[];
}[];
triangulateConvexFacesVertices: ({ faces_vertices }: FOLD) => number[][];
triangulateNonConvexFacesVertices: ({ vertices_coords, faces_vertices }: FOLD, earcut: any) => number[][];
triangulate: ({ vertices_coords, edges_vertices, edges_assignment, edges_foldAngle, faces_vertices, faceOrders, }: FOLD, earcut: any) => {
result: FOLD;
changes: {
faces?: {
map: number[][];
};
edges?: {
new: number[];
};
};
};
minimumSpanningTrees: (array_array?: number[][], rootIndices?: number[]) => import("./graph/trees.js").BreadthFirstTreeNode[][][];
unitize: (graph: FOLD) => FOLD;
translate2: (graph: FOLD, translation: [number, number] | [number, number, number]) => FOLD;
translate3: (graph: FOLD, translation: [number, number] | [number, number, number]) => FOLD;
translate: (graph: FOLD, translation: [number, number] | [number, number, number]) => FOLD;
scaleUniform2: (graph: FOLD, scaleAmount?: number, origin?: [number, number] | [number, number, number]) => FOLD;
scaleUniform3: (graph: FOLD, scaleAmount?: number, origin?: [number, number] | [number, number, number]) => FOLD;
scaleUniform: (graph: FOLD, scaleAmount?: number, origin?: [number, number] | [number, number, number]) => FOLD;
scale2: (graph: FOLD, scaleAmounts?: [number, number] | [number, number, number], origin?: [number, number] | [number, number, number]) => FOLD;
scale3: (graph: FOLD, scaleAmounts?: [number, number] | [number, number, number], origin?: [number, number] | [number, number, number]) => FOLD;
scale: (graph: FOLD, scaleAmounts?: [number, number] | [number, number, number], origin?: [number, number] | [number, number, number]) => FOLD;
transform: ({ vertices_coords }: FOLD, matrix: number[]) => [number, number] | [number, number, number][];
rotate: (graph: FOLD, angle: number, vector?: number[], origin?: number[]) => FOLD;
rotateX: (graph: FOLD, angle: number, origin?: number[]) => FOLD;
rotateY: (graph: FOLD, angle: number, origin?: number[]) => FOLD;
rotateZ: (graph: FOLD, angle: number, origin?: number[]) => FOLD;
transferPointInFaceBetweenGraphs: (from: FOLD, to: FOLD, face: number, point: [number, number]) => [number, number];
sweepVertices: ({ vertices_coords }: FOLD, axis?: number, epsilon?: number) => {
t: number;
vertices: number[];
}[];
sweepValues: ({ edges_vertices, vertices_edges }: FOLD, values: number[], epsilon?: number) => SweepEvent[];
sweepEdges: ({ vertices_coords, edges_vertices, vertices_edges }: FOLD, axis?: number, epsilon?: number) => SweepEvent[];
sweepFaces: ({ vertices_coords, faces_vertices }: FOLD, axis?: number, epsilon?: number) => SweepEvent[];
sweep: ({ vertices_coords, edges_vertices, faces_vertices, }: FOLD, axis?: number, epsilon?: number) => {
vertices: number[];
t: number;
edges: {
start: number[];
end: number[];
};
faces: {
start: number[];
end: number[];
};
}[];
selfRelationalArraySubset: (array_array: number[][], indices: number[]) => number[][];
subgraphExclusive: (graph: FOLD, indicesToKeep?: any) => FOLD;
subgraph: (graph: FOLD, indicesToKeep?: any) => FOLD;
subgraphWithFaces: (graph: FOLD, faces: number[]) => FOLD;
subgraphWithVertices: (graph: any, vertices?: any[]) => FOLD;
splitGraphWithLineAndPoints: (graph: FOLD, { vector, origin }: VecLine2, lineDomain?: Function, interiorPoints?: [number, number][], epsilon?: number) => import("./graph/split/splitGraph.js").SplitGraphEvent;
splitGraphWithLine: (graph: FOLD, line: VecLine2, epsilon?: number) => import("./graph/split/splitGraph.js").SplitGraphEvent;
splitGraphWithRay: (graph: FOLD, ray: VecLine2, epsilon?: number) => import("./graph/split/splitGraph.js").SplitGraphEvent;
splitGraphWithSegment: (graph: FOLD, segment: [number, number][], epsilon?: number) => import("./graph/split/splitGraph.js").SplitGraphEvent;
splitLineToSegments: ({ vertices_coords, edges_vertices, faces_vertices, faces_edges }: FOLD, { vector, origin }: VecLine2, lineDomain?: Function, interiorPoints?: [number, number][], epsilon?: number) => {
vertices: number[];
edges: LineLineEvent[];
faces: {
vertices: FaceVertexEvent[];
edges: FaceEdgeEvent[];
points: FacePointEvent[];
}[];
segments: {
vertices: any[];
edges_face: number[];
edges_vertices?: any;
};
};
splitLineIntoEdges: ({ vertices_coords, edges_vertices, faces_vertices, faces_edges }: FOLD, line: VecLine2, lineDomain?: Function, interiorPoints?: [number, number][], epsilon?: number) => {
vertices?: number[];
edges_vertices?: number[][];
edges_collinear?: boolean[];
edges_face?: number[];
};
splitFaceWithLeafEdge: (graph: FOLD, face: number, vertexFace: number, vertexLeaf: number, assignment?: string, foldAngle?: number) => {
edge: number;
faces: {};
};
splitFaceWithEdge: (graph: FOLD, face: number, vertices: [number, number], assignment?: string, foldAngle?: number) => {
edge?: number;
faces?: {
map?: (number | number[])[];
new?: number[];
remove?: number;
};
};
splitFace: (graph: FOLD, face: number, vertices: [number, number], assignment?: string, foldAngle?: number) => {
edge?: number;
faces?: {
map?: (number | number[])[];
new?: number[];
remove?: number;
};
};
splitEdge: (graph: FOLD, oldEdge: number, coords?: number[]) => {
vertex: number;
edges: {
map: (number | number[])[];
add: [number, number];
remove: number;
};
};
replace: (graph: FOLD, key: string, replaceIndices: number[]) => number[];
prepareForRenderingWithCycles: (inputGraph: FOLDExtended, { earcut, layerNudge }?: {
earcut?: Function;
layerNudge?: number;
}) => FOLD;
prepareForRendering: (inputGraph: FOLDExtended, { earcut, layerNudge }?: {
earcut?: Function;
layerNudge?: number;
}) => FOLD;
remove: (graph: FOLD, key: string, removeIndices: number[]) => number[];
raycast: (graph: FOLD, ray: VecLine) => void;
populate: (graph: FOLD, options?: any) => FOLD;
pleat: ({ vertices_coords, edges_vertices }: FOLD, lineA: VecLine2, lineB: VecLine2, count: number, epsilon?: number) => [[number, number], [number, number]][][];
pleatEdges: ({ vertices_coords, edges_vertices }: FOLD, edgeA: number, edgeB: number, count: number, epsilon?: number) => number[][][][];
planarizeOverlaps: ({ vertices_coords, vertices_edges, edges_vertices, edges_assignment, edges_foldAngle }: FOLD, epsilon?: number) => {
result: FOLD;
changes: {
vertices: {
map: number[];
};
edges: {
map: number[][];
};
};
};
planarizeMakeFaces: (oldGraph: FOLD, newGraph: FOLD, { edges: { map: edgeNextMap } }: {
edges: {
map: number[][];
};
}) => {
faces_vertices: number[][];
faces_edges: number[][];
faceMap: number[][];
};
planarizeCollinearVertices: (graph: FOLD, epsilon?: number) => {
result: FOLD;
changes: {
vertices: {
map: number[];
};
edges: {
map: number[][];
};
};
};
planarizeCollinearEdges: ({ vertices_coords, edges_vertices, edges_assignment, edges_foldAngle, }: FOLD, epsilon?: number) => {
result: FOLD;
changes: {
vertices: {
map: number[];
};
edges: {
map: number[][];
};
};
};
intersectAllEdges: ({ vertices_coords, vertices_edges, edges_vertices, }: FOLD, epsilon?: number) => {
i: number;
j: number;
a: number;
b: number;
point: [number, number];
}[];
planarizeEdgesVerbose: (graph: FOLD, epsilon?: number) => {
result: FOLD;
changes: {
vertices: {
map: number[][];
};
edges: {
map: number[][];
};
};
};
planarizeEdges: ({ vertices_coords, edges_vertices, edges_assignment, edges_foldAngle, }: FOLD, epsilon?: number) => FOLD;
planarizeVerbose: (graph: FOLD, epsilon?: number) => {
result: FOLD;
changes: {
vertices: {
map: number[][];
};
edges: {
map: number[][];
};
faces: {
map: number[][];
};
};
};
planarize: (graph: FOLD, epsilon?: number) => FOLD;
getFacesFacesOverlap: ({ vertices_coords, faces_vertices, }: FOLD, epsilon?: number) => number[][];
getEdgesEdgesCollinearOverlap: ({ vertices_coords, edges_vertices, }: FOLD, epsilon?: number) => number[][];
getOverlappingComponents: ({ vertices_coords, edges_vertices, faces_vertices, }: FOLD, epsilon?: number) => {
verticesVertices: boolean[][];
verticesEdges: boolean[][];
edgesEdges: boolean[][];
facesVertices: boolean[][];
};
getFacesEdgesOverlap: ({ vertices_coords, edges_vertices, faces_vertices, faces_edges, }: FOLD, epsilon?: number) => number[][];
getEdgesFacesOverlap: ({ vertices_coords, edges_vertices, faces_vertices, faces_edges, }: FOLD, epsilon?: number) => number[][];
faceOrdersSubset: (faceOrders: [number, number, number][], faces: number[]) => [number, number, number][];
overlappingFaceOrdersClusters: ({ faceOrders }: FOLD) => {
clusters_faces: number[][];
clusters_faceOrders: [number, number, number][][];
};
faceOrdersToDirectedEdges: ({ vertices_coords, faces_vertices, faceOrders, faces_normal }: FOLDExtended, rootFace?: number) => [number, number][];
linearizeFaceOrders: ({ vertices_coords, faces_vertices, faceOrders, faces_normal }: FOLDExtended, rootFace?: number) => number[];
linearize2DFaces: ({ vertices_coords, faces_vertices, faceOrders, faces_layer, faces_normal, }: FOLDExtended, rootFace?: number) => number[];
nudgeFacesWithFaceOrders: ({ vertices_coords, faces_vertices, faceOrders, faces_normal: facesNormal, }: FOLDExtended) => {
vector: [number, number, number];
layer: number;
}[];
nudgeFacesWithFacesLayer: ({ faces_layer }: FOLDExtended) => {
vector: [number, number] | [number, number, number];
layer: number;
}[];
makeFacesLayer: ({ vertices_coords, faces_vertices, faceOrders, faces_normal }: FOLDExtended) => number[];
flipFacesLayer: (faces_layer: number[]) => number[];
makeFacesNormal: ({ vertices_coords, faces_vertices }: FOLD) => [number, number, number][];
makeVerticesNormal: ({ vertices_coords, faces_vertices, faces_normal }: FOLDExtended) => number[][];
normalize: (graph: FOLD) => FOLD;
nearestVertex: ({ vertices_coords }: FOLD, point: number[]) => number;
nearestEdge: ({ vertices_coords, edges_vertices }: FOLD, point: number[]) => number;
nearestFace: (graph: FOLD, point: [number, number]) => number;
invertFlatMap: (map: number[]) => number[];
invertArrayToFlatMap: (map: number[][]) => number[];
invertFlatToArrayMap: (map: number[]) => number[][];
invertArrayMap: (map: number[][]) => number[][];
mergeFlatNextmaps: (...maps: number[][]) => number[];
mergeNextmaps: (...maps: (number | number[])[][]) => number[][];
mergeFlatBackmaps: (...maps: number[][]) => number[];
mergeBackmaps: (...maps: (number | number[])[][]) => number[][];
remapKey: (graph: FOLD, key: string, indexMap: number[]) => void;
makeVerticesVertices2D: ({ vertices_coords, vertices_edges, edges_vertices }: FOLD) => number[][];
makeVerticesVerticesFromFaces: ({ vertices_coords, vertices_faces, faces_vertices, }: FOLD) => number[][];
makeVerticesVertices: (graph: FOLD) => number[][];
makeVerticesVerticesUnsorted: ({ vertices_edges, edges_vertices }: FOLD) => number[][];
makeVerticesFacesUnsorted: ({ vertices_coords, vertices_edges, faces_vertices }: FOLD) => number[][];
makeVerticesFaces: ({ vertices_coords, vertices_vertices, faces_vertices }: FOLD) => number[][];
makeVerticesEdgesUnsorted: ({ edges_vertices }: FOLD) => number[][];
makeVerticesEdges: ({ edges_vertices, vertices_vertices }: FOLD) => number[][];
makeVerticesVerticesVector: ({ vertices_coords, vertices_vertices, vertices_edges, vertices_faces, edges_vertices, edges_vector, faces_vertices, }: FOLDExtended) => [number, number][][];
makeVerticesSectors: ({ vertices_coords, vertices_vertices, edges_vertices, edges_vector, }: FOLDExtended) => number[][];
makeVerticesToEdge: ({ edges_vertices }: FOLD, edges?: number[]) => {
[key: string]: number;
};
makeVerticesToFace: ({ faces_vertices }: FOLD, faces?: number[]) => {
[key: string]: number;
};
makeEdgesToFace: ({ faces_edges }: FOLD, faces?: number[]) => {
[key: string]: number;
};
makeFacesVerticesFromEdges: ({ edges_vertices, faces_edges }: FOLD) => number[][];
makeFacesFaces: ({ faces_vertices }: FOLD) => number[][];
makeFacesEdgesFromVertices: ({ edges_vertices, faces_vertices }: FOLD) => number[][];
makePlanarFaces: ({ vertices_coords, vertices_vertices, vertices_edges, vertices_sectors, edges_vertices, edges_vector, }: FOLDExtended) => {
faces_vertices: number[][];
faces_edges: number[][];
faces_sectors: number[][];
};
makeFacesPolygon: ({ vertices_coords, faces_vertices }: FOLD, epsilon?: number) => ([number, number] | [number, number, number])[][];
makeFacesPolygonQuick: ({ vertices_coords, faces_vertices }: FOLD) => ([number, number] | [number, number, number])[][];
makeFacesCentroid2D: ({ vertices_coords, faces_vertices }: FOLD) => [number, number][];
makeFacesCenter2DQuick: ({ vertices_coords, faces_vertices }: FOLD) => [number, number][];
makeFacesCenter3DQuick: ({ vertices_coords, faces_vertices }: FOLD) => [number, number, number][];
makeFacesCenterQuick: ({ vertices_coords, faces_vertices }: FOLD) => [number, number][] | [number, number, number][];
makeEdgesVerticesFromFaces: ({ faces_vertices }: FOLD) => [number, number][];
makeEdgesFoldAngle: ({ edges_assignment }: FOLD) => number[];
makeEdgesFoldAngleFromFaces: ({ vertices_coords, edges_vertices, edges_faces, edges_assignment, faces_vertices, faces_edges, faces_normal, faces_center, }: FOLDExtended) => number[];
makeEdgesFacesUnsorted: ({ edges_vertices, faces_vertices, faces_edges }: FOLD) => number[][];
makeEdgesFaces: ({ vertices_coords, edges_vertices, edges_vector, faces_vertices, faces_edges, faces_center, }: FOLDExtended) => number[][];
makeEdgesEdges: ({ edges_vertices, vertices_edges }: FOLD) => number[][];
makeEdgesAssignmentSimple: ({ edges_foldAngle }: FOLD) => string[];
makeEdgesAssignment: ({ edges_vertices, edges_foldAngle, edges_faces, faces_vertices, faces_edges, }: FOLD) => string[];
makeEdgesCoords: ({ vertices_coords, edges_vertices }: FOLD) => [[number, number] | [number, number, number], [number, number] | [number, number, number]][];
makeEdgesVector: ({ vertices_coords, edges_vertices }: FOLD) => ([number, number] | [number, number, number])[];
makeEdgesLength: ({ vertices_coords, edges_vertices }: FOLD) => number[];
makeEdgesBoundingBox: ({ vertices_coords, edges_vertices, }: FOLD, epsilon?: number) => Box[];
join: (target: FOLD, source: FOLD) => any;
intersectLineVertices: ({ vertices_coords }: FOLD, { vector, origin }: VecLine2, lineDomain?: Function, epsilon?: number) => number[];
intersectLineVerticesEdges: ({ vertices_coords, edges_vertices }: FOLD, { vector, origin }: VecLine2, lineDomain?: Function, epsilon?: number) => {
vertices: number[];
edges: LineLineEvent[];
};
intersectLine: ({ vertices_coords, edges_vertices, faces_vertices, faces_edges }: FOLD, { vector, origin }: VecLine2, lineDomain?: Function, epsilon?: number) => {
vertices: number[];
edges: LineLineEvent[];
faces: (FaceVertexEvent | FaceEdgeEvent)[][];
};
intersectLineAndPoints: ({ vertices_coords, edges_vertices, faces_vertices, faces_edges }: FOLD, { vector, origin }: VecLine2, lineDomain?: Function, interiorPoints?: [number, number][], epsilon?: number) => {
vertices: number[];
edges: LineLineEvent[];
faces: {
vertices: FaceVertexEvent[];
edges: FaceEdgeEvent[];
points: FacePointEvent[];
}[];
};
filterCollinearFacesData: ({ edges_vertices }: FOLD, { vertices, faces }: {
vertices: number[];
edges: LineLineEvent[];
faces: {
vertices: FaceVertexEvent[];
edges: FaceEdgeEvent[];
points: FacePointEvent[];
}[];
}) => void;
explodeFaces: ({ vertices_coords, edges_vertices, edges_assignment, edges_foldAngle, faces_vertices, faces_edges, }: FOLD) => FOLD;
explodeEdges: ({ vertices_coords, edges_vertices, edges_assignment, edges_foldAngle, }: FOLD) => FOLD;
disjointGraphsIndices: (graph: FOLD) => {
vertices: number[];
edges: number[];
faces: number[];
}[];
disjointGraphs: (graph: FOLD) => FOLD[];
topologicalSortQuick: (directedEdges: [number, number][]) => number[];
topologicalSort: (directedEdges: [number, number][]) => number[];
fixCycles: (graph: FOLD) => FOLD;
count: (graph: FOLD, key: string) => number;
countVertices: ({ vertices_coords, vertices_vertices, vertices_edges, vertices_faces, }: FOLD) => number;
countEdges: ({ edges_vertices, edges_faces }: FOLD) => number;
countFaces: ({ faces_vertices, faces_edges, faces_faces }: FOLD) => number;
countImplied: (graph: FOLD, key: string) => number;
countImpliedVertices: (graph: FOLD) => number;
countImpliedEdges: (graph: FOLD) => number;
countImpliedFaces: (graph: FOLD) => number;
connectedComponents: (array_array: number[][]) => number[];
connectedComponentsPairs: (array_array: number[][]) => [number, number][];
clean: (graph: FOLD, epsilon?: number) => any;
boundingBox: ({ vertices_coords }: FOLD, padding?: number) => Box;
boundaryVertices: ({ edges_vertices, edges_assignment }: FOLD) => number[];
boundary: ({ vertices_edges, edges_vertices, edges_assignment }: FOLD) => {
vertices: number[];
edges: number[];
};
boundaries: ({ vertices_edges, edges_vertices, edges_assignment }: FOLD) => {
vertices: number[];
edges: number[];
}[];
boundaryPolygons: ({ vertices_coords, vertices_edges, edges_vertices, edges_assignment, }: FOLD) => ([number, number] | [number, number, number])[][];
boundaryPolygon: ({ vertices_coords, vertices_edges, edges_vertices, edges_assignment, }: FOLD) => ([number, number] | [number, number, number])[];
planarBoundary: ({ vertices_coords, vertices_edges, vertices_vertices, edges_vertices, }: FOLD) => {
vertices: number[];
edges: number[];
};
planarBoundaries: ({ vertices_coords, vertices_edges, vertices_vertices, edges_vertices, }: FOLD) => {
vertices: number[];
edges: number[];
}[];
sortVerticesCounterClockwise: ({ vertices_coords }: FOLD, vertices: number[], vertex: number) => number[];
sortVerticesAlongVector: ({ vertices_coords }: FOLD, vertices: number[], vector: number[]) => number[];
edgeIsolatedVertices: ({ vertices_coords, edges_vertices }: FOLD) => number[];
faceIsolatedVertices: ({ vertices_coords, faces_vertices }: FOLD) => number[];
isolatedVertices: ({ vertices_coords, edges_vertices, faces_vertices }: FOLD) => number[];
removeIsolatedVertices: (graph: FOLD, remove_indices?: number[]) => any;
makeVerticesCoords3DFolded: ({ vertices_coords, vertices_faces, edges_vertices, edges_foldAngle, edges_assignment, faces_vertices, faces_faces, faces_matrix, }: FOLDExtended, rootFaces?: number[]) => [number, number, number][];
makeVerticesCoordsFlatFolded: ({ vertices_coords, edges_vertices, edges_foldAngle, edges_assignment, faces_vertices, faces_faces, }: FOLD, rootFaces?: number[]) => [number, number][];
makeVerticesCoordsFolded: (graph: FOLD, rootFaces?: number[]) => [number, number][] | [number, number, number][];
makeVerticesCoordsFoldedFromMatrix2: ({ vertices_coords, vertices_faces, faces_vertices, }: FOLD, faces_matrix: number[][]) => [number, number][];
duplicateVertices: ({ vertices_coords }: FOLD, epsilon?: number) => number[][];
removeDuplicateVertices: (graph: FOLD, epsilon?: number, makeAverage?: boolean) => {
map: number[];
remove: number[];
};
getOtherVerticesInEdges: ({ edges_vertices }: FOLD, vertex: number, edges: number[]) => number[];
isVertexCollinear: ({ vertices_coords, vertices_edges, edges_vertices, }: FOLD, vertex: number, epsilon?: number) => boolean;
getVerticesClusters: ({ vertices_coords }: FOLD, epsilon?: number) => number[][];
transferPoint: (from: FOLD, to: FOLD, { vertex, edge, face, point, b }: any) => number[];
foldGraphIntoSubgraph: (cp: FOLD, folded: FOLD, line: VecLine2, lineDomain?: Function, interiorPoints?: [number, number][], assignment?: string, foldAngle?: number, epsilon?: number) => {
vertices_coords: number[][];
edges_vertices: number[][];
edges_assignment: string[];
edges_foldAngle: number[];
};
foldGraphIntoSegments: ({ vertices_coords, edges_vertices, edges_foldAngle, edges_assignment, faces_vertices, faces_edges, faces_faces, }: FOLD, { vector, origin }: VecLine2, assignment?: string, epsilon?: number) => {
intersections: (FaceVertexEvent | FaceEdgeEvent)[];
assignment: string;
points: [number, number][];
}[];
foldGraph: (graph: FOLD, { vector, origin }: VecLine2, lineDomain?: Function, interiorPoints?: [number, number][], assignment?: string, foldAngle?: number, vertices_coordsFolded?: [number, number][] | [number, number, number][], epsilon?: number) => import("./graph/fold/foldGraph.js").FoldGraphEvent;
foldLine: (graph: FOLD, line: VecLine2, assignment?: string, foldAngle?: number, vertices_coordsFolded?: [number, number][] | [number, number, number][], epsilon?: number) => import("./graph/fold/foldGraph.js").FoldGraphEvent;
foldRay: (graph: FOLD, ray: VecLine2, assignment?: string, foldAngle?: number, vertices_coordsFolded?: [number, number][] | [number, number, number][], epsilon?: number) => import("./graph/fold/foldGraph.js").FoldGraphEvent;
foldSegment: (graph: FOLD, segment: [[number, number], [number, number]], assignment?: string, foldAngle?: number, vertices_coordsFolded?: [number, number][] | [number, number, number][], epsilon?: number) => import("./graph/fold/foldGraph.js").FoldGraphEvent;
getVerticesCollinearToLine: ({ vertices_coords }: {
vertices_coords: any;
}, { vector, origin }: {
vector: any;
origin: any;
}, epsilon?: number) => any;
getEdgesCollinearToLine: ({ vertices_coords, edges_vertices, vertices_edges }: FOLD, { vector, origin }: VecLine, epsilon?: number) => number[];
flatFold: (graph: FOLDFileMetadata & FOLDFrame & FOLDOutOfSpec & {
faces_matrix2: number[][];
faces_winding: boolean[];
faces_crease: VecLine2[];
faces_side: boolean[];
}, { vector, origin }: VecLine2, assignment?: string, epsilon?: number) => any;
makeFacesWinding: ({ vertices_coords, faces_vertices }: FOLD) => boolean[];
makeFacesWindingFromMatrix: (faces_matrix: number[][]) => boolean[];
makeFacesWindingFromMatrix2: (faces_matrix2: number[][]) => boolean[];
facesSharedEdgesVertices: (verticesA: number[], verticesB: number[]) => number[][];
makeFacesMatrix: ({ vertices_coords, edges_vertices, edges_foldAngle, edges_assignment, faces_vertices, faces_faces, }: FOLD, rootFaces?: number[]) => number[][];
makeFacesMatrix2: ({ vertices_coords, edges_vertices, edges_foldAngle, edges_assignment, faces_vertices, faces_faces, }: FOLD, rootFaces?: number[]) => number[][];
getFacesPlane: ({ vertices_coords, faces_vertices }: FOLD, epsilon?: number) => {
planes: {
normal: number[];
origin: number[];
}[];
planes_faces: number[][];
planes_transform: number[][];
faces_plane: number[];
faces_winding: boolean[];
};
getCoplanarAdjacentOverlappingFaces: ({ vertices_coords, faces_vertices, faces_faces }: FOLD, epsilon?: number) => {
planes: {
normal: number[];
origin: number[];
}[];
planes_faces: number[][];
planes_transform: number[][];
planes_clusters: number[][];
faces_winding: boolean[];
faces_plane: number[];
faces_cluster: number[];
clusters_plane: number[];
clusters_faces: number[][];
};
doEdgesOverlap: ({ vertices_coords, edges_vertices }: FOLD, epsilon?: number) => boolean;
edgeToLine2: ({ vertices_coords, edges_vertices }: FOLD, edge: number) => VecLine2;
edgesToLines: ({ vertices_coords, edges_vertices }: FOLD) => VecLine[];
edgesToLines2: ({ vertices_coords, edges_vertices }: FOLD) => VecLine2[];
edgesToLines3: ({ vertices_coords, edges_vertices }: FOLD) => VecLine3[];
getEdgesLine: ({ vertices_coords, edges_vertices }: FOLD, epsilon?: number) => {
lines: VecLine[];
edges_line: number[];
};
getEdgesLineBruteForce: ({ vertices_coords, edges_vertices }: FOLD, epsilon?: number) => {
lines: VecLine[];
edges_line: number[];
};
duplicateEdges: ({ edges_vertices }: FOLD) => number[];
getSimilarEdges: ({ vertices_coords, vertices_edges, edges_vertices }: FOLD, epsilon?: number) => number[][];
removeDuplicateEdges: (graph: FOLD, replace_indices?: number[]) => {
remove: number[];
map: number[];
};
circularEdges: ({ edges_vertices }: FOLD) => number[];
removeCircularEdges: (graph: FOLD, remove_indices?: number[]) => {
remove: number[];
map: number[];
};
addEdge: (graph: FOLD, vertices: [number, number], faces?: number[], assignment?: string, foldAngle?: number) => number;
addIsolatedEdge: (graph: FOLD, vertices: [number, number], assignment?: string, foldAngle?: number) => number;
addVertex: (graph: FOLD, coords: [number, number] | [number, number, number], vertices?: number[], edges?: number[], faces?: number[]) => number;
addVertices: (graph: FOLD, points?: [number, number][] | [number, number, number][]) => number[];
foldKeys: {
file: string[];
frame: string[];
graph: string[];
orders: string[];
};
foldFileClasses: string[];
foldFrameClasses: string[];
foldFrameAttributes: string[];
VEF: string[];
edgesAssignmentValues: string[];
edgesAssignmentNames: {
B: string;
M: string;
V: string;
F: string;
J: string;
C: string;
U: string;
};
assignmentFlatFoldAngle: {
B: number;
b: number;
M: number;
m: number;
V: number;
v: number;
F: number;
f: number;
J: number;
j: number;
C: number;
c: number;
U: number;
u: number;
};
assignmentCanBeFolded: {
B: boolean;
b: boolean;
M: boolean;
m: boolean;
V: boolean;
v: boolean;
F: boolean;
f: boolean;
J: boolean;
j: boolean;
C: boolean;
c: boolean;
U: boolean;
u: boolean;
};
assignmentIsBoundary: {
B: boolean;
b: boolean;
M: boolean;
m: boolean;
V: boolean;
v: boolean;
F: boolean;
f: boolean;
J: boolean;
j: boolean;
C: boolean;
c: boolean;
U: boolean;
u: boolean;
};
edgeAssignmentToFoldAngle: (assignment: string) => number;
edgeFoldAngleToAssignment: (angle: number) => string;
edgeFoldAngleIsFlatFolded: (angle: number) => boolean;
edgeFoldAngleIsFlat: (angle: number) => boolean;
edgesFoldAngleAreAllFlat: ({ edges_foldAngle }: FOLD) => boolean;
filterKeysWithPrefix: (obj: FOLD, prefix: string) => string[];
filterKeysWithSuffix: (obj: FOLD, suffix: string) => string[];
getAllPrefixes: (obj: FOLD) => string[];
getAllSuffixes: (obj: FOLD) => string[];
transposeGraphArrays: (graph: FOLD, geometry_key: string) => any[];
transposeGraphArrayAtIndex: (graph: FOLD, geometry_key: string, index: number) => any;
isFoldObject: (object?: FOLD) => number;
getDimension: ({ vertices_coords }: FOLD, epsilon?: number) => number;
getDimensionQuick: ({ vertices_coords }: FOLD) => number;
isFoldedForm: ({ vertices_coords, edges_vertices, faces_vertices, faces_edges, frame_classes, file_classes, }: FOLD, epsilon?: number) => boolean;
makeEdgesIsFolded: ({ edges_vertices, edges_foldAngle, edges_assignment }: FOLD) => boolean[];
invertAssignment: (assign: string) => string;
invertAssignments: (graph: FOLD) => FOLD;
sortEdgesByAssignment: ({ edges_vertices, edges_assignment }: FOLD) => {
B?: number[];
V?: number[];
M?: number[];
F?: number[];
J?: number[];
C?: number[];
U?: number[];
};
getFileMetadata: (FOLD?: FOLD) => {
file_spec?: number;
file_creator?: string;
file_author?: string;
file_title?: string;
file_description?: string;
file_classes?: string[];
};
flattenFrame: (graph: FOLD, frameNumber?: number) => FOLD;
getFileFramesAsArray: (graph: FOLD) => FOLD[];
countFrames: ({ file_frames }: FOLD) => number;
getFramesByClassName: (graph: FOLD, className: string) => FOLD[];
assignmentColor: {
B: string;
M: string;
V: string;
F: string;
J: string;
C: string;
U: string;
};
rgbToAssignment: (red?: number, green?: number, blue?: number) => string;
};
layer: ((graph: FOLD, epsilon?: number) => {
count: (this: LayerFork) => any;
structure: (this: LayerFork) => any;
leaves: (this: LayerFork) => any;
gather: (this: LayerFork, ...pattern: number[]) => any;
gatherAll: (this: LayerFork) => {
[key: string]: number;
}[][];
compile: (this: LayerFork, ...pattern: number[]) => any;
compileAll: (this: LayerFork) => {
[key: string]: number;
}[][];
faceOrders: (this: LayerFork, ...pattern: number[]) => any;
}) & {
layer3D: (graph: FOLD, epsilon?: number) => {
count: (this: LayerFork) => any;
structure: (this: LayerFork) => any;
leaves: (this: LayerFork) => any;
gather: (this: LayerFork, ...pattern: number[]) => any;
gatherAll: (this: LayerFork) => {
[key: string]: number;
}[][];
compile: (this: LayerFork, ...pattern: number[]) => any;
compileAll: (this: LayerFork) => {
[key: string]: number;
}[][];
faceOrders: (this: LayerFork, ...pattern: number[]) => any;
};
makeTransitivity: ({ faces_polygon }: FOLDExtended, facesFacesOverlap: number[][], epsilon?: number) => TransitivityConstraint[];
getTransitivityTriosFromTacos: ({ taco_taco, taco_tortilla }: {
taco_taco: TacoTacoConstraint[];
taco_tortilla: TacoTortillaConstraint[];
}) => {
[key: string]: boolean;
};
makeTortillaTortillaFacesCrossing: (edges_faces: number[][], edgesFacesSide: number[][], edgesFacesOverlap: number[][]) => TortillaTortillaConstraint[];
makeTacosAndTortillas: ({ vertices_coords, edges_vertices, edges_faces, faces_vertices, faces_edges, faces_center, }: FOLDExtended, epsilon?: number) => {
taco_taco: TacoTacoConstraint[];
taco_tortilla: TacoTortillaConstraint[];
tortilla_tortilla: TortillaTortillaConstraint[];
};
table: {
taco_taco: {
[key: string]: Readonly<boolean | [number, number]>;
};
taco_tortilla: {
[key: string]: Readonly<boolean | [number, number]>;
};
tortilla_tortilla: {
[key: string]: Readonly<boolean | [number, number]>;
};
transitivity: {
[key: string]: Readonly<boolean | [number, number]>;
};
};
solver: ({ constraints, lookup, facePairs, orders }: {
constraints: {
taco_taco: TacoTacoConstraint[];
taco_tortilla: TacoTortillaConstraint[];
tortilla_tortilla: TortillaTortillaConstraint[];
transitivity: TransitivityConstraint[];
};
lookup: {
taco_taco: number[][];
taco_tortilla: number[][];
tortilla_tortilla: number[][];
transitivity: number[][];
};
facePairs: string[];
orders: {
[key: string]: number;
};
}) => LayerFork;
solveLayerOrders: ({ vertices_coords, edges_vertices, edges_faces, edges_assignment, edges_foldAngle, faces_vertices, faces_edges, faces_faces, edges_vector, }: FOLDExtended, epsilon?: number) => {
orders: {
[key: string]: number;
};
branches?: LayerBranch[];
faces_winding: boolean[];
};
solveLayerOrdersSingleBranches: ({ vertices_coords, edges_vertices, edges_faces, edges_assignment, faces_vertices, faces_edges, edges_vector, }: FOLDExtended, epsilon?: number) => {
orders: {};
faces_winding: any[];
} | {
faces_winding: boolean[];
root: {
[key: string]: number;
};
branches: {
[key: string]: number;
}[][];
orders?: undefined;
};
solveLayerOrders3D: ({ vertices_coords, edges_vertices, edges_faces, edges_assignment, edges_foldAngle, faces_vertices, faces_edges, faces_faces, }: FOLD, epsilon?: number) => {
orders: {
[key: string]: number;
};