@ue-too/curve 0.5.2 → 0.7.0

package/src/composite-curve.ts

@@ -1,243 +0,0 @@
-import { Point, PointCal } from "@ue-too/math";
-
-export type HandleType = "ALIGNED" | "VECTOR" | "FREE";
-
-export type HandlePoint = {
-    position: Point;
-    type: HandleType;
-}
-
-export class ControlPoint {
-
-    private position: Point;
-    private leftHandle: HandlePoint;
-    private rightHandle: HandlePoint;
-
-    constructor(position: Point, leftHandle: HandlePoint, rightHandle: HandlePoint){
-        this.position = position;
-        this.leftHandle = leftHandle;
-        this.rightHandle = rightHandle;
-    }
-
-    setPosition(destinationPosition: Point, prevControlPoint: ControlPoint | undefined, nextControlPoint: ControlPoint | undefined){
-        let diff = PointCal.subVector(destinationPosition, this.position);
-        this.position = destinationPosition;
-        this.leftHandle.position = PointCal.addVector(this.leftHandle.position, diff);
-        this.rightHandle.position = PointCal.addVector(this.rightHandle.position, diff);
-        if(this.leftHandle.type == "VECTOR" && prevControlPoint){
-            let relativeVector = PointCal.subVector(prevControlPoint.getPosition(), this.position);
-            relativeVector = PointCal.multiplyVectorByScalar(relativeVector, 1 / 3);
-            this.leftHandle.position = PointCal.addVector(this.position, relativeVector);
-            if(this.rightHandle.type == "ALIGNED"){
-                let relativeVector = PointCal.subVector(this.rightHandle.position, this.position);
-                let mag = PointCal.magnitude(relativeVector);
-                let direction = PointCal.unitVectorFromA2B(this.leftHandle.position, this.position);
-                this.rightHandle.position = PointCal.addVector(this.position, PointCal.multiplyVectorByScalar(direction, mag));
-            }
-        }
-        if(this.rightHandle.type == "VECTOR" && nextControlPoint){
-            let relativeVector = PointCal.subVector(nextControlPoint.getPosition(), this.position);
-            relativeVector = PointCal.multiplyVectorByScalar(relativeVector, 1 / 3);
-            this.rightHandle.position = PointCal.addVector(this.position, relativeVector);
-            if(this.leftHandle.type == "ALIGNED"){
-                let mag = PointCal.distanceBetweenPoints(this.leftHandle.position, this.position);
-                let direction = PointCal.subVector(this.position, this.rightHandle.position);
-                this.leftHandle.position = PointCal.addVector(this.position, PointCal.multiplyVectorByScalar(direction, mag));
-            }
-        }
-        if(prevControlPoint !== undefined && prevControlPoint.getRightHandle().type == "VECTOR"){
-            let relativeVector = PointCal.subVector(this.position, prevControlPoint.getPosition());
-            relativeVector = PointCal.multiplyVectorByScalar(relativeVector, 1 / 3);
-            prevControlPoint.setRightHandlePosition(PointCal.addVector(prevControlPoint.getPosition(), relativeVector));
-        }
-        if(nextControlPoint !== undefined && nextControlPoint.getLeftHandle().type == "VECTOR"){
-            let relativeVector = PointCal.subVector(this.position, nextControlPoint.getPosition());
-            relativeVector = PointCal.multiplyVectorByScalar(relativeVector, 1 / 3);
-            nextControlPoint.setLeftHandlePosition(PointCal.addVector(nextControlPoint.getPosition(), relativeVector));
-        }
-    }
-
-    getPosition(): Point{
-        return this.position;
-    }
-
-    setLeftHandleTypeVector(prevControlPoint: ControlPoint | undefined){
-        if(this.rightHandle.type != "VECTOR"){
-            this.rightHandle.type = "FREE";
-        }
-        let relativeVector: Point;
-        if(prevControlPoint == undefined){
-            relativeVector = PointCal.subVector(this.leftHandle.position, this.position);
-        } else {
-            relativeVector = PointCal.subVector(prevControlPoint.getPosition(), this.position);
-            relativeVector = PointCal.multiplyVectorByScalar(relativeVector, 1 / 3);
-        }
-        this.leftHandle.position = PointCal.addVector(this.position, relativeVector);
-    }
-
-    setLeftHandleTypeAligned(){
-        this.leftHandle.type = "ALIGNED";
-        if(this.rightHandle.type == "VECTOR"){
-            let direction = PointCal.unitVectorFromA2B(this.rightHandle.position, this.position);
-            let mag = PointCal.distanceBetweenPoints(this.position, this.leftHandle.position);
-            this.leftHandle.position = PointCal.addVector(this.position, PointCal.multiplyVectorByScalar(direction, mag));
-        }
-    }
-
-    setLeftHandleTypeFree(){
-        this.leftHandle.type = "FREE";
-    }
-
-    setRightHandleTypeVector(nextControlPoint: ControlPoint | undefined) {
-        if(this.leftHandle.type != "VECTOR"){
-            this.leftHandle.type = "FREE";
-        }
-        let relativeVector: Point;
-        if(nextControlPoint == undefined){
-            relativeVector = PointCal.subVector(this.rightHandle.position, this.position);
-        } else {
-            relativeVector = PointCal.subVector(nextControlPoint.getPosition(), this.position);
-            relativeVector = PointCal.multiplyVectorByScalar(relativeVector, 1 / 3);
-        }
-        this.rightHandle.position = PointCal.addVector(this.position, relativeVector);
-    }
-
-    setRightHandleTypeAligned(){
-        this.rightHandle.type = "ALIGNED";
-        if(this.leftHandle.type == "VECTOR") {
-            let direciton = PointCal.unitVectorFromA2B(this.leftHandle.position, this.position);
-            let mag = PointCal.distanceBetweenPoints(this.position, this.rightHandle.position);
-            this.rightHandle.position = PointCal.addVector(this.position, PointCal.multiplyVectorByScalar(direciton, mag));
-        } 
-    }
-
-    setRightHandleTypeFree(){
-        this.rightHandle.type = "FREE";
-    }
-
-    setLeftHandlePosition(destPos: Point){
-        let leftHandleType = this.leftHandle.type;
-        switch(leftHandleType){
-            case "ALIGNED":
-                if(this.rightHandle.type == "VECTOR"){
-                    let diff = PointCal.subVector(destPos, this.position);
-                    let rightHandleDiff = PointCal.unitVectorFromA2B(this.rightHandle.position, this.position);
-                    let resMag = PointCal.dotProduct(diff, rightHandleDiff);
-                    let res = PointCal.multiplyVectorByScalar(rightHandleDiff, resMag);
-                    this.leftHandle.position = PointCal.addVector(this.position, res);
-                } else if (this.rightHandle.type == "ALIGNED"){
-                    this.leftHandle.position = destPos;
-                    let mag = PointCal.distanceBetweenPoints(this.rightHandle.position, this.position);
-                    let direction = PointCal.unitVectorFromA2B(this.leftHandle.position, this.position);
-                    let res = PointCal.multiplyVectorByScalar(direction, mag);
-                    this.rightHandle.position = PointCal.addVector(res, this.position);
-                } else {
-                    this.leftHandle.position = destPos;
-                }
-                break;
-            case "FREE":
-                this.leftHandle.position = destPos;
-                break;
-            case "VECTOR":
-                break;
-            default:
-                throw new Error(`Unknown left handle type for control point`);
-        }
-    }
-
-    setRightHandlePosition(destPos: Point){
-        let rightHandleType = this.rightHandle.type;
-        switch(rightHandleType){
-            case "ALIGNED":
-                if(this.leftHandle.type == "VECTOR"){
-                    let diff = PointCal.subVector(destPos, this.position);
-                    let leftHandleDiff = PointCal.unitVectorFromA2B(this.leftHandle.position, this.position);
-                    let resMag = PointCal.dotProduct(diff, leftHandleDiff);
-                    let res = PointCal.multiplyVectorByScalar(leftHandleDiff, resMag);
-                    this.rightHandle.position = PointCal.addVector(this.position, res);
-                } else if (this.rightHandle.type == "ALIGNED"){
-                    this.rightHandle.position = destPos;
-                    let mag = PointCal.distanceBetweenPoints(this.leftHandle.position, this.position);
-                    let direction = PointCal.unitVectorFromA2B(this.rightHandle.position, this.position);
-                    let res = PointCal.multiplyVectorByScalar(direction, mag);
-                    this.leftHandle.position = PointCal.addVector(res, this.position);
-                } else {
-                    this.rightHandle.position = destPos;
-                }
-                break;
-            case "FREE":
-                this.rightHandle.position = destPos;
-                break;
-            case "VECTOR":
-                break;
-            default:
-                throw new Error(`Unknown left handle type for control point`);
-        }
-    }
-
-    getLeftHandle(): HandlePoint{
-        return this.leftHandle;
-    }
-
-    getRightHandle(): HandlePoint{
-        return this.rightHandle;
-    }
-}
-
-export class CompositeBCurve{
-
-    private controlPoints: ControlPoint[];
-
-    constructor(controlPoints: ControlPoint[] = []){
-        this.controlPoints = controlPoints;
-    }
-
-    getControlPoints(): ControlPoint[]{
-        return this.controlPoints;
-    }
-
-    appendControlPoint(position: Point){
-        let leftHandlePosition = PointCal.addVector(position, {x: -100, y: 0});
-        let rightHandlePosition = PointCal.addVector(position, {x: 100, y: 0});
-        let leftHandlePoint: HandlePoint = {
-            position: leftHandlePosition,
-            type: "FREE"
-        }
-        let rightHandlePoint: HandlePoint = {
-            position: rightHandlePosition,
-            type: "FREE"
-        }
-
-        let newControlPoint = new ControlPoint(position, leftHandlePoint, rightHandlePoint);
-        this.controlPoints.push(newControlPoint);
-    }
-
-    setLeftHandlePositionOfControlPoint(controlPointIndex: number, destPos: Point){
-        if(controlPointIndex >= this.controlPoints.length || controlPointIndex < 0){
-            return;
-        }
-        this.controlPoints[controlPointIndex].setLeftHandlePosition(destPos);
-    }
-
-    setRightHandlePositionOfControlPoint(controlPointIndex: number, destPos: Point){
-        if(controlPointIndex >= this.controlPoints.length || controlPointIndex < 0){
-            return;
-        }
-        this.controlPoints[controlPointIndex].setRightHandlePosition(destPos);
-    }
-    
-    setPositionOfControlPoint(controlPointIndex: number, destPos: Point){
-        if(controlPointIndex >= this.controlPoints.length || controlPointIndex < 0){
-            return;
-        }
-        let prevControlPoint = undefined;
-        let nextControlPoint = undefined;
-        if(controlPointIndex + 1 < this.controlPoints.length){
-            nextControlPoint = this.controlPoints[controlPointIndex + 1];
-        }
-        if(controlPointIndex - 1 >= 0){
-            prevControlPoint = this.controlPoints[controlPointIndex - 1];
-        }
-        this.controlPoints[controlPointIndex].setPosition(destPos, prevControlPoint, nextControlPoint);
-    }
-}

package/src/index.ts

@@ -1,4 +0,0 @@
-export * from "./b-curve";
-export * from "./line";
-export * from "./composite-curve";
-export * from "./path";

package/src/line.ts

@@ -1,98 +0,0 @@
-import { PointCal, Point } from "@ue-too/math";
-
-export class Line {
-    private startPoint: Point;
-    private endPoint: Point;
-
-    constructor(startPoint: Point, endPoint: Point){
-        this.startPoint = startPoint;
-        this.endPoint = endPoint;
-    }
-
-    getStartPoint(): Point{
-        return this.startPoint;
-    }
-
-    getEndPoint(): Point{
-        return this.endPoint;
-    }
-
-    intersectionWithAnotherLine(lineToIntersect: Line){
-        return getLineIntersection(this.startPoint, this.endPoint, lineToIntersect.getStartPoint(), lineToIntersect.getEndPoint());
-    }
-
-    projectPoint(point: Point){
-        return projectPointOntoLine(point, this.getStartPoint(), this.getEndPoint());
-    }
-
-    length(): number{
-        return PointCal.distanceBetweenPoints(this.startPoint, this.endPoint);
-    }
-    
-    getTranslationRotationToAlginXAxis(){
-        const translation = PointCal.subVector({x: 0, y: 0}, this.startPoint);
-        const rotationAngle = PointCal.angleFromA2B(PointCal.subVector(this.endPoint, this.startPoint), {x: 1, y: 0});
-
-        return {translation, rotationAngle};
-    }
-
-    pointInLine(point: Point): boolean{
-        const baseVector = PointCal.unitVectorFromA2B(this.startPoint, this.endPoint);
-        const start2PointVector = PointCal.subVector(point, this.startPoint);
-        const length = PointCal.dotProduct(start2PointVector, baseVector);
-        const start2PointUnitVector = PointCal.unitVector(start2PointVector);
-        const errorThreshold = PointCal.distanceBetweenPoints(this.startPoint, this.endPoint) * 0.0001;
-        return length <= PointCal.distanceBetweenPoints(this.startPoint, this.endPoint) && length >= 0 && Math.abs(start2PointUnitVector.x - baseVector.x) < 0.0001 && Math.abs(start2PointUnitVector.y - baseVector.y) < 0.0001;
-    }
-
-    lerp(ratio: number): Point {
-        return PointCal.linearInterpolation(this.startPoint, this.endPoint, ratio);
-    }
-}
-
-export function getLineIntersection(startPoint: Point, endPoint: Point, startPoint2: Point, endPoint2: Point):{
-    intersects: boolean,
-    intersection?: Point,
-    offset?: number
-}{
-    const numerator = (endPoint2.x - startPoint2.x) * (startPoint.y - startPoint2.y) - (endPoint2.y - startPoint2.y) * (startPoint.x - startPoint2.x);
-    const denominator = (endPoint2.y - startPoint2.y) * (endPoint.x - startPoint.x) - (endPoint2.x - startPoint2.x) * (endPoint.y - startPoint.y);
-    
-    if (denominator === 0){
-        return {intersects: false};
-    }
-    const t = numerator / denominator;
-    if (t >= 0 && t <= 1){
-        return {
-            intersects: true, 
-            intersection: PointCal.linearInterpolation(startPoint, endPoint, t),
-            offset: t
-        }
-    } else {
-        return {
-            intersects: false,
-        }
-    }
-
-}
-
-export function projectPointOntoLine(point: Point, lineStartPoint: Point, lineEndPoint: Point): {
-    within: boolean,
-    projectionPoint?: Point,
-    offset?: number
-}{
-    const baseVector = PointCal.unitVector(PointCal.subVector(lineEndPoint, lineStartPoint));
-    const vectorToPoint = PointCal.subVector(point, lineStartPoint);
-    const res = PointCal.dotProduct(vectorToPoint, baseVector);
-    if (res < 0 || res > PointCal.magnitude(PointCal.subVector(lineEndPoint, lineStartPoint))){
-        return {
-            within: false,
-        };
-    }
-    return {
-        within: true,
-        projectionPoint: PointCal.addVector(lineStartPoint, PointCal.multiplyVectorByScalar(baseVector, res)),
-        offset: res / PointCal.magnitude(PointCal.subVector(lineEndPoint, lineStartPoint))
-    };
-
-}

package/src/path.ts

@@ -1,75 +0,0 @@
-import { Line } from "./line";
-import { Point } from "@ue-too/math";
-
-export class Path {
-
-    private lines: Line[];
-
-    constructor(lines: Line[]){
-        this.lines = lines;
-    }
-
-    append(line: Line): void{
-        this.lines.push(line);
-    }
-
-    clear(): void{
-        this.lines = [];
-    }
-
-    prepend(line: Line): void{
-        this.lines.unshift(line);
-    }
-
-    getLines(): Line[]{
-        return this.lines;
-    }
-
-    getLength(): number{
-        let res = 0;
-        this.lines.forEach((line)=>{
-            res += line.length();
-        });
-        return res;
-    }
-
-    getPercentages(): {start: number, end: number}[]{
-        const length = this.getLength();
-        let currentCurvePercentage = 0;
-        const res: {start: number, end: number}[] = [];
-        this.lines.forEach((line)=>{
-            const lineLength = line.length();
-            const linePercentage = lineLength / length;
-            let start = currentCurvePercentage;
-            currentCurvePercentage += linePercentage;
-            let end = currentCurvePercentage;
-            res.push({start, end});
-        });
-        res[res.length - 1].end = 1;
-        return res;
-    }
-
-    getPointByPercentage(percentage: number): Point | never{
-        if (percentage < 0 || percentage > 1){
-            throw new Error("Percentage must be between 0 and 1");
-        }
-        const percentages = this.getPercentages();
-        let left = 0;
-        let right = percentages.length - 1;
-        while (left <= right){
-            const mid = Math.floor((left + right) / 2);
-            if (percentage < percentages[mid].end){
-                right = mid - 1;
-            } else if (percentage > percentages[mid].end){
-                left = mid + 1;
-            } else {
-                left = mid;
-                break;
-            }
-        }
-        const line = this.lines[left];
-        const linePercentage = percentages[left];
-        const ratio = (percentage - linePercentage.start) / (linePercentage.end - linePercentage.start);
-        return line.lerp(ratio);
-    }
-}

package/src/utils.ts

@@ -1,47 +0,0 @@
-import { Point, PointCal } from '@ue-too/math';
-
-//JavaScript implementation of winding number algorithm to determine whether a point is inside a polygon
-//Based on C++ implementation of wn_PnPoly() published on http://geomalgorithms.com/a03-_inclusion.html
-// Original is vlasky's implementation on https://gist.github.com/vlasky/d0d1d97af30af3191fc214beaf379acc
-// TypeScript by gmac Greg MacWilliam https://gist.github.com/gmac
-
-function isLeft(x: Point, y: Point, z: Point): number {
-    return (y.x - x.x) * (z.y - x.y) - (z.x - x.x) * (y.y - x.y);
-}
-  
-export function pointInPolygonWN(p: Point, points: Array<Point>): boolean {
-    let wn = 0; // winding number
-
-    points.forEach((a, i) => {
-        const b = points[(i+1) % points.length];
-        if (a.y <= p.y) {
-        if (b.y > p.y && isLeft(a, b, p) > 0) {
-            wn += 1;
-        }
-        } else if (b.y <= p.y && isLeft(a, b, p) < 0) {
-        wn -= 1;
-        }
-    });
-
-    return wn !== 0;
-}
-
-export function pointInPolygon(polygonVertices: Point[], interestedPoint: Point){
-    let angleCheck = polygonVertices.map((point, index, array)=>{
-        let endPoint: Point;
-        if (index == polygonVertices.length - 1) {
-            // last one need to wrap to the first point
-            endPoint = array[0];
-        }else {
-            endPoint = array[index + 1];
-        }
-        let baseVector = PointCal.subVector(endPoint, point);
-        let checkVector = PointCal.subVector(interestedPoint, point);
-        return PointCal.angleFromA2B(baseVector, checkVector);
-    });
-    let outOfPolygon = angleCheck.filter((angle)=>{
-        return angle > 0;
-    }).length > 0;
-
-    return !outOfPolygon;
-}