@labelbee/lb-annotation 1.0.0-alpha.1

package/dist/types/core/pointCloud/index.d.ts

@@ -0,0 +1,374 @@
+/**
+ * @file POINTCLOUD - ALPHA - DEMO
+ * @createdate 2022-07-11
+ * @author Ron <ron.f.luo@gmail.com>
+ */
+import * as THREE from 'three';
+import { TMatrix4Tuple, EPerspectiveView, IVolume, IPointCloudBox, IPointCloudSphere, I3DSpaceCoord, IPointCloudConfig } from '@labelbee/lb-utils';
+import { OrthographicCamera, PerspectiveCamera, Shader } from 'three';
+import { IPolygonPoint } from '@/types/tool/polygon';
+import { PCDLoader } from './PCDLoader';
+import { OrbitControls } from './OrbitControls';
+interface IOrthographicCamera {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    near: number;
+    far: number;
+}
+interface IProps {
+    container: HTMLElement;
+    noAppend?: boolean;
+    isOrthographicCamera?: boolean;
+    orthographicParams?: IOrthographicCamera;
+    backgroundColor?: string;
+    config?: IPointCloudConfig;
+}
+export declare class PointCloud {
+    renderer: THREE.WebGLRenderer;
+    scene: THREE.Scene;
+    camera: THREE.OrthographicCamera | THREE.PerspectiveCamera;
+    controls: OrbitControls;
+    axesHelper: THREE.AxesHelper;
+    pcdLoader: PCDLoader;
+    config?: IPointCloudConfig;
+    /**
+     * zAxis Limit for filter point over a value
+     */
+    zAxisLimit: number;
+    initCameraPosition: THREE.Vector3;
+    private container;
+    private isOrthographicCamera;
+    private pointsUuid;
+    private sideMatrix?;
+    private backgroundColor;
+    private pointCloudObjectName;
+    private rangeObjectName;
+    private cacheInstance;
+    private showDirection;
+    private currentPCDSrc?;
+    /**
+     * Record the src of Highlight PCD.
+     *
+     * Avoiding src error problems caused by asynchronous
+     */
+    private highlightPCDSrc?;
+    constructor({ container, noAppend, isOrthographicCamera, orthographicParams, backgroundColor, // GRAY_BACKGROUND
+    config, }: IProps);
+    get DEFAULT_INIT_CAMERA_POSITION(): THREE.Vector3;
+    get containerWidth(): number;
+    get containerHeight(): number;
+    setInitCameraPosition(vector: THREE.Vector3): void;
+    setConfig(config: IPointCloudConfig): void;
+    /**
+     * Init OrthographicCamera to default config by size
+     * @param orthographicParams
+     * @returns
+     */
+    initOrthographicCamera(orthographicParams: IOrthographicCamera): void;
+    /**
+     * Init PerspectiveCamera to default config by size
+     * @returns
+     */
+    initPerspectiveCamera(): void;
+    initCamera(): void;
+    initControls(): void;
+    setDefaultControls(): void;
+    initRenderer(): void;
+    init(): void;
+    removeObjectByName(name: string): void;
+    /**
+     * Render box by params
+     * @param boxParams
+     * @param color
+     */
+    generateBox(boxParams: IPointCloudBox, color?: number): void;
+    getAllAttributeColor(boxes: IPointCloudBox[]): {
+        [k: string]: any;
+    };
+    /**
+     * add new sphere just like adding new box
+     * @param sphereParams
+     */
+    addSphereToSense: (sphereParams: IPointCloudSphere, color?: string) => void;
+    generateSphere: (sphereParams: IPointCloudSphere) => void;
+    generateSpheres: (spheres: IPointCloudSphere[]) => void;
+    AddBoxToSense: (boxParams: IPointCloudBox, color?: number) => void;
+    generateBoxes(boxes: IPointCloudBox[]): void;
+    /**
+     * Get OrthographicCamera Params to Change
+     * @param boxParams
+     * @returns
+     */
+    getOrthographicCamera(boxParams: IPointCloudBox): {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+        near: number;
+        far: number;
+        zoom: number;
+    };
+    updateCameraZoom(zoom: number): void;
+    /**
+     * Update Camera position & target
+     * @param boxParams
+     * @param perspectiveView
+     * @param customCameraVector Provide a custom way.
+     */
+    updateCameraByBox(boxParams: IPointCloudBox, perspectiveView: EPerspectiveView, customCameraVector?: I3DSpaceCoord): THREE.Vector3;
+    updateCameraBySphere(sphereParams: IPointCloudSphere, perspectiveView: EPerspectiveView): THREE.Vector3;
+    updateOrthoCamera(boxParams: IPointCloudBox, perspectiveView: EPerspectiveView): {
+        cameraPositionVector: THREE.Vector3;
+    };
+    updateOrthoCameraBySphere(sphereParams: IPointCloudSphere, perspectiveView: EPerspectiveView): {
+        cameraPositionVector: THREE.Vector3;
+    };
+    /**
+     * Initialize the camera to the initial position
+     */
+    updateTopCamera(): void;
+    /**
+     * Update camera position & target
+     * @param position
+     * @param target
+     */
+    updateCamera(position: I3DSpaceCoord, target: I3DSpaceCoord): void;
+    /**
+     * Reset camera to center-top
+     */
+    resetCamera(): void;
+    /**
+     * Get camera target from matrix
+     * @param camera
+     * @returns
+     */
+    getOrthographicCameraTarget(camera: OrthographicCamera): THREE.Vector3;
+    applyCameraTarget: (camera: OrthographicCamera | PerspectiveCamera) => void;
+    createThreeMatrix4(matrix4: TMatrix4Tuple): THREE.Matrix4;
+    /**
+     * For pcd filter point under box
+     * @param boxParams
+     * @param points
+     * @param color
+     * @returns
+     */
+    filterPointsByBox(boxParams: IPointCloudBox, points?: Float32Array, color?: Float32Array): Promise<{
+        geometry: any;
+        num: number;
+    } | undefined>;
+    getCameraVector(centerPoint: I3DSpaceCoord, rotationZ: number, volume: IVolume, perspectiveView?: EPerspectiveView, defaultDistance?: number): THREE.Vector3;
+    createRange(radius: number): THREE.Line<THREE.BufferGeometry, THREE.LineBasicMaterial>;
+    overridePointShader: (shader: Shader) => void;
+    renderPointCloud(points: THREE.Points, radius?: number): void;
+    clearPointCloud(): void;
+    clearPointCloudAndRender(): void;
+    /**
+     *
+     * @param src
+     * @param radius Render the range of circle
+     */
+    loadPCDFile: (src: string, radius?: number) => Promise<void>;
+    /**
+     * It needs to be updated after load PointCloud's data.
+     * @param boxParams
+     * @returns
+     */
+    highlightOriginPointCloud(pointCloudBoxList?: IPointCloudBox[]): Promise<THREE.BufferAttribute[] | undefined> | undefined;
+    updateColor(color: any[]): void;
+    /**
+     * Load PCD File by box
+     * @param src
+     * @param boxParams
+     * @param scope
+     */
+    loadPCDFileByBox: (src: string, boxParams: IPointCloudBox, scope?: Partial<{
+        width: number;
+        height: number;
+        depth: number;
+    }>) => Promise<void>;
+    setShowDirection(showDirection: boolean): void;
+    generateRange: (radius: number) => void;
+    generateBoxArrow: ({ width }: IPointCloudBox) => THREE.ArrowHelper;
+    generateBoxTrackID: (boxParams: IPointCloudBox) => THREE.Sprite | undefined;
+    getTextCanvas(text: string): HTMLCanvasElement;
+    /**
+     * Filter road points and noise in all directions
+     * 1. The first 5% of the z-axis is used as the road coordinate
+     * 2. Filter out points 10cm above the road surface.
+     * 3. Filter out the first 0.5% of noise points in other directions
+     */
+    filterNoise(innerPointList: I3DSpaceCoord[]): I3DSpaceCoord[];
+    getFittedCoordinates(polygon: IPolygonPoint[], innerPointList: ICoordinate[]): import("@labelbee/lb-utils").ICoordinate[];
+    getSensesPointZAxisInPolygon(polygon: IPolygonPoint[], zScope?: [number, number], intelligentFit?: boolean): {
+        maxZ: number;
+        minZ: number;
+        count: number;
+        zCount: number;
+        fittedCoordinates: ICoordinate[];
+    };
+    /**
+     * ViewPort - Transformation
+     * @param vector
+     * @returns
+     */
+    getBasicCoordinate2Canvas(vector: THREE.Vector3): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    get basicCoordinate2CanvasMatrix4(): THREE.Matrix4;
+    /**
+     * ViewPort - Transformation
+     * @param vector
+     * @returns
+     */
+    getCanvas2BasicCoordinate(vector: THREE.Vector3): THREE.Vector3;
+    /**
+     * The order of pointList is lt => lb => rb => rt
+     * The basic coordinate is top view(senseBee pointCloud topView coordinate)
+     * @param boxParams
+     * @returns
+     */
+    getPolygonSidePoints(boxParams: IPointCloudBox): {
+        x: number;
+        y: number;
+        z: number;
+    }[];
+    getPolygonBackPoints(boxParams: IPointCloudBox): {
+        x: number;
+        y: number;
+        z: number;
+    }[];
+    getPolygonTopPoints(boxParams: IPointCloudBox): {
+        x: number;
+        y: number;
+        z: number;
+    }[];
+    getModelTransformationMatrix(boxParams: IPointCloudBox): THREE.Matrix4;
+    /**
+     * Get Polygon from boxParams
+     *
+     * Notice.
+     * 1. You need to rotate camera to correct direction base because it uses matrixWorldInverse & projectionMatrix from camera
+     * @param boxParams
+     * @returns
+     */
+    getBoxSidePolygon2DCoordinate(boxParams: IPointCloudBox): {
+        polygon2d: THREE.Vector3[];
+        zoom: number;
+    };
+    getBoxBackPolygon2DCoordinate(boxParams: IPointCloudBox): {
+        polygon2d: THREE.Vector3[];
+        zoom: number;
+    };
+    getSphereSidePoint2DCoordinate(sphereParams: IPointCloudSphere): {
+        point2d: THREE.Vector3;
+        zoom: number;
+    };
+    getSphereBackPoint2DCoordinate(sphereParams: IPointCloudSphere): {
+        point2d: THREE.Vector3;
+        zoom: number;
+    };
+    boxParams2ViewPolygon(boxParams: IPointCloudBox, perspectiveView: EPerspectiveView): {
+        x: number;
+        y: number;
+        z: number;
+    }[];
+    /**
+     * Box to 2d Coordinate.
+     *
+     * Flow:
+     * 1. Model Translation
+     * 2. View Translation
+     * 3. Projection Translation
+     * 4. Viewport Translation
+     *
+     *
+     * @param boxParams
+     * @param perspectiveView
+     * @returns
+     */
+    getBoxPolygon2DCoordinate(boxParams: IPointCloudBox, perspectiveView: EPerspectiveView): {
+        polygon2d: THREE.Vector3[];
+        zoom: number;
+    };
+    getSpherePoint2DCoordinate(sphereParams: IPointCloudSphere): {
+        point2d: THREE.Vector3;
+        zoom: number;
+    };
+    getSphereTopPoint2DCoordinate(sphereParams: IPointCloudSphere): {
+        point2d: {
+            x: number;
+            y: number;
+        };
+        zoom: number;
+    };
+    getBoxTopPolygon2DCoordinate(boxParams: IPointCloudBox): {
+        polygon2d: {
+            x: number;
+            y: number;
+        }[];
+        zoom: number;
+    };
+    getNewBoxBySideUpdate(offsetCenterPoint: {
+        x: number;
+        y: number;
+        z: number;
+    }, // Just use x now.
+    offsetWidth: number, offsetDepth: number, selectedPointCloudBox: IPointCloudBox): {
+        newBoxParams: IPointCloudBox;
+    };
+    getNewBoxByBackUpdate(offsetCenterPoint: {
+        x: number;
+        y: number;
+        z: number;
+    }, offsetWidth: number, offsetDepth: number, selectedPointCloudBox: IPointCloudBox): {
+        newBoxParams: IPointCloudBox;
+    };
+    /**
+     * Get new Box by matrix , but it's work.
+     *
+     * Use it later.
+     * @param pointList
+     * @param offsetHeight
+     * @param offsetZ
+     * @returns
+     */
+    getNewBoxBySideUpdateByPoints(pointList: any[], offsetHeight: number, offsetZ: number, selectedPointCloudBox: IPointCloudBox): {
+        newBoxParams: {
+            center: {
+                x: number;
+                y: number;
+                z: number;
+            };
+            width: number;
+            height: number;
+            depth: number;
+            rotation: number;
+            attribute: string;
+            id: string;
+            valid: boolean;
+            trackID?: number | undefined;
+            subAttribute?: {
+                [k: string]: string;
+            } | undefined;
+            count?: number | undefined;
+            newPointList?: import("@labelbee/lb-utils").ICoordinate[] | undefined;
+        };
+    } | undefined;
+    /**
+     * Filter Point by z-aixs
+     */
+    filterZAxisPoints(pcdPoints?: any): void;
+    applyZAxisPoints: (zAxisLimit: number) => void;
+    /**
+     * Update point size
+     * @param zoomIn
+     */
+    updatePointSize: (zoomIn: boolean) => void;
+    render(): void;
+}
+export * from './matrix';
+export * from './annotation';

package/dist/types/core/pointCloud/matrix.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The set of Matrix multiplication
+ */
+import * as THREE from 'three';
+import { TMatrix4Tuple, IPointCloudBox, I3DSpaceCoord, TMatrix14Tuple, TMatrix13Tuple } from '@labelbee/lb-utils';
+export declare function createThreeMatrix4(matrix4: TMatrix4Tuple): THREE.Matrix4;
+/**
+ * Transfer the Kitti format (defined by array) to Three Matrix (flatten array)
+ * @param P
+ * @param R
+ * @param T
+ * @returns
+ */
+export declare function transferKitti2Matrix(P: [TMatrix14Tuple, TMatrix14Tuple, TMatrix14Tuple], R: [TMatrix13Tuple, TMatrix13Tuple, TMatrix13Tuple], T: [TMatrix14Tuple, TMatrix14Tuple, TMatrix14Tuple]): {
+    composeMatrix4: THREE.Matrix4;
+    PM: THREE.Matrix4;
+    RM: THREE.Matrix4;
+    TM: THREE.Matrix4;
+};
+export declare function rotatePoint(points: {
+    x: number;
+    y: number;
+    z?: number;
+}, centerPoint: I3DSpaceCoord, rotationZ: number): THREE.Vector3;
+export declare function lidar2image(point: {
+    x: number;
+    y: number;
+    z: number;
+}, composeMatrix4: THREE.Matrix4): THREE.Vector4 | undefined;
+export declare function getCuboidFromPointCloudBox(boxParams: IPointCloudBox): {
+    polygonPointList: {
+        x: number;
+        y: number;
+    }[];
+    zMax: number;
+    zMin: number;
+    attribute: string;
+    center: I3DSpaceCoord;
+    id: string;
+    rotation: number;
+    valid: boolean;
+    trackID?: number | undefined;
+    subAttribute?: {
+        [k: string]: string;
+    } | undefined;
+    count?: number | undefined;
+    newPointList?: import("@labelbee/lb-utils").ICoordinate[] | undefined;
+    width: number;
+    height: number;
+    depth: number;
+};
+export declare function pointCloudLidar2image(boxParams: IPointCloudBox, cameraMatrix: {
+    P: [TMatrix14Tuple, TMatrix14Tuple, TMatrix14Tuple];
+    R: [TMatrix13Tuple, TMatrix13Tuple, TMatrix13Tuple];
+    T: [TMatrix14Tuple, TMatrix14Tuple, TMatrix14Tuple];
+}): {
+    type: string;
+    pointList: {
+        id: string;
+        x: number;
+        y: number;
+    }[];
+}[];

package/dist/types/core/scheduler.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @file For multi-level management of tools
+ * @createDate 2022-07-27
+ * @author Ron <ron.f.luo@gmail.com>
+ */
+import { EToolName, THybridToolName } from '@/constant/tool';
+import { RectOperation } from './toolOperation/rectOperation';
+import PolygonOperation from './toolOperation/polygonOperation';
+import SegmentByRect from './toolOperation/segmentByRect';
+interface IToolSchedulerOperation {
+}
+interface IToolSchedulerProps {
+    container: HTMLElement;
+    size: ISize;
+    toolName: THybridToolName;
+    imgNode?: HTMLImageElement;
+    config?: string;
+    style?: any;
+}
+export declare class HybridToolUtils {
+    static isSingleTool(toolName: THybridToolName): boolean;
+    static isHybridTool(toolName: THybridToolName): boolean;
+    static getTopToolName: (toolName: THybridToolName) => EToolName;
+}
+export declare class ToolScheduler implements IToolSchedulerOperation {
+    private container;
+    private toolOperationList;
+    private toolOperationDom;
+    private toolOperationNameList;
+    private size;
+    private config;
+    private style;
+    private imgNode?;
+    constructor(props: IToolSchedulerProps);
+    setImgNode(imgNode: HTMLImageElement, basicImgInfo?: Partial<{
+        valid: boolean;
+        rotate: number;
+    }>): void;
+    setImgAttribute(imgAttribute: IImageAttribute): void;
+    setSize(size: ISize): void;
+    syncPosition(currentPos: ICoordinate, zoom: number, imgInfo: ISize, currentToolInstance: any): void;
+    get defaultSize(): {
+        width: number;
+        height: number;
+    };
+    createDom(): HTMLDivElement;
+    getEmptyImage(width: number, height: number): HTMLImageElement;
+    /**
+     * Unified creation of toolInstance
+     * @param tool
+     * @param imgNode
+     * @param config
+     * @returns
+     */
+    createOperation(tool?: EToolName, imgNode?: HTMLImageElement, config?: Object): any;
+    /**
+     * Notice & TODO. Temporary additions
+     * Just to switch last two canvas。
+     *
+     * It will be deleted later.
+     */
+    switchLastTwoCanvas(): RectOperation | PolygonOperation | undefined;
+    /**
+     * Notice & TODO. Temporary additions
+     * Just to set data to toolInstance.
+     * @returns
+     */
+    getFirstToolOperation(): RectOperation | PolygonOperation | SegmentByRect;
+    /**
+     * Switch to canvas by given toolName
+     * TODO: change operationList to operationMap
+     */
+    switchToCanvas(toolName: EToolName): RectOperation | PolygonOperation | undefined;
+    /**
+     *
+     * @param toolName
+     * @param result
+     * Update result by give toolName
+     * All the operation instances are maintained in toolOperationList,
+     * there is no more specific instance like pointCloud2dOperation you can reach,
+     * so if you need to update result in specific operation instance, you can try this.
+     */
+    updateDataByToolName(toolName: EToolName, result: any): void;
+    clearStatusAndResult(): void;
+    destroyAllLayer(): void;
+    init(): void;
+}
+export {};