gs-bim-air 1.6.1-cae.3 → 1.6.1-cae.5

package/types/longan/src/objects/earthObject.d.ts

@@ -0,0 +1,132 @@
+import { ViewerEvent } from "../longan/gs.viewer";
+import { RenderObject } from "./renderObject";
+export declare class EarthObject extends RenderObject {
+    typeName: string;
+    _name: string;
+    protected _expanded: boolean;
+    protected _showTreeNode: boolean;
+    private credentialsKey;
+    elevationBoundary: number;
+    initZoomLevel: number;
+    currentZoomLevel: number;
+    maxZoomLevel: number;
+    count: number;
+    static EarthRadius: number;
+    isHaveInit: boolean;
+    private isFirstInit;
+    private static westEquator;
+    private static eastEquator;
+    meshMapTile: TileData[];
+    loadingMeshArray: Tile[];
+    static earthObjectKey: any;
+    imageType: string;
+    static resolution: any;
+    private cameraRotateMatrix;
+    private cameraRotateOfGrivityMatrix;
+    private static _instance;
+    private lastResultTileArray;
+    private dict;
+    static id: number;
+    private getElevationsTimeout;
+    private setRenderTimeout;
+    private static tileToLoad;
+    private static tileLoaded;
+    _visible: boolean;
+    obliFlag: boolean;
+    testFlag: boolean;
+    static renderingObjectsKeyList: any[];
+    loadingSegmentNum: number;
+    lastLoadingSegmentNum: number;
+    tiandituKey: string;
+    static a: number;
+    static b: number;
+    static e: number;
+    static w: number;
+    static N: number;
+    earthMapDataSource: number;
+    constructor();
+    static getInstance(): EarthObject;
+    static deleteInstance(): void;
+    afterInstantiate(): void;
+    initEarth(): void;
+    baiduTileToLatLon(x: any, y: any, zoomLevel: any): Vector2D;
+    deserialize(obj: any): void;
+    render(): void;
+    computeZoomLevel(camera: any): number;
+    getZoomLevel(pixelDistance: number): number;
+    reBuildMeshByKey(currentZoomLevel: number): void;
+    IntersectionLinePlane(line_point: Float32Array, line_dir: Float32Array, plane_point: Float32Array, plane_dir: Float32Array): Float32Array;
+    DIntersectionLinePlane(line_point: Float64Array, line_dir: Float64Array, plane_point: Float64Array, plane_dir: Float64Array): Float64Array;
+    getTargetTileIndexArray(targetZL: number): Tile[];
+    getBase64Image(img: any): string;
+    dataURLtoBlob(dataurl: any): {
+        u8arr: Uint8Array;
+        type: string;
+    };
+    generateSegments(TL: Vector2D, BR: Vector2D, tileX: number, tileY: number, zoomLevel: number, id: number, tileData?: TileData, time?: number): void;
+    ajaxRequest(BR: Vector2D, TL: Vector2D, divNumber: number, zoomLevel: number, self: EarthObject, mesh_key: number, id: number, count: number): void;
+    splitElevationData(elevationStr: string): string[];
+    meshDivisionPolicy(topLeft: Vector2D, buttomRight: Vector2D, divNumber: number): number[];
+    getMeshPointWithElevation(topLeft: Vector2D, buttomRight: Vector2D, divNumber: number, elevations?: any): number[];
+    viewToHK(target: Float64Array, yRotateDegreed: number, cameraWidth?: number): void;
+    sceneSwitchTo(target: Float64Array, cameraWidth: number, rotateDegreed: number): void;
+    private set3DCameraOfEarthSurface;
+    switchImageType(imageType: string): void;
+    switchMapType(dataSource: number): void;
+    setModel2D(): void;
+    setModel3D(): void;
+    getRotateCameraUpOfMButtonAtGrivity(camPosOf2D: Float64Array, newTarget: Float64Array): Float64Array;
+    getRotateCameraPosOfMButtonGrivity(camPosOf2D: Float64Array, newTarget: Float64Array): Float64Array;
+    getRotateCameraUpOfMButtonAtGrivityX(camPosOf2D: Float64Array, cameraUp: Float64Array, newTarget: Float64Array, upDegreed?: number): Float64Array;
+    getRotateCameraPosWithDegreed(cameraPos: Float64Array, newTarget: Float64Array, cameraUP: Float64Array, rotateDeg: number): Float64Array;
+    mousePos2LatLon(e: ViewerEvent): Vector2D;
+    static long2tilex(lonOfDegreed: number, z: number): number;
+    static lat2tiley(latOfDegreed: number, z: number): number;
+    rad2Degreed(rad: number): number;
+    static tilex2lon(x: number, z: number): number;
+    static tiley2lat(y: number, z: number): number;
+    getLatLonFromTile(x: number, y: number, zoomLevel: number): Vector2D;
+    static latLon2Vector3D(lonOfDegreed: number, latOfDegreed: number, height: number): Float64Array;
+    static vector3D2LatLon(vector: EarthVector3D): Vector2D;
+    deleteArrayElement(array: any[], element: any): any[];
+    deleteHTMLImageElement(array: HTMLImageElement[], element: HTMLImageElement): HTMLImageElement[];
+    static EarthDataSource: {
+        TianDiTu: number;
+        GaoDe: number;
+        Google: number;
+    };
+}
+declare class Tile {
+    X: number;
+    Y: number;
+    ZL: number;
+    mapType: number;
+    isRepeated: boolean;
+    constructor();
+}
+declare class TileData {
+    X: number;
+    Y: number;
+    ZL: number;
+    MeshKey: number;
+    Visible: boolean;
+    State: any;
+    mapType: number;
+    constructor();
+}
+declare class Vector2D {
+    Lon: number;
+    Lat: number;
+    constructor();
+}
+export declare class EarthVector3D {
+    X: number;
+    Y: number;
+    Z: number;
+    constructor();
+    module(): number;
+    normolize(): EarthVector3D;
+    cross(vtarger: EarthVector3D): EarthVector3D;
+    multiplyNumber(float: number): EarthVector3D;
+}
+export {};

package/types/longan/src/objects/gisBIMObject.d.ts

@@ -0,0 +1,32 @@
+import { PersistenceManager } from "../managers/persistenceManager";
+import { LightModel } from "./lightModel";
+export declare class GISBIMObject extends LightModel {
+    typeName: string;
+    _name: string;
+    loadedFunction: any;
+    static loadModelAction: string;
+    static useTranslate: boolean;
+    _translateToHeight: number[];
+    _lonlat: number[];
+    _gravityDegreedOffset: number;
+    _xDegreedOffset: number;
+    selfXAxis: Float64Array;
+    selfYAxis: Float64Array;
+    selfZAxis: Float64Array;
+    selfCenter: Float64Array;
+    lastTranslateMatrix: any;
+    lastPhiMatrix: any;
+    lastLamdaMatrix: any;
+    set scale(value: number[]);
+    constructor();
+    getStructure(modelType: number): {
+        key: number;
+        name: string;
+    };
+    private createStructure;
+    serialize(): any;
+    deserialize(obj: any, persistenceManager: PersistenceManager): void;
+    toScale(self: GISBIMObject, scale: Float32Array): void;
+    reTranslate(self: GISBIMObject, lonlat: number[], translateToHeight?: number[]): void;
+    toTranslate(self: GISBIMObject, lonlat: number[], translateToHeight: number[]): void;
+}

package/types/longan/src/objects/labelObject.d.ts

@@ -0,0 +1,15 @@
+import { List } from "../longan/gs.collections";
+import { RenderObject } from "./renderObject";
+export declare class LabelObject extends RenderObject {
+    typeName: string;
+    _name: string;
+    _labelId: string;
+    _position: number[];
+    _type: number;
+    markerKey: number;
+    renderDiv: List<() => void>;
+    constructor();
+    serialize(): any;
+    deserialize(obj: any): void;
+    addDiv(id: string, pixelX: number, pixelY: number): void;
+}

package/types/longan/src/objects/labelObjectList.d.ts

@@ -0,0 +1,16 @@
+import { Viewer } from "../viewer";
+import { RenderObject } from "./renderObject";
+export declare class LabelObjectList extends RenderObject {
+    typeName: string;
+    _name: string;
+    _idList: string[];
+    _positionList: number[];
+    _typeList: number[];
+    _dataList: string[];
+    static updatePosition: any;
+    markerkeyList: number[];
+    constructor();
+    serialize(): any;
+    deserialize(obj: any): void;
+    afterInstantiate(viewer: Viewer, instanceObj: any): void;
+}

package/types/longan/src/objects/lightModel.d.ts

@@ -0,0 +1,44 @@
+import { List } from "../longan/gs.collections";
+import { PersistenceManager } from "../managers/persistenceManager";
+import { RenderObject } from "./renderObject";
+export declare class LightModel extends RenderObject {
+    typeName: string;
+    protected _name: string;
+    protected _image: string;
+    protected _expanded: boolean;
+    protected _modelKey: number;
+    protected _translate: number[];
+    protected _scale: number[];
+    protected _rotate: number[];
+    protected _translateMatrix4: Float32Array;
+    protected _scaleMatrix4: Float32Array;
+    protected _rotateMatrix4: Float32Array;
+    protected _faceColor: number[];
+    protected _modelFile: string;
+    protected _modelId: string;
+    protected _version: number;
+    protected _fitWorldModelLoaded: boolean;
+    protected _updateDisplayModelLoaded: boolean;
+    modelLoaded: List<() => void>;
+    get modelKey(): number;
+    set modelKey(modelKey: number);
+    get translate(): number[];
+    set translate(value: number[]);
+    get scale(): number[];
+    set scale(value: number[]);
+    get rotate(): number[];
+    set rotate(value: number[]);
+    get fitWorldModelLoaded(): boolean;
+    set fitWorldModelLoaded(value: boolean);
+    get faceColor(): number[];
+    set faceColor(value: number[]);
+    get modelFile(): string;
+    set modelFile(value: string);
+    get modelId(): string;
+    set modelId(value: string);
+    get version(): number;
+    set version(value: number);
+    constructor();
+    serialize(): any;
+    deserialize(obj: any, persistenceManager: PersistenceManager): void;
+}

package/types/longan/src/objects/panoramaObject.d.ts

@@ -0,0 +1,36 @@
+import { List } from "../longan/gs.collections";
+import { RenderObject } from "./renderObject";
+export declare class PanoramaObject extends RenderObject {
+    typeName: string;
+    _name: string;
+    _modelKey: number;
+    _modelFile: string;
+    modelLoaded: List<() => void>;
+    static loadModelAction: string;
+    flag: boolean;
+    static panaramaRadius: number;
+    constructor();
+    initPanorama(textureURL: string): void;
+    meshDivisionPolicy(TL: PanoVector2D, BR: PanoVector2D, divNumber: number): number[];
+    getMeshPointWithElevation(topLeft: PanoVector2D, buttomRight: PanoVector2D, divNumber: number): number[];
+    latLon2Vector3D(lonOfDegreed: number, latOfDegreed: number, height: number, earthRadius: number): PanoVector3D;
+    getLatLonFromTile(x: number, y: number, pointNumber: number): PanoVector2D;
+    serialize(): any;
+    deserialize(obj: any): void;
+}
+declare class PanoVector2D {
+    Lon: number;
+    Lat: number;
+    constructor();
+}
+declare class PanoVector3D {
+    X: number;
+    Y: number;
+    Z: number;
+    constructor();
+    module(): number;
+    normolize(): PanoVector3D;
+    cross(vtarger: PanoVector3D): PanoVector3D;
+    multiplyNumber(float: number): PanoVector3D;
+}
+export {};

package/types/longan/src/objects/referenceObject.d.ts

@@ -0,0 +1,14 @@
+import { PersistenceManager } from "../managers/persistenceManager";
+import { RenderObject } from "./renderObject";
+export declare class ReferenceObject extends RenderObject {
+    typeName: string;
+    _reference: RenderObject;
+    get reference(): RenderObject;
+    set reference(value: RenderObject);
+    constructor();
+    serialize(): any;
+    serializeCopy(): any;
+    deserialize(obj: any, persistenceManager?: PersistenceManager): void;
+    deserializeCopy(obj: any, persistenceManager?: PersistenceManager): void;
+    protected getMcaRequest(id: string, persistenceManager: PersistenceManager): any;
+}

package/types/longan/src/objects/renderInstanceObject.d.ts

@@ -0,0 +1,27 @@
+import { Viewer } from "../viewer";
+import { Segment } from "../longan/segment";
+import { RenderObject } from "./renderObject";
+export declare class RenderInstanceObject {
+    private static noCounter;
+    private _no;
+    protected _viewer: Viewer;
+    protected _renderObject: RenderObject;
+    _segment: Segment;
+    _parent: RenderInstanceObject;
+    _childObjects: Array<RenderInstanceObject>;
+    viewerVisible: boolean;
+    protected _visible: boolean;
+    get visible(): boolean;
+    set visible(value: boolean);
+    get no(): number;
+    get viewer(): Viewer;
+    get renderObject(): RenderObject;
+    get childObjects(): RenderInstanceObject[];
+    get segment(): Segment;
+    get parent(): RenderInstanceObject;
+    constructor(viewer: Viewer, renderObject: RenderObject);
+    init(): void;
+    fina(): void;
+    update(): void;
+    afterRender(): void;
+}

package/types/longan/src/objects/renderObject.d.ts

@@ -0,0 +1,73 @@
+import { List, NumberKeyList, StringKeyList } from "../longan/gs.collections";
+import { Segment } from "../longan/segment";
+import { Process } from "../process";
+import { Viewer } from "../viewer";
+import { CloneManager } from "../managers/cloneManager";
+import { PersistenceManager } from "../managers/persistenceManager";
+import { RenderInstanceObject } from "./renderInstanceObject";
+import { PropertyComponent } from "../propertyComponents/propertyComponent";
+export declare class RenderObject {
+    private static noCounter;
+    typeName: string;
+    protected _no: number;
+    protected _id: string;
+    protected _segment: Segment;
+    protected _name: string;
+    protected _image: string;
+    protected _visible: boolean;
+    protected _expanded: boolean;
+    protected _needSerialization: boolean;
+    protected _parent: RenderObject;
+    protected _childObjects: RenderObject[];
+    protected _showTreeNode: boolean;
+    protected _properties: any;
+    protected _propertyComponents: NumberKeyList<List<PropertyComponent>>;
+    instanceTypes: StringKeyList<RenderInstanceObject>;
+    constructor();
+    get no(): number;
+    get id(): string;
+    set id(value: string);
+    get segment(): Segment;
+    get name(): string;
+    set name(na: string);
+    get parent(): RenderObject;
+    set parent(parent: RenderObject);
+    get image(): string;
+    set image(image: string);
+    get visible(): boolean;
+    set visible(value: boolean);
+    get expanded(): boolean;
+    set expanded(expanded: boolean);
+    get showTreeNode(): boolean;
+    set showTreeNode(showTreeNode: boolean);
+    get needSerialization(): boolean;
+    set needSerialization(value: boolean);
+    get childObjects(): RenderObject[];
+    get properties(): any;
+    set properties(props: any);
+    addPropertyComponent(component: PropertyComponent, segment?: Segment): void;
+    removePropertyComponent(component: PropertyComponent): void;
+    clearPropertyComponents(): void;
+    findPropertyComponent<T>(type: any, segment?: Segment): T;
+    findPropertyComponents<T>(type: any): List<T>;
+    dispose(): void;
+    render(): void;
+    addChildObject(ro: RenderObject): void;
+    removeChildObject(ro: RenderObject): void;
+    clearChildObjects(): void;
+    remove(): void;
+    delete(): void;
+    afterRender(process?: Process): void;
+    loadModel(data: ArrayBuffer, process?: Process, ...args: any[]): Promise<void>;
+    protected clone(cloneObj: any, cloneManager?: CloneManager): any;
+    backupSegment(): Segment;
+    backup(): {
+        [key: string]: any;
+    };
+    serialize(): any;
+    deserialize(obj: any, persistenceManager?: PersistenceManager): void;
+    afterInstantiate(viewer: Viewer, instanceObj: any): void;
+    afterDeInstantiate(viewer: Viewer, instanceObj: any): void;
+    private internalForEach;
+    forEach(callback: (ro: RenderObject) => any): void;
+}

package/types/longan/src/objects/roamPathObjectList.d.ts

@@ -0,0 +1,15 @@
+import { RenderObject } from "./renderObject";
+export declare class RoamPathObjectList extends RenderObject {
+    typeName: string;
+    _name: string;
+    _roamPathList: RoamPath[];
+    constructor();
+    serialize(): any;
+    deserialize(obj: any): void;
+}
+declare class RoamPath {
+    name: string;
+    points: number[];
+    roamTime: number;
+}
+export {};

package/types/longan/src/objects/segmentViewObject.d.ts

@@ -0,0 +1,14 @@
+import { Segment } from "../longan/segment";
+import { Include } from "../longan/include";
+import { RenderObject } from "./renderObject";
+export declare class SegmentViewObject extends RenderObject {
+    typeName: string;
+    _name: string;
+    _image: string;
+    _expanded: boolean;
+    _viewSegment: Segment;
+    _include: Include;
+    get viewSegment(): Segment;
+    set viewSegment(value: Segment);
+    constructor();
+}

package/types/longan/src/objects/viewPointObjectList.d.ts

@@ -0,0 +1,17 @@
+import { RenderObject } from "./renderObject";
+export declare class ViewPointObjectList extends RenderObject {
+    typeName: string;
+    _name: string;
+    _viewPointList: ViewPoint[];
+    constructor();
+    serialize(): any;
+    deserialize(obj: any): void;
+}
+export declare class ViewPoint {
+    name: string;
+    camPosition: number[];
+    camUp: number[];
+    camTarget: number[];
+    camWidth: number;
+    camHeight: number;
+}

package/types/longan/src/operators/cameraMouse.d.ts

@@ -0,0 +1,108 @@
+import { List } from "../longan/gs.collections";
+import { DWcs } from "../longan/gs.math";
+import { ViewerEvent } from "../longan/gs.viewer";
+import { Viewer } from "../viewer";
+import { CameraOperateState, MoveButtonType, ViewerOperator } from "./viewerOperator";
+export declare enum LButtonState {
+    select = 0,
+    translation = 1,
+    rotation = 2,
+    scale = 3,
+    zoom = 4
+}
+export declare enum ViewType {
+    near = 0,
+    normal = 1
+}
+export declare class CameraMouse extends ViewerOperator {
+    typeName: string;
+    lButtonDown: List<(...params: any[]) => void>;
+    lButtonUp: List<(...params: any[]) => void>;
+    mouseWheel: List<(...params: any[]) => void>;
+    protected state: CameraOperateState;
+    protected radius: number;
+    protected _moveButtonType: MoveButtonType;
+    protected _rotationDisabled: boolean;
+    protected rotating: boolean;
+    protected mButtonDowned: boolean;
+    protected lButtonDowned: boolean;
+    protected rButtonDowned: boolean;
+    protected shiftKeyDowned: boolean;
+    protected downWorldPos: Float32Array;
+    protected downWinPos: Float32Array;
+    protected downPixelPos: Float32Array;
+    protected centerPos: Float64Array;
+    protected downSpherePos: Float32Array;
+    protected moveSpherePos: Float32Array;
+    protected downWcs: DWcs;
+    protected downSelectedDist: number;
+    protected downCameraLength: any;
+    protected downUnitLength: number;
+    protected framerate: number;
+    protected cullingThreshold: number;
+    private radiusDist;
+    private scaleEnd;
+    protected zoomTimeout: any;
+    private zoomStepRatio;
+    private preZoomStepRatio;
+    private initialDistance;
+    protected _lButtonSate: LButtonState;
+    winPos: any;
+    downPos: Float64Array;
+    cameraTarget: Float64Array;
+    viewType: ViewType;
+    setCetnerByHover: boolean;
+    lbuttonDownWinPos: any;
+    lbuttonMoveFlag: boolean;
+    minScaleValue: number;
+    /**
+     * 滚轮缩放方向
+     * true = 滚轮往前放大，往后缩小
+     * false = 滚轮往后放大，往前缩小
+     */
+    mouseWheelDirection: boolean;
+    /**
+     * 正在滚轮(指还没松开滚轮.)
+     */
+    protected onMouseWheeling: boolean;
+    static recordIsBusy: boolean;
+    static drawRotatePointSVG: List<(point: Float64Array) => void>;
+    static clearRotatePointSVG: List<() => void>;
+    static lButtonDown: List<(cm: CameraMouse, e: ViewerEvent) => void>;
+    static lButtonUp: List<(cm: CameraMouse, e: ViewerEvent) => void>;
+    static lButtonDownAndMove: List<(cm: CameraMouse, e: ViewerEvent) => void>;
+    static rButtonDown: List<(cm: CameraMouse, e: ViewerEvent) => void>;
+    static rButtonUp: List<(cm: CameraMouse, e: ViewerEvent) => void>;
+    static rButtonDownAndMove: List<(cm: CameraMouse, e: ViewerEvent) => void>;
+    static mButtonDown: List<(cm: CameraMouse, e: ViewerEvent) => void>;
+    static mButtonUp: List<(cm: CameraMouse, e: ViewerEvent) => void>;
+    static mButtonDownAndMove: List<(cm: CameraMouse, e: ViewerEvent) => void>;
+    static mouseWheel: List<(cm: CameraMouse, e: ViewerEvent) => void>;
+    static mouseWheelStop: List<(cm: CameraMouse, e: ViewerEvent) => void>;
+    get lButtonSate(): LButtonState;
+    set lButtonSate(value: LButtonState);
+    constructor();
+    init(): void;
+    fina(): void;
+    setFramerate(framerate: number, cullingThreshold: number): void;
+    moveButtonType(type?: MoveButtonType): MoveButtonType;
+    rotationDisabled(disable?: boolean): boolean;
+    onLButtonDown(e: ViewerEvent): void;
+    onLButtonUp(e: ViewerEvent): void;
+    onRButtonDown(e: ViewerEvent): void;
+    onRButtonUp(e: ViewerEvent): void;
+    onMButtonDown(e: ViewerEvent): void;
+    onMButtonUp(e: ViewerEvent): void;
+    onWindowKeyDown(e: ViewerEvent): void;
+    onWindowKeyUp(e: ViewerEvent): void;
+    setLightModelExtent(pixel: any): void;
+    computeDistance(): void;
+    setCameraWheelSpeed(viewer: Viewer, factor: number, min: Float64Array, max: Float64Array): number;
+    onMouseWheel(e: ViewerEvent): void;
+    onMouseWheelByLButton(e: ViewerEvent): void;
+    onLButtonDownAndMove(e: ViewerEvent): void;
+    onMButtonDownAndMove(e: ViewerEvent): void;
+    onRButtonDownAndMove(e: ViewerEvent): void;
+    getSpherePoint(e: ViewerEvent): Float32Array;
+    setCameraCenter(e: ViewerEvent): void;
+}

package/types/longan/src/operators/cameraPlanMouse.d.ts

@@ -0,0 +1,7 @@
+import { ViewerEvent } from "../longan/gs.viewer";
+import { CameraMouse } from "./cameraMouse";
+export declare class CameraPlanMouse extends CameraMouse {
+    onRButtonDown(e: ViewerEvent): void;
+    onRButtonUp(e: ViewerEvent): void;
+    onRButtonDownAndMove(e: ViewerEvent): void;
+}

package/types/longan/src/operators/cameraTouch.d.ts

@@ -0,0 +1,41 @@
+import { ViewerEvent } from "../longan/gs.viewer";
+import { List } from "../longan/gs.collections";
+import { ProjectionType } from "../longan/segment";
+import { CameraOperateState, ViewerOperator } from "./viewerOperator";
+export declare enum TouchOpertionType {
+    Pan = 0,
+    Rotate = 1,
+    RotateCenter = 2
+}
+export declare class CameraTouch extends ViewerOperator {
+    static drawRotatePointSVG: List<(point: Float64Array) => void>;
+    static clearRotatePointSVG: List<() => void>;
+    typeName: string;
+    state: CameraOperateState;
+    protected radius: number;
+    downWorldPos: Float32Array;
+    protected downWorldPos1: Float32Array;
+    protected downSpherePos: Float32Array;
+    protected moveSpherePos: Float32Array;
+    protected projectionType: ProjectionType;
+    protected downCamera: any;
+    protected downSelectedDist: number;
+    protected centerPos: Float64Array;
+    protected cameraTarget: Float64Array;
+    downPos: Float64Array;
+    protected winPos: Float32Array;
+    protected _operationType: TouchOpertionType;
+    protected radiusDist: number;
+    protected framerate: number;
+    protected cullingThreshold: number;
+    touchWindowPos: any;
+    constructor();
+    get operationType(): TouchOpertionType;
+    set operationType(type: TouchOpertionType);
+    onTouchStart(e: ViewerEvent): void;
+    onTouchMove(e: ViewerEvent): void;
+    onTouchEnd(e: ViewerEvent): void;
+    onTouchCancel(e: ViewerEvent): void;
+    getSpherePoint(e: ViewerEvent): Float32Array;
+    setCameraCenter(e: ViewerEvent): void;
+}

package/types/longan/src/operators/cuttingBox.d.ts

@@ -0,0 +1,42 @@
+import { SelectionKey } from "../managers/selectionManager";
+import { CuttingPlanes, Shell } from "../longan/geometry";
+import { ViewerEvent } from "../longan/gs.viewer";
+import { Segment } from "../longan/segment";
+import { ViewerOperator } from "./viewerOperator";
+export declare class CuttingBox extends ViewerOperator {
+    typeName: string;
+    _bb: Float32Array;
+    _box: Float32Array;
+    _planes: Float32Array;
+    _cuttingBoxSegment: Segment;
+    _frontShell: Shell;
+    _backShell: Shell;
+    _leftShell: Shell;
+    _rightShell: Shell;
+    _topShell: Shell;
+    _bottomShell: Shell;
+    _selectionKey: SelectionKey;
+    _selectedShell: Shell;
+    _cuttingPlanes: CuttingPlanes;
+    _downPos: Float32Array;
+    _prePos: Float32Array;
+    _boxVisible: boolean;
+    get box(): Float32Array;
+    set box(box: Float32Array);
+    get boxVisible(): boolean;
+    set boxVisible(value: boolean);
+    constructor();
+    init(): void;
+    fina(): void;
+    computePlaneNormal(plane: Float32Array): Float32Array;
+    updateBox(): void;
+    onMouseMove(e: ViewerEvent): void;
+    onLButtonDown(e: ViewerEvent): void;
+    onLButtonUp(e: ViewerEvent): void;
+    onMButtonDown(e: ViewerEvent): void;
+    onRButtonDown(e: ViewerEvent): void;
+    onLButtonDownAndMove(e: ViewerEvent): void;
+    setYValue(start: number, end: number): void;
+    setXValue(start: number, end: number): void;
+    setZValue(start: number, end: number): void;
+}