@labelbee/lb-annotation 1.0.0-alpha.1

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

@@ -0,0 +1,238 @@
+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 {
+    /**
+     * 获取原图坐标下，相对当前图片的偏移值
+     * @param coordinate
+     * @param currentPos
+     * @param zoom
+     */
+    static getOffsetCoordinate(coordinate: ICoordinate, currentPos: ICoordinate, zoom: number): {
+        x: number;
+        y: number;
+    };
+    static changeDrawOutsideTarget(coord: ICoordinate, currentPos: ICoordinate, imgInfo: ISize, drawOutsideTarget?: boolean, basicResult?: IRect, zoom?: number): ICoordinate;
+    static changeCoordinateByRotate(coordinate: ICoordinate, rotate: number, imgSize: ISize): ICoordinate;
+    /**
+     * 计算点在 zoom 和 currentPos 的转换
+     * @param rect
+     * @param zoom
+     * @param currentPos
+     * @returns
+     */
+    static changeRectByZoom(rect: IRect, zoom: number, currentPos?: ICoordinate): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        id: string;
+        sourceID: string;
+        valid: boolean;
+        order?: number | undefined;
+        attribute: string;
+        textAttribute: string;
+        disableDelete?: boolean | undefined;
+        label?: string | undefined;
+    };
+    /**
+     * 计算点在 zoom 和 currentPos 的转换
+     * @param point
+     * @param zoom
+     * @param currentPos
+     * @returns
+     */
+    static changePointByZoom(point: IPoint | IPolygonPoint, zoom: number, currentPos?: ICoordinate): {
+        x: number;
+        y: number;
+        specialPoint?: boolean | undefined;
+        specialEdge?: boolean | undefined;
+    } | {
+        x: number;
+        y: number;
+    };
+    /**
+     * 计算点集在 zoom 和 currentPos 的转换
+     * @param pointList
+     * @param zoom
+     * @param currentPos
+     * @returns
+     */
+    static changePointListByZoom(pointList: IPoint[] | IPolygonPoint[], zoom: number, currentPos?: ICoordinate): ({
+        x: number;
+        y: number;
+        specialPoint?: boolean | undefined;
+        specialEdge?: boolean | undefined;
+    } | {
+        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
+     * @param radius
+     * @returns
+     */
+    static axisArea(axis: ICoordinate, radius?: number): {
+        x: number;
+        y: number;
+    }[];
+    /**
+     * 计算当前坐标相对于原图的坐标
+     * @param coord 在 canvas 内的相对坐标
+     */
+    static getOriginCoordinateWithOffsetCoordinate(coord: ICoordinate, zoom?: number, currentPos?: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    /**
+     * 获取当前坐标是否在当前点
+     * 注意：checkPoint 为原图的坐标
+     *
+     * @export
+     * @param {IPolygonPoint} checkPoint
+     * @param {IPolygonPoint[]} polygonPoints
+     * @param {number} [scope=3]
+     * @returns {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;
+    /**
+     * 对比两个点是否在一范围内
+     *
+     * @export
+     * @param {IPolygonPoint} currentCoord
+     * @param {IPolygonPoint} targetCoord
+     * @param {number} scope
+     * @returns
+     */
+    static getIsInScope(currentCoord: ICoordinate, targetCoord: ICoordinate, scope: number): boolean;
+}
+export declare class CoordinateUtils {
+    private currentPos;
+    private zoom;
+    private basicImgInfo;
+    private basicResult?;
+    private dependToolConfig?;
+    private dependToolName;
+    constructor(props: any);
+    get isDependPolygon(): boolean;
+    get isDependRect(): boolean;
+    get isDependOriginalImage(): boolean;
+    /**
+     * 渲染坐标 => 绝对坐标
+     * @param renderCoordinate
+     */
+    getAbsCoord(renderCoord: ICoordinate): {
+        x: number;
+        y: number;
+    };
+    /**
+     * 绝对坐标 => 渲染坐标
+     * @param absoluteCoordinate
+     */
+    getRenderCoord(absCoord: ICoordinate): {
+        x: number;
+        y: number;
+    };
+    /**
+     * 在矩形内的点
+     * @param absCoord
+     * @param rect
+     */
+    coordInsideRect(absCoord: ICoordinate, rect: {
+        x: number;
+        y: number;
+        height: number;
+        width: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    getPolygonPointList(lineType: ELineTypes, pointList: IPoint[]): any[];
+    /**
+     * 计算线段与线段的交点
+     * @param curCoord
+     * @param preCoord
+     * @param polygonPointListToLineList
+     */
+    getIntersection(curCoord: ICoordinate, preCoord: ICoordinate, polygonPointListToLineList: IPoint[]): {
+        point: ICoordinate;
+        minDistance?: undefined;
+    } | {
+        point: IPoint;
+        minDistance: number;
+    } | undefined;
+    /**
+     * 在多边形内的点
+     * @param absCoord
+     * @param rect
+     */
+    coordInsidePolygon(curCoord: ICoordinate, preCoord: ICoordinate, polygon: IPolygonData, polygonToolConfig: IPolygonConfig): ICoordinate;
+    coordInsideImage(coord: ICoordinate): {
+        x: number;
+        y: number;
+    };
+    /**
+     * 根据依赖工具计算下一个点的绝对坐标
+     * @param curAbsCoord
+     * @param preAbsCoord
+     */
+    getNextCoordByDependTool(curAbsCoord: ICoordinate, preAbsCoord: ICoordinate): ICoordinate | undefined;
+    setDependInfo(dependToolName: EToolName | '', dependToolConfig?: IRectConfig | IPolygonConfig): void;
+    setBasicImgInfo(basicImgInfo: any): void;
+    setBasicResult(basicResult: any): void;
+    setZoomAndCurrentPos(zoom: number, currentPos: ICoordinate): void;
+    isCoordInsideTarget(coord: ICoordinate): boolean;
+    isInBasicPolygon(coord: ICoordinate): boolean;
+}

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

@@ -0,0 +1,46 @@
+export default class CanvasUtils {
+    static getMousePositionOnCanvasFromEvent(event: MouseEvent, canvas: HTMLCanvasElement): {
+        x: number;
+        y: number;
+    } | null;
+    static getClientRect(canvas: HTMLCanvasElement): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    static getSize(canvas: HTMLCanvasElement): {
+        width: number;
+        height: number;
+    } | null;
+    /**
+     * 点在视野内
+     * @param coord
+     * @param viewPort
+     */
+    static inViewPort(coord: ICoordinate | undefined, viewPort: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    }): boolean;
+    /**
+     * 计算视野边界点
+     * @param canvas
+     * @param originOffset
+     * @param zoom
+     * @returns
+     */
+    static getViewPort: (canvas: HTMLCanvasElement | ISize, originOffset: ICoordinate, zoom: number) => {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    /**
+     * 获取当前的渲染像素比例
+     * @param context
+     * @returns
+     */
+    static getPixelRatio: (context: any) => number;
+}

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

@@ -0,0 +1,105 @@
+import { IPolygonPoint } from '../../types/tool/polygon';
+import { ESortDirection } from '../../constant/annotation';
+type point = {
+    id: string;
+    x: number;
+    y: number;
+};
+export default class CommonToolUtils {
+    /**
+     * 找到指定步骤的数据
+     * @param step 获取的步骤
+     * @param stepList 步骤列表
+     * @returns 步骤配置
+     */
+    static getStepInfo(step: number, stepList: IStepInfo[]): IStepInfo;
+    /**
+     * 获取当前步骤的步骤配置信息，用于当前标注配置的获取
+     * 注意： 需要与 getStepInfo 区分，因为 getStepInfo 拿取的是直接的步骤信息
+     * @export
+     * @param {number} currentStep
+     * @param {IStepInfo[]} stepList
+     * @returns {*}
+     */
+    static getCurrentStepInfo(currentStep: number, stepList: IStepInfo[]): any;
+    static jsonParser: (content: any, defaultValue?: any) => any;
+    /**
+     * 获取结果中最大的order
+     *
+     * @export
+     * @param {any[]} result
+     * @returns {number}
+     */
+    static getMaxOrder(result: any[]): number;
+    /**
+     * 表单控件控件判断 返回 Boolean
+     * hotkey is effective only whene filter return true
+     * @param event
+     * @returns {boolean}
+     */
+    static hotkeyFilter(event: any): boolean;
+    static getNextSelectedRectID(rectList: point[], sort?: ESortDirection, selectedID?: string): point;
+    static getNextSelectedRectIDByEvent(pointList: point[], event: KeyboardEvent, selectedID?: string): point;
+    /**
+     * 计算当前状态下需要展示的结果集合
+     * @param T 当前图片的结果框
+     * @param sourceID 当前状态依赖的框体，若依赖原图则返回 '0'
+     * @param attributeLockList 当前展示的属性
+     * @param selectedID 是否含有选中逻辑
+     * @returns
+     */
+    static getRenderResultList<T = any>(resultList: any[], sourceID: string, attributeLockList?: string[], selectedID?: string): [T[], T | undefined];
+    /**
+     * 获取当前依赖情况下的 sourceID 提取
+     */
+    static getSourceID(basicResult?: any): any;
+    /**
+     * 获取当前点集的所有线条
+     * @param pointList
+     * @returns
+     */
+    static findAllLine(pointList: IPolygonPoint[] | point[], isClose?: boolean): {
+        point1: IPolygonPoint | point;
+        point2: IPolygonPoint | point;
+        pointIndex: number;
+    }[];
+    /**
+     * 转换当前依赖 sourceID
+     * @param sourceID
+     * @returns
+     */
+    static translateSourceID(sourceID: string | number | undefined): string | number;
+    /**
+     * 兼容判断 sourceID 为 空字符串、不存在、数字的情况
+     * @param sourceA
+     * @param sourceB
+     * @returns
+     */
+    static isDifferSourceID(sourceIDA: string | number, sourceIDB: string | number): boolean;
+    /**
+     * 兼容判断是否为相同类型的 sourceID
+     * @param sourceIDA
+     * @param sourceIDB
+     * @returns
+     */
+    static isSameSourceID(sourceIDA: string | number | undefined, sourceIDB: string | number | undefined): boolean;
+    /**
+     * 获取下一个列表标记的值和位置
+     * @param resultList
+     * @param markerList
+     * @param markerIndex
+     * @returns
+     */
+    static getNextMarker(resultList: Array<IPointUnit | IRect>, markerList?: IInputList[], markerIndex?: number): {
+        label: string;
+        index: number;
+    } | undefined;
+    /**
+     * 获取当前值在列表标注的位置
+     * @param label
+     * @param markerList
+     * @returns
+     */
+    static getCurrentMarkerIndex(label: string, markerList?: IInputList[]): number;
+}
+export {};

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/DblClickEventListener.d.ts

@@ -0,0 +1,47 @@
+declare class DblClickEventListener {
+    private dom;
+    private setTimeFun?;
+    private clickCoord;
+    private isDoubleClick;
+    private rcTime;
+    private delay;
+    private mouseUp;
+    private mouseMove;
+    private dblclick;
+    private cacheFunction;
+    private mouseDownTime;
+    constructor(dom: HTMLElement, delay: number);
+    getRcTime(): number;
+    /**
+     * 获取当前的坐标，用于点击位置的快速获取
+     *
+     * @param {MouseEvent} e
+     * @returns
+     * @memberof DblClickEventListen
+     */
+    getCoord(e: MouseEvent): {
+        x: number;
+        y: number;
+    };
+    /**
+     * 删除绑定事件
+     *
+     * @returns
+     * @memberof DblClickEventListen
+     */
+    removeEvent(): void;
+    onMouseDown: () => void;
+    /**
+     * 用于添加鼠标单击事件， 左键双击事件，右键双击事件
+     *
+     * @param {*} singleClickFun
+     * @param {*} leftDblClick
+     * @param {*} rightDblClick
+     * @param {*} isAllowDouble 是否允许执行 double click，如果为 true 则进行的延迟，否则将立即执行，增加操作流畅性
+     * @returns {void}
+     * @memberof DblClickEventListen
+     */
+    addEvent(singleClickFun: any, leftDblClick: any, rightDblClick: any, isAllowDouble?: (e: any) => boolean): void;
+    clearRightDblClick(): void;
+}
+export default DblClickEventListener;