tela.js 1.0.0

package/src/Scene/Point.js

@@ -0,0 +1,109 @@
+import Box from "../Box/Box.js";
+import Color from "../Color/Color.js";
+import { none, some } from "../Monads/Monads.js";
+import Vec, { Vec3 } from "../Vector/Vector.js";
+
+class Point {
+    constructor({ name, position, normal, color, radius }) {
+        this.name = name;
+        this.color = color;
+        this.normal = normal;
+        this.radius = radius;
+        this.position = position;
+    }
+
+    distanceToPoint(p) {
+        return this.position.sub(p).length() - this.radius;
+    }
+
+    interceptWith(ray) {
+        return sphereInterception(this, ray)
+            .map(t => {
+                const pointOnSphere = ray.trace(t);
+                const normal = pointOnSphere.sub(this.position).normalize();
+                return [pointOnSphere, normal];
+            })
+    }
+
+    getBoundingBox() {
+        if (this.boundingBox) return this.boundingBox;
+        const n = this.position.dim;
+        this.boundingBox = new Box(
+            this.position.add(Vec.ONES(n).scale(-this.radius)),
+            this.position.add(Vec.ONES(n).scale(this.radius))
+        );
+        return this.boundingBox;
+    }
+
+    static builder() {
+        return new PointBuilder();
+    }
+}
+
+
+
+class PointBuilder {
+    constructor() {
+        this._name;
+        this._color = Color.WHITE;
+        this._radius = 1;
+        this._normal = Vec3(1, 0, 0);
+        this._position = Vec3(0, 0, 0);
+    }
+
+    name(name) {
+        this._name = name;
+        return this;
+    }
+
+    color(color) {
+        this._color = color;
+        return this;
+    }
+
+
+    radius(radius) {
+        this._radius = radius;
+        return this;
+    }
+
+    normal(normal) {
+        this._normal = normal;
+        return this;
+    }
+
+    position(posVec3) {
+        this._position = posVec3;
+        return this;
+    }
+
+    build() {
+        const attrs = {
+            name: this._name,
+            color: this._color,
+            radius: this._radius,
+            normal: this._normal,
+            position: this._position,
+        }
+        if (Object.values(attrs).some((x) => x === undefined)) {
+            throw new Error("Point is incomplete");
+        }
+        return new Point(attrs);
+    }
+}
+
+function sphereInterception(point, ray) {
+    const { init, dir } = ray;
+    const diff = init.sub(point.position);
+    const b = 2 * dir.dot(diff);
+    const c = diff.squareLength() - point.radius * point.radius;
+    const discriminant = b * b - 4 * c; // a = 1
+    if (discriminant < 0) return none();
+    const sqrt = Math.sqrt(discriminant);
+    const [t1, t2] = [(-b - sqrt) / 2, (-b + sqrt) / 2];
+    const t = Math.min(t1, t2);
+    if (t1 * t2 < 0) return some(t);
+    return t1 >= 0 && t2 >= 0 ? some(t) : none();
+}
+
+export default Point;

package/src/Scene/PointCloud.js

@@ -0,0 +1,51 @@
+class PointCloud {
+    constructor({ name, pointCloud }) {
+        this.name = name;
+        this.pointCloud = pointCloud
+    }
+
+    interceptWith(ray) {
+        // TODO;
+    }
+
+    getBoundingBox() {
+        if (this.boundingBox) return this.boundingBox;
+        // TODO
+    }
+
+    static builder() {
+        return new PointCloudBuilder();
+    }
+}
+
+
+
+class PointCloudBuilder {
+    constructor() {
+        this._name;
+        this._pointCloud = [];
+    }
+
+    name(name) {
+        this._name = name;
+        return this;
+    }
+
+    objFile(objString) {
+        //TODO
+        return this;
+    }
+
+    build() {
+        const attrs = {
+            name: this._name,
+            pointCloud: this._pointCloud
+        }
+        if (Object.values(attrs).some((x) => x === undefined)) {
+            throw new Error("Point is incomplete");
+        }
+        return new PointCloud(attrs);
+    }
+}
+
+export default PointCloud;

package/src/Scene/Scene.js

@@ -0,0 +1,200 @@
+
+import Box from "../Box/Box.js";
+import { none, some } from "../Monads/Monads.js";
+import { argmin } from "../Utils/Utils.js";
+import Point from "./Point.js";
+import Ray from "../Ray/Ray.js";
+import Vec from "../Vector/Vector.js";
+import { smin } from "../Utils/Math.js";
+
+export default class Scene {
+  constructor() {
+    this.id2ElemMap = {};
+    this.sceneElements = [];
+    this.boundingBoxScene = new Node();
+  }
+
+  add(...elements) {
+    return this.addList(elements);
+  }
+
+  addList(elements) {
+    for (let i = 0; i < elements.length; i++) {
+      const elem = elements[i];
+      const classes = [Point];
+      if (!classes.some((c) => elem instanceof c)) return this;
+      const { name } = elem;
+      this.id2ElemMap[name] = elem;
+      this.sceneElements.push(elem);
+      this.boundingBoxScene.add(elem);
+    }
+    return this;
+  }
+
+  clear() {
+    this.id2ElemMap = {};
+    this.sceneElements = [];
+    this.boundingBoxScene = new Node();
+  }
+
+  getElements() {
+    return this.sceneElements;
+  }
+
+  interceptWith(ray, level) {
+    return this.boundingBoxScene.interceptWith(ray, level);
+  }
+
+  distanceToPoint(p) {
+    return this.boundingBoxScene.distanceToPoint(p)
+  }
+
+  estimateNormal(p) {
+    const epsilon = 1e-3;
+    const n = p.dim;
+    const grad = [];
+    const d = this.distanceToPoint(p);
+    for (let i = 0; i < n; i++) {
+      grad.push(this.distanceToPoint(p.add(Vec.e(n)(i).scale(epsilon))) - d);
+    }
+    return Vec.fromArray(grad).scale(Math.sign(d)).normalize();
+  }
+}
+
+class Node {
+  isLeaf = false;
+  numberOfLeafs = 0;
+  leafs = [];
+  constructor() {
+    this.box = Box.EMPTY;
+  }
+
+  add(element) {
+    this.numberOfLeafs += 1;
+    this.leafs.push(element);
+    const elemBox = element.getBoundingBox();
+    this.box = this.box.add(elemBox);
+    if (!this.left) {
+      this.left = new Leaf(element);
+    } else if (!this.right) {
+      this.right = new Leaf(element);
+    } else {
+      this._addElementWhenTreeIsFull(element, elemBox);
+    }
+    return this;
+  }
+
+  distanceToPoint(p) {
+    if (this.numberOfLeafs <= 2) {
+      return this.getElements().reduce((e, leaf) => smin(e, leaf.distanceToPoint(p)), 1000);
+    }
+    const children = [this.left, this.right];
+    const index = argmin(children, c => c.box.distanceToPoint(p));
+    return children[index].distanceToPoint(p);
+  }
+
+  getElements() {
+    return this.leafs;
+  }
+
+  getRandomLeaf() {
+    return Math.random() < 0.5 ? this.left.getRandomLeaf() : this.right.getRandomLeaf();
+  }
+
+  interceptWith(ray, depth = 1) {
+    if (this.numberOfLeafs === 5) {
+      // return this.getRandomLeaf().interceptWith(ray, 10);
+      return this.box.interceptWith(ray).map(p => [p, this.box.estimateNormal(p)]);
+    }
+    return this.box.interceptWith(ray).flatMap((p) => {
+      const children = [this.left, this.right].filter(x => x);
+      const hits = [];
+      for (let i = 0; i < children.length; i++) {
+        const maybeHit = children[i].interceptWith(ray, depth + 1);
+        if (maybeHit.isSome()) hits.push(maybeHit.orElse());
+      }
+      const minIndex = argmin(hits, ([point]) => point.sub(ray.init).length());
+      if (minIndex === -1) return none();
+      return some(hits[minIndex]);
+    })
+  }
+
+  _addElementWhenTreeIsFull(element, elemBox) {
+    if (this.left.isLeaf && this.right.isLeaf) {
+      this._addWithLeafs(element);
+    } else {
+      // at least one children is not a leaf
+      const minIndex = argmin([
+        this.left.box.distanceToBox(elemBox),
+        this.right.box.distanceToBox(elemBox)
+      ]);
+      this._updateChildren(minIndex, element);
+    }
+  }
+
+  _updateChildren(minIndex, element) {
+    let child = [this.left, this.right][minIndex];
+    if (!child.isLeaf) {
+      child.add(element);
+    } else {
+      const aux = child.element;
+      if (minIndex === 0) this.left = new Node().add(aux).add(element);
+      if (minIndex === 1) this.right = new Node().add(aux).add(element);
+    }
+  }
+
+  _addWithLeafs(element) {
+    const elemBox = element.getBoundingBox();
+    const distances = [
+      elemBox.distanceToBox(this.left.box),
+      elemBox.distanceToBox(this.right.box),
+      this.left.box.distanceToBox(this.right.box)
+    ]
+    const index = argmin(distances);
+    const index2Action = {
+      0: () => {
+        const aux = this.left;
+        this.left = new Node();
+        this.left.add(aux.element).add(element);
+      },
+      1: () => {
+        const aux = this.right;
+        this.right = new Node();
+        this.right.add(aux.element).add(element);
+      },
+      2: () => {
+        const aux = this.left;
+        this.left = new Node();
+        this.left.add(aux.element).add(this.right.element);
+        this.right = new Leaf(element);
+      }
+    }
+    index2Action[index]();
+  }
+}
+
+class Leaf {
+  isLeaf = true;
+  constructor(element) {
+    this.element = element;
+    this.box = element.getBoundingBox();
+  }
+
+  distanceToPoint(x) {
+    // return this.box.distanceToPoint(x);
+    return this.element.distanceToPoint(x);
+  }
+
+  getLeafs() {
+    return [this];
+  }
+
+  getRandomLeaf() {
+    return this;
+  }
+
+  interceptWith(ray, depth) {
+    // return this.box.interceptWith(ray).map(pos => [pos, this.box.estimateNormal(pos)]);
+    return this.element.interceptWith(ray);
+  }
+}

package/src/Stream/Stream.js

@@ -0,0 +1,10 @@
+export default class Stream {
+    constructor(initialState, updateStateFunction) {
+        this._head = initialState;
+        this._tail = updateStateFunction;
+    }
+
+    get head() { return this._head; }
+
+    get tail() { return new Stream(this._tail(this._head), this._tail); }
+}

package/src/Utils/Constants.js

@@ -0,0 +1 @@
+export const MAX_8BIT = 255;

package/src/Utils/Math.js

@@ -0,0 +1,65 @@
+export function smin(a, b, k = 32) {
+    const res = Math.exp(-k * a) + Math.exp(-k * b);
+    return -Math.log(res) / k;
+}
+
+export function clipLine(p0, p1, box) {
+    const pointStack = [p0, p1];
+    const inStack = [];
+    const outStack = [];
+    for (let i = 0; i < pointStack.length; i++) {
+        const p = pointStack[i];
+        if (box.collidesWith(p)) {
+            inStack.push(p);
+        } else {
+            outStack.push(p);
+        }
+    }
+    // both points are inside
+    if (inStack.length >= 2) {
+        return inStack;
+    }
+    // one of them is inside
+    if (inStack.length === 1) {
+        const [inPoint] = inStack;
+        const [outPoint] = outStack;
+        return [inPoint, ...lineBoxIntersection(inPoint, outPoint)];
+    }
+    // both points are outside,need to intersect the boundary
+    return lineBoxIntersection(...outStack, box);
+}
+
+function lineBoxIntersection(start, end, box) {
+    const width = box.max.get(0) - box.min.get(0);
+    const height = box.max.get(1) - box.min.get(1);
+    const v = end.sub(start);
+    // point and direction of boundary
+    const boundary = [
+        [vec2.ZERO, vec2.of(height, 0)],
+        [vec2.of(height, 0), vec2.of(0, width)],
+        [vec2.of(height, width), vec2.of(-height, 0)],
+        [vec2.of(0, width), vec2.of(0, -width)],
+    ];
+    const intersectionSolutions = [];
+    boundary.forEach(([s, d]) => {
+        if (d.get(0) === 0) {
+            const solution = this._solveLowTriMatrix(v, -d.get(1), s.sub(start));
+            solution !== undefined && intersectionSolutions.push(solution);
+        } else {
+            const solution = this._solveUpTriMatrix(v, -d.get(0), s.sub(start));
+            solution !== undefined && intersectionSolutions.push(solution);
+        }
+    });
+    const validIntersections = [];
+    intersectionSolutions.forEach((solution) => {
+        const [x, y] = [solution.get(0), solution.get(1)];
+        if (0 <= x && x <= 1 && 0 <= y && y <= 1) {
+            validIntersections.push(solution);
+        }
+    });
+    if (validIntersections.length === 0) return [];
+    return validIntersections.map((solution) => {
+        const t = solution.get(0);
+        return start.add(v.scale(t));
+    });
+}

package/src/Utils/Utils.js

@@ -0,0 +1,39 @@
+export function measureTime(lambda) {
+    const t = performance.now();
+    lambda()
+    return 1e-3 * (performance.now() - t);
+}
+
+export function measureTimeWithResult(lambda) {
+    const t = performance.now();
+    const result = lambda();
+    return { result, time: 1e-3 * (performance.now() - t) };
+}
+
+export function compose(f, g) {
+    return x => f(g(x));
+}
+
+export function or(...lambdas) {
+    for (let i = 0; i < lambdas.length; i++) {
+        try {
+            return lambdas[i]();
+        } catch (err) {
+            continue;
+        }
+    }
+}
+
+export function argmin(array, costFunction = x => x) {
+    let argminIndex = -1;
+    let cost = Number.MAX_VALUE;
+    // faster than forEach
+    for (let i = 0; i < array.length; i++) {
+        const newCost = costFunction(array[i]);
+        if (newCost < cost) {
+            cost = newCost;
+            argminIndex = i;
+        }
+    }
+    return argminIndex;
+}