flo-mat 2.0.4 → 3.0.0

package/src/point-on-shape.ts

@@ -1,231 +0,0 @@
-import { dot, fromTo, toUnitVector, rotateNeg90Degrees } from 'flo-vector2d';
-import { memoize } from 'flo-memoize';
-import { curvature, evalDeCasteljau, tangent }   from 'flo-bezier3';
-import { Curve, getCornerAtEnd } from './curve.js';
-import { Circle } from './circle.js';
-
-
-interface IPointOnShape {
-    /** The [[ICurve]] on the shape boundary this points belong to. */
-    curve: Curve;
-    /** The bezier parameter value on the curve identifying the point coordinates. */
-    t: number;
-    p: number[];
-}
-
-
-/**
- * Represents a point on the shape boundary for which MAT vertex information 
- * has not *necessarily* been calculated.
- */
-class PointOnShape implements IPointOnShape {
-
-    /** 
-     * @param curve	The [[ICurve]] on the shape boundary this points belong to.
-     * @param t The bezier parameter value on the curve to identify the point
-     * coordinates.
-     */	
-    constructor(
-            public readonly curve: Curve,
-            public readonly t: number) {
-    }	
-
-
-    // Cache
-    private p_ : number[] = undefined;
-    /**
-     * The planar point coordinates of this [[PointOnShape]].
-     */
-    get p() {
-        return this.p_ === undefined
-            ? this.p_ = evalDeCasteljau(this.curve.ps, this.t)
-            : this.p_;
-    }
-}
-
-
-/**
- * @hidden
- */
-function isPosCorner(pos: IPointOnShape) {
-    return (pos.t === 0 || pos.t === 1);
-}
-
-
-/**
- * @hidden
- */
-function getPosCorner(pos: IPointOnShape) {
-    return getCornerAtEnd(
-        pos.t === 1 ? pos.curve : pos.curve.prev
-    );
-}
-
-
-/**
- * @hidden
- */
-const isPosSharpCorner = memoize((pos: IPointOnShape) => {
-    if (!isPosCorner(pos)) { return false; }
-
-    return getPosCorner(pos).isSharp;
-});
-
-
-/**
- * @hidden
- */
-const isPosDullCorner = memoize((pos: IPointOnShape) => {
-    if (!isPosCorner(pos)) { return false; }
-
-    return getPosCorner(pos).isDull;
-});
-
-
-/**
- * @hidden
- */
-const isPosQuiteSharpCorner = memoize((pos: IPointOnShape) => {
-    if (!isPosCorner(pos)) { return false; }
-
-    return getPosCorner(pos).isQuiteSharp;
-});
-
-
-/**
- * @hidden
- */
-const isPosQuiteDullCorner = memoize((pos: IPointOnShape) => {
-    if (!isPosCorner(pos)) { return false; }
-
-    return getPosCorner(pos).isQuiteDull;
-});
-
-
-/**
- * Returns a human-readable string of the given [[PointOnShape]]. 
- * For debugging only.
- * @hidden
- */
-function posToHumanString(pos: IPointOnShape) {
-    return '' + pos.p[0] + ', ' + pos.p[1] + 
-        ' | bz: '   + pos.curve.idx + 
-        ' | t: '    + pos.t 
-}
-
-
-/**
- * @hidden
- * Calculates the order (to distinguish between points lying on top of each 
- * other) of the contact point if it is a dull corner.
- * @param pos
- */
-function calcPosOrder(
-        circle : Circle, 
-        pos    : IPointOnShape): number {
-
-    if (!isPosCorner(pos)) { return 0; }
-    if (!isPosDullCorner(pos)) { return 0; }
-    //if (!isPosDullCorner(pos)) { return 0; }
-
-    const corner = getPosCorner(pos);
-
-    const n = rotateNeg90Degrees(corner.tangents[0]);
-    const v = toUnitVector( fromTo(pos.p, circle.center) );
-
-    return -dot(n, v);
-}
-
-
-/**
- * Compares two [[PointOnShape]]s according to their cyclic ordering imposed
- * by their relative positions on the shape boundary. 
- * @param a The first [[PointOnShape]].
- * @param b The second [[PointOnShape]].
- * @hidden
- */
-function comparePoss(a: IPointOnShape, b: IPointOnShape) {
-    if (a === undefined || b === undefined) {
-        return undefined;
-    }
-    
-    let res;
-    
-    res = a.curve.idx - b.curve.idx;
-    if (res !== 0) { return res; }
-
-    res = a.t - b.t;
-
-    return res;
-}
-
-
-/**
- * Calculates and returns the osculating circle radius of the bezier at a 
- * specific t. If it is found to have negative or nearly zero radius
- * it is clipped to have positive radius so it can point into the shape.
- * @param ps
- * @param t
- * @hidden
- */
-const calcOsculatingCircleRadius = memoize((pos: IPointOnShape) => {
-    const ps = pos.curve.ps;
-    const t  = pos.t;
-
-    const c = -curvature(ps, t); 
-
-    // c > 0 => bending inwards
-
-    return 1/c;
-});
-
-
-/**
- * Returns the osculating circle at this point of the curve.
- * @param maxOsculatingCircleRadius If not Number.POSITIVE_INFINITY then the
- * circle radius will be limited to this value.
- * @param pos The [[PointOnShape]] identifying the point.
- */
-function getOsculatingCircle(
-        maxOsculatingCircleRadius: number, 
-        pos: IPointOnShape): Circle {
-
-    if (isPosSharpCorner(pos)) {
-        return { center: pos.p, radius: 0 };
-    }
-
-    let radius = calcOsculatingCircleRadius(pos); 
-
-    if (radius < 0) { radius = Number.POSITIVE_INFINITY; }
-    radius = Math.min(
-        radius, 
-        maxOsculatingCircleRadius
-    );
-
-    const ps = pos.curve.ps;
-    const t  = pos.t;
-    
-    const tangent_ = tangent(ps,t);
-    const normal_ = toUnitVector([-tangent_[1],tangent_[0]]);
-    const p = evalDeCasteljau(ps,t);
-    const circleCenter = [
-        p[0] - normal_[0]*radius,
-        p[1] - normal_[1]*radius
-    ];
-
-    return { center: circleCenter, radius };
-}
-
-
-export { 
-    IPointOnShape,
-    PointOnShape, 
-    getOsculatingCircle,
-    comparePoss, 
-    calcPosOrder,
-    posToHumanString,
-    isPosSharpCorner,
-    isPosDullCorner,
-    isPosQuiteSharpCorner,
-    isPosQuiteDullCorner
-}

package/src/svg/get-curvature-at-interface.ts

@@ -1,55 +0,0 @@
-// TODO - move to another library
-import { tangent } from 'flo-bezier3';
-import { dot, cross, toUnitVector } from 'flo-vector2d';
-import { Curve } from '../curve.js';
-
-
-/**
- * @hidden
- * Get the angle between the given bezier endpoint and the
- * startpoint of the next bezier.
- * @param curve
- */
-function getCurvatureAtInterface(curve: Curve) {	
-	const pss = [
-		curve.ps,
-		curve.next.ps
-	];
-	
-	const tans = [ 
-		toUnitVector(tangent(pss[0], 1)), 
-		toUnitVector(tangent(pss[0], 0))
-	];
-	
-	// The integral of a kind of Dirac Delta function.
-	const cosθ = dot  (tans[0], tans[1]);
-	const sinθ = cross(tans[0], tans[1]);
-	const θ = acos(cosθ);
-	
-	const result = sinθ >= 0 ? θ : -θ;
-	
-	return result;
-}
-
-
-/**
- * @hidden
- * Floating-point 'safer' version of acos. If x is larger than 1 (or smaller 
- * than -1), still returns 0 (or Math.PI) instead of NAN.
- * @param x
- * @example 
- * 		acos(1);  //=> 0
- *      acos(2);  //=> 0
- */
-function acos(x: number): number {
-	if (x > 1) {
-		return 0;
-	} else if (x < -1) {
-		return Math.PI;
-	}
-	
-	return Math.acos(x);
-}
-
-
-export { getCurvatureAtInterface }