Kelder/planet-wars
32
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

add working voronoi js file with types

Browse source
This commit is contained in:
ajuvercr 2020-04-18 12:25:07 +02:00
parent ddbf7a026c
commit 2c9dc46b48
5 changed files with 1792 additions and 645 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

149
frontend/www/dcel.ts
View file

@ -1,149 +0,0 @@
import { create } from "domain";
export class Vertex {
coords: [number, number];
incident_edge: HalfEdge;
constructor(x: number, y: number) {
this.coords = [x, y];
}
get_all(): HalfEdge[] {
const out = [];
let current = this.incident_edge;
do {
out.push(current);
current = current.twin.next;
} while (current != this.incident_edge);
return out;
}
}
export class Face {
attributes: any;
outer_component: HalfEdge;
inner_components: HalfEdge[];
constructor(attributes?: any) {
this.attributes = attributes;
}
loop(): [number, number][] {
const out = [];
let iter = 0;
let current = this.outer_component;
do {
if (iter > 100) {
throw new Error("Fuck off");
}
iter += 1;
console.log(current.id, current.face.attributes, current.origin.coords);
out.push(current.origin.coords);
current = current.next;
} while (current != this.outer_component);
return out;
}
}
var id = 0;
function next_id(): number {
id += 1;
return id;
}
export class HalfEdge {
origin: Vertex;
// destination = twin.origin
next: HalfEdge;
prev: HalfEdge;
twin: HalfEdge;
face: Face;
id: number;
constructor(origin: Vertex, f1: Face, f2?: Face) {
this.id = next_id();
this.origin = origin;
this.next = this;
this.prev = this;
if (f2) {
this.twin = new HalfEdge(origin, f2);
} else {
this.twin = this;
}
this.face = f1;
}
insert(at: Vertex, update_twin = true): HalfEdge {
const new_edge = new HalfEdge(at, this.face);
new_edge.next = this.next;
new_edge.prev = this;
new_edge.twin = this.twin;
this.next.prev = new_edge;
this.next = new_edge;
if (update_twin) {
this.twin = this.twin.insert(at, false);
}
return new_edge;
}
split(to: Vertex) {
const e_to = new HalfEdge(this.origin, this.face);
const e_from = new HalfEdge(to, this.face);
e_to.twin = e_from;
e_from.twin = e_to;
e_to.prev = this.prev;
e_to.next = e_from;
e_from.next = this;
e_from.prev = e_to;
this.prev.next = e_to;
this.prev = e_from;
}
add_face() {
}
to_string(): string {
return `Halfedge from ${this.origin ? this.origin.coords : undefined} face1 ${this.face ? this.face.attributes : undefined}`;
}
}
export function test() {
const f1 = new Face("Face 1");
const f2 = new Face("Face 2");
const v1 = new Vertex(0, 0);
const v2 = new Vertex(1, 1);
const v3 = new Vertex(-1, 0);
const v4 = new Vertex(2, 0);
const e1 = new HalfEdge(v1, f1, f2);
f1.outer_component = e1;
const e2 = e1.insert(v2);
const e3 = e2.split(v3);
const e4 = e2.insert(v4);
e1.twin.next = e4.twin;
f2.outer_component = e4.twin;
// const e3 = e1.insert(v3);
console.log(f1.loop());
console.log(f2.loop());
}

14
frontend/www/src/index.ts
View file

@ -8,6 +8,7 @@ import { VertexBufferLayout, VertexArray } from "./webgl/vertexBufferLayout";
import { Texture } from "./webgl/texture";
import { callbackify } from "util";
import { defaultLabelFactory, LabelFactory, Align, Label } from "./webgl/text";
import Voronoi = require("./voronoi/voronoi-core");
function f32v(ptr: number, size: number): Float32Array {
return new Float32Array(memory.buffer, ptr, size);
@ -437,3 +438,16 @@ function step(time: number) {
// set_loading(false);
requestAnimationFrame(step);
(function() {
console.log(Voronoi);
console.log(new Voronoi());
var sites = [{x:300,y:300}, {x:100,y:100}, {x:200,y:500}, {x:250,y:450}, {x:600,y:150}];
var bbox = {xl:0, xr:800, yt:0, yb:600};
const voronoi = new Voronoi();
const result = voronoi.compute(sites, bbox);
console.log(result);
})();

54
frontend/www/src/voronoi/voronoi-core.d.ts vendored Normal file
View file

@ -0,0 +1,54 @@
declare class Point {
x: number;
y: number;
}
declare class Site {
x: number;
y: number;
voronoiId: number;
}
declare class Cell {
site: Site;
halfedges: HalfEdge[];
closeMe: boolean;
}
declare class Edge {
lSite: Site;
rSite: Site;
vb: Point;
va: Point;
}
declare class HalfEdge {
site: Site;
edge: Edge;
angle: number;
getStartpoint(): Point;
getEndpoint(): Point;
}
declare class BBox {
xl: number;
xr: number;
yt: number;
yb: number;
}
declare class VoronoiDiagram {
site: any;
cells: Cell[];
edges: Edge[];
vertices: Point[];
execTime: number;
}
declare class Voronoi {
constructor();
compute(sites: Point[], bbox: BBox): VoronoiDiagram;
}
export = Voronoi;

1724
frontend/www/src/voronoi/voronoi-core.js Normal file
View file

File diff suppressed because it is too large Load diff

496
frontend/www/voronoi.ts
View file

@ -1,496 +0,0 @@
import { Heap } from 'ts-heap'
import { HalfEdge, Face, Vertex } from './dcel';
interface WithPriority {
get_priority(): number;
}
export class Point {
x: number;
y: number;
face?: Face;
constructor(x: number, y: number, face? :Face) {
this.x = x;
this.y = y;
this.face = face;
}
equals(other: Point): boolean {
return Math.abs(this.x - other.x) + Math.abs(this.y - other.y) < 0.00001;
}
toString(): string {
return `{x: ${this.x}, y: ${this.y}}`;
}
}
class CircleEvent implements WithPriority {
y: number;
alive: boolean = true;
center: Vertex;
leaf: Leaf;
from: Point[];
static
from_sites(s1: Point, s2: Point, s3: Point, leaf: Leaf): CircleEvent {
const a = s1.x * (s2.y - s3.y) - s1.y*(s2.x - s3.x) + s2.x*s3.y - s3.x * s2.y;
const b = (s1.x ** 2 + s1.y ** 2) * (s3.y - s2.y) + (s2.x ** 2 + s2.y ** 2)*(s1.y - s3.y) + (s3.x ** 2 + s3.y ** 2) * (s2.y - s1.y);
const c = (s1.x ** 2 + s1.y ** 2) * (s2.x - s3.x) + (s2.x ** 2 + s2.y ** 2)*(s3.x - s1.x) + (s3.x ** 2 + s3.y ** 2) * (s1.x - s2.x);
const d = (s1.x ** 2 + s1.y ** 2) * (s3.x*s2.y - s2.x*s3.y) + (s2.x ** 2 + s2.y ** 2)*(s1.x*s3.y - s3.x*s1.y) + (s3.x ** 2 + s3.y ** 2) * (s2.x*s1.y - s1.x*s2.y);
const center = new Vertex(-b / (2. * a), -c / (2. * a));
const r = Math.sqrt((b ** 2 + c ** 2 - 4. * a * d) / (4. * a ** 2));
const y = center.coords[1] - r;
const out = new CircleEvent();
out.y = y;
out.center = center;
out.leaf = leaf;
out.from = [s1, s2, s3];
return out;
}
get_priority(): number {
return this.y;
}
print() {
console.log(`Circle event at ${this.y} ${JSON.stringify(this.center)}, ${this.leaf.point.toString()} from ${JSON.stringify(this.from.map((e) => e.toString()))}`);
}
}
class SiteEvent implements WithPriority{
face: Face;
point: Point;
constructor(point: Point) {
this.face = new Face(point);
this.point = point;
this.point.face = this.face;
}
get_priority(): number {
return this.point.y;
}
print() {
console.log(`Site event ${this.point.toString()}`);
}
}
function calc_x(left: Point, right: Point, y: number): number {
const [a1, b1, c1] = from_focus_vertex(left, y);
const [a2, b2, c2] = from_focus_vertex(right, y);
if (Math.abs(a1 - a2) < 0.0001) {
return (left.x + right.x) / 2.;
}
const da = a1 - a2;
const db = b1 - b2;
const dc = c1 - c2;
const d = db * db - 4. * da * dc;
if (d <= 0.) {
throw new Error(`D is less then 0 ${d}`);
}
const dd = Math.sqrt(d);
const x = (-db + dd) / (2. * da);
return x;
}
function from_focus_vertex(focus: Point, y: number): number[] {
const a = (focus.y - y) / 2;
const h = focus.x;
const k = focus.y - a;
return [1 / (4. * a), -h / (2 * a), (h ** 2 / (4 * a)) + k]
}
function cmp_event(e1: WithPriority, e2: WithPriority) {
return e2.get_priority() - e1.get_priority();
}
type Queue = Heap<WithPriority>;
type Node = Leaf | Breakpoint;
type Parent = Breakpoint | State;
class Leaf {
point: Point;
event: CircleEvent | undefined;
left: Leaf | undefined;
right: Leaf | undefined;
parent: Parent;
half_edge: HalfEdge;
constructor(point: Point, parent: Parent) {
this.point = point;
this.parent = parent;
this.half_edge = new HalfEdge(undefined, undefined);
}
false_alarm() {
if(this.event) {
console.log(`False alarm ${JSON.stringify(this.event.center)} ${this.event.y}`);
this.event.alive = false;
}
}
update_left(leaf: Leaf) {
if (this.left) {
this.left.right = leaf;
}
leaf.left = this.left;
}
update_right(leaf: Leaf) {
if (this.right) {
this.right.left = leaf;
}
leaf.right = this.right;
}
split(point: Point, events: Queue) {
this.false_alarm();
if (this.point.y == point.y) {
const middle = new Leaf(point, undefined);
const parent = this.parent;
if (this.point.x > point.x) {
const br = new Breakpoint([point, middle], [this.point, this], this.parent);
if (this.left) this.left.right = middle;
this.left = middle;
middle.right = this;
if (parent instanceof Breakpoint) {
parent.set_me(this, br);
} else {
parent.root = br;
}
const maybe_left = middle.check_circles(point.y, events);
if (maybe_left && maybe_left.center.coords[0] < middle.point.x) {
console.log(`Adding circle`);
maybe_left.print();
middle.event = maybe_left;
events.add(maybe_left);
}
const maybe_right = this.check_circles(point.y, events);
if (maybe_right && maybe_right.center.coords[0] >= middle.point.x) {
console.log(`Adding circle`);
maybe_right.print();
this.event = maybe_right;
events.add(maybe_right);
}
} else {
const br = new Breakpoint([this.point, this], [point, middle], this.parent);
if (this.right) this.right.left = middle;
this.right = middle;
middle.left = this;
if (parent instanceof Breakpoint) {
parent.set_me(this, br);
} else {
parent.root = br;
}
const maybe_left = this.check_circles(point.y, events);
if (maybe_left && maybe_left.center.coords[0] < middle.point.x) {
console.log(`Adding circle`);
maybe_left.print();
this.event = maybe_left;
events.add(maybe_left);
}
const maybe_right = middle.check_circles(point.y, events);
if (maybe_right && maybe_right.center.coords[0] >= middle.point.x) {
console.log(`Adding circle`);
maybe_right.print();
middle.event = maybe_right;
events.add(maybe_right);
}
}
return;
}
const left = new Leaf(this.point, undefined);
left.left = this.left;
if (this.left) this.left.right = left;
const right = new Leaf(this.point, undefined);
right.right = this.right;
if (this.right) this.right.left = right;
const middle = new Leaf(point, undefined);
middle.left = left;
middle.right = right;
right.left = middle;
left.right = middle;
const br1 = new Breakpoint([this.point, left], [point, middle], undefined);
const br2 = new Breakpoint([point, br1], [this.point, right], this.parent);
br1.parent = br2;
if (this.parent instanceof Breakpoint) {
this.parent.set_me(this, br2);
} else {
this.parent.root = br2;
}
const maybe_left = left.check_circles(point.y, events);
if (maybe_left && maybe_left.center.coords[0] < middle.point.x) {
console.log(`Adding circle`);
maybe_left.print();
left.event = maybe_left;
events.add(maybe_left);
}
const maybe_right = right.check_circles(point.y, events);
if (maybe_right && maybe_right.center.coords[0] >= middle.point.x) {
console.log(`Adding circle`);
maybe_right.print();
right.event = maybe_right;
events.add(maybe_right);
}
}
check_circles(y: number, events: Queue): CircleEvent | undefined {
const left = this.left;
const right = this.right;
if (left && right) {
const circle = CircleEvent.from_sites(left.point, this.point, right.point, this);
console.log(`${circle.y} < ${y}`);
if (circle.y < y ) {
return circle;
}
}
}
delete(vertex: Vertex) {
if (this.parent instanceof Breakpoint) {
this.parent.remove_me(this.point, vertex);
} else {
console.error("Shouldnt be here");
}
}
print(indent: string) {
console.log(`${indent}Leaf from ${this.point.toString()} vertex: ${this.half_edge.to_string()}`);
}
}
class Breakpoint {
left: [Point, Node];
right: [Point, Node];
parent: Parent;
half_edge: HalfEdge;
constructor(left: [Point, Node], right: [Point, Node], parent: Parent) {
this.left = left;
this.right = right;
this.left[1].parent = this;
this.right[1].parent = this;
this.parent = parent;
this.half_edge = new HalfEdge(undefined, left[0].face, right[0].face);
}
remove_me(point: Point, vertex: Vertex) {
const edge = this.half_edge.insert(vertex);
const other = this.get_other(point);
if (this.parent instanceof Breakpoint) {
this.parent.set_me(this, other);
this.parent.set_edge(edge);
} else {
this.parent.root = other;
}
}
set_edge(edge: HalfEdge) {
this.left[1].half_edge = edge;
// this.right[1].half_edge = edge.split(edge.origin);
}
set_me(old_me: Node, new_me: Node) {
if (this.left[1] == old_me) {
this.left[1] = new_me;
} else {
this.right[1] = new_me;
}
}
get(point: Point): Leaf {
const { x, y } = point;
const test_x = calc_x(this.left[0], this.right[0], y);
if (test_x >= x) {
if (this.left[1] instanceof Leaf) {
return this.left[1];
} else {
return this.left[1].get(point);
}
} else {
if (this.right[1] instanceof Leaf) {
return this.right[1];
} else {
return this.right[1].get(point);
}
}
}
get_other(point: Point): Node {
if (this.left[0].equals(point)) {
return this.right[1];
} else {
return this.left[1];
}
}
print(indent: string) {
console.log(`${indent}vertex: ${this.half_edge.to_string()}`);
console.log(`${indent}left`);
this.left[1].print(indent + ' ');
console.log(`${indent}right`);
this.right[1].print(indent + ' ');
}
}
function get_from_node(root: Node, point: Point): Leaf {
if (root instanceof Leaf) {
return root;
} else {
return root.get(point);
}
}
class State {
root: Node | undefined;
print() {
if (this.root) {
this.root.print('');
} else {
console.log("No root no tree");
}
}
}
export function voronoi(points: Point[]): Point[] {
const out = [];
const state = new State;
const queue = new Heap<WithPriority>(cmp_event);
for (let point of points) {
queue.add(new SiteEvent(point));
}
let event;
while (event = queue.pop()){
console.log('---------------------------');
event.print();
if (event instanceof SiteEvent) {
handle_site_event(event, queue, state, out);
} else {
if (!event.alive) {
console.log("Dead");
continue;
}
handle_circle_event(event, queue, state, out);
}
state.print();
console.log(queue);
print_leaves(get_from_node(state.root, new Point(0, 0)));
}
return out;
}
function handle_site_event(event: SiteEvent, queue: Queue, state: State, out: Point[]) {
if (state.root) {
const leaf = get_from_node(state.root, event.point);
leaf.split(event.point, queue);
} else {
state.root = new Leaf(event.point, state);
}
}
function handle_circle_event(event: CircleEvent, queue: Queue, state: State, out: [number, number][]) {
if (!event.alive) return;
event.leaf.delete(event.center);
const right = event.leaf.right;
const left = event.leaf.left;
if (right) {
right.false_alarm();
// if (right.right) right.right.false_alarm();
right.left = left;
const maybe_right = right.check_circles(event.y, queue);
if (maybe_right){
console.log(`Adding circle event`);
maybe_right.print();
right.event = maybe_right;
queue.add(maybe_right);
}
}
if (left) {
left.false_alarm();
// if (left.left) left.left.false_alarm();
left.right = right;
const maybe_left = left.check_circles(event.y, queue);
if (maybe_left){
console.log(`Adding circle event`);
maybe_left.print();
left.event = maybe_left;
queue.add(maybe_left);
}
}
out.push(event.center.coords);
}
function print_leaves(start: Leaf) {
let current = start;
while (current.left) {
current = current.left;
}
const points = [current.point];
while (current.right) {
current = current.right;
points.push(current.point);
}
console.log(JSON.stringify(points.map((p) => p.toString())));
}