@ccpc/math 0.1.0 → 0.1.3

package/types/base/vec2.d.ts

@@ -0,0 +1,146 @@
+import { Vec } from './vec';
+import { types } from '../type_define/i_types';
+import { EN_GEO_TYPE } from '../type_define/i_element_type';
+/**
+ *  既是向量，也是点，二维可变
+ */
+declare class Vec2 extends Vec implements types.IXY {
+    /**
+     *  定义常量
+     */
+    static O(): Vec2;
+    static X(x?: number): Vec2;
+    static Y(y?: number): Vec2;
+    /**
+     * 全局的临时变量，使用该变量能减少对象的创建
+     */
+    static tmp(x?: number, y?: number): Vec2;
+    /**
+     *  只读常量 Vec2(0, 0)
+     */
+    static rO(): Vec2;
+    /**
+     *  只读常量 Vec2(1, 0)
+     */
+    static rX(): Vec2;
+    /**
+     *  只读常量 Vec2(0, 1)
+     */
+    static rY(): Vec2;
+    protected readonly _data: number[];
+    /**
+     * 空的构造方法，默认都是0
+     * @param x
+     * @param y
+     */
+    constructor();
+    /**
+     * 根据x值与y值构造
+     * @param x
+     * @param y
+     */
+    constructor(x: number, y: number);
+    /**
+     * 根据XY接口(xy都是小写)来构造
+     */
+    constructor(xy: types.IXY);
+    /**
+     * 两点构造一个向量
+     * @param pointA
+     * @param pointB
+     */
+    constructor(pointA: types.IXY, pointB: types.IXY);
+    /**
+     * 根据数组构造，默认取数组的前2个元素
+     */
+    constructor(xy: number[]);
+    get data(): types.numberArr2;
+    add(another: types.IXY): this;
+    added(another: types.IXY): Vec2;
+    subtract(another: types.IXY): this;
+    subtracted(another: types.IXY | Vec2): Vec2;
+    multiplied(scale: number): Vec2;
+    dot(another: types.IXY): number;
+    reversed(): Vec2;
+    interpolate(another: types.IXY, alpha: number): this;
+    interpolated(another: types.IXY, alpha: number): Vec2;
+    midTo(another: types.IXY): Vec2;
+    normalized(): Vec2;
+    translated(vec: types.IXY): Vec2;
+    /**
+     * 点的变换，包括平移、选择、缩放，会改变this
+     * @param matrix
+     */
+    transform(matrix: types.IMatrix3 | types.numberArrs3X3): this;
+    /**
+     * 向量的变换，会自动忽略平移量，会改变this
+     * @param matrix
+     */
+    vecTransform(matrix: types.IMatrix3 | types.numberArrs3X3): this;
+    transformed(matrix: types.IMatrix3 | types.numberArrs3X3): Vec2;
+    vecTransformed(matrix: types.IMatrix3 | types.numberArrs3X3): Vec2;
+    /**
+     * 点的旋转，改变自己
+     * @param refPt 参考点
+     * @param angle 弧度制
+     */
+    rotate(refPt: types.IXY, angle: number): this;
+    /**
+     * 点的旋转，得到一个新的对象
+     * @param refPt 参考点
+     * @param angle 弧度制
+     */
+    rotated(refPt: types.IXY, angle: number): Vec2;
+    /**
+     * 向量的旋转，改变自己
+     * @param angle
+     */
+    vecRotate(angle: number): this;
+    /**
+     * 向量的旋转，得到一个新对象
+     * @param angle
+     */
+    vecRotated(angle: number): Vec2;
+    /**
+     * 二维向量的叉乘 a X b = |a|·|b|·sinAB，
+     * 该值其实是第三个轴的分量
+     * @param another
+     */
+    cross(another: types.IXY): number;
+    /**
+     * 两向量之间的夹角，区间[0,PI]
+     * @param another
+     */
+    angle(another: types.IXY): number;
+    /**
+     *  从this转到anotherr的有向角，区间[0,2*PI)
+     */
+    angleTo(another: types.IXY): number;
+    /**
+     * 两向量是否平行（同向或反向）
+     * @param another
+     * @param tolerance  角度容差
+     */
+    isParallel(another: types.IXY, tolerance?: number): boolean;
+    isPerpendicular(another: types.IXY, eps?: number): boolean;
+    /**
+     * 与另外一个向量的距离
+     */
+    distanceTo(another: types.IXY): number;
+    /**
+     * 与另外一个向量的平方距离
+     */
+    sqDistanceTo(another: types.IXY): number;
+    /**
+     * 向量是否相等
+     * @param param
+     * @param eps 容差
+     */
+    equals(another: types.IXY, eps?: number): boolean;
+    getType(): EN_GEO_TYPE.VEC_2;
+    dump(): types.IDBVector2;
+    clone(): Vec2;
+    copy(another: types.IXY): this;
+    private _reset;
+}
+export { Vec2 };

package/types/base/vec3.d.ts

@@ -0,0 +1,158 @@
+import { Vec } from './vec';
+import { types } from '../type_define/i_types';
+import { EN_GEO_TYPE } from '../type_define/i_element_type';
+import { Tol } from './tol';
+/**
+ *  既是向量，也是点，三维可变
+ */
+export declare class Vec3 extends Vec implements types.IXYZ {
+    static O(): Vec3;
+    static X(x?: number): Vec3;
+    static Y(y?: number): Vec3;
+    static Z(z?: number): Vec3;
+    static XY({ x, y }: types.IXY, z?: number): Vec3;
+    /**
+     * 全局的临时变量，使用该变量能减少对象的创建
+     */
+    static tmp(x?: number, y?: number, z?: number): Vec3;
+    /**
+     *  只读常量 Vec2(0, 0, 0)
+     */
+    static rO(): Vec3;
+    /**
+     *  只读常量 Vec2(1, 0, 0)
+     */
+    static rX(): Vec3;
+    /**
+     *  只读常量 (0, 1, 0)
+     */
+    static rY(): Vec3;
+    /**
+     *  只读常量 Vec3(0, 0, 1)
+     */
+    static rZ(): Vec3;
+    get z(): number;
+    set z(y: number);
+    get data(): types.numberArr3;
+    protected readonly _data: number[];
+    /**
+     * 返回zero
+     */
+    constructor();
+    /**
+     * 根据x值y值z值构造
+     * @param x
+     * @param y
+     */
+    constructor(x: number, y: number, z: number);
+    /**
+     * 根据XYZ接口(xyz都是小写)来构造
+     */
+    constructor(xyz: types.IXYZ);
+    /**
+     * 两点构造一个向量
+     * @param pointA
+     * @param pointB
+     */
+    constructor(pointA: types.IXYZ, pointB: types.IXYZ);
+    /**
+     * 根据数组构造，默认取数组的前3个元素
+     */
+    constructor(xyz: number[]);
+    add(another: types.IXYZ): this;
+    added(another: types.IXYZ): Vec3;
+    subtract(another: types.IXYZ): this;
+    subtracted(another: types.IXYZ): Vec3;
+    multiplied(scale: number): Vec3;
+    dot(another: types.IXYZ): number;
+    reversed(): Vec3;
+    interpolate(another: types.IXYZ, alpha: number): this;
+    interpolated(another: types.IXYZ, alpha: number): Vec3;
+    midTo(another: types.IXYZ): Vec3;
+    normalized(): Vec3;
+    translated(vec: types.IXYZ): Vec3;
+    /**
+     * 点的变换，包括平移、选择、缩放，会改变this
+     * @param matrix
+     */
+    transform(matrix: types.IMatrix4 | types.numberArrs4X4): this;
+    transformed(matrix: types.IMatrix4 | types.numberArrs4X4): Vec3;
+    /**
+     * 向量的变换，会自动忽略平移量，会改变this
+     * @param matrix
+     */
+    vecTransform(matrix: types.IMatrix4 | types.numberArrs4X4): this;
+    vecTransformed(matrix: types.IMatrix4 | types.numberArrs4X4): Vec3;
+    /**
+     * 点的旋转，改变自己
+     * @param refPt 参考点
+     * @param angle 弧度制
+     */
+    rotate(ptOnAxis: types.IXYZ, axis: types.IXYZ, angle: number): this;
+    /**
+     * 点的旋转
+     * @param refPt 参考点
+     * @param angle 弧度制
+     */
+    rotated(ptOnAxis: types.IXYZ, axis: types.IXYZ, angle: number): Vec3;
+    /**
+     * 向量的旋转，改变自己
+     * @param angle 弧度制
+     */
+    vecRotate(axis: types.IXYZ, angle: number): this;
+    /**
+     * 向量的旋转，返回一个新的向量对象
+     * @param angle 弧度制
+     */
+    vecRotated(axis: types.IXYZ, angle: number): Vec3;
+    /**
+     * 获取任意垂线
+     */
+    getPerpendicular(): Vec3;
+    /**
+     * | i  j  k  |
+     * | ux uy uv |
+     * | vx vy vz |
+     * @param another
+     */
+    cross(another: types.IXYZ): Vec3;
+    /**
+     * 两向量是否平行（同向或反向）
+     * @param another
+     * @param eps  角度容差
+     */
+    isParallel(another: types.IXYZ, eps?: number): boolean;
+    isPerpendicular(another: types.IXYZ, eps?: number): boolean;
+    /**
+     * 两向量之间的夹角，区间[0,PI]
+     * @param another 另一个向量
+     * @param axisOut 两向量之间的旋转轴
+     */
+    angle(another: types.IXYZ, axisOut?: types.IXYZ, tol?: Tol): number;
+    /**
+     * 获取当前向量逆时针旋转至另一向量的夹角
+     * @param other   另一个向量
+     * @param refVec  参考向量（逆时针方向的确定依赖于观察方向，观察方向由该参数在平面法向上的分量确定）
+     * @return 夹角[0, 2 * PI]
+     */
+    angleTo(other: types.IXYZ, refVec: types.IXYZ): number;
+    /**
+     * 与另外一个向量的距离
+     */
+    distanceTo(another: types.IXYZ): number;
+    /**
+     * 与另外一个向量的平方距离
+     */
+    sqDistanceTo(another: types.IXYZ): number;
+    /**
+     * 向量是否相等
+     * @param param
+     * @param eps 容差
+     */
+    equals(another: types.IXYZ, eps?: number): boolean;
+    getType(): EN_GEO_TYPE.VEC_3;
+    dump(): types.IDBVector3;
+    clone(): Vec3;
+    copy(another: types.IXYZ): this;
+    private _reset;
+}

package/types/brep-src/algorithm/alg_const.d.ts

@@ -0,0 +1,23 @@
+export declare enum PreviewType {
+    TryGenerate = 0,
+    GenerateOnly = 1,
+    PreviewOnly = 2
+}
+export declare enum SweepErrorCode {
+    CoordinateZUnparallelWithPath = "CoordinateZUnparallelWithPath",
+    PathReversedConnection = "PathReversedConnection",
+    PathTwistedLoop = "PathTwistedLoop",
+    SurfaceDegenerate = "SurfaceDegenerate"
+}
+export declare enum RevolveErrorCode {
+    InputInvalidLoop = "InputInvalidLoop",
+    AllCurveInRevolveLine = "AllCurveInRevolveLine",
+    PathProjectError = "PathProjectError",
+    InvalidRevolveBody = "InvalidRevolveBody"
+}
+export declare enum FilletErrorCode {
+    InputInvalidRadius = "InputInvalidRadius",
+    InputInvalidEdges = "InputInvalidEdges",
+    FilletSelfIntersect = "FilletSelfIntersect",
+    InvalidFilletBody = "InvalidFilletBody"
+}

package/types/brep-src/algorithm/alg_types.d.ts

@@ -0,0 +1,47 @@
+import { Edge } from '../brep/edge';
+import { Face } from '../brep/face';
+import { Vertex } from '../brep/vertex';
+/** 扫掠体的拓扑索引 */
+export interface ISweepTopo {
+    /** 顶点，索引序号依次为 path, loop, edge, sub */
+    vertices: Vertex[][][][];
+    /** 扫掠边，索引序号依次为 path, loop, edge, sub */
+    sweepEdges: Edge[][][][];
+    /** 轮廓边，索引序号依次为 path, loop, edge, sub */
+    frameEdges: Edge[][][][];
+    /** 面，索引序号依次为 path, loop, edge */
+    sideFaces: Face[][][];
+    /** 起始面 */
+    firstFace?: Face;
+    /** 终止面 */
+    lastFace?: Face;
+    /** 路径在预处理中的分段 */
+    pathSplitCounts: number[];
+    /** 轮廓线在预处理中的分段数，索引序号依次为 loop, edge */
+    baseLoopSplitCounts: number[][];
+}
+/**
+ * 拉伸体的拓扑索引
+ * 此处注意由于smoothpoly原因导致边，侧面需要额外数据记录序号
+ */
+export interface IExtrudeTopo {
+    topVertexs: Vertex[][];
+    bottomVertexs: Vertex[][];
+    topEdges: Edge[][];
+    sideEdges: Edge[][];
+    bottomEdges: Edge[][];
+    topFace: Face;
+    sideFaces: Face[][];
+    bottomFace: Face;
+}
+/** 布尔运算的拓扑索引 */
+export interface IBool3dTopo {
+    /** 各面的来源面 */
+    faceSources: Map<string, string[]>;
+}
+/** 投影的附带信息 */
+export interface IProjectInfo {
+    distance: number;
+    projFace: Face;
+    upDistance?: number;
+}

package/types/brep-src/algorithm/algorithm_util/base_define.d.ts

@@ -0,0 +1,7 @@
+export declare enum PositionType {
+    UNKWON = 0,
+    OUT = 1,
+    IN = 2,
+    INOUT = 3,// 左内右外
+    OUTIN = 4
+}

package/types/brep-src/algorithm/algorithm_util/body_base_util.d.ts

@@ -0,0 +1,4 @@
+import { Edge } from '../../brep/edge';
+import { Coedge3d } from '../../brep/coedge3d';
+export declare function getLeftAndRightCoedge(edge: Edge): Coedge3d[];
+export declare function getLeftAndRightCoedgeEx(edge: Edge): Coedge3d[][];

package/types/brep-src/algorithm/algorithm_util/curve_solid_analysis.d.ts

@@ -0,0 +1,28 @@
+import { Curve3, Vec3, alg } from '../../..';
+import { Face } from '../../brep/face';
+import { Edge } from '../../brep/edge';
+export declare class CurveSolidAnalysis {
+    /**
+     * curve与face相交，判断curve交点前后两段与face的内外关系
+     * @param curve curve3d
+     * @param xPointInfo curve与face的交点
+     * @param face 面
+     * @param prevRefParam 如果相切，用于判断前面一段在face内外
+     * @param nextRefParam 如果相切，用于判断后面一段在face内外
+     */
+    static curveFace(curve: Curve3, face: Face, xPointInfo: Vec3 | alg.ICvSurfXInfo): {
+        prev: number;
+        next: number;
+    };
+    static curveEdge(curve: Curve3, edge: Edge, xPt: Vec3, edgeFaces?: Face[]): {
+        prev: number;
+        next: number;
+    };
+    private static _curveFaceTangent;
+    /**
+     * 简单判断curve是否重合在face中
+     * @param faces
+     * @param curve
+     */
+    private static _edgeFacesContainsCurve;
+}

package/types/brep-src/algorithm/algorithm_util/face_face_analysis.d.ts

@@ -0,0 +1,39 @@
+import { Curve3 } from '../../..';
+import { Face } from '../../brep/face';
+import { PositionType } from './base_define';
+export interface IFaceFacePosition {
+    position1: PositionType;
+    position2: PositionType;
+}
+interface IFacePair {
+    face1: Face;
+    face2: Face;
+    isOverlap: boolean;
+    isFaceSameDir?: boolean;
+}
+export declare class FaceFaceAnalysis {
+    /**
+     * 返回0，不是相切，互不包含，相互穿插(因为这种情况只需要加入face就行，不需要管加入哪个face，所以不需要区分inout和outin)
+     * 返回1，相切并且face2在face1外面（face1不包含face2）
+     * 返回2，相切并且face2在face1里面（face1包含face2）
+     * @param face1
+     * @param face2
+     * @param xCurve
+     */
+    static FaceFace(face1: Face, face2: Face, xCurve: Curve3, eps?: number): PositionType;
+    static FaceAndEdgeFaces(face: Face, edgeCurve: Curve3, edgeFaces: Face[], overlapFacePairs: IFacePair[], eps?: number): IFaceFacePosition;
+    static EdgeFacesAndEdgeFaces(edgeCurve: Curve3, edgeSameDir: boolean, edge1Faces: Face[], edge2Faces: Face[], overlapFacePairs: IFacePair[], eps?: number): IFaceFacePosition;
+    /**
+     * 返回0，不是相切，互不包含；返回1，face1包含face2(face2在face1里面)；返回-1，face2包含face1(face1在face2里面)
+     * @param face1
+     * @param face2
+     * @param xCurve
+     */
+    static FaceHalfFace(face1: Face, face2: Face, xCurve: Curve3, isLeft: boolean, eps?: number): number;
+    private static _tangentFaceHalfFaceTryPosition;
+    private static _judgeFaceAndEdgeFacesPostion;
+    private static _adjustFaceProjectDir;
+    private static _classifyOverlapFacePair;
+    private static _calcTryPtsNumber;
+}
+export {};

package/types/brep-src/algorithm/algorithm_util/search_wire.d.ts

@@ -0,0 +1,8 @@
+import { Surface } from '../../..';
+import { Coedge3d } from '../../brep/coedge3d';
+import { Wire } from '../../brep/wire';
+export declare function searchCoedge(surf: Surface, prevCoedge: Coedge3d, allCoedges: Coedge3d[]): Coedge3d | undefined;
+export declare function isWireDegenerated(coedges: Coedge3d[] | readonly Coedge3d[]): boolean;
+export declare function searchWire(surf: Surface, stCoedge: Coedge3d, allCoedges: Coedge3d[]): Wire | undefined;
+export declare function searchWires(surf: Surface, newCoedges: Coedge3d[], oldCoedges: Coedge3d[], simpleLoop?: boolean): Wire[];
+export declare function searchOneWireInReciprocateCoedges(surf: Surface, newCoedges: Coedge3d[], oldCoedges: Coedge3d[]): Wire | undefined;

package/types/brep-src/algorithm/body_builder/basic_body_builder.d.ts

@@ -0,0 +1,15 @@
+import { Coord3 } from '../../..';
+import { BrepBody } from '../../brep/brep_body';
+/**
+ * 简单体构造
+ */
+export declare class BasicBodyBuilder {
+    /**
+     * 构造立方体
+     * @param coord 左下角所在的坐标系
+     * @param a x轴向长度
+     * @param b y轴向长度
+     * @param c z轴向长度
+     */
+    static makeCubic(coord: Coord3, a: number, b?: number, c?: number): BrepBody;
+}

package/types/brep-src/algorithm/body_builder/extrude_body.d.ts

@@ -0,0 +1,23 @@
+import { Coord3, Polygon, Vec3 } from '../../..';
+import { BrepBody } from '../../brep/brep_body';
+import { IExtrudeTopo } from '../alg_types';
+/**
+ * @author tiansk
+ *  拉伸体
+ *  支持轮廓线为直线段和圆弧，暂时不支持斜拉伸（还没有斜圆柱面）
+ */
+export declare class ExtrudeBody {
+    /**
+     * 拉伸造体
+     * @param coordinate 局部坐标系
+     * @param polygon 在坐标轴下的polyogn
+     * @param dir 拉伸方向
+     * @param startOffset 起始偏移
+     * @param endOffset 终止偏移
+     * @param bCalPolygonEx 是否依据环的包含关系，将polygon分成多个区域，默认为true
+     * 如果输入明确只有一个区域，可以设置成false，提高性能
+     */
+    static execute(coordinate: Coord3, polygon: Polygon, dir: Vec3, startHeight: number, endHeight: number, bCalPolygonEx?: boolean, useRealCurve?: boolean, extrudeTopo?: IExtrudeTopo[]): BrepBody;
+    static extrudePolygonEx(coordinate: Coord3, polygon: Polygon, _dir: Vec3, startHeight: number, endHeight: number, extrudeTopo: IExtrudeTopo): BrepBody;
+    private static _decomposeSmoothPoly;
+}

package/types/brep-src/algorithm/body_builder/sweep_body.d.ts

@@ -0,0 +1,37 @@
+import { Coord3, Polygon, Curve3, Curve2 } from '../../..';
+import { Face } from '../../brep/face';
+import { BrepBody } from '../../brep/brep_body';
+/**
+ *
+ *  扫掠体
+ * 路径支持Line3d, Arc3
+ * 轮廓支持Line2d，Polygon包含一个外环，多个内环
+ */
+export declare class SweepBody {
+    coordinate: Coord3;
+    polygon2d: Polygon;
+    path3d: Curve3[];
+    adjustProfile: boolean;
+    adjustPath: boolean;
+    topoTrack?: Map<Curve2 | 0 | 1, Face[]> | undefined;
+    private _pathClosed;
+    private _profile2ds;
+    private _profileReverse;
+    constructor(coordinate: Coord3, polygon2d: Polygon, path3d: Curve3[], adjustProfile?: boolean, adjustPath?: boolean, topoTrack?: Map<Curve2 | 0 | 1, Face[]> | undefined);
+    execute(): BrepBody;
+    private _init;
+    private _decomposeSmoothPoly;
+    private _pathIsValid;
+    private _profileIsValid;
+    private _adjustPath;
+    private _adjustProfile;
+    private _calcSweepCurves;
+    private _trimSweepCurves;
+    private _calculateTrimedPoint;
+    private _calculateTrimedCurve;
+    private _buildSweepBody;
+    private _extendCurve;
+    private _getPointsCCWNormal;
+    private _getNormalOfPtSequence;
+    private _getNormalOfThreePoints;
+}

package/types/brep-src/algorithm/body_builder.d.ts

@@ -0,0 +1,36 @@
+import { Coord3, Polygon, Vec3, Curve3, Curve2 } from '../..';
+import { BrepBody } from '../brep/brep_body';
+import type { Face } from '../brep/face';
+import { IExtrudeTopo } from './alg_types';
+/**
+ * 造体：拉伸、扫掠
+ */
+export declare class BodyBuilder {
+    /**
+     * 构造立方体
+     * @param coord 左下角所在的坐标系
+     * @param a x轴向长度
+     * @param b y轴向长度
+     * @param c z轴向长度
+     */
+    static createCubic(coord: Coord3, a: number, b?: number, c?: number): BrepBody;
+    /**
+     *  !!!!注意，外面使用时，尽量避免将很多个polygon一起扔进去拉伸，会影响效率，尽量不同的polyfor循环分开拉升body
+     * 拉伸造体
+     * @param coordinate 局部坐标系
+     * @param polygon 在坐标轴下的polyogn
+     * @param dir 拉伸方向
+     * @param startOffset 起始偏移
+     * @param endOffset 终止偏移
+     * @param bCalPolygonEx 是否依据环的包含关系，将polygon分成多个区域，默认为true
+     * 如果输入明确只有一个区域，可以设置成false，提高性能
+     */
+    static extrude(coordinate: Coord3, polygon: Polygon, dir: Vec3, startOffset: number, endOffset: number, bCalPolygonEx?: boolean, extrudeTopo?: IExtrudeTopo[]): BrepBody;
+    /**
+     * @deprecated
+     *  构造扫掠体
+     * @param profileLines  扫掠的截面线，可以封闭，也可以不封闭
+     * @param path3d    扫描路径，可以封闭，也可以不封闭
+     */
+    static sweep(coordinate: Coord3, polygon2d: Polygon, path3d: Curve3[], adjustProfile?: boolean, adjustPath?: boolean, topoTrack?: Map<Curve2 | 0 | 1, Face[]>): BrepBody;
+}

package/types/brep-src/algorithm/body_util.d.ts

@@ -0,0 +1,21 @@
+import { BrepBody } from '../brep/brep_body';
+import { Face } from '../brep/face';
+export declare class BodyUtil {
+    /**
+     * 找到body中与参考face（传入的face0）方向相反的face（如果不传入，默认为朝内的face为需要reversed face）
+     * @param body body
+     * @param face0 作为正方向的参考face
+     */
+    static getReversedFaces(body: BrepBody, face0?: Face): Set<Face>;
+    /**
+     * 处理face的方向，使所有face方向都一致朝向体外
+     * @param body
+     */
+    static unifyFaceDirectOutside(body: BrepBody): void;
+    /**
+     * 合并body中重合的vertex和edge
+     * @param body
+     */
+    static mergeCoincideVertexAndEdges(body: BrepBody): void;
+    private static _replaceEdge;
+}

package/types/brep-src/algorithm/bool_sk/brep_converter.d.ts

@@ -0,0 +1,11 @@
+import { BrepBody } from "../../brep/brep_body";
+/**
+ * 现有brep转sk brep
+ * @param brep
+ */
+export declare function brepToSk(brep: BrepBody): any;
+/**
+ * 司空brep转现有brep
+ * @param brep
+ */
+export declare function skToBrep(brep: any): BrepBody;

package/types/brep-src/algorithm/brep_calc_project.d.ts

@@ -0,0 +1,50 @@
+import { Polygon, PolyCurve, Coord3 } from '../..';
+import { Face } from '../brep/face';
+import { BrepBody } from '../brep/brep_body';
+import { IProjectInfo } from './alg_types';
+/**
+ * 投影算法
+ * - face向coordinate投影
+ * - body向coordinate投影
+ * - bodys向coordinate投影
+ */
+export declare class BRepCalcProject {
+    /**
+     * face沿coordinate z轴向coordinateXOY面投影，投影出的线成环，返回Polygon，否则返回Polyline[]
+     * 目前支持柱面和平面投影，但是目前不支持消隐，也即只针对面的边界进行投影，遮挡关系没有考虑
+     */
+    static face(face: Face, coordinate: Coord3): PolyCurve[] | Polygon;
+    /**
+     * face沿coordinate z轴向coordinateXOY面投影
+     * 注：与上面face投影接口对比不一样的是：对于曲线，这个接口投影出来的是离散的直线；如果用上面的face接口，投影出来是曲线。
+     * 曲面也可以投影，但是曲面可能投影出多个polygon轮廓。因为曲面有face的边界轮廓还有非边界轮廓。平面face只会投影出一个polygon
+     */
+    static faceToDiscretePolygons(face: Face, coordinate: Coord3): Polygon[];
+    /**
+     * 将body投影到一个局部坐标系下，得到polygon
+     * 目前支持柱面和平面投影，但是目前不支持消隐，也即只针对面的边界进行投影，遮挡关系没有考虑
+     */
+    static body(body: BrepBody, coordinate: Coord3): Polygon;
+    /**
+     * 将输入bodys沿着投影坐标系投影至投影面上，输出从投影面看过去可以看到的面的投影polygon以及对应距离（类似消隐效果）
+     * 目前投影面仅支持平面，仅支持平行投影，也即投影坐标系与face方向相同
+     * 同时，被投影体仅支持平面图形
+     */
+    static bodysProject(projectFace: Face, projectCoord: Coord3, projectedBodies: BrepBody[]): Map<Polygon, IProjectInfo>;
+    /**
+     * 视图投影，实现类似某一视角看上去是视图的感觉
+     * 目前投影面仅支持平面，仅支持平行投影，也即投影坐标系与face方向相同
+     * 同时，被投影体仅支持平面图形
+     */
+    static viewProject(projectFace: Face, projectCoord: Coord3, projectedBodies: BrepBody[]): Map<Polygon, IProjectInfo>;
+    /**
+     * 投影只输出一个polygon，对应的投影面的信息以及投影距离，包含遮挡关系
+     * @param projectCoord 投影坐标系
+     * @param projectedBodies 投影body
+     * @returns
+     */
+    static bodyProjectSimple(projectCoord: Coord3, projectedBodies: BrepBody[]): {
+        poly: Polygon;
+        info: IProjectInfo[];
+    } | undefined;
+}