@labelbee/lb-annotation 1.13.1-alpha.0 → 1.14.0-alpha.1

package/dist/types/core/toolOperation/cuboidOperation.d.ts

@@ -0,0 +1,174 @@
+import { ECuboidDirection } from '@/constant/annotation';
+import type { ICuboid, ICuboidConfig, IDrawingCuboid } from '@/types/tool/cuboid';
+import { BasicToolOperation } from './basicToolOperation';
+import type { IBasicToolOperationProps } from './basicToolOperation';
+import { ITextAttributeFuc } from './textAttributeClass';
+type ICuboidOperationProps = IBasicToolOperationProps;
+/**
+ * Just use for the drawing.
+ */
+declare enum EDrawingStatus {
+    Ready = 1,
+    FirstPoint = 2,
+    Cuboid = 3
+}
+declare class CuboidOperation extends BasicToolOperation implements ITextAttributeFuc {
+    private toggleButtonInstance?;
+    drawingCuboid?: IDrawingCuboid;
+    /**
+     * The coordinates of the first click, used for creating a cuboid.
+     */
+    firstClickCoord?: ICoordinate;
+    drawingStatus: EDrawingStatus;
+    cuboidList: ICuboid[];
+    selectedID?: string;
+    config: ICuboidConfig;
+    hoverID: string;
+    private dragInfo?;
+    private highlightInfo?;
+    private _textAttributeInstance?;
+    get selectedText(): string;
+    constructor(props: ICuboidOperationProps);
+    destroy(): void;
+    /**
+     * Get the showing cuboidList which is needed to be shown.
+     *
+     * Filter Condition: (It is not enabled currently)
+     * 1. basicResult
+     * 2. attributeLockList
+     */
+    get currentShowList(): ICuboid[];
+    get selectedCuboid(): ICuboid | undefined;
+    get dataList(): ICuboid[];
+    get isNeedCheckCuboidSize(): boolean;
+    /**
+     * Whether the mouse is in the hover range.
+     * @param e
+     * @returns
+     */
+    getIsHoverSelectedCuboid(e: MouseEvent): boolean | undefined;
+    /**
+     * Forbidden to draw a cuboid if the backPlane is front than the frontPlane.
+     * @param e
+     * @param cuboid
+     * @returns
+     */
+    isForbiddenMove(e: MouseEvent, cuboid: ICuboid | IDrawingCuboid): boolean;
+    getHoverData: (e: MouseEvent) => {
+        hoverID: string;
+        hoverCuboid: ICuboid | undefined;
+    } | {
+        hoverID?: undefined;
+        hoverCuboid?: undefined;
+    };
+    updateSelectedCuboid(newCuboid: ICuboid): void;
+    getStylesToRender(attribute: string, valid: boolean): {
+        strokeColor: any;
+        toolColor: any;
+        fillColor: any;
+        lineWidth: any;
+    };
+    /**
+     * Get Selected Data.
+     *
+     * Exclusive: TextAttributeInstance.
+     * @param attribute
+     * @param valid
+     * @returns
+     */
+    getCurrentSelectedData(): {
+        width: number;
+        textAttribute: string;
+        color: any;
+    } | undefined;
+    /**
+     * Update text Input.
+     *
+     * Exclusive: TextAttributeInstance.
+     * @param attribute
+     * @param valid
+     * @returns
+     */
+    updateSelectedTextAttribute(newTextAttribute?: string): void;
+    setResult(cuboidList: ICuboid[]): void;
+    /**
+     * 获取当前页面标注结果
+     */
+    get currentPageResult(): ICuboid[];
+    clearResult(): void;
+    exportData(): any[];
+    setSelectedID(newID?: string): void;
+    setSelectedIDAndRender(newID?: string): void;
+    setCuboidValidAndRender(id: string): void;
+    onRightDblClick(e: MouseEvent): void;
+    setCuboidList(cuboidList: ICuboid[], isUpload?: boolean): void;
+    deleteCuboid(id: string): void;
+    onKeyDown(e: KeyboardEvent): void;
+    onKeyUp(e: KeyboardEvent): void;
+    onMouseDown(e: MouseEvent): void;
+    onMouseUp(e: MouseEvent): boolean | void;
+    onMouseMove(e: MouseEvent): boolean | void;
+    drawingFrontPlanesMove(e: MouseEvent): true | undefined;
+    drawingBackPlaneMove(e: MouseEvent): void;
+    onDragMove(e: MouseEvent): void;
+    /**
+     * onMouseMove in hover.
+     *
+     * Highlight the position of hover.
+     * @param e
+     */
+    onHoverMove(e: MouseEvent): void;
+    createNewDrawingCuboid(e: MouseEvent, basicSourceID: string): void;
+    /**
+     * Change Status
+     * From drawing frontPlane to backPlane
+     */
+    closeNewDrawingFrontPlane(): void;
+    closeAndCreateNewCuboid(): void;
+    deleteSelectedID(): void;
+    clearDrawingStatus(): void;
+    clearActiveStatus(): void;
+    rightMouseUp(e: MouseEvent): void;
+    /**
+     * Render the highlight components
+     *
+     * Situation:
+     * 1. hover
+     * 2. selected.
+     *
+     * Components:
+     * 1. 6 Points
+     * 2. 5 Lines.
+     *
+     * @param cuboid
+     */
+    renderHighlightCuboidCom(cuboid: ICuboid | IDrawingCuboid): void;
+    /**
+     * TODO - Need to optimize.
+     * @param cuboid
+     */
+    renderSingleCuboid(cuboid: ICuboid | IDrawingCuboid): void;
+    setDefaultAttribute(defaultAttribute?: string): void;
+    renderToggleButton(): void;
+    renderTextAttribute(): void;
+    renderDrawing(): void;
+    renderStatic(): void;
+    renderSelected(): void;
+    updateMouseOperation(type: 'in' | 'out'): void;
+    toggleDirection(direction: ECuboidDirection): void;
+    /**
+     * Notice: Hover is under selectedCuboid.
+     */
+    renderHover(): void;
+    renderCuboid(): void;
+    render(): void;
+    undo(): void;
+    redo(): void;
+    /**
+     * Sidebar Callback Function
+     * @param v
+     * @returns
+     */
+    textChange: (v: string) => void;
+}
+export default CuboidOperation;

package/dist/types/core/toolOperation/cuboidToggleButtonClass.d.ts

@@ -0,0 +1,38 @@
+import { ECuboidDirection } from '@/constant/annotation';
+interface IBaseInfo {
+    cuboidButtonMove: (type: 'in' | 'out') => void;
+    toggleDirection: (direction: ECuboidDirection) => void;
+}
+interface ITextAttributeProps {
+    container: HTMLElement;
+}
+export default class CuboidToggleButtonClass {
+    private container;
+    private direction;
+    private _cuboidButtonDOM?;
+    private _cuboidFABDOM?;
+    private isFrontSide;
+    private _cuboidMoreDOM?;
+    private _cuboidMoreListDOM?;
+    private cuboidButtonMove;
+    private onToggleDirection;
+    constructor(props: ITextAttributeProps & IBaseInfo);
+    appendToContainer(): void;
+    initCuboidButtonDOM(): HTMLDivElement;
+    initcuboidFABDOM(icon: any): HTMLDivElement;
+    initcuboidMoreDOM(icon: any): HTMLDivElement;
+    initcuboidMoreListDOM(): HTMLDivElement;
+    /**
+     * Update current button (top)
+     * @param position
+     */
+    update(position: {
+        left: number;
+        top: number;
+        color: string;
+        width?: number;
+    }): void;
+    clearCuboidButtonDOM(): void;
+    clearCuboidMoreListDOM(): void;
+}
+export {};

package/dist/types/core/toolOperation/pointOperation.d.ts

@@ -1,6 +1,8 @@
 import { BasicToolOperation, IBasicToolOperationProps } from './basicToolOperation';
 export interface IPointOperationProps extends IBasicToolOperationProps {
     style: any;
+    forbidAddNew?: boolean;
+    forbidDelete?: boolean;
 }
 declare class PointOperation extends BasicToolOperation {
     config: IPointToolConfig;
@@ -12,6 +14,8 @@ declare class PointOperation extends BasicToolOperation {
         dragStartCoord: ICoordinate;
         originPointList: IPointUnit[];
     };
+    forbidAddNew?: boolean;
+    forbidDelete?: boolean;
     private _textAttributInstance?;
     constructor(props: IPointOperationProps);
     get dataList(): IPointUnit[];
@@ -43,7 +47,7 @@ declare class PointOperation extends BasicToolOperation {
     clearResult(): void;
     setDefaultAttribute(defaultAttribute?: string): void;
     /**
-     * 外层 sidabr 调用
+     * 外层 sidebar 调用
      * @param v
      * @returns
      */
@@ -75,6 +79,7 @@ declare class PointOperation extends BasicToolOperation {
     createPoint(e: MouseEvent): void;
     isInPoint(pos: ICoordinate, point: ICoordinate, zoom?: number): boolean;
     getHoverId(): string | undefined;
+    get selectedPoint(): IPointUnit | undefined;
     rightMouseUp(): void;
     onTabKeyDown(e: KeyboardEvent): void;
     /**

package/dist/types/core/toolOperation/textAttributeClass.d.ts

@@ -53,4 +53,13 @@ export default class TextAttributeClass {
      */
     changeSelected(): void;
 }
+/**
+ * TextAttribute injection requires content changes.
+ *
+ * Custom Changes.
+ * 1. Need to init textAttribute when creating data.
+ */
+export interface ITextAttributeFuc extends IBaseInfo {
+    selectedText: string;
+}
 export {};

package/dist/types/index.d.ts

@@ -28,9 +28,10 @@ import ActionsHistory from './utils/ActionsHistory';
 import DblClickEventListener from './utils/tool/DblClickEventListener';
 import AnnotationEngine from './core';
 import UnitUtils from './utils/tool/UnitUtils';
+import StyleUtils from './utils/tool/StyleUtils';
 declare const CommonToolUtils: typeof EnhanceCommonToolUtils;
 declare const toolUtils: typeof EnhanceCommonToolUtils;
-export { RectOperation, TagOperation, PointOperation, LineToolOperation, PolygonOperation, TextToolOperation, BasicToolOperation, MeasureOperation, ViewOperation, PointCloud2dOperation, cAnnotation, cAnnotationTask, cKeyCode, cStyle, cTool, toolUtils, DblClickEventListener, CommonToolUtils, uuid, MarkerUtils, RectUtils, AxisUtils, TagUtils, DrawUtils, ImgUtils, MathUtils, AttributeUtils, AnnotationEngine, ScribbleTool, UnitUtils, ActionsHistory, };
+export { RectOperation, TagOperation, PointOperation, LineToolOperation, PolygonOperation, TextToolOperation, BasicToolOperation, MeasureOperation, ViewOperation, PointCloud2dOperation, cAnnotation, cAnnotationTask, cKeyCode, cStyle, cTool, toolUtils, DblClickEventListener, CommonToolUtils, uuid, MarkerUtils, RectUtils, AxisUtils, TagUtils, DrawUtils, ImgUtils, MathUtils, AttributeUtils, AnnotationEngine, ScribbleTool, UnitUtils, StyleUtils, ActionsHistory, };
 export * from './newCore';
 export * from './constant/tool';
 export * from './core/pointCloud';

package/dist/types/utils/MathUtils.d.ts

@@ -49,7 +49,7 @@ export default class MathUtils {
      * @param {boolean} ignoreRatio
      * @returns
      */
-    static getFootOfPerpendicular: (pt: ICoordinate, begin: ICoordinate, end: ICoordinate, useAxisRange?: boolean) => any;
+    static getFootOfPerpendicular: (pt: ICoordinate, begin: ICoordinate, end: ICoordinate, useAxisRange?: boolean, allowOverRange?: boolean) => any;
     /**
      * 获取当前文本的背景面积
      * @param canvas

package/dist/types/utils/tool/AttributeUtils.d.ts

@@ -77,6 +77,13 @@ export default class AttributeUtils {
      */
     static changeTextAttributeInLog(toolLog: any[][], toolList: any[]): any[][];
     static getTextIconSvg(attribute: string | undefined, attributeList: IInputList[], attributeConfigurable: boolean | undefined, baseIcon: any): any;
+    static generateIconAttribute({ fill, width, height, xmlns, xlink, }: {
+        fill?: string;
+        width?: number;
+        height?: number;
+        xmlns?: string;
+        xlink?: string;
+    }): string;
     /**
      * 根据keycode返回attribute, 没有匹配到时为undefined
      * @param keyCode

package/dist/types/utils/tool/AxisUtils.d.ts

@@ -1,4 +1,5 @@
 import { EToolName, ELineTypes } from '@/constant/tool';
+import type { ICuboid, IDrawingCuboid, IPlanePoints } from '@/types/tool/cuboid';
 import { IPolygonPoint, IPolygonData, IPolygonConfig } from '../../types/tool/polygon';
 export default class AxisUtils {
     /**
@@ -66,6 +67,9 @@ export default class AxisUtils {
         x: number;
         y: number;
     })[];
+    static changePlanePointByZoom(planePoints: IPlanePoints, zoom: number, currentPos?: ICoordinate): IPlanePoints;
+    static changeCuboidByZoom(cuboid: ICuboid | IDrawingCuboid, zoom: number, currentPos?: ICoordinate): ICuboid | IDrawingCuboid;
+    static transformPlain2PointList({ tl, tr, br, bl }: IPlanePoints): any[];
     /**
      * 扩大点的热区范围
      * @param axis
@@ -97,7 +101,52 @@ export default class AxisUtils {
      * @param {number} [scope=3]
      * @returns {number}
      */
-    static returnClosePointIndex(checkPoint: IPolygonPoint, polygonPoints: IPolygonPoint[], scope?: number): number;
+    static returnClosePointIndex(checkPoint: IPolygonPoint | ICoordinate, polygonPoints: IPolygonPoint[] | ICoordinate[], scope?: number): number;
+    /**
+     * Judge the mousePoint is in the hoverRange of cuboid.
+     * @param checkPoint
+     * @param cuboid
+     * @param options
+     * @returns
+     */
+    static isCloseCuboid(checkPoint: ICoordinate, cuboid: ICuboid, options?: Partial<{
+        scope: number;
+        zoom: number;
+    }>): boolean;
+    /**
+     * Judge the mousePoint is in the hoverRange of cuboidList.
+     * @param checkPoint
+     * @param cuboid
+     * @param options
+     * @returns
+     */
+    static isCloseCuboidList(checkPoint: ICoordinate, cuboidList: ICuboid[], options?: Partial<{
+        scope: number;
+        zoom: number;
+    }>): boolean;
+    /**
+     * Point > Line
+     * @param checkPoint
+     * @param cuboid
+     * @param scope
+     */
+    static returnClosePointOrLineInCuboid(checkPoint: ICoordinate, cuboid: ICuboid, options?: Partial<{
+        scope: number;
+        zoom: number;
+    }>): {
+        type: string;
+        points: ({
+            x: number;
+            y: number;
+            specialPoint?: boolean | undefined;
+            specialEdge?: boolean | undefined;
+        } | {
+            x: number;
+            y: number;
+        })[];
+        originCuboid: ICuboid;
+        positions: import("@/types/tool/cuboid").ICuboidPosition[];
+    }[] | undefined;
     /**
      * 对比两个点是否在一范围内
      *

package/dist/types/utils/tool/CuboidUtils.d.ts

@@ -0,0 +1,267 @@
+import { ECuboidLineDirection, ECuboidPlain, ECuboidPosition, EDragTarget, ECuboidDirection } from '@/constant/annotation';
+import type { ICuboid, ICuboidConfig, ICuboidPosition, IDrawingCuboid, IPlanePoints } from '@/types/tool/cuboid';
+/**
+ * Get the basicInfo of cuboid-frontPoints.
+ * @param param0
+ * @returns
+ */
+export declare function getPlanePointsBasicInfo({ tr, tl, br }: IPlanePoints): {
+    width: number;
+    height: number;
+    centerPoints: {
+        x: number;
+        y: number;
+    };
+};
+export declare function getCuboidBasicInfo({ frontPoints, backPoints, }: {
+    frontPoints: IPlanePoints;
+    backPoints: IPlanePoints;
+}): {
+    frontCenter: {
+        x: number;
+        y: number;
+    };
+    backCenter: {
+        x: number;
+        y: number;
+    };
+    frontWidth: number;
+    frontHeight: number;
+    backWidth: number;
+    backHeight: number;
+    isLeftSide: boolean;
+};
+/**
+ * Use two diagonalPoints to create Regular Rect(Plain)
+ * @param p1
+ * @param p2
+ * @returns
+ */
+export declare function getPlainPointsByDiagonalPoints(p1: ICoordinate, p2: ICoordinate): IPlanePoints;
+/**
+ * Get the max external quadrilateral by points.
+ * @param points
+ * @returns
+ */
+export declare function getMaxExternalQuadrilateral(points: IPlanePoints): {
+    tl: {
+        x: any;
+        y: any;
+    };
+    tr: {
+        x: any;
+        y: any;
+    };
+    bl: {
+        x: any;
+        y: any;
+    };
+    br: {
+        x: any;
+        y: any;
+    };
+};
+export declare function judgeCuboidLineIsRowOrColumn(pointList: [ICuboidPosition, ICuboidPosition]): ECuboidLineDirection | undefined;
+/**
+ * Copy the plain through points and new bottomRightPoint.
+ * @param param0
+ * @returns
+ */
+export declare function getPointsByBottomRightPoint({ coord, points, }: {
+    coord: ICoordinate;
+    points: IPlanePoints;
+}): IPlanePoints;
+/**
+ * Copy the plain through points and new bottomLeftPoint.
+ *
+ * Notice: currentPoints is just regular rectangle.
+ *
+ * @param param0
+ * @returns
+ */
+export declare function getPointsByBottomLeftPoint({ coord, points, }: {
+    coord: ICoordinate;
+    points: IPlanePoints;
+}): IPlanePoints;
+/**
+ * The showing sideline is line that connects the front and back planes.
+ * @param param0
+ * @returns
+ */
+export declare function getCuboidShowingSideLine({ frontPoints, backPoints, }: {
+    frontPoints: IPlanePoints;
+    backPoints: IPlanePoints;
+}): {
+    top: {
+        p1: ICoordinate;
+        p2: ICoordinate;
+    };
+    bottom: {
+        p1: ICoordinate;
+        p2: ICoordinate;
+    };
+};
+/**
+ * Get the intersections from frontPoints & backPoints.
+ *
+ * @param param0
+ * @returns
+ */
+export declare function getPointsByIntersection({ frontPoints, backPoints, }: {
+    frontPoints: IPlanePoints;
+    backPoints: IPlanePoints;
+}): {
+    backPoints: {
+        bl: ICoordinate;
+        tl: ICoordinate;
+        br: ICoordinate;
+        tr: ICoordinate;
+    };
+};
+/**
+ * When the point
+ * @param frontPoints
+ * @param backPoints
+ */
+export declare function getBackPointsByFrontPoints({ frontPoints, backPoints, }: {
+    frontPoints: IPlanePoints;
+    backPoints: IPlanePoints;
+}): {
+    frontPoints: IPlanePoints;
+    backPoints: {
+        bl: ICoordinate;
+        tl: ICoordinate;
+        br: ICoordinate;
+        tr: ICoordinate;
+    };
+};
+export declare function getFrontPointsByBackPoints({ frontPoints, backPoints, }: {
+    frontPoints: IPlanePoints;
+    backPoints: IPlanePoints;
+}): {
+    frontPoints: {
+        bl: ICoordinate;
+        tl: ICoordinate;
+        br: ICoordinate;
+        tr: ICoordinate;
+    };
+    backPoints: IPlanePoints;
+};
+/**
+ * Get SideLine By FrontPoints & BackPoints
+ * @param param0
+ * @returns
+ */
+export declare function getCuboidAllSideLine({ frontPoints, backPoints }: ICuboid): {
+    p1: ICoordinate;
+    p2: ICoordinate;
+}[];
+export declare function getHighlightLines(cuboid: ICuboid): ({
+    p1: ICoordinate;
+    p2: ICoordinate;
+    positions: {
+        plain: ECuboidPlain;
+        position: ECuboidPosition;
+    }[];
+    plain?: undefined;
+} | {
+    p1: ICoordinate;
+    p2: ICoordinate;
+    plain: ECuboidPlain;
+    positions: {
+        plain: ECuboidPlain;
+        position: ECuboidPosition;
+    }[];
+})[];
+/**
+ * Just showing the points which can be adjusted
+ * @param cuboid
+ * @returns
+ */
+export declare function getHighlightPoints(cuboid: ICuboid): {
+    point: ICoordinate;
+    positions: ICuboidPosition[];
+}[];
+/**
+ * Get the range of Cuboid in 2D.
+ *
+ * @param param0
+ * @returns
+ */
+export declare function getCuboidHoverRange(cuboid: ICuboid): ICoordinate[];
+/**
+ * Notice: positions just support point and line moving.
+ * @param param0
+ */
+export declare function getNewPointsAfterOffset({ offset, frontPoints, backPoints, positions, }: {
+    frontPoints: IPlanePoints;
+    backPoints: IPlanePoints;
+    offset: ICoordinate;
+    positions?: ICuboidPosition[];
+}): {
+    frontPoints: IPlanePoints;
+    backPoints: IPlanePoints;
+};
+/**
+ * Update cuboid when dragging.
+ * @param param0
+ * @returns
+ */
+export declare function getCuboidDragMove({ offset, cuboid, dragTarget, positions, }: {
+    offset: ICoordinate;
+    cuboid: ICuboid;
+    dragTarget: EDragTarget;
+    positions?: ICuboidPosition[];
+}): ICuboid | undefined;
+/**
+ * Get the points of the corresponding faces by direction
+ * @param cuboid
+ * @returns
+ */
+export declare function getPointListsByDirection({ direction, frontPoints, backPoints, }: {
+    direction: ECuboidDirection;
+    frontPoints: IPlanePoints;
+    backPoints: IPlanePoints;
+}): any[] | undefined;
+/**
+ * Get the offset of toggleDirection Dom.
+ *
+ * Calculation
+ * 1. FrontPoints left centerPoints.
+ * 2. Offset the size of toggleDom.
+ * @param param0
+ * @returns
+ */
+export declare function getToggleDirectionButtonOffset({ cuboid, currentPos, zoom, }: {
+    cuboid: ICuboid;
+    currentPos: ICoordinate;
+    zoom: number;
+}): {
+    left: number;
+    top: number;
+};
+/**
+ * The default offset is base on iconSvg.
+ *
+ * @param param0
+ * @returns
+ */
+export declare function getCuboidTextAttributeOffset({ cuboid, currentPos, zoom, leftOffset, topOffset, }: {
+    cuboid: ICuboid | IDrawingCuboid;
+    currentPos: ICoordinate;
+    zoom: number;
+    leftOffset?: number;
+    topOffset?: number;
+}): {
+    left: number;
+    top: number;
+};
+/**
+ * Judgement of minWidth & minHeight
+ * @param param0
+ * @returns
+ */
+export declare function isCuboidWithInLimits({ cuboid, config }: {
+    cuboid: ICuboid | IDrawingCuboid;
+    config: ICuboidConfig;
+}): boolean;

package/dist/types/utils/tool/DrawUtils.d.ts

@@ -1,3 +1,4 @@
+import type { ICuboid, ICuboidConfig, IDrawingCuboid } from '@/types/tool/cuboid';
 import { ELineTypes } from '../../constant/tool';
 import { IPolygonPoint } from '../../types/tool/polygon';
 export interface IDrawTextConfig {
@@ -163,4 +164,35 @@ export default class DrawUtils {
         theta: number;
         headLen: number;
     }>): void;
+    /**
+     * Expansion of other base draw.
+     *
+     * Simple Version.
+     * @param param0
+     */
+    static drawCuboid(canvas: HTMLCanvasElement, cuboid: ICuboid | IDrawingCuboid, options?: Partial<{
+        strokeColor: string;
+        fillColor: string;
+        thickness: number;
+    }>): void;
+    /**
+     * Draw Cuboid and Text in header & bottom.
+     * @param canvas
+     * @param cuboid
+     * @param options
+     * @param dataConfig
+     */
+    static drawCuboidWithText(canvas: HTMLCanvasElement, cuboid: ICuboid | IDrawingCuboid, options: {
+        strokeColor: string;
+        fillColor?: string;
+        thickness?: number;
+    }, dataConfig: {
+        config: ICuboidConfig;
+        hiddenText?: boolean;
+        currentPos: ICoordinate;
+        zoom: number;
+        selectedID?: string;
+        headerText?: string;
+        bottomText?: string;
+    }): void;
 }

package/dist/types/utils/tool/EnhanceCommonToolUtils.d.ts

@@ -5,6 +5,8 @@
  */
 import { ECheckModel, EToolName } from '@/constant/tool';
 import ScribbleTool from '@/core/toolOperation/ScribbleTool';
+import CuboidOperation from '@/core/toolOperation/cuboidOperation';
+import PointCloud2dOperation from '@/core/toolOperation/pointCloud2dOperation';
 import CheckOperation from '../../core/toolOperation/checkOperation';
 import PolygonOperation from '../../core/toolOperation/polygonOperation';
 import RectOperationAsNewName from '../../core/toolOperation/rectOperation';
@@ -13,9 +15,9 @@ import LineToolOperation from '../../core/toolOperation/LineToolOperation';
 import PointOperation from '../../core/toolOperation/pointOperation';
 import TextToolOperation from '../../core/toolOperation/TextToolOperation';
 import CommonToolUtils from './CommonToolUtils';
-declare const getCurrentOperation: (toolName: EToolName | ECheckModel) => typeof RectOperationAsNewName | typeof TagOperation | typeof PointOperation | typeof LineToolOperation | typeof TextToolOperation | typeof PolygonOperation | typeof ScribbleTool | typeof CheckOperation;
+declare const getCurrentOperation: (toolName: EToolName | ECheckModel) => typeof RectOperationAsNewName | typeof TagOperation | typeof PointOperation | typeof LineToolOperation | typeof TextToolOperation | typeof PolygonOperation | typeof ScribbleTool | typeof PointCloud2dOperation | typeof CuboidOperation | typeof CheckOperation;
 declare class EnhanceCommonToolUtils extends CommonToolUtils {
-    static getCurrentOperation: (toolName: EToolName | ECheckModel) => typeof RectOperationAsNewName | typeof TagOperation | typeof PointOperation | typeof LineToolOperation | typeof TextToolOperation | typeof PolygonOperation | typeof ScribbleTool | typeof CheckOperation;
+    static getCurrentOperation: (toolName: EToolName | ECheckModel) => typeof RectOperationAsNewName | typeof TagOperation | typeof PointOperation | typeof LineToolOperation | typeof TextToolOperation | typeof PolygonOperation | typeof ScribbleTool | typeof PointCloud2dOperation | typeof CuboidOperation | typeof CheckOperation;
 }
 export { getCurrentOperation };
 export default EnhanceCommonToolUtils;