@ccpc/math 0.1.0 → 0.1.7

package/types/algorithm/pj/pt_loop_pj.d.ts

@@ -0,0 +1,24 @@
+import { PtLoopPJType } from './pj_type';
+import { Vec2 } from '../../base/vec2';
+import { Loop } from '../../topology/loop';
+import { Curve2 } from '../../geometry/curve2';
+/**
+ *
+ *  点与Loop的位置关系判断
+ *  [参考文献](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.88.5498&rep=rep1&type=pdf)
+ */
+declare class PtLoopPJ {
+    /**
+     * @param point
+     * @param loop
+     * @param tolerance
+     * @returns `CurvesPJType`
+     */
+    static execute(pt: Vec2, loop: Loop, eps?: number): {
+        type: PtLoopPJType;
+        curve?: Curve2;
+    };
+    private static _dealHorizontalLineLoop;
+    private static _getRefPt;
+}
+export { PtLoopPJ };

package/types/algorithm/pj/pt_polygon_pj.d.ts

@@ -0,0 +1,18 @@
+import { PtLoopPJType } from './pj_type';
+import { Vec2 } from '../../base/vec2';
+import { Polygon } from '../../topology/polygon';
+/**
+ *
+ * 点和PolygonEx的位置关系判断
+ */
+export declare class PtPolygonPJ {
+    /**
+     * 点与Polygon的位置关系判断
+     *
+     * @param point
+     * @param polygon
+     * @param tolerance
+     * @returns `CurvesPJType`
+     */
+    static execute(pt: Vec2, polygon: Polygon, tolerance?: number): PtLoopPJType;
+}

package/types/algorithm/pj/pt_polygon_position_judger.d.ts

@@ -0,0 +1,11 @@
+import { types } from '../../type_define/i_types';
+import { PtLoopPJType } from './pj_type';
+/**
+ * 仅用于点和多边形的内外关系判断
+ * 通过对边的排序，使得对多个点的判断效率为 O(n log(m))，n为点数，m为边数
+ */
+export declare class PtPolygonPositionJudger {
+    private _tree;
+    constructor(pointLoops: types.IXY[][]);
+    judge(point: types.IXY, eps?: number): PtLoopPJType;
+}

package/types/algorithm/position_judge.d.ts

@@ -0,0 +1,72 @@
+import { CurvesPJType, LoopsPJType, PtLoopPJType } from './pj/pj_type';
+import { Vec } from '../base/vec';
+import { Curve } from '../geometry/curve';
+import { Vec3 } from '../base/vec3';
+import { Plane } from '../geometry/plane';
+import { Loop } from '../topology/loop';
+import { Vec2 } from '../base/vec2';
+import { Polygon } from '../topology/polygon';
+import { Curve2 } from '../geometry/curve2';
+export interface IPtLoopResult {
+    type: PtLoopPJType;
+    curve?: Curve2;
+}
+declare class PJ {
+    /**
+     * 点是否在平面的右侧，
+     *
+     * 规定：点在平面法线一侧为右侧，否则为左侧
+     *
+     * @param point 任意一点
+     * @param plane 任意平面
+     */
+    static isPtAbovePlane(point: Vec3, plane: Plane): boolean;
+    /**
+     * 曲线与曲线的位置关系判断:相交，重叠，不相交。
+     * 支持 直线和圆弧
+     * @param curve1
+     * @param curve2
+     * @param tolerance
+     * @returns `CurvesPJType`
+     */
+    static curveToCurve<PointType extends Vec>(curve1: Curve<PointType>, curve2: Curve<PointType>, distanceTol?: number, angleTol?: number): CurvesPJType;
+    /**
+     * 曲线和曲线是否重叠关系判断：不重叠，重叠，部分重叠
+     * 支持直线、圆弧
+     * @param curve1
+     * @param curve2
+     * @param distanceTol
+     * @param angleTol
+     */
+    static curvesOverlap<PointType extends Vec>(curve1: Curve<PointType>, curve2: Curve<PointType>, distanceTol?: number, angleTol?: number): CurvesPJType;
+    /**
+     * 点与Loop的位置关系判断:ONEDGE, ONVERTEX，IN，OUT
+     *
+     * @param point
+     * @param loop
+     * @param tolerance
+     * @returns `CurvesPJType`
+     */
+    static ptToLoop(pt: Vec2, loop: Loop, tolerance?: number): IPtLoopResult;
+    /**
+     * 点与Polygon的位置关系判断
+     *
+     * @param point
+     * @param Polygon
+     * @param tol
+     * @returns `CurvesPJType`
+     */
+    static ptToPolygon(pt: Vec2, polygon: Polygon, tol?: number): PtLoopPJType;
+    /**
+     * Loop1与Loop2的位置关系判断：相离、外切、相交、内切、包含
+     * 逆时针的环为外环，顺时针的环为内环
+     *
+     * @param curve 2d曲线
+     * @param loop
+     * @param tolerance
+     * @param tangentIsIntersect 如果是true将内切和外切的情况判断为intersect；如果是false，则外切的情况认为是out，内切的情况认为是contain或者in。默认为false
+     * @returns `CurvesPJType`
+     */
+    static loopToLoop(loop1: Loop, loop2: Loop, tol?: number, tangentIsIntersect?: boolean): LoopsPJType;
+}
+export { PJ };

package/types/algorithm/project/curve3d_to_plane_project.d.ts

@@ -0,0 +1,11 @@
+import { Plane } from '../../geometry/plane';
+import { Curve3 } from '../../geometry/curve3d';
+import { Curve2 } from '../../geometry/curve2';
+import { Tol } from '../../base/tol';
+export declare class Curve3ProjectToPlane {
+    private _plane;
+    private _curve;
+    private _tol;
+    constructor(curve: Curve3, plane: Plane, tol?: Tol);
+    execute(): Curve2 | undefined;
+}

package/types/algorithm/project/curve_curve_project.d.ts

@@ -0,0 +1,9 @@
+import { Interval } from '../../base/interval';
+import { ILine } from '../../type_define/i_geometry';
+import { Vec } from '../../base/vec';
+/**
+ * curve1 向 curve2 投影，返回一个区间，该区间代表投影后的线在 curve2 参数域上的区间
+ */
+export declare class CurvesProject {
+    static lines<VectorType extends Vec>(line1: ILine<VectorType>, line2: ILine<VectorType>): Interval;
+}

package/types/algorithm/search_graph/iloops_polygonex.d.ts

@@ -0,0 +1,28 @@
+import { Loop } from '../../topology/loop';
+interface INestedLoop {
+    loop: ILoop;
+    nesting: INestedLoop[];
+    level: number;
+    isCCW: boolean;
+}
+interface ILoop {
+    reverse(): any;
+}
+/**
+ * Polygon变成PolygonEx
+ */
+export declare class ILoopsToPolygonExes {
+    /**
+     * 根据Polygon内部环的嵌套包含关系，将Polygon拆分成polygonEx
+     * 条件：Polygon环之间不相交
+     * @param polygon
+     * @param keepPositive 是否保持结果都是正向的（外环逆时针，内环顺时针）
+     * @param considerLoopDir 是否考虑环之间的相对方向(如果不考虑，则会将所有的直接子环作为内环，如果考虑，则只会将方向相反的直接子环作为内环)
+     * @param convertToLoop 转换成Loop的方法
+     */
+    static execute<T>(polygon: ILoop[], keepPositive: boolean, considerLoopDir?: boolean, convertToLoop?: (iLoop: T) => Loop): T[][];
+    static getNestedLoops(loops: ILoop[], convertToLoop: (iLoop: ILoop) => Loop): INestedLoop[];
+    static createFaces(nestedLoop: INestedLoop, considerLoopDir: boolean, usedLoopMap: Map<ILoop, boolean>, newFaces: INestedLoop[][]): void;
+    private static _loopContainsLoop;
+}
+export {};

package/types/algorithm/search_graph/loop_tree_node.d.ts

@@ -0,0 +1,30 @@
+import { Loop } from '../../topology/loop';
+import { Polygon } from '../../topology/polygon';
+/**
+ * 根据包含关系创建的loop树节点
+ */
+declare class LoopTreeNode {
+    children: LoopTreeNode[];
+    data?: Loop;
+    addToChild(node: LoopTreeNode): void;
+    isPolygonValid(): boolean;
+    /**
+     * 转成一个合法的polygon
+     */
+    makeValid(isAntiClock: boolean): void;
+    /**
+     * 搜集所有的loop
+     */
+    collectLoops(loops: Loop[]): void;
+    /**
+     * 搜集所有的loop
+     */
+    collectHoles(polygons: Polygon[]): void;
+    /**
+     * 搜集所有的PolygonExes
+     */
+    collectNewPolygonExes(polygons: Polygon[]): void;
+    private _makeClockwise;
+    private _makeAnticlockwise;
+}
+export { LoopTreeNode };

package/types/algorithm/search_graph/loops_to_loop_tree_search_graph.d.ts

@@ -0,0 +1,25 @@
+import { LoopTreeNode } from './loop_tree_node';
+import { Loop } from '../../topology/loop';
+/**
+ * 根据包含关系，将loop[]，组成polygon
+ */
+declare class LoopsToLoopTreeSearchGraph {
+    static scale: number;
+    /**
+     * 根据包含关系，将loop[]，组成polygon
+     * @param curve
+     * @param polygon
+     */
+    static execute(loops: Loop[]): LoopTreeNode;
+    private static _ptToKey;
+    private static _ptsToKey;
+    private static _polyTreeToLoopTree;
+    /**
+     * clipper布尔运算时会自动合并边，并且会圆整整数，因此采用一个点去拓扑追踪原来的环
+     * @param path
+     * @param originLoops
+     * @param loops
+     */
+    private static _findLoop;
+}
+export { LoopsToLoopTreeSearchGraph };

package/types/algorithm/search_graph/polygon_polygonex.d.ts

@@ -0,0 +1,13 @@
+import { Polygon } from '../../topology/polygon';
+/**
+ * Polygon变成PolygonEx
+ */
+export declare class PolygonToPolygonExes {
+    /**
+     * 根据Polygon内部环的嵌套包含关系，将Polygon拆分成polygonEx
+     * 条件：Polygon环之间不相交
+     * @param polygon
+     * @returns polygon[]
+     */
+    static execute(polygon: Polygon): Polygon[];
+}

package/types/algorithm/search_graph/search_loop2d.d.ts

@@ -0,0 +1,20 @@
+import { Curve2 } from '../../geometry/curve2';
+import { Loop } from '../../topology/loop';
+/**
+ *
+ * 搜索环
+ */
+export declare class SearchLoop2D {
+    /**
+     * 从输入的有向曲线中找到所有的最小环
+     * 条件：曲线已经求交打断过的，且没有同向完全重叠的曲线
+     * @param curve2ds 输入的有向曲线
+     * @param bMin true -> 找最小环, false -> 找最大环
+     * @param distTol 距离容差
+     */
+    static execute(curve2ds: Curve2[], bMin: boolean, distTol?: number): Loop[];
+    private static _findMaxTurning2D;
+    private static _getAppropriateUnitStepLength;
+    private static _calcStepAngle;
+    private static _getAppropriateParamStep;
+}

package/types/algorithm/search_graph/search_polyline.d.ts

@@ -0,0 +1,11 @@
+import { Curve2 } from '../../geometry/curve2';
+import { PolyCurve } from '../../topology/polycurve';
+import { Loop } from '../../topology/loop';
+/**
+ * 搜索简单Polyline，简单Polyline就是Coedge只在端点处相交，且交点最多连接2条线
+ */
+export declare class SearchSimpleLoop {
+    static execute(_curve2ds: Curve2[], tolerance?: number): (PolyCurve | Loop)[];
+    private static _findAndRemoveLongestCurve;
+    private static _findAndRemoveNextCurve;
+}

package/types/algorithm/search_graph.d.ts

@@ -0,0 +1,45 @@
+import { Curve2 } from '../geometry/curve2';
+import { Polygon } from '../topology/polygon';
+import { Loop } from '../topology/loop';
+import { PolyCurve } from '../topology/polycurve';
+/**
+ * 搜索算法：搜环，搜polygon，搜洞
+ */
+declare class SearchGraph {
+    /**
+     * 从一堆有向的曲线中搜索环
+     * @param curves
+     * @param bMin true则找到最小环，false则找到最大环
+     * @param distanceTol
+     */
+    static searchLoop2D(curves: Curve2[], bMin: boolean, distanceTol?: number): Loop[];
+    /**
+     * 搜索简单环
+     * 假设输入的曲线中，每个连接点处，最多只有两个曲线
+     * @param curves
+     * @param polygon
+     */
+    static simpleLoop(curves: Curve2[], tolerance?: number): (PolyCurve | Loop)[];
+    /**
+     * 输入一堆线，按包含关系搜索出合法polygon
+     * 假设输入的曲线中，每个连接点处，最多只有两个曲线
+     * @param curves
+     * @param polygon
+     */
+    static simplePolygon(curves: Curve2[], tolerance?: number): Polygon | undefined;
+    /**
+     * 根据包含关系，将loop[]，组成polygonEx
+     * 条件：环之间不相交
+     * @param loops
+     * @returns polygon[]
+     */
+    static loopsToPolygonExes(loops: Loop[]): Polygon[];
+    /**
+     * 根据包含关系，将polygon，组成polygonEx
+     * 条件：Polygon环之间不相交
+     * @param polygon
+     * @returns polygon[]
+     */
+    static polygonToPolygonExes(polygon: Polygon): Polygon[];
+}
+export { SearchGraph };

package/types/algorithm/topology_edit.d.ts

@@ -0,0 +1,10 @@
+import { Loop } from '../topology/loop';
+import { Polygon } from '../topology/polygon';
+export declare class TopologyEdit {
+    /**
+     * 只支持一个外环多个内环，不支持多个外环
+     * @param polygon 要分割的polygon
+     */
+    static splitPolygonRegion(polygon: Polygon): Loop;
+    private static _splitLoopLoopRegion;
+}

package/types/base/box.d.ts

@@ -0,0 +1,100 @@
+import { Vec } from './vec';
+import { types } from '../type_define/i_types';
+/**
+ *  AABB包围盒
+ */
+export declare abstract class Box<PointType extends Vec> {
+    max: PointType;
+    min: PointType;
+    constructor();
+    abstract clone(): Box<PointType>;
+    /**
+     * 包围盒置空，改变自己
+     */
+    abstract makeEmpty(): this;
+    /**
+     * 包围盒扩展，改变自己
+     * @param point
+     */
+    abstract expandByPoint(...point: types.IXY[] | PointType[]): this;
+    /**
+     * 是否包含点
+     * @param point
+     * @param tolerance
+     */
+    abstract containsPt(point: types.IXY | PointType, tolerance: number): boolean;
+    /**
+     * 计算到点或包围盒的平方距离
+     * @param that
+     */
+    abstract getSquareDistanceTo(that: types.IXY | PointType | Box<PointType>): number;
+    /**
+     * 根据传入的中心点和包围盒尺寸重置包围盒，改变自己
+     * @param center
+     * @param size
+     */
+    abstract setFromCenterAndSize(center: types.IXY | PointType, size: types.IXY | PointType): this;
+    /**
+     * 获取包围盒的角点
+     */
+    abstract getCornerPts(): PointType[];
+    /**
+     * 包围盒扩展，改变自己
+     * @param point
+     */
+    expandByScalar(scale: number): this;
+    /**
+     * 根据传入的点重置包围盒，改变自己
+     * @param points
+     */
+    setFromPoints(points?: types.IXY[] | PointType[]): this;
+    /**
+     * 获取中点
+     */
+    getCenter(): PointType;
+    /**
+     * 获取包围盒大小，最大点减去最小点
+     */
+    getSize(): PointType;
+    /**
+     * 是否包含包围盒
+     * @param box
+     * @param eps
+     */
+    containsBox(box: Box<PointType>, eps?: number): boolean;
+    /**
+     * 是否和另一个包围盒有交
+     * @param box
+     * @param tolerance
+     */
+    intersectsBox(box: Box<PointType>, tolerance?: number): boolean;
+    /**
+     * 包围盒的合并，改变自己
+     * @param box
+     */
+    union(box: Box<PointType>): this;
+    /**
+     * 包围盒是否退化，即在x、或y、或z方向长度为0
+     */
+    isZeroSizeBox(): boolean;
+    /**
+     * 包围盒是否合法，max >= min
+     */
+    isValid(): boolean;
+    /**
+     * 包围盒是否相等
+     * @param other
+     * @param tol
+     */
+    equals(other: Box<PointType>, tol?: number): boolean;
+    /**
+     * 包围盒的平移，改变自己
+     * @param offset
+     */
+    translate(offset: types.IXY | PointType): this;
+    /**
+     * 复制，使得自己和另一个包围盒一样大小，改变自己
+     * @param another
+     */
+    copy(another: Box<PointType>): this;
+}

package/types/base/box2.d.ts

@@ -0,0 +1,17 @@
+import { Box } from './box';
+import { Vec2 } from './vec2';
+import { types } from '../type_define/i_types';
+/**
+ * 二维AABB包围盒
+ */
+declare class Box2 extends Box<Vec2> {
+    constructor(points?: types.IXY[]);
+    makeEmpty(): this;
+    getCornerPts(): Vec2[];
+    expandByPoint(...points: types.IXY[]): this;
+    containsPt(point: types.IXY, tolerance?: number): boolean;
+    getSquareDistanceTo(that: types.IXY | Box2): number;
+    setFromCenterAndSize(center: types.IXY, size: types.IXY): this;
+    clone(): Box2;
+}
+export { Box2 };

package/types/base/box3.d.ts

@@ -0,0 +1,20 @@
+import { Box } from './box';
+import { Vec3 } from './vec3';
+import { types } from '../type_define/i_types';
+/**
+ * 三维AABB包围盒
+ */
+declare class Box3 extends Box<Vec3> {
+    constructor(points?: types.IXYZ[]);
+    makeEmpty(): this;
+    /**
+     * 前四个点为底面角点，后四个为顶面角点，点顺序为逆时针（从上往下看）
+     */
+    getCornerPts(): Vec3[];
+    expandByPoint(...points: types.IXYZ[]): this;
+    containsPt(point: types.IXYZ, tolerance?: number): boolean;
+    getSquareDistanceTo(that: types.IXYZ | Box3): number;
+    setFromCenterAndSize(center: types.IXYZ, size: types.IXYZ): this;
+    clone(): Box3;
+}
+export { Box3 };

package/types/base/coord.d.ts

@@ -0,0 +1,10 @@
+import { GeoElement } from './geo_element';
+import { Vec } from './vec';
+/**
+ * 坐标系
+ */
+export declare abstract class Coord<VectorType extends Vec> extends GeoElement {
+    constructor();
+    abstract getDx(): VectorType;
+    abstract getDy(): VectorType;
+}

package/types/base/coord2.d.ts

@@ -0,0 +1,92 @@
+import { Vec2 } from './vec2';
+import { types } from '../type_define/i_types';
+import { EN_GEO_TYPE } from '../type_define/i_element_type';
+import { Coord } from './coord';
+import { Matrix3 } from './matrix3';
+/**
+ * 二维坐标系
+ */
+export declare class Coord2 extends Coord<Vec2> {
+    /**
+     * 构造XOY坐标系
+     */
+    static XOY(): Coord2;
+    private _origin;
+    private _xDir;
+    private _yDir;
+    constructor(origin?: types.IXY, xDir?: types.IXY);
+    /**
+     * 获取X方向
+     */
+    getDx(): Vec2;
+    /**
+     * 设置X方向
+     * @param v
+     */
+    setDx(v: types.IXY): void;
+    /**
+     * 获取Y方向
+     */
+    getDy(): Vec2;
+    /**
+     * 获取原点
+     */
+    getOrigin(): Vec2;
+    /**
+     * 设置原点
+     */
+    setOrigin(origin: types.IXY): void;
+    /**
+     * 将当前坐标系平移，改变自己
+     * @param delta
+     */
+    translate(delta: types.IXY): this;
+    /**
+     * 坐标系平移，得到一个新的坐标系对象
+     * @param delta
+     */
+    translated(delta: types.IXY): Coord2;
+    /**
+     * 将当前坐标系变换，改变自己。非等比缩放时，保证 dx 方向能正确变换
+     * @param matrix
+     */
+    transform(matrix: types.IMatrix3 | types.numberArrs3X3): this;
+    /**
+     * 坐标系变换，得到一个新的坐标系对象。非等比缩放时，保证 dx 方向能正确变换
+     * @param matrix
+     */
+    transformed(matrix: types.IMatrix3 | types.numberArrs3X3): Coord2;
+    /**
+     * 根据局部坐标系的点获取世界坐标系的点
+     * @param uv
+     */
+    getWorldPtAt(uv: types.IXY): Vec2;
+    /**
+     * 根据世界坐标系的点获取局部坐标系的点
+     * @param worldPt
+     */
+    getLocalPtAt(worldPt: types.IXY): Vec2;
+    /**
+     * 根据局部坐标系的向量获取世界坐标系的向量
+     * @param localVec
+     */
+    getWorldVectorAt(localVec: types.IXY): Vec2;
+    /**
+     * 根据世界坐标系的向量获取局部坐标系的向量
+     * @param worldVec
+     */
+    getLocalVectorAt(worldVec: types.IXY): Vec2;
+    /**
+     * 构造一个矩阵，将局部坐标系的(x, y)变换到世界坐标系
+     */
+    getLocalToWorldMatrix(): Matrix3;
+    /**
+     * 构造一个矩阵，将世界坐标系位置变换到局部坐标系
+     */
+    getWorldToLocalMatrix(): Matrix3;
+    dump(): types.IDBCoordinate2;
+    load({ data: [o, x] }: types.IDBCoordinate2): this;
+    clone(): Coord2;
+    getType(): EN_GEO_TYPE.COORD_2;
+    private _updateY;
+}