plebeiangraphlibrary 1.0.6

package/Build/pgl.d.ts

@@ -0,0 +1,642 @@
+import * as THREE from "three";
+import { OrbitControls } from "three/examples/jsm/controls/OrbitControls";
+interface Point {
+    x: number;
+    y: number;
+    z: number;
+}
+declare class Point {
+    /**
+     * Constructs a point based on the x y z values
+     * @param x x value
+     * @param y y value
+     * @param z z value
+     */
+    constructor(x: number, y: number, z: number);
+    /**
+     * Displaces a point - note this method moves the existing point
+     * @param Point This is the displacement vactor, used as a point but the same idea holds
+     */
+    translate(Point: Point): void;
+}
+interface Line {
+    points: Point[];
+}
+declare class Line {
+    /**
+     * Constructs a line from an array of points
+     * @param points an array of points
+     */
+    constructor(points: Point[]);
+}
+interface _Node {
+    data: any;
+    neighbours: number[];
+}
+/**
+ * This is the node class - they have an ID which is
+ * essentially an index and some data associated with it
+ * The data also contains the position of the
+ */
+declare class _Node {
+    /**
+     *
+     * @param data Data associated with the node, be sure to be careful to pass in any "pos" data as they correspond to position of the nodes in the visuals of the graph
+     */
+    constructor(data: any);
+}
+interface Edge {
+    start: number;
+    end: number;
+    data: any;
+}
+/**
+ * The edge class, edges have a start and end but they can also have data associated with that edge
+ */
+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 Data associated, note that ldata is reserved for how to draw the lines associated with the edge
+     */
+    constructor(start: number, end: number, data: any);
+}
+export interface Graph {
+    nodes: Map<number, _Node>;
+    edges: Map<number, Edge>;
+}
+/**
+ * The main graph object - this contrains nodes and edges that get modified with different
+ * Operations etc.
+ */
+export 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 assocaiated 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 a node adajaceny list 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 adjaceny lists in the 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 noce 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 Get the adjaceny (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 with a graph is made up of {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 positon map and the edge map as pmap and emap
+     */
+    get_map(): {
+        pmap: Map<number, Point>;
+        emap: Map<number, Line>;
+    };
+    /**
+     * get the postion of the nodes in the graph
+     * @returns the position map
+     */
+    get_position_map(): Map<number, Point>;
+}
+/**
+ *
+ * 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>;
+export const GraphMethods: {
+    GraphDiameter: typeof GraphDiameter;
+    Dijkstra: typeof Dijkstra;
+    BFSSearch: typeof BFSSearch;
+    SelectSubgraph: typeof SelectSubgraph;
+};
+/**
+ * construct a graph based on an edge list and node list
+ * @param nodes nodes as a list
+ * @param edges edges as a list
+ * @returns A graph that was construct from the list of nodes and edges
+ */
+declare function ConstructGraphNodeEdgesList(nodes: any[], edges: any[]): Promise<Graph>;
+export const Constructors: {
+    ConstructGraphNodeEdgesList: typeof ConstructGraphNodeEdgesList;
+};
+/**
+ * calculate the average of an array of numberss
+ * @param arr an array of number whose average has to be calculated
+ * @returns the average
+ */
+declare function calculateAverage(arr: number[]): number;
+/**
+ * Calculate the distance betweeen two points
+ * @param p1 the first point
+ * @param p2 the second point
+ * @returns the distance between the points
+ */
+declare function calculateDistance(p1: Point, p2: Point): number;
+/**
+ * Calculate the squared distance between two points
+ * @param p1 the first point
+ * @param p2 the second point
+ * @returns the squared distance between the two points
+ */
+declare function calculateSquaredDistance(p1: Point, p2: Point): number;
+/**
+ * get a random subset of something from a array of things must provide the number of things we want from that array
+ * @param arr the array from which the subset has to be made
+ * @param n number of items to select
+ * @returns a new array made up of a random sample from the original array
+ */
+declare function getRandomSubset(arr: any[], n: number): any[];
+/**
+ * This is a super useful method to get a random number of edges or something that you would like to draw
+ * this is primarily done because there are way too many edges sometimes and and the number of edges is really
+ * What slows the whole rendering process down
+ * @param map - the map that youd like to reduce
+ * @param n - the fraction of items that youd like to return from this map
+ * @returns A reduced map with a fractio of those many entries
+ */
+declare function getRandomSubset_map(map: Map<number, any>, n: number): Map<any, any>;
+export const Utilities: {
+    calculateAverage: typeof calculateAverage;
+    calculateDistance: typeof calculateDistance;
+    calculateSquaredDistance: typeof calculateSquaredDistance;
+    getRandomSubset: typeof getRandomSubset;
+    getRandomSubset_map: typeof getRandomSubset_map;
+};
+/**
+ * Creates a line based on the number of divisons
+ *
+ * @param start the start point
+ * @param end the end point
+ * @param divisions the number of divisions
+ * @returns the line object
+ */
+declare function line_from_start_end_divisions(start: Point, end: Point, divisions: number): Line;
+/**
+ * Divides the line into a number of divisions based on distance
+ * @param start - the start point
+ * @param end - the end point
+ * @param distance - the distance at which this line must be divided
+ * @returns A line object with the right number of points
+ */
+declare function line_from_start_end_distance(start: Point, end: Point, distance: number): Line;
+/**
+ * Calculates the centroid of an array of points
+ * @param points An array of points
+ * @returns the central point of the array of points
+ */
+declare function centroid(points: Point[]): Point;
+export const Geometry: {
+    line_from_start_end_divisions: typeof line_from_start_end_divisions;
+    line_from_start_end_distance: typeof line_from_start_end_distance;
+    centroid: typeof centroid;
+};
+/**
+ * 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 And node map of all the nodes and their simulated positions - Please note: position maps have to 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;
+export const Drawing: {
+    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;
+};
+/**
+ *
+ * @returns the raw ZKC dataset
+ */
+declare function LoadZKC(): Promise<Graph>;
+/**
+ *
+ * @returns the ZKC dataset with the positons simulated before hand
+ */
+declare function LoadZKCSimulated(): Promise<Graph>;
+export const SampleData: {
+    LoadZKC: typeof LoadZKC;
+    LoadZKCSimulated: typeof LoadZKCSimulated;
+};
+/**
+ *
+ * Draw the veritces of the graph out as a point cloud
+ *
+ * @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 garph
+ * @param size - The size of all the nodes - either input an array the same length of the number of nodes decribing how big each node is, or a global node value as a number or defaults to 1
+ * @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 JS group that contains all the vertices as a point cloud or a three js points object that can be added to the scene
+ */
+declare function DrawTHREEGraphVertices(Graph: Graph, bounds?: number, size?: number | number[], color?: number, alpha?: number): THREE.Group;
+/**
+ *
+ * Draws out all the edges (Thick edges of a graph)
+ *
+ * @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.2)
+ * @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;
+/**
+ *
+ * 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.2
+ * @returns
+ */
+declare function DrawThickEdgesFromEdgeMap(EdgeMap: Map<number, Line>, bounds: number, color?: number, thickness?: number): THREE.Group;
+/**
+ *
+ * Draw thin lines for all the edges given a graph
+ *
+ * @param Graph - The graph that has to be drawn
+ * @param bounds - The global scale factor for the the edges - defaults to 1
+ * @param color - color of the lines - defaults to white
+ * @returns
+ */
+declare function DrawTHREEGraphEdgesThin(Graph: Graph, bounds?: number, color?: number): THREE.Group;
+/**
+ *
+ * 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;
+/**
+ *
+ * Adde boxes where all the boxes are
+ *
+ * @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 of vertices that contains all of the boxes associated with each one of the vertices
+ */
+declare function AddBoxBasedImaging(nodeMap: Map<number, Point>, bounds?: number, color?: number, size?: number | number[]): THREE.Group;
+/**
+ *
+ * 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;
+/**
+ *
+ * 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;
+/**
+ *
+ * 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>;
+    EdgeGroups: Map<number, THREE.Group>;
+}>;
+/**
+ *
+ * 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;
+/**
+ *
+ * Change all the vertex colors based on some array of properties
+ *
+ * @param vertices - ThreeJS Points object, be sure to pass in the points object and not the group that the points belong too
+ * @param indexArray - The array of the indices of all the nodes whose values that have to be changed
+ * @param color - The color that they have to be changed too
+ */
+declare function ChangeTheVertexColours(vertices: THREE.Points, indexArray: number[], color: number): void;
+/**
+ *
+ * This resets all the colors to white
+ *
+ * @param vertices - ThreeJS Points object, be sure to pass in the points object and not the group that the points belong too
+ */
+declare function ResetVertexColors(vertices: THREE.Points): void;
+export const ThreeWrapper: {
+    DrawTHREEGraphVertices: typeof DrawTHREEGraphVertices;
+    DrawTHREEGraphEdgesThick: typeof DrawTHREEGraphEdgesThick;
+    DrawTHREEGraphEdgesThin: typeof DrawTHREEGraphEdgesThin;
+    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;
+};
+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 above options are construdeted into a single object and passed into the Options elem
+     */
+    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 geomerty element + material element to add to the scene as a group line or point cloud
+     */
+    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 const GraphDrawer: {
+    GraphDrawer3d: typeof GraphDrawer3d;
+};
+/**
+ * The G ( n , p ) G(n,p) model, a graph is constructed by connecting labeled nodes randomly. Each edge is included in the graph with probability p p, independently from every other edge.
+ * https://en.wikipedia.org/wiki/Erd%C5%91s%E2%80%93R%C3%A9nyi_model
+ * @param n Number of nodes
+ * @param p Probability of two edges to eb connected
+ * @returns A Erdos Reyni graph
+ */
+declare function GenerateErdosReyni_n_p(n: number, p: number): Promise<Graph>;
+export const Models: {
+    GenerateErdosReyni_n_p: typeof GenerateErdosReyni_n_p;
+};
+
+//# sourceMappingURL=pgl.d.ts.map

package/Build/pgl.d.ts.map

@@ -0,0 +1 @@
+{"mappings":"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","sources":["Src/Src/HelperClasses/Point.ts","Src/Src/HelperClasses/Line.ts","Src/Src/Core/_Node.ts","Src/Src/Core/Edge.ts","Src/Src/Core/Graph.ts","Src/Src/GraphAlgorithms/GraphMethods.ts","Src/Src/SampleData/ZKC.ts","Src/Src/SampleData/ZKC_simulated.ts","Src/Src/HelperClasses/GraphConstructors.ts","Src/Src/HelperClasses/Utilities.ts","Src/Src/HelperClasses/GeometryHelpers.ts","Src/Src/Drawing/Drawing.ts","Src/Src/SampleData/DataLoader.ts","Src/Src/HelperClasses/ColorHelper.ts","Src/Src/Shaders/vertexShader.glsl.ts","Src/Src/Shaders/fragmentShader.glsl.ts","Src/Src/Drawing/ThreeJSDrawer.ts","Src/Src/Drawing/GraphDrawer.ts","Src/Src/Models/ErdosRenyiModel.ts","Src/Src/index.ts","Src/index.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,"export { default as Graph } from \"./Core/Graph\";\r\nexport { default as GraphMethods } from \"./GraphAlgorithms/GraphMethods\";\r\nexport { default as SampleData } from \"./SampleData/DataLoader\";\r\nexport { default as Constructors } from \"./HelperClasses/GraphConstructors\";\r\nexport { default as Drawing } from \"./Drawing/Drawing\";\r\nexport { default as Geometry } from \"./HelperClasses/GeometryHelpers\";\r\nexport { default as Utilities } from \"./HelperClasses/Utilities\";\r\nexport { default as ThreeWrapper } from \"./Drawing/ThreeJSDrawer\";\r\nexport { default as GraphDrawer } from \"./Drawing/GraphDrawer\";\r\nexport { default as Models } from \"./Models/ErdosRenyiModel\";\r\n"],"names":[],"version":3,"file":"pgl.d.ts.map"}