@ccpc/math 0.1.0 → 0.1.3

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

@@ -0,0 +1,34 @@
+import { Curve3, PolyCurve, Loop, Tol, Ln3, Vec3 } from '../..';
+import { Face } from '../brep/face';
+/**
+ * 几何元素求交，线线求交，线面求交
+ */
+export declare class BRepCalcX {
+    /**
+     * Face与Face相交，结果为交线（交点可认为是退化成的线）
+     * @param face1
+     * @param face2
+     * @returns 交线可能不止一条，故返回交线的数组,若无交线，则返回空数组
+     */
+    static faces(face1: Face, face2: Face, tolerance?: number): Curve3[];
+    /**
+     * Face 与 多个Face分别求交，然后将交线封装成Polyline[]
+     *
+     * 数组内的元素有可能是loop，也有可能是Polyline
+     * @param face
+     * @param faces
+     */
+    static faceFaces(face: Face, faces: Face[], tolerance?: number): (PolyCurve | Loop)[];
+    /**
+     * 计算line与Face的有交点
+     * @param line
+     * @param face
+     */
+    static line3dFace(line: Ln3, face: Face, tol?: Tol): Vec3[];
+    /**
+     * 计算line与Face的有交点
+     * @param line
+     * @param face
+     */
+    static isIntersectLine3dFace(curve: Curve3, face: Face, tol?: Tol): boolean;
+}

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

@@ -0,0 +1,47 @@
+import { Vec3, Tol } from '../..';
+import { BrepBody } from '..';
+import { Face } from '../brep/face';
+import { BrepBodyPositionType } from './podition_judge/body_pj';
+import { ExtrudeInfo } from './podition_judge/extrude_pj';
+import { PtBodyPositionType } from './podition_judge/pt_body_pj';
+export declare class BrepPJ {
+    /**
+     * 点是否在Face内
+     *
+     * @param point 任意一点
+     * @param face
+     */
+    static isPtInFace(point: Vec3, face: Face, tolerance?: number): boolean;
+    /**
+     * 点是否在Face的上侧
+     *
+     * 规定：点在平面法线一侧为上侧，否则为下侧
+     *
+     * @param point 任意一点
+     * @param plane 任意平面
+     */
+    static isPtAboveFace(point: Vec3, face: Face): boolean;
+    /**
+     * 点和brep的位置关系判断
+     * 通过（1,0,0）方向将射线与face求交，判断点位置
+     * @param point
+     * @param body 默认自封闭的body
+     * @param tol
+     * @param useBoundBox 使用包围盒计算，快速判断，如果此项为true，点在body上统一为ON_FACE
+     */
+    static pointBrepBodyPositionJudge(point: Vec3, body: BrepBody, eps?: number, useBoundBox?: boolean): PtBodyPositionType;
+    /**
+     * brep体之间的位置关系判断，一般来说直接采用包围和计算能满足大多数情况，如果需要较为精确的关系，例如已知某个物件的大致形状以及可能关系，可以采用一个brep为包围盒点情况
+     * 对于均不采用包围盒的情况，存在曲面的情况下求交可能会导致比较慢
+     * @param body1 默认自封闭body
+     * @param body2 默认自封闭body
+     * @param eps
+     * @param useBoundBox1 body1是否使用包围盒计算
+     * @param useBoundBox2 body2是否使用包围盒计算
+     * @returns
+     */
+    static BrepBodiesPositionJudge(body1: BrepBody, body2: BrepBody, eps?: number, useBoundBox1?: boolean, useBoundBox2?: boolean): BrepBodyPositionType;
+    static ExtrudeBodiesPositionJudge(body1: ExtrudeInfo, body2: ExtrudeInfo, info?: {
+        tol: Tol;
+    }): BrepBodyPositionType;
+}

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

@@ -0,0 +1,5 @@
+export { BodyBuilder } from './body_builder';
+export { BrepPJ } from './brep_pj';
+export type { ISweepTopo, IExtrudeTopo, IBool3dTopo } from './alg_types';
+export { BodyUtil } from './body_util';
+export { ShellEdit } from './shell_edit';

package/types/brep-src/algorithm/intersect/curve_face_overlap.d.ts

@@ -0,0 +1,10 @@
+import { Tol, Curve3, Interval, Polygon } from '../../..';
+import { Face } from '../../brep/face';
+export declare class CurveFacesOverlap {
+    /**
+     * 计算line与Face的有交点
+     * @param curve
+     * @param face
+     */
+    static execute(curve: Curve3, face: Face, tol?: Tol, facePoly?: Polygon): Interval[];
+}

package/types/brep-src/algorithm/intersect/face_face_intersect.d.ts

@@ -0,0 +1,22 @@
+import { Curve3 } from '../../..';
+import { Face } from '../../brep/face';
+/**
+ * face 与 face求交，返回值为交线
+ */
+export declare class FacesX {
+    /**
+     * Face与Face相交，结果为交线（交点可认为是退化成的线）
+     * @param face1
+     * @param face2
+     * @returns 交线可能不止一条，故返回交线的数组,若无交线，则返回空数组
+     */
+    static execute(face1: Face, face2: Face, tolerance?: number): Curve3[];
+    /**
+     * 取 curve 在 face 上的参数区域（默认 curve 在 face 上）
+     * @param curve
+     * @param face
+     * @param face 额外的需要求交的线段
+     * @returns [start, end]
+     */
+    private static _getInterRanges;
+}

package/types/brep-src/algorithm/intersect/face_faces_intersect.d.ts

@@ -0,0 +1,15 @@
+import { PolyCurve, Loop } from '../../..';
+import { Face } from '../../brep/face';
+/**
+ * Face 与 多个Face分别求交，然后将交线封装成Polyline[]
+ */
+declare class FaceFacesIntersect {
+    /**
+     * Face 与 多个Face分别求交，然后将交线封装成Polyline[]
+     * @param face1
+     * @param faces
+     * @returns 返回Loop的数组
+     */
+    static execute(face: Face, faces: Face[], tolerance?: number): (PolyCurve | Loop)[];
+}
+export { FaceFacesIntersect };

package/types/brep-src/algorithm/intersect/line_face_intersect.d.ts

@@ -0,0 +1,16 @@
+import { Ln3, Tol, Vec3, Curve3 } from '../../..';
+import { Face } from '../../brep/face';
+export declare class LineFacesIntersect {
+    /**
+     * 计算line与Face的有交点
+     * @param line
+     * @param face
+     */
+    static execute(line: Ln3, face: Face, tol?: Tol): Vec3[];
+    /**
+     * 计算line与Face的有交点
+     * @param curve
+     * @param face
+     */
+    static hasIntersect(curve: Curve3, face: Face, tol?: Tol): boolean;
+}

package/types/brep-src/algorithm/podition_judge/body_pj.d.ts

@@ -0,0 +1,25 @@
+import { BrepBody } from '../..';
+export declare enum BrepBodyPositionType {
+    INTERSECT = "INTERSECT",
+    OUTSIDE = "OUTSIDE",
+    INSIDE = "INSIDE",
+    CONTAIN = "CONTAIN",
+    EQUAL = "EQUAL",
+    INSIDE_AND_TANGENCY = "INSIDE_AND_TANGENCY",
+    OUTSIDE_AND_TANGENCY = "OUTSIDE_AND_TANGENCY",
+    CONTAIN_AND_TANGENCY = "CONTAIN_AND_TANGENCY"
+}
+export declare class BrepBodyPJ {
+    /**
+     * 处理brepbody间的位置关系
+     * body1和body2的关系可能为相交，相离，被包含，包含
+     */
+    static PJ(body1: BrepBody, body2: BrepBody, eps?: number, useBoundBox1?: boolean, useBoundBox2?: boolean): BrepBodyPositionType;
+    /**
+     * 处理brepbody间的位置关系
+     * body1和body2的关系可能为相交，相离，被包含，包含
+     */
+    static PositionJudgeSimple(body1: BrepBody, body2: BrepBody, eps?: number, useBoundBox1?: boolean, useBoundBox2?: boolean): BrepBodyPositionType;
+    static PositionJudgeComplex(body1: BrepBody, body2: BrepBody, eps?: number): BrepBodyPositionType;
+    private static _generalBodyPositionJudge;
+}

package/types/brep-src/algorithm/podition_judge/extrude_pj.d.ts

@@ -0,0 +1,28 @@
+import { Coord3, Polygon, Tol, Vec3 } from '../../..';
+import { BrepBodyPositionType } from './body_pj';
+export interface ExtrudeInfo {
+    coordinate: Coord3;
+    polygon: Polygon;
+    dir: Vec3;
+    startHeight: number;
+    endHeight: number;
+}
+/**
+ * @author jinxin
+ *  拉伸体位置关系判断
+ */
+export declare class ExtrudeBodyPJ {
+    /**
+     * 处理brepbody间的位置关系
+     * body1和body2的关系可能为相交，相离，被包含，包含
+     */
+    static PJ(body1: ExtrudeInfo, body2: ExtrudeInfo, info?: {
+        tol?: Tol;
+        ignoreOBBJudge?: boolean;
+    }): BrepBodyPositionType;
+    private static _sameDirectionJudeg;
+    /**
+     * 通过三次投影判断两拉伸体的位置关系，三次投影的方向分别为 dir1、dir2、cross(dir1, dir2)
+     */
+    private static _projectionJudge;
+}

package/types/brep-src/algorithm/podition_judge/pt_body_pj.d.ts

@@ -0,0 +1,32 @@
+import { Vec3, Box3 } from '../../..';
+import { BrepBody, Face } from '../..';
+export declare enum PtBodyPositionType {
+    INSIDE = 0,
+    OUTSIDE = 1,
+    ON_VERTEX = 2,
+    ON_EDGE = 3,
+    ON_FACE = 4
+}
+export interface IPtBodyPositionContext {
+    bodyBox: Box3;
+    faceBoxMap: Map<Face, Box3>;
+}
+export declare class PtBodyPosition {
+    /**
+     * 通过（1,0,0）方向将射线与face求交，判断点位置
+     * @param point
+     * @param body 默认自封闭的body
+     * @param tol
+     * @param useBoundBox 使用包围盒计算，快速判断，如果点在body上，统一为ON_FACE
+     * @param context 缓存信息，避免重复计算
+     */
+    static PJ(point: Vec3, body: BrepBody, eps?: number, useBoundBox?: boolean, context?: IPtBodyPositionContext): PtBodyPositionType;
+    /**
+     * x正方向平行线与box求交，特殊处理
+     * @param line
+     * @param box
+     */
+    private static _isIntersectBox;
+    private static _calUVPosition;
+    private static _farthestDis;
+}

package/types/brep-src/algorithm/project/body_project.d.ts

@@ -0,0 +1,8 @@
+import { Coord3, Polygon } from '../../..';
+import { BrepBody } from '../../brep/brep_body';
+/**
+ * 将body投影到一个局部坐标系下，得到polygon
+ */
+export declare class BodyProject {
+    static execute(brepbody: BrepBody, coordinate: Coord3): Polygon;
+}

package/types/brep-src/algorithm/project/face_project.d.ts

@@ -0,0 +1,20 @@
+import { Polygon, PolyCurve, Coord3, Vec2 } from '../../..';
+import { Face } from '../../brep/face';
+/**
+ * line1向line2投影，返回一个区间，该区间代表投影后的线在line2上的区间
+ */
+declare class FaceProject {
+    static execute(face: Face, coordinate: Coord3): PolyCurve[] | Polygon;
+    static toDiscretePolygons(face: Face, coordinate: Coord3): Polygon[];
+    static mergeLines(paths: Vec2[][]): PolyCurve[];
+    /**
+     * 针对垂直平面的柱面，投影一定是二维圆弧，整体逻辑为：
+     * 构造圆弧，针对每条投影曲线设置正确的参数域
+     * @param cylinder
+     * @param curve2d
+     * @param projPlace
+     * @returns
+     */
+    private static _makeArc2d;
+}
+export { FaceProject };

package/types/brep-src/algorithm/project/face_surface_project.d.ts

@@ -0,0 +1,8 @@
+import { Surface, Polygon } from '../../..';
+import { Face } from '../../brep/face';
+/**
+ * line1向line2投影，返回一个区间，该区间代表投影后的线在line2参数域上的区间
+ */
+export declare class FaceProjectToSurface {
+    static execute(face1: Face, face2: Surface): Polygon;
+}

package/types/brep-src/algorithm/project/space_project.d.ts

@@ -0,0 +1,26 @@
+import { Coord3, Polygon } from '../../..';
+import { BrepBody } from '../../brep/brep_body';
+import { Face } from '../../brep/face';
+import { IProjectInfo } from '../alg_types';
+/**
+ * 投影求取body对应的polygon与距离
+ * 目前仅支持brep面为平面的情况，同时对于body上面有内孔的平面支持不完善，接口兼容
+ */
+export declare class SpaceProject {
+    private _projectFace;
+    private _projectedBodies;
+    private _canProjectedBody;
+    private _baseLoop;
+    private _projectPlane;
+    private _onPlaneBody;
+    private _tol;
+    constructor(_projectFace: Face, _projectCoord: Coord3, _projectedBodies: BrepBody[]);
+    canProject(): boolean;
+    execute(): Map<Polygon, IProjectInfo>;
+    private _projectBodies;
+    private _getDistanceFromLoop;
+    private _GetMinDistance;
+    private _analyseLoop;
+    private _polygonPosition;
+    private _judgeBodyPosition;
+}

package/types/brep-src/algorithm/project/space_project_simple.d.ts

@@ -0,0 +1,10 @@
+import { Coord3, Polygon } from '../../..';
+import { BrepBody } from '../..';
+import { IProjectInfo } from '../alg_types';
+export declare class SpaceProjectSimple {
+    static spaceProjectSimple(coord: Coord3, bodies: BrepBody[]): {
+        poly: Polygon;
+        info: IProjectInfo[];
+    } | undefined;
+    private static _judgeBodyPosition;
+}

package/types/brep-src/algorithm/project/view_project.d.ts

@@ -0,0 +1,25 @@
+import { Coord3, Polygon } from '../../..';
+import { BrepBody } from '../../brep/brep_body';
+import { Face } from '../../brep/face';
+import { IProjectInfo } from '../alg_types';
+/**
+ * 视图投影，实现类似线框视图的效果
+ */
+export declare class ViewProject {
+    private _projectFace;
+    private _projectedBodies;
+    private _canProjectedBody;
+    private _baseLoop;
+    private _projectPlane;
+    private _onPlaneBody;
+    private _tol;
+    constructor(_projectFace: Face, _projectCoord: Coord3, _projectedBodies: BrepBody[]);
+    canProject(): boolean;
+    execute(): Map<Polygon, IProjectInfo>;
+    private _projectBodies;
+    private _getDistanceFromLoop;
+    private _analyseLoop;
+    private _sortInfo;
+    private _polygonPosition;
+    private _judgeBodyPosition;
+}

package/types/brep-src/algorithm/shell_builder/create_shell_from_curves.d.ts

@@ -0,0 +1,38 @@
+import { Curve3, Surface, Tol } from '../../..';
+import { Shell } from '../../brep/shell';
+/**
+ * 构造face组成的壳：目前只支持surface为平面、且只有一个外环多个内环的face的壳
+ */
+export declare class createShellFromCurve3ds {
+    /**
+     * @author
+     * function 输入一个组curve3d和一个surface，构造有一个face的shell。//会检查curve3ds是否首尾相接。不检查逆时针、自交等，所以调用接口时需保证逆时针成环。
+     * @param surf 输入curve3d所在的surface曲面
+     * @param curve3ds 输入一组curve3d，要求：1.curve3ds必须都在的surf曲面上，2.curve3ds必须首尾相接，封闭成一个环，3.curve3d环逆时针，且不自交
+     */
+    static createSingWireShell(surf: Surface, curve3ds: Curve3[], tolerance?: Tol): Shell;
+    /**
+     * @author  //当前只支持一个外环多个内环的情况，后续有需求再修改支持多外环。
+     * function 输入一个curve3d二维数组和一个surface，构造有一个外环多个内环的face的shell。会检查curve3ds是否首尾相接。不检查逆时针、自交等。
+     * @param surf 输入curve3d所在的surface曲面
+     * @param curve3ds curve3d的二维数组。每个一维数组为一个环，规定第一个curve3d数组为外环，其余都为内环
+     */
+    static createShell(surf: Surface, curve3dss: Curve3[][], tolerance?: Tol): Shell;
+    static createShells(surf: Surface, faceObjs: Curve3[][][], option?: {
+        checkOverlap?: boolean;
+        smoothTess?: boolean;
+        ratio?: number;
+    }, tolerance?: Tol): Shell[];
+    /**
+     * @author
+     *  检查输入的curve3ds是否合法：检查是否首尾相接，是否封闭。不检查是否自交。
+     * @param curve3ds 输入一个组curve3d
+     */
+    private static _checkCurve3dsStrictValid;
+    /**
+     * @author
+     *  传入一组curve3d生成shell的wire
+     */
+    private static _createWireFromCurve3ds;
+    private static _createWireFromCurve3dsWithCache;
+}

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

@@ -0,0 +1,25 @@
+import { Surface, Curve3, Tol } from '../..';
+import { IShellModelingResult } from './shell_edit/shell_modeling_result';
+/**
+ * 构造壳：目前只支持surface为平面、且只有一个外环多个内环的face的壳
+ */
+export declare class ShellBuilder {
+    /**
+     * @author  //当前只支持一个外环多个内环的情况，后续有需求再修改支持多外环。
+     * function 输入一个curve3d二维数组和一个surface，构造有一个外环多个内环的face的shell。会检查curve3ds是否首尾相接。不检查逆时针、自交等。
+     * @param surf 输入curve3d所在的surface曲面
+     * @param curve3ds curve3d的二维数组。每个一维数组为一个环，规定第一个curve3d数组为外环，其余都为内环
+     */
+    static createShell(surf: Surface, curve3dss: Curve3[][], tolerance?: Tol): IShellModelingResult;
+    /**
+     * 通过几何数据，创建一些面
+     * @param surf 输入curve3d所在的surface曲面
+     * @param faceObjs curve3d的三维数组。第一维是面，第二维是环（外环+内环），第三维是曲线
+     * @param option 配置参数（checkOverlap -- 检查重叠的点、边, 不会创建重复的拓扑）
+     */
+    static createFacesFromCurves(surf: Surface, faceObjs: Curve3[][][], option?: {
+        checkOverlap?: boolean;
+        smoothTess?: boolean;
+        ratio?: number;
+    }, tolerance?: Tol): IShellModelingResult;
+}

package/types/brep-src/algorithm/shell_edit/add_edges/add_edges.d.ts

@@ -0,0 +1,14 @@
+import { Curve3, Cylinder, Plane } from '../../../..';
+import ShellModelingBase from '../shell_modeling_base';
+import { Shell } from '../../../brep/shell';
+import { IShellModelingResult } from '../shell_modeling_result';
+/**
+ *
+ * 加边成面
+ */
+export default class AddEdges extends ShellModelingBase {
+    private _curves;
+    private _curvePlane;
+    constructor(curves: Curve3[], plane: Plane | Cylinder | undefined, context: Shell[]);
+    protected _executeImpl(): IShellModelingResult;
+}

package/types/brep-src/algorithm/shell_edit/add_edges/add_edges_core.d.ts

@@ -0,0 +1,11 @@
+import { Face } from '../../../brep/face';
+import { Shell } from '../../../brep/shell';
+import { IShellModelingResult } from '../shell_modeling_result';
+import { Plane } from '../../../../geometry/plane';
+import { Cylinder } from '../../../../geometry/cylinder';
+import { Curve3 } from '../../../../geometry/curve3d';
+export interface IAddEdgesResult extends IShellModelingResult {
+    faceSplitMap: Map<Face, Face[]>;
+    newOuterFaces: Face[];
+}
+export declare function addEdgesCore(cc: Curve3[], curvePlane: Plane | Cylinder | undefined, model: Shell[], result: IAddEdgesResult): void;

package/types/brep-src/algorithm/shell_edit/copy_faces.d.ts

@@ -0,0 +1,20 @@
+import { Matrix4 } from '../../..';
+import { Shell } from '../../brep/shell';
+import { Face } from '../../brep/face';
+import { IShellModelingResult } from './shell_modeling_result';
+import ShellModelingBase from './shell_modeling_base';
+export default class CopyFaces extends ShellModelingBase {
+    private _faces;
+    private _reuseTag;
+    private _matrix;
+    constructor(faces: Face[], reuseTag?: boolean, matrix?: Matrix4, context?: Shell[]);
+    /**
+     * 复制面到新的位置，深拷贝
+     * @param this._faces source face
+     * @param this._reuseTag
+     * @param this._matrix
+     * @returns origin face --> new face map
+     */
+    protected _executeImpl(): IShellModelingResult;
+    private _cloneFacesByShell;
+}

package/types/brep-src/algorithm/shell_edit/delete_faces_edges/delete_edge.d.ts

@@ -0,0 +1,9 @@
+import { Edge } from '../../../brep/edge';
+import { IShellModelingResult } from '../shell_modeling_result';
+export default class DeleteEdges {
+    static execute(deleteEdges: Edge[]): IShellModelingResult;
+    private static _findFaceGroup;
+    private static _reverseFaces;
+    private static _getSourceFace;
+    private static _processCylinder;
+}

package/types/brep-src/algorithm/shell_edit/delete_faces_edges/delete_faces_edges.d.ts

@@ -0,0 +1,17 @@
+import { Edge } from '../../../brep/edge';
+import { Face } from '../../../brep/face';
+import { Shell } from '../../../brep/shell';
+import ShellModelingBase from '../shell_modeling_base';
+import { IShellModelingResult } from '../shell_modeling_result';
+/**
+ * 删除多个面、边；
+ * 如果边是曲面的边，则直接将该曲面删除；
+ * 如果边是平面的边，则在平面上重新搜环（DeleteEdges）；
+ */
+export default class DeleteFacesEdges extends ShellModelingBase {
+    private _faces;
+    private _edges;
+    private _mergeEdge;
+    constructor(faces: Face[], edges: Edge[], mergeEdge?: boolean, context?: Shell[]);
+    protected _executeImpl(): IShellModelingResult;
+}

package/types/brep-src/algorithm/shell_edit/faces_boolean/faces_boolean.d.ts

@@ -0,0 +1,19 @@
+import { Tol } from '../../../..';
+import { Face } from '../../../brep/face';
+import { IShellModelingResult } from '../shell_modeling_result';
+export declare function addToSetInMap(map: Map<any, any>, key: any, value: any): void;
+export declare function addOverlapInfo<T>(infos: Set<T>[], a: T, b: T): void;
+export declare enum BooleanType {
+    kUnion = 0,
+    kIntersect = 1,
+    kSubtract = 2,
+    kXor = 3,
+    kSplit = 4
+}
+export interface IFacesBooleanResult extends IShellModelingResult {
+    resultFaces: Face[];
+}
+export declare function facesBooleanCore(fs1: Face[], fs2: Face[], type: BooleanType, updateSmooth?: boolean, noOverlap1?: boolean, noOverlap2?: boolean, tol?: Tol): IFacesBooleanResult;
+export declare function facesUnion(faces1: Face[], faces2: Face[], updateSmooth?: boolean): IFacesBooleanResult;
+export declare function facesSubtract(faces1: Face[], faces2: Face[], updateSmooth?: boolean): IFacesBooleanResult;
+export declare function facesSplit(faces1: Face[], faces2: Face[], updateSmooth?: boolean): IFacesBooleanResult;

package/types/brep-src/algorithm/shell_edit/faces_boolean/faces_shells_boolean.d.ts

@@ -0,0 +1,13 @@
+import { Tol } from '../../../..';
+import { Face } from '../../../brep/face';
+import { IShellModelingResult } from '../shell_modeling_result';
+import { Shell } from '../../../brep/shell';
+import ShellModelingBase from '../shell_modeling_base';
+export default class FacesShellsMerge extends ShellModelingBase {
+    private _faces;
+    private _checkOverlap;
+    private _updateSmooth;
+    private _tolerance;
+    constructor(faces: Face[], context: Shell[], checkFacesOverlap?: boolean, updateSmooth?: boolean, tolerance?: Tol);
+    protected _executeImpl(): IShellModelingResult;
+}

package/types/brep-src/algorithm/shell_edit/faces_boolean/octree.d.ts

@@ -0,0 +1,11 @@
+import { Vec3 } from '../../../..';
+export declare class Octree<T> {
+    private _root;
+    private _getBound;
+    private _maxDepth;
+    private _objectIndexMap;
+    constructor(objs: T[], getBound: (t: T) => Vec3[], origin?: Vec3, halfLength?: number, maxDepth?: number);
+    getCandidateOverlaps(obj: T, objBound?: Vec3[]): T[];
+    remove(objs: T[]): void;
+    add(obj: T, objBound?: Vec3[]): void;
+}

package/types/brep-src/algorithm/shell_edit/isolate_faces.d.ts

@@ -0,0 +1,21 @@
+import { Shell } from '../../brep/shell';
+import { Face } from '../../brep/face';
+import { IShellModelingResult } from './shell_modeling_result';
+import ShellModelingBase from './shell_modeling_base';
+export interface IIsolateFacesResult extends IShellModelingResult {
+    newShell: Shell;
+    edgesDelete: string[];
+}
+export default class IsolateFaces extends ShellModelingBase {
+    private _faces;
+    private _originShell;
+    constructor(faces: Face[], originShell: Shell, context?: Shell[]);
+    /**
+     * @static
+     * @param {Shell} this._originShell 原shell
+     * @param {Face[]} this._faces 构成新组合的faces
+     * @return {*}  {Shell} 新shell
+     * @memberof GroupShell
+     */
+    protected _executeImpl(): IIsolateFacesResult;
+}

package/types/brep-src/algorithm/shell_edit/merge_connect_faces.d.ts

@@ -0,0 +1,14 @@
+import { Face } from '../../brep/face';
+import { IShellModelingResult } from './shell_modeling_result';
+import { Shell } from '../../brep/shell';
+import ShellModelingBase from './shell_modeling_base';
+export default class MergeConnectFaces extends ShellModelingBase {
+    private _faces;
+    constructor(faces: Face[], context?: Shell[]);
+    /**
+     * 将一堆面中，满足共surface, 且相邻的情况，进行合并。
+     * 不做布尔运算，（暂时只支持平面，不支持曲面）
+     * @param faces 待合并的面
+     */
+    protected _executeImpl(): IShellModelingResult;
+}

package/types/brep-src/algorithm/shell_edit/merge_edges.d.ts

@@ -0,0 +1,8 @@
+import { Edge } from '../../brep/edge';
+import ShellModelingBase from './shell_modeling_base';
+import { IShellModelingResult } from './shell_modeling_result';
+export default class MergeEdges extends ShellModelingBase {
+    private _edges;
+    constructor(edges: Edge[]);
+    protected _executeImpl(): IShellModelingResult;
+}

package/types/brep-src/algorithm/shell_edit/move_operators/move_edges.d.ts

@@ -0,0 +1,31 @@
+import { Vec3 } from '../../../..';
+import { Edge } from '../../../brep/edge';
+import { Shell } from '../../../brep/shell';
+import { IShellModelingResult } from '../shell_modeling_result';
+import ShellModelingBase from '../shell_modeling_base';
+/**
+ * 输入：要移动的edges，移动的起始点和终止点，场景内所有的shell（或者移动edges后所有可能相交的shell），如果不穿shells则不会求交分割
+ * 限制：目前不允许移动edge之后face自交
+ */
+export declare class MoveEdges extends ShellModelingBase {
+    private _edges;
+    private _transVect;
+    private _overlapInfo;
+    private _shell;
+    constructor(edges: Edge[], moveVect: Vec3, context?: Shell[]);
+    preview(): IShellModelingResult;
+    /**
+     * move edges and connect vertices
+     */
+    protected _executeImpl(): IShellModelingResult;
+    private _moveEdgesCore;
+    private _previewCore;
+    private _getAllConnectElems;
+    private _getAllAdjacentEdges;
+    private _getAllAdjacentFaces;
+    private _canUseTransVect;
+    private _judgeSelfIntersect;
+    private _dealAdjacentCurves;
+    private _dealAdjacentFaces;
+    private _dealDegeneratedCase;
+}

package/types/brep-src/algorithm/shell_edit/move_operators/move_faces.d.ts

@@ -0,0 +1,14 @@
+import { Vec3 } from '../../../..';
+import { Face } from '../../../brep/face';
+import { IShellModelingResult } from '../shell_modeling_result';
+import ShellModelingBase from '../shell_modeling_base';
+import { Shell } from '../../../brep/shell';
+export declare class MoveFaces extends ShellModelingBase {
+    private _faces;
+    private _transVect;
+    constructor(faces: Face[], moveVect: Vec3, context?: Shell[]);
+    /**
+     * move faces and connect edges, vertices. // move face不会导致移动的face自相交，因此后续可改进，移动edge不用判断自相交。或者都继承自一个基类 //
+     */
+    protected _executeImpl(): IShellModelingResult;
+}

package/types/brep-src/algorithm/shell_edit/operator/dispose_topo.d.ts

@@ -0,0 +1,2 @@
+import { Face } from '../../../brep/face';
+export declare function disposeFace(face: Face): void;

package/types/brep-src/algorithm/shell_edit/operator/merge_connect_edge.d.ts

@@ -0,0 +1,3 @@
+import { Edge } from '../../../brep/edge';
+import { Vertex } from '../../../brep/vertex';
+export declare function mergeConnectedEdge(edge1: Edge, edge2: Edge, commonV: Vertex): Edge | undefined;