plebeiangraphlibrary 2.0.1 → 2.1.2

package/Build/Core/Edge.d.ts

@@ -0,0 +1,20 @@
+interface Edge {
+    start: number;
+    end: number;
+    data: any;
+}
+/**
+ * Edge class: connects two nodes by start/end IDs; can hold optional data (e.g. "ldata" for line geometry).
+ */
+declare class Edge {
+    /**
+     *
+     * Construct an edge
+     *
+     * @param start Start index of the edge based on the array of nodes
+     * @param end End index of the edge based on the array of nodes
+     * @param data - Optional data; "ldata" is reserved for line geometry used when drawing the edge
+     */
+    constructor(start: number, end: number, data: any);
+}
+export default Edge;

package/Build/Core/Graph.d.ts

@@ -0,0 +1,114 @@
+import { default as Line } from '../HelperClasses/Line';
+import { default as Point } from '../HelperClasses/Point';
+import { default as _Node } from './_Node';
+import { default as Edge } from './Edge';
+interface Graph {
+    nodes: Map<number, _Node>;
+    edges: Map<number, Edge>;
+}
+/**
+ * The main graph object: contains nodes and edges that get modified with different
+ * operations (layout, clustering, etc.).
+ */
+declare class Graph {
+    /**
+     *
+     * Construct a graph object (no initializing)
+     *
+     * @param nodes - Map of all the nodes associated with the graph
+     * @param edges - Map of all the edges associated with the graph
+     */
+    constructor(nodes: Map<number, _Node>, edges: Map<number, Edge>);
+    /**
+     * Prints out a snapshot of data associated with this graph like how many nodes and how many edges
+     */
+    printData(): void;
+    /**
+     * Initializes the graph and constructs the node adjacency list.
+     */
+    initialize(): Promise<void>;
+    /**
+     *
+     * This is the official create method to make a graph based on a set of nodes and edges
+     * It also auto-initializes the graph and sets all the adjacency lists in memory.
+     *
+     * @param nodes - map of nodes
+     * @param edges - map of edges
+     * @returns
+     */
+    static create(nodes: Map<number, _Node>, edges: Map<number, Edge>): Promise<Graph>;
+    /**
+     * Constructs the adjacency associated with the graph
+     */
+    constructAdjacencyList(): Promise<void>;
+    /**
+     * Add a node to the graph.
+     * @param nodeID - The node ID
+     * @param data - Data associated with the node
+     */
+    add_node(nodeID: number, data: _Node): void;
+    /**
+     * Add an edge to the graph
+     * @param start - Starting index of the edge
+     * @param end - The end index of the edge
+     * @param data - data associated with the edge
+     */
+    add_edge(start: number, end: number, data: any): void;
+    /**
+     *
+     * @returns The adjacency lists associated with the graph
+     */
+    get_adjacency(): Map<number, number[]>;
+    /**
+     * Apply a position map based on some data
+     * @param data - the position map that has to be applied to the graph
+     */
+    apply_position_map(data: Map<number, Point>): void;
+    /**
+     * Apply an line map to a graph
+     * @param data Line data that has to be applied to the graph
+     */
+    apply_edge_pos_maps(data: Map<number, Line>): void;
+    /**
+     * get the current edge map
+     * @returns The current set of edges associated with the graph
+     */
+    get_edge_map(): Map<number, Line>;
+    /**
+     * Applies all the maps to the graph
+     * @param layout - Applies an object of maps associated with a graph: {pmap:(the position map), emap:(the edge map)}
+     */
+    apply_drawing_maps(layout: {
+        pmap: Map<number, Point>;
+        emap: Map<number, Line>;
+    }): void;
+    /**
+     * Gets the position map and the edge map respectively
+     * @returns The position map and the edge map as pmap and emap
+     */
+    get_map(): {
+        pmap: Map<number, Point>;
+        emap: Map<number, Line>;
+    };
+    /**
+     * Get the position of the nodes in the graph.
+     * @returns The position map (node ID to Point)
+     */
+    get_position_map(): Map<number, Point>;
+    /**
+     * Returns a deterministic order of node IDs (same as iteration order of nodes).
+     * Use this order for adjacency matrix rows/columns, simulation buffers, and drawer indices.
+     * @returns Array of node IDs in stable order
+     */
+    get_node_ids_order(): number[];
+    /**
+     * Returns the adjacency matrix and the node ID order. Dense form is for small/medium graphs;
+     * for very large graphs use get_adjacency() (sparse) instead.
+     * @returns { matrix: Float32Array (row-major n×n), nodeIds: number[] }
+     */
+    get_adjacency_matrix(): {
+        matrix: Float32Array;
+        nodeIds: number[];
+    };
+}
+export default Graph;

package/Build/Core/_Node.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Graph node: holds arbitrary data (e.g. `pos` for layout) and neighbour IDs.
+ * Named `_Node` to avoid confusion with Node.js and Three.js Vertices.
+ */
+interface _Node {
+    data: any;
+    neighbours: number[];
+}
+/**
+ * Node class: each node has an ID (index) and arbitrary data.
+ * The data typically includes "pos" (Point) for visualization.
+ */
+declare class _Node {
+    /**
+     *
+     * @param data - Data associated with the node; include "pos" (Point) for graph visuals
+     */
+    constructor(data: any);
+}
+export default _Node;

package/Build/Core/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Graph } from './Graph';
+export { default as _Node } from './_Node';
+export { default as Edge } from './Edge';

package/Build/Drawing/Drawing.d.ts

@@ -0,0 +1,129 @@
+import { default as Point } from '../HelperClasses/Point';
+import { default as Line } from '../HelperClasses/Line';
+import { default as Graph } from '../Core/Graph';
+/**
+ * Simulates Kamada kawai for a network in 2d. 3d is not supported yet
+ * Note: This is an async function as it take time for some of the large graphs
+ *
+ * @param Graph - The first input number
+ * @param iterations - The second input number
+ *  @param simulationBound - The bounds of simulation (Mostly a global number to scale the graph up or down)
+ *  @param cohesionValue - How sticky the nodes are i.r. how much they cluster together
+ * @returns A node map of all the nodes and their simulated positions. Note: position maps have to be applied to the graph.
+ *
+ */
+declare function SimulateKamadaKawai(Graph: Graph, iterations: number, simulationBound?: number, cohesionValue?: number, repulsionValue?: number): Promise<Map<number, Point>>;
+/**
+ *
+ * Randomly sets all the positions for a graph
+ * Not really very useful but I've used it in some cases and have kept it around
+ *
+ *  @param Graph - The graph who's nodes you would want to reposition
+ *
+ * @return A position map of all the nodes and its corresponding positions
+ */
+declare function InstanciateRandomPositions(Graph: Graph): Map<number, Point>;
+/**
+ *
+ * Constructs the edges as lines, Note: these are just a representation of the lines
+ * they then have to be visulized using one of the Three JS Drawer functions like
+ * draw a thick line or a thin line. This draws out the edges divided by some number of
+ * divisions that you specify
+ *
+ * @param Graph - The graph whos edges are getting drawn
+ * @param divDistance - How many divisions (distance) to make along the edge
+ * @returns A line map - which holds a map of all the edge indices and the corresponding line representations
+ */
+declare function DrawEdgeLines(Graph: Graph, divDistance: number): Map<number, Line>;
+/**
+ *
+ * Constructs the edges as lines, Note: these are just a representation of the lines
+ * they then have to be visulized using one of the Three JS Drawer functions like
+ * draw a thick line or a thin line - this draws them based on the number of divisions
+ * you would like them to have
+ * @param Graph - The graph whos edges are getting drawn
+ * @param numberOfDivs - How many divisions to make along the edge
+ * @returns A line map - which holds a map of all the edge indices and the corresponding line representations
+ */
+declare function DrawEdgeLinesDivisions(Graph: Graph, numberOfDivs: number): Map<number, Line>;
+/**
+ *
+ * Edge bundling - this isnt as fast as the current KDE based methods - but it provides a basic  method of
+ * Visualizing large edge flows. Note: This is an aysnc function as it takes a while for the edge bundling to happen
+ *
+ * @param LineMap - The map of edges as a line map
+ * @param iterations - The number of iterations to run edge bundling
+ * @param distance - A shorthand for how close together the vertices need to be before they get influnced by each other
+ * @returns A line map with all the updated positions of the line (Where they are bundled together) Again - this needs to be applied to the graph!
+ */
+declare function DrawEdgeBundling(LineMap: Map<number, Line>, iterations: number, distance: number): Promise<Map<number, Line>>;
+/**
+ *
+ * Displace the edges vertically, almost akin to the Deck.gl arcs
+ * The displacement is done in a sin curve with the ends still touching the nodes
+ * Note: This is an inplace modification of the edges
+ *
+ * @param LineMap - The map of edges as a line map
+ * @param displacement - the amount of vertical displacement
+ */
+declare function DisplaceEdgeInY(LineMap: Map<number, Line>, displacement: number): Map<number, Line>;
+/**
+ *
+ * Displace the vertices vertically based on some prameter (For example degree or modularity)
+ *
+ * @param Graph - the graph whos nodes have to be displaced
+ * @param parameter - the prameter based on which you want to modify the
+ * @param displacement - the maximum amunt of displacement, all the other values are rescaled linerly
+ */
+declare function DisplaceVertices(Graph: Graph, parameter: string, displacement: number): void;
+/**
+ *
+ * Generates a hive plot for a graph, this includes the option to displace the graph vertically based on degrees and how far away each node is
+ *
+ * @param Graph - The graph
+ * @param selectedNode - the node around which the hive plot is generated
+ * @param step - If the hive should step up or down if yes then by what increments
+ * @param startPosition - Starting position
+ * @returns
+ */
+declare function HivePlot(Graph: Graph, selectedNode: number, step: number, startPosition: Point): Promise<{
+    pmap: Map<any, any>;
+    emap: Map<number, Line>;
+}>;
+/**
+ * Move a graph somewhere (like the physical location) - This is an inplace movement and overwrites existing values
+ *
+ * @param Graph - The graph that has to be moved
+ * @param dispacement - This is a point and I end up using Point and Vector interchangably. So here the xyz values from the point are used to displace the nodes
+ */
+declare function MoveGraph(Graph: Graph, dispacement: Point): void;
+/**
+ *
+ *  Draw new lines from edges, and draw them based on the distance of divisions (i.e. divide the line up every 10 units) Note: This is an in place update that takes place on the graph - it overwrites the existing data.
+ *
+ * @param Graph - The grapht who's edges have to be updated
+ * @param divDistance - The distance by which the divisions are made
+ */
+declare function UpdateEdgeLinesDist(Graph: Graph, divDistance: number): void;
+/**
+ *
+ * Draw new lines from edges, and draw them based on divisions (i.e. divide the line into 10 units) Note: This is an in place update that takes place on the graph - it overwrites the existing data.
+
+ * @param Graph - The grapht who's edges have to be updated
+ * @param Divs - The number of divisions to be made
+ */
+declare function UpdateEdgeLinesDivs(Graph: Graph, Divs: number): void;
+declare const _default: {
+    SimulateKamadaKawai: typeof SimulateKamadaKawai;
+    DrawEdgeLines: typeof DrawEdgeLines;
+    DrawEdgeLinesDivisions: typeof DrawEdgeLinesDivisions;
+    DrawEdgeBundling: typeof DrawEdgeBundling;
+    HivePlot: typeof HivePlot;
+    DisplaceEdgeInY: typeof DisplaceEdgeInY;
+    MoveGraph: typeof MoveGraph;
+    InstanciateRandomPositions: typeof InstanciateRandomPositions;
+    DisplaceVertices: typeof DisplaceVertices;
+    UpdateEdgeLinesDist: typeof UpdateEdgeLinesDist;
+    UpdateEdgeLinesDivs: typeof UpdateEdgeLinesDivs;
+};
+export default _default;

package/Build/Drawing/GraphDrawer.d.ts

@@ -0,0 +1,70 @@
+import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';
+import { default as Graph } from '../Core/Graph';
+import * as THREE from "three";
+interface GraphDrawer3d {
+    canvas: HTMLCanvasElement;
+    width: number;
+    height: number;
+    geometryMap: Map<any, any>;
+    materialMap: Map<any, any>;
+    meshMap: Map<any, any>;
+    controls: OrbitControls;
+    renderer: THREE.WebGLRenderer;
+    camera: THREE.PerspectiveCamera;
+    scene: THREE.Scene;
+    graphs: Map<number, Graph>;
+}
+/**
+ * This is the main graph drawer class
+ */
+declare class GraphDrawer3d {
+    /**
+     * To initialize the graph drawer there are a set of graph drawing settings that have to be set.
+     * Here are the details to do the same:
+     * canvas - the html canvas element that you would like to render
+     * height - the the height of the initialized canvas
+     * width - the width of the initialized canvas
+     * geometry map - a map that keeps track of all the geometry in the scene (Optional)
+     * material map - a mapt that keeps track of all the materials in the scene (Optional)
+     * controls - Controls that define how one can navigate this 3d space (Self initialized)
+     * renderer - Renderer element form the three JS library
+     * camera -  A perspective camera from the threeJS library
+     * scene - The three JS scene that gets define automatically
+     *
+     * @param GraphDrawerOptions3d - These options are constructed into a single object and passed in
+     */
+    constructor(GraphDrawerOptions3d: {
+        canvas: HTMLCanvasElement;
+        width: number;
+        height: number;
+        geometryMap: Map<any, any>;
+        materialMap: Map<any, any>;
+        meshMap: Map<any, any>;
+        controls: OrbitControls;
+        renderer: THREE.WebGLRenderer;
+        camera: THREE.PerspectiveCamera;
+        scene: THREE.Scene;
+    });
+    /**
+     * This essentially initializes the drawing element based on the settings
+     * Remember to do this since if if its not done the scene will not render
+     */
+    init(): Promise<void>;
+    /**
+     *
+     * This is the main way to add elements to the viewer window that gets initialized
+     *
+     * @param element A geometry element (THREE.Group, Line, or Points) to add to the scene
+     */
+    addVisElement(element: THREE.Group | THREE.Line | THREE.Points): void;
+    /**
+     * This is the render call that is called every frame to update the rendering of the canvas
+     * Remember to do this since this is a common are for bugs to occur
+     */
+    rendercall(): void;
+}
+export { GraphDrawer3d };
+declare const _default: {
+    GraphDrawer3d: typeof GraphDrawer3d;
+};
+export default _default;

package/Build/Drawing/MeshLineGeometry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Ribbon geometry for billboarded thick lines (MeshLine-style).
+ * Each line point becomes two vertices (left/right edge); the material
+ * expands them in screen space so the line has visible thickness.
+ */
+import * as THREE from "three";
+/**
+ * Build a BufferGeometry for one polyline as a ribbon (strip of quads).
+ * Attributes: position, positionPrev, positionNext, side.
+ */
+export declare function buildMeshLineGeometry(positions: THREE.Vector3[]): THREE.BufferGeometry;

package/Build/Drawing/MeshLineMaterial.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Billboarded thick-line material (screen-space width).
+ * Adapted from the MeshLine approach: vertex shader expands the ribbon
+ * in clip space so lines have consistent pixel width and always face the camera.
+ */
+import * as THREE from "three";
+export interface MeshLineMaterialOptions {
+    color?: number;
+    lineWidth?: number;
+    resolution?: THREE.Vector2;
+}
+/**
+ * Material for billboarded thick lines. Width is in pixels (screen space).
+ * Requires resolution uniform (canvas size) for correct scaling.
+ */
+export declare function createMeshLineMaterial(options?: MeshLineMaterialOptions): THREE.ShaderMaterial;

package/Build/Drawing/ThickLine.d.ts

@@ -0,0 +1,21 @@
+import { default as Line } from '../HelperClasses/Line';
+/**
+ * Internal thick-line drawing: billboarded mesh-line (ribbon with screen-space width).
+ * No dependency on Three.js examples; geometry and material are maintained in-house.
+ * Based on the MeshLine approach (see e.g. threejs-meshline / THREE.MeshLine).
+ */
+import * as THREE from "three";
+/**
+ * Create a single thick line mesh from a Line (array of points).
+ * Uses a ribbon geometry + shader material so the line is billboarded
+ * and has consistent pixel width on screen.
+ *
+ * @param line - Line with .points (Point[])
+ * @param bounds - Scale factor applied to point coordinates (same as thin lines)
+ * @param color - Hex color
+ * @param lineWidthPx - Line width in pixels (screen space)
+ * @param resolution - Canvas size for correct scaling (optional)
+ * @returns A Three.js Mesh that can be added to the scene
+ */
+export declare function createThickLineMesh(line: Line, bounds: number, color: number, lineWidthPx?: number, resolution?: THREE.Vector2): THREE.Mesh;
+export declare function createThickEdgesGroup(edgeMap: Map<number, Line>, bounds: number, color: number, thickness?: number, resolution?: THREE.Vector2): THREE.Group;

package/Build/Drawing/ThreeJSDrawer.d.ts

@@ -0,0 +1,197 @@
+import { default as Point } from '../HelperClasses/Point';
+import { default as Line } from '../HelperClasses/Line';
+import { default as Graph } from '../Core/Graph';
+import * as THREE from "three";
+/**
+ * Draw the vertices of the graph as a point cloud. **Static geometry** — use for one-shot layout.
+ * For time-based simulation use DrawTHREEGraphVerticesMutable and updatePositions() each frame.
+ *
+ * @param Graph - the graph that has to be drawn out
+ * @param bounds - A global scaling parameter defaults to 1 but change to scale up a graph
+ * @param size - The size of all the nodes - either an array the same length as nodes or a single number
+ * @param color - the color of the node defaults to white
+ * @param alpha - the alpha value of the node defaults to 1 (opaque)
+ * @returns a THREE.Group containing the point cloud
+ */
+declare function DrawTHREEGraphVertices(Graph: Graph, bounds?: number, size?: number | number[], color?: number, alpha?: number): THREE.Group<THREE.Object3DEventMap>;
+/**
+ * Result of DrawTHREEGraphVerticesMutable. Use `updatePositions()` each frame with simulation positions.
+ */
+export interface MutableVerticesResult {
+    /** THREE.Group to add to the scene */
+    group: THREE.Group;
+    /** Update vertex positions from Float32Array (node order) or Map&lt;nodeId, Point&gt; */
+    updatePositions(positions: Float32Array | Map<number, Point>): void;
+}
+/**
+ * **Mutable** point cloud: positions can be updated each frame. Use for time-based simulation.
+ * Call updatePositions(simulation.getPositions()) (or a Map) in your animation loop.
+ * Node order matches get_node_ids_order().
+ */
+declare function DrawTHREEGraphVerticesMutable(Graph: Graph, bounds?: number, size?: number | number[], color?: number, alpha?: number): MutableVerticesResult;
+/**
+ * Draws all edges as thick lines. **Static geometry** — use for one-shot layout.
+ *
+ * @param Graph - The graph whose edges have to be drawn
+ * @param bounds - the global scale for all the edges to be drawn defaults to 1
+ * @param color - color of the edges defaults to white
+ * @param thickness - thickness of the edges (defaults to 0.4; screen-space pixels ≈ thickness × 100 for values &lt; 1)
+ * @returns a Three Js group of edges that can be added to the scene
+ */
+declare function DrawTHREEGraphEdgesThick(Graph: Graph, bounds?: number, color?: number, thickness?: number): THREE.Group<THREE.Object3DEventMap>;
+/**
+ *
+ * Draw thick edges from an edge map
+ *
+ * @param EdgeMap - The edge map associated with the graph
+ * @param bounds - The global scale of the graph - defaults to 1
+ * @param color - The color of the edges - defaults to white
+ * @param thickness - thickness of the edges (defaults to 0.4; pixels ≈ thickness × 100 for values &lt; 1)
+ * @returns
+ */
+declare function DrawThickEdgesFromEdgeMap(EdgeMap: Map<number, Line>, bounds: number, color?: number, thickness?: number): THREE.Group<THREE.Object3DEventMap>;
+/**
+ * Draw thin lines for all edges. **Static geometry** — use for one-shot layout.
+ * For time-based simulation use DrawTHREEGraphEdgesThinMutable and updateEdges() each frame.
+ *
+ * @param Graph - The graph that has to be drawn
+ * @param bounds - The global scale factor for the edges - defaults to 1
+ * @param color - color of the lines - defaults to white
+ * @returns a THREE.Group of lines
+ */
+declare function DrawTHREEGraphEdgesThin(Graph: Graph, bounds?: number, color?: number): THREE.Group<THREE.Object3DEventMap>;
+/**
+ * Result of DrawTHREEGraphEdgesThinMutable. Call `updateEdges()` after applying new positions to the graph.
+ */
+export interface MutableEdgesResult {
+    /** THREE.Group containing the line segments */
+    group: THREE.Group;
+    /** Rebuild edge geometry from the graph's current position and edge maps */
+    updateEdges(): void;
+}
+/**
+ * **Mutable** thin edges: geometry is refreshed from the graph each frame. Use for time-based simulation.
+ * After updating the graph's position map and edge map, call updateEdges() in your animation loop.
+ */
+declare function DrawTHREEGraphEdgesThinMutable(Graph: Graph, bounds?: number, color?: number): MutableEdgesResult;
+/**
+ * Draw a single thick line through an ordered list of node IDs (e.g. a path).
+ * Uses graph positions; line width in pixels (pass thickness >= 1 for pixel width).
+ *
+ * @param Graph - Graph with position map
+ * @param bounds - Scale factor for positions
+ * @param pathNodeIds - Ordered node IDs (start to end)
+ * @param color - Hex color for the path line
+ * @param thickness - Line width in pixels (e.g. 5 for a thick path)
+ */
+declare function DrawThickPathFromNodeIds(Graph: Graph, bounds: number, pathNodeIds: number[], color?: number, thickness?: number): THREE.Group<THREE.Object3DEventMap>;
+/**
+ *
+ * Draw Line map as lines given the edge map assocaited with the graph
+ *
+ * @param LineMap - The edge map that has to be drawn out
+ * @param bounds - Global scale for the edges to be drawn defaults to 1
+ * @param color - Color of the edges defaults to 1
+ * @returns
+ */
+declare function DrawThinEdgesFromEdgeMap(LineMap: Map<number, Line>, bounds?: number, color?: number): THREE.Group<THREE.Object3DEventMap>;
+/**
+ * Add boxes for all nodes using one InstancedMesh (efficient for 1000s of boxes).
+ *
+ * @param nodeMap - a map of all the nodes
+ * @param bounds - global scale of the edges to be drawn, defaults to 1
+ * @param color - default color of the edges, defaults to white
+ * @param size - size of the nodes defaults to 10
+ * @returns a group containing one InstancedMesh for all boxes
+ */
+declare function AddBoxBasedImaging(nodeMap: Map<number, Point>, bounds?: number, color?: number, size?: number | number[]): THREE.Group<THREE.Object3DEventMap>;
+/**
+ * Result of DrawTHREEBoxBasedVerticesMutable. Use `updatePositions()` each frame for simulation.
+ */
+export interface MutableBoxVerticesResult {
+    /** THREE.Group containing the instanced box mesh */
+    group: THREE.Group;
+    /** Update box positions from Float32Array or Map&lt;nodeId, Point&gt; */
+    updatePositions(positions: Float32Array | Map<number, Point>): void;
+}
+/**
+ * Box-based vertices as one InstancedMesh with updatable positions (e.g. for simulation).
+ * Node order matches get_node_ids_order() when called with a graph's position map.
+ */
+declare function DrawTHREEBoxBasedVerticesMutable(Graph: Graph, bounds?: number, color?: number, size?: number | number[]): MutableBoxVerticesResult;
+/**
+ *
+ * Draw box based verices given a graph
+ *
+ * @param Graph - The graph that needs its vertices drawn
+ * @param bounds - A global scale for the graph, defaults to one
+ * @param color - Default color of the boxes defaults to white
+ * @param size - Default size of the nodes defaults to 10
+ * @returns
+ */
+declare function DrawTHREEBoxBasedVertices(Graph: Graph, bounds?: number, color?: number, size?: number | number[]): THREE.Group<THREE.Object3DEventMap>;
+/**
+ *
+ * Draw cylinders where all the vertices are based on a node map
+ *
+ * @param nodeMap - the node map assiciate with the graph that has to be drawn out
+ * @param divisonLength - the length of the divisions that are there in each one of the cylinder (this is a circumfurence amount), defaults to 16
+ * @param color - the default color of the cylinder, defaults to white
+ * @param size - the default size of the cylinder, defaults to 10
+ * @returns
+ */
+declare function AddCylinderBasedImaging(nodeMap: Map<number, Point>, divisonLength?: number, color?: number, size?: number | number[]): THREE.Group<THREE.Object3DEventMap>;
+/**
+ *
+ * Split up a graph and return an boject containing a bunch of node groups and edge groups based on some parameterS
+ *
+ * @param Graph - the graph that you want to split up
+ * @param propertyName - the property that you want to split them on
+ * @returns - an object that hasa set of node vertices and a set of edge lines based on the splitting factor
+ */
+declare function AddInModularityBasedPointGroups(Graph: Graph, propertyName: string): Promise<{
+    nodeGroups: Map<number, THREE.Group<THREE.Object3DEventMap>>;
+    EdgeGroups: Map<number, THREE.Group<THREE.Object3DEventMap>>;
+}>;
+/**
+ *
+ * Draw simplified line edges (thin based) based on some number. This number is a fraction of the total number of edges (so if you specify 0.1 it would draw 10% of the edges)
+ *
+ * @param Graph - The graph that has to be drawn out
+ * @param amount - The fraction of edges to be drawn
+ * @param color - color of these edges - defaults to 0.1
+ * @returns - a group of simple lines based on all the edges supplied to it
+ */
+declare function DrawSimplifiedEdges(Graph: Graph, amount: number, color?: number): THREE.Group<THREE.Object3DEventMap>;
+/**
+ * Set vertex colors by node ID. Uses the geometry's "label" attribute (node ID per vertex) to map node IDs to vertex indices; if "label" is missing, indexArray is treated as vertex indices.
+ *
+ * @param vertices - THREE.Points with customColor (and optionally label) attribute, or a Group whose first child is that Points object
+ * @param indexArray - Node IDs to color, or vertex indices if geometry has no label attribute
+ * @param color - Hex color to apply
+ */
+declare function ChangeTheVertexColours(vertices: THREE.Points | THREE.Group, indexArray: number[], color: number): void;
+/**
+ * Reset all vertex colors to white.
+ * @param vertices - THREE.Points with customColor attribute, or a Group whose first child is that Points object
+ */
+declare function ResetVertexColors(vertices: THREE.Points | THREE.Group): void;
+declare const _default: {
+    DrawTHREEGraphVertices: typeof DrawTHREEGraphVertices;
+    DrawTHREEGraphVerticesMutable: typeof DrawTHREEGraphVerticesMutable;
+    DrawTHREEGraphEdgesThick: typeof DrawTHREEGraphEdgesThick;
+    DrawTHREEGraphEdgesThin: typeof DrawTHREEGraphEdgesThin;
+    DrawTHREEGraphEdgesThinMutable: typeof DrawTHREEGraphEdgesThinMutable;
+    DrawThickPathFromNodeIds: typeof DrawThickPathFromNodeIds;
+    AddBoxBasedImaging: typeof AddBoxBasedImaging;
+    AddInModularityBasedPointGroups: typeof AddInModularityBasedPointGroups;
+    DrawThinEdgesFromEdgeMap: typeof DrawThinEdgesFromEdgeMap;
+    DrawThickEdgesFromEdgeMap: typeof DrawThickEdgesFromEdgeMap;
+    AddCylinderBasedImaging: typeof AddCylinderBasedImaging;
+    DrawSimplifiedEdges: typeof DrawSimplifiedEdges;
+    ChangeTheVertexColours: typeof ChangeTheVertexColours;
+    ResetVertexColors: typeof ResetVertexColors;
+    DrawTHREEBoxBasedVertices: typeof DrawTHREEBoxBasedVertices;
+    DrawTHREEBoxBasedVerticesMutable: typeof DrawTHREEBoxBasedVerticesMutable;
+};
+export default _default;

package/Build/Drawing/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Drawing } from './Drawing';
+export { default as ThreeWrapper } from './ThreeJSDrawer';
+export { default as GraphDrawer } from './GraphDrawer';

package/Build/GraphAlgorithms/GraphMethods.d.ts

@@ -0,0 +1,47 @@
+import { default as Graph } from '../Core/Graph';
+/**
+ *
+ * Performs a BFS search on a graph - Async because it takes a while on large graphs
+ *
+ * @param Graph - The graph which has to be searched using the BFS algorithm
+ * @param node - The node form which to start
+ * @returns - A map of which node was explored from which other node
+ */
+declare function BFSSearch(Graph: Graph, node: number): Promise<Map<number, number>>;
+/**
+ *
+ * Performs a dijkstra search on a graph
+ *
+ * @param Graph - The graph on which to perform the Dijkstra search
+ * @param Node - The node from which to start
+ * @returns - Map from which each one of the nodes was searched from
+ */
+declare function Dijkstra(Graph: Graph, Node: number): Promise<Map<number, number>>;
+/**
+ *
+ * Finds the diameter of the graph
+ *
+ * @param Graph
+ * @returns returns an object with a start, end - the two points of a graph and the diameter of the graph
+ */
+declare function GraphDiameter(Graph: Graph): Promise<{
+    start: number;
+    end: number;
+    distance: number;
+}>;
+/**
+ *
+ * Select a subgraph
+ *
+ * @param graph - The main graph to select from
+ * @param nodeList - The selection of nodes that we want to select from this graph
+ * @returns A graph object that contains this subgraph
+ */
+declare function SelectSubgraph(graph: Graph, nodeList: number[]): Promise<Graph>;
+declare const _default: {
+    GraphDiameter: typeof GraphDiameter;
+    Dijkstra: typeof Dijkstra;
+    BFSSearch: typeof BFSSearch;
+    SelectSubgraph: typeof SelectSubgraph;
+};
+export default _default;

package/Build/GraphAlgorithms/index.d.ts

@@ -0,0 +1 @@
+export { default as GraphMethods } from './GraphMethods';