@labelbee/lb-annotation 1.13.0 → 1.13.1

package/es/core/pointCloud/selector/lassoSelector.js

@@ -0,0 +1,22 @@
+import DefaultSelector from './selector.js';
+
+class LassoSelector extends DefaultSelector {
+  mouseDown(ev) {
+    if (ev.button === 2) {
+      this.pushPoint(ev.offsetX, ev.offsetY);
+    }
+  }
+  mouseUp(ev) {
+    if (ev.button === 2) {
+      this.store.getPointsInPolygon(this.polygon2d);
+      this.updatePolygon2d([]);
+    }
+  }
+  mouseMove(ev) {
+    if (ev.button === 2) {
+      this.pushPoint(ev.offsetX, ev.offsetY);
+    }
+  }
+}
+
+export { LassoSelector as default };

package/es/core/pointCloud/selector/selector.js

@@ -0,0 +1,16 @@
+class DefaultSelector {
+  constructor(store) {
+    this.store = store;
+    this.polygon2d = [];
+  }
+  pushPoint(x, y) {
+    this.polygon2d.push({x, y});
+    this.store.syncPolygon2d(this.polygon2d);
+  }
+  updatePolygon2d(polygon2d) {
+    this.polygon2d = polygon2d;
+    this.store.syncPolygon2d(this.polygon2d);
+  }
+}
+
+export { DefaultSelector as default };

package/es/core/pointCloud/store/fsm.js

@@ -0,0 +1,41 @@
+import { EPointCloudSegmentStatus } from '@labelbee/lb-utils';
+
+class PointCloudFSM {
+  constructor() {
+    this.segmentStatus = EPointCloudSegmentStatus.Ready;
+  }
+  statusToggle() {
+    switch (this.segmentStatus) {
+      case EPointCloudSegmentStatus.Ready:
+        this.segmentStatus = EPointCloudSegmentStatus.Check;
+        break;
+      case EPointCloudSegmentStatus.Check:
+        this.segmentStatus = EPointCloudSegmentStatus.Edit;
+        break;
+      case EPointCloudSegmentStatus.Edit:
+        this.segmentStatus = EPointCloudSegmentStatus.Ready;
+        break;
+      default: {
+        console.error("Error Status in PointCloudSegmentFSM");
+      }
+    }
+  }
+  updateStatus2Edit() {
+    this.segmentStatus = EPointCloudSegmentStatus.Edit;
+  }
+  updateStatus2Check() {
+    this.segmentStatus = EPointCloudSegmentStatus.Check;
+  }
+  get isReadyStatus() {
+    return this.segmentStatus === EPointCloudSegmentStatus.Ready;
+  }
+  get isCheckStatus() {
+    return this.segmentStatus === EPointCloudSegmentStatus.Check;
+  }
+  get isEditStatus() {
+    return this.segmentStatus === EPointCloudSegmentStatus.Edit;
+  }
+}
+const instance = new PointCloudFSM();
+
+export { instance as default };

package/es/core/pointCloud/store/index.js

@@ -0,0 +1,376 @@
+import * as THREE from 'three';
+import { EPointCloudSegmentMode, EPointCloudSegmentCoverMode, PointCloudUtils } from '@labelbee/lb-utils';
+import { isInPolygon } from '../../../utils/tool/polygonTool.js';
+import uuid from '../../../utils/uuid.js';
+import instance from './fsm.js';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {enumerable: true, configurable: true, writable: true, value}) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const DEFAULT_PREFIX = "LABELBEE_CANVAS_";
+class PointCloudStore {
+  constructor({container, scene, camera, renderer, emit, on, unbind}) {
+    this.canvas2d = null;
+    this.polygon2d = [];
+    this.forbidOperation = false;
+    this.raycaster = new THREE.Raycaster();
+    this.mouse = new THREE.Vector2();
+    this.cloudData = new Map();
+    this.segmentData = new Map();
+    this.hoverPointsID = "";
+    this.segmentMode = EPointCloudSegmentMode.Add;
+    this.segmentCoverMode = EPointCloudSegmentCoverMode.Cover;
+    this.updatePointCloud = false;
+    this.addPointCloud = false;
+    this.orbiting = false;
+    this.currentAttribute = "";
+    this.pointCloudObjectName = "pointCloud";
+    this.updateCoverPoints = (coverPoints = new Float32Array([])) => {
+      this.segmentData.forEach((seg, id) => {
+        var _a;
+        if (id !== ((_a = this.cacheSegData) == null ? void 0 : _a.id)) {
+          const newPoints = this.splitPointsFromPoints(seg.points, coverPoints);
+          seg.points = newPoints;
+          const originPoints = this.scene.getObjectByName(id);
+          if (originPoints) {
+            originPoints.geometry.setAttribute("position", new THREE.Float32BufferAttribute(newPoints, 3));
+            originPoints.geometry.attributes.position.needsUpdate = true;
+          }
+        }
+      });
+      this.emit("reRender3d");
+    };
+    this.container = container;
+    this.scene = scene;
+    this.camera = camera;
+    this.renderer = renderer;
+    this.emit = emit;
+    this.on = on;
+    this.unbind = unbind;
+    this.createCanvas2d();
+    this.clearStash = this.clearStash.bind(this);
+    this.addStash2Store = this.addStash2Store.bind(this);
+    this.updateCheck2Edit = this.updateCheck2Edit.bind(this);
+    this.setAttribute = this.setAttribute.bind(this);
+    this.setSegmentMode = this.setSegmentMode.bind(this);
+    this.setSegmentCoverMode = this.setSegmentCoverMode.bind(this);
+    this.initMsg();
+    this.setupRaycaster();
+  }
+  initMsg() {
+    this.on("clearStash", this.clearStash);
+    this.on("addStash2Store", this.addStash2Store);
+    this.on("updateCheck2Edit", this.updateCheck2Edit);
+    this.on("setSegmentMode", this.setSegmentMode);
+    this.on("setSegmentCoverMode", this.setSegmentCoverMode);
+  }
+  unbindMsg() {
+    this.unbind("clearStash", this.clearStash);
+    this.unbind("addStash2Store", this.addStash2Store);
+    this.unbind("updateCheck2Edit", this.updateCheck2Edit);
+    this.unbind("setSegmentMode", this.setSegmentMode);
+    this.unbind("setSegmentCoverMode", this.setSegmentCoverMode);
+  }
+  get containerWidth() {
+    return this.container.clientWidth;
+  }
+  get containerHeight() {
+    return this.container.clientHeight;
+  }
+  get allSegmentPoints() {
+    return this.scene.children.filter((v) => v.type === "Points" && v.name !== this.pointCloudObjectName);
+  }
+  get segmentStatus() {
+    return instance.segmentStatus;
+  }
+  get isReadyStatus() {
+    return instance.isReadyStatus;
+  }
+  get isCheckStatus() {
+    return instance.isCheckStatus;
+  }
+  get isEditStatus() {
+    return instance.isEditStatus;
+  }
+  statusToggle() {
+    instance.statusToggle();
+  }
+  updateStatus2Edit() {
+    instance.updateStatus2Edit();
+  }
+  createCanvas(id) {
+    const canvas = document.createElement("canvas");
+    canvas.id = id;
+    this.updateCanvasBasicStyle(canvas, {width: this.containerWidth, height: this.containerHeight}, 10);
+    return canvas;
+  }
+  createCanvas2d() {
+    this.canvas2d = this.createCanvas(`${DEFAULT_PREFIX}2d`);
+    this.container.appendChild(this.canvas2d);
+  }
+  setupRaycaster() {
+    this.raycaster.params = {
+      Mesh: {},
+      Line: {threshold: 1},
+      LOD: {},
+      Points: {threshold: 0.2},
+      Sprite: {}
+    };
+  }
+  setHoverPointsID(id) {
+    this.hoverPointsID = id;
+  }
+  setSegmentMode(mode) {
+    this.segmentMode = mode;
+  }
+  setSegmentCoverMode(coverMode) {
+    this.segmentCoverMode = coverMode;
+  }
+  updateCanvasBasicStyle(canvas, size, zIndex) {
+    const pixel = 1;
+    canvas.style.position = "absolute";
+    canvas.width = size.width * pixel;
+    canvas.height = size.height * pixel;
+    canvas.style.width = `${size.width}px`;
+    canvas.style.height = `${size.height}px`;
+    canvas.style.left = "0";
+    canvas.style.top = "0";
+    canvas.style.zIndex = `${zIndex} `;
+  }
+  syncPolygon2d(polygon2d) {
+    this.polygon2d = polygon2d;
+  }
+  getPointsInPolygon(originPolygon) {
+    var _a, _b, _c;
+    const polygon = originPolygon;
+    const originPoints = this.scene.getObjectByName(this.pointCloudObjectName);
+    const cloudDataArrayLike = (_c = (_b = (_a = originPoints == null ? void 0 : originPoints.geometry) == null ? void 0 : _a.attributes) == null ? void 0 : _b.position) == null ? void 0 : _c.array;
+    if (cloudDataArrayLike) {
+      const len = cloudDataArrayLike.length;
+      const vertices = [];
+      const covers = [];
+      for (let i = 0; i < len; i += 3) {
+        const vector3d = new THREE.Vector3(cloudDataArrayLike[i], cloudDataArrayLike[i + 1], cloudDataArrayLike[i + 2]);
+        vector3d.project(this.camera);
+        const projection = {x: 0, y: 0};
+        projection.x = Math.round(vector3d.x * this.container.clientWidth / 2 + this.container.clientWidth / 2);
+        projection.y = Math.round(-vector3d.y * this.container.clientHeight / 2 + this.container.clientHeight / 2);
+        const isIn = isInPolygon(projection, polygon);
+        if (isIn) {
+          const x = cloudDataArrayLike[i];
+          const y = cloudDataArrayLike[i + 1];
+          const z = cloudDataArrayLike[i + 2];
+          const key = PointCloudUtils.getCloudKeys(x, y, z);
+          if (this.segmentMode === EPointCloudSegmentMode.Remove) {
+            this.cloudData.get(key).visible = false;
+            vertices.push(cloudDataArrayLike[i], cloudDataArrayLike[i + 1], cloudDataArrayLike[i + 2]);
+          }
+          if (this.segmentMode === EPointCloudSegmentMode.Add) {
+            if (this.segmentCoverMode === EPointCloudSegmentCoverMode.Cover) {
+              vertices.push(cloudDataArrayLike[i], cloudDataArrayLike[i + 1], cloudDataArrayLike[i + 2]);
+              if (this.cloudData.get(key).visible === true) {
+                covers.push(cloudDataArrayLike[i], cloudDataArrayLike[i + 1], cloudDataArrayLike[i + 2]);
+              }
+            }
+            if (this.segmentCoverMode === EPointCloudSegmentCoverMode.Uncover) {
+              if (this.cloudData.get(key).visible === false) {
+                vertices.push(cloudDataArrayLike[i], cloudDataArrayLike[i + 1], cloudDataArrayLike[i + 2]);
+              }
+            }
+            if (this.cloudData.get(key).visible === false) {
+              this.cloudData.get(key).visible = true;
+            }
+          }
+        }
+      }
+      const verticesArray = new Float32Array(vertices);
+      const coversArray = new Float32Array(covers);
+      this.updateStatusBySelector(verticesArray, coversArray);
+    }
+  }
+  updateStatusBySelector(verticesArray, coversArray) {
+    switch (this.segmentMode) {
+      case EPointCloudSegmentMode.Add:
+        if (this.cacheSegData) {
+          const {points, coverPoints = new Float32Array([])} = this.cacheSegData;
+          const combinedLength = points.length + verticesArray.length;
+          const combined = new Float32Array(combinedLength);
+          combined.set(points, 0);
+          combined.set(verticesArray, points.length);
+          const coverCombinedLength = coverPoints.length + coversArray.length;
+          const coverCombined = new Float32Array(coverCombinedLength);
+          coverCombined.set(coverPoints, 0);
+          coverCombined.set(coversArray, coverPoints.length);
+          this.cacheSegData = __spreadProps(__spreadValues({}, this.cacheSegData), {
+            points: combined,
+            coverPoints: coverCombined
+          });
+          this.emit("updateNewPoints", this.cacheSegData);
+        } else {
+          this.cacheSegData = {
+            id: uuid(),
+            attribute: this.currentAttribute,
+            points: verticesArray,
+            coverPoints: coversArray
+          };
+          this.emit("addNewPointsCloud", this.cacheSegData);
+        }
+        break;
+      case EPointCloudSegmentMode.Remove:
+        if (this.cacheSegData) {
+          const {points} = this.cacheSegData;
+          this.cacheSegData = __spreadProps(__spreadValues({}, this.cacheSegData), {
+            points: this.splitPointsFromPoints(points, verticesArray)
+          });
+          this.emit("updateNewPoints", this.cacheSegData);
+        }
+        break;
+    }
+    this.updateStatus2Edit();
+    this.emit("syncPointCloudStatus", {
+      segmentStatus: this.segmentStatus,
+      cacheSegData: this.cacheSegData
+    });
+  }
+  splitPointsFromPoints(originPoints, splitPoints) {
+    const splitMap = new Map();
+    for (let i = 0; i < splitPoints.length; i += 3) {
+      splitMap.set(PointCloudUtils.getCloudKeys(splitPoints[i], splitPoints[i + 1], splitPoints[i + 2]), 1);
+    }
+    const result = [];
+    for (let i = 0; i < originPoints.length; i += 3) {
+      const key = PointCloudUtils.getCloudKeys(originPoints[i], originPoints[i + 1], originPoints[i + 2]);
+      if (!splitMap.has(key)) {
+        result.push(originPoints[i], originPoints[i + 1], originPoints[i + 2]);
+      }
+    }
+    return new Float32Array(result);
+  }
+  syncPointCloudStatus() {
+    this.statusToggle();
+    const {segmentStatus, cacheSegData} = this;
+    this.emit("syncPointCloudStatus", {segmentStatus, cacheSegData});
+  }
+  addStash2Store() {
+    if (this.isEditStatus && this.cacheSegData) {
+      if (this.cacheSegData.coverPoints && this.cacheSegData.coverPoints.length !== 0) {
+        this.updateCoverPoints(this.cacheSegData.coverPoints);
+      }
+      delete this.cacheSegData.coverPoints;
+      this.segmentData.set(this.cacheSegData.id, this.cacheSegData);
+      this.cacheSegData = void 0;
+      this.syncPointCloudStatus();
+    }
+  }
+  updateCloudDataStatus(points, status) {
+    for (let i = 0; i < points.length; i += 3) {
+      const x = points[i];
+      const y = points[i + 1];
+      const z = points[i + 2];
+      const key = PointCloudUtils.getCloudKeys(x, y, z);
+      const data = this.cloudData.get(key);
+      Object.keys(status).forEach((k) => {
+        data[k] = status[k];
+      });
+    }
+  }
+  clearStash() {
+    if (this.isEditStatus && this.cacheSegData) {
+      this.updateCloudDataStatus(this.cacheSegData.points, {visible: false});
+      if (this.segmentData.has(this.cacheSegData.id)) {
+        const originSegmentData = this.segmentData.get(this.cacheSegData.id);
+        if (originSegmentData) {
+          this.emit("updateNewPoints", originSegmentData);
+          this.updateCloudDataStatus(originSegmentData == null ? void 0 : originSegmentData.points, {visible: true});
+        }
+      } else {
+        this.emit("clearStashRender");
+      }
+      this.cacheSegData = void 0;
+      this.syncPointCloudStatus();
+    }
+  }
+  updateCheck2Edit() {
+    if (this.isCheckStatus) {
+      this.syncPointCloudStatus();
+    }
+  }
+  checkPoints() {
+    const hoverPoints = this.segmentData.get(this.hoverPointsID);
+    if (hoverPoints) {
+      this.cacheSegData = __spreadProps(__spreadValues({}, hoverPoints), {
+        points: new Float32Array(hoverPoints.points)
+      });
+      instance.updateStatus2Check();
+      this.emit("syncPointCloudStatus", {
+        segmentStatus: this.segmentStatus,
+        cacheSegData: this.cacheSegData
+      });
+    }
+  }
+  editPoints() {
+    const hoverPoints = this.segmentData.get(this.hoverPointsID);
+    if (hoverPoints) {
+      this.cacheSegData = __spreadProps(__spreadValues({}, hoverPoints), {
+        points: new Float32Array(hoverPoints.points)
+      });
+      this.emit("updateNewPoints");
+      this.syncPointCloudStatus();
+    }
+  }
+  setForbidOperation(forbidOperation) {
+    this.forbidOperation = forbidOperation;
+  }
+  updateMouse(offset) {
+    const x = offset.x / this.containerWidth * 2 - 1;
+    const y = -(offset.y / this.containerHeight) * 2 + 1;
+    this.mouse.setX(x);
+    this.mouse.setY(y);
+  }
+  resetAllSegDataSize() {
+    this.allSegmentPoints.forEach((points) => {
+      var _a;
+      if (((_a = this.cacheSegData) == null ? void 0 : _a.id) === points.name) {
+        return;
+      }
+      points.material.size = 5;
+    });
+  }
+  resetHoverPointsID() {
+    this.hoverPointsID = "";
+  }
+  resetAllSegDataSizeAndRender() {
+    this.resetAllSegDataSize();
+    this.emit("reRender3d");
+  }
+  highlightPoints(newPoints) {
+    if (!(this.isCheckStatus || this.isReadyStatus)) {
+      return;
+    }
+    this.resetAllSegDataSize();
+    newPoints.material.size = 10;
+    this.hoverPointsID = newPoints.name;
+    this.emit("reRender3d");
+  }
+  setAttribute(attribute) {
+    this.currentAttribute = attribute;
+  }
+}
+
+export { PointCloudStore as default };

package/es/core/toolOperation/Selection.js

@@ -0,0 +1,101 @@
+import _ from 'lodash';
+import CommonToolUtils from '../../utils/tool/CommonToolUtils.js';
+
+class Selection {
+  constructor(toolInstance) {
+    if (!toolInstance) {
+      console.error("MultipleSelect is require a tool instance");
+    }
+    this._selectedIDs = [];
+    this.toolInstance = toolInstance;
+  }
+  get selectedIDs() {
+    return this._selectedIDs;
+  }
+  get selectedID() {
+    return this._selectedIDs.length === 1 ? this._selectedIDs[0] : void 0;
+  }
+  get visibleDataList() {
+    const {dataList, attributeLockList, basicResult} = this.toolInstance;
+    const [showingDataList] = CommonToolUtils.getRenderResultList(dataList, CommonToolUtils.getSourceID(basicResult), attributeLockList);
+    return showingDataList;
+  }
+  get dataList() {
+    return this.toolInstance.dataList;
+  }
+  set selectedIDs(selectedIDs) {
+    var _a;
+    (_a = this.toolInstance._textAttributeInstance) == null ? void 0 : _a.selectedIDsChanged(this.selectedIDs, selectedIDs);
+    this._selectedIDs = selectedIDs;
+    this.toolInstance.render();
+  }
+  updateSelectedIDs(selectedID) {
+    if (!selectedID) {
+      this._selectedIDs = [];
+      return;
+    }
+    if (this.selectedIDs.includes(selectedID)) {
+      this.selectedIDs = this.selectedIDs.filter((id) => id !== selectedID);
+    } else {
+      this.selectedIDs = [...this.selectedIDs, selectedID];
+    }
+  }
+  setSelectedIDs(id, isAppend = false) {
+    if (isAppend) {
+      this.updateSelectedIDs(id);
+      return;
+    }
+    this.selectedIDs = id ? [id] : [];
+  }
+  hardSetSelectedIDs(ids) {
+    this.selectedIDs = ids;
+  }
+  selectAll() {
+    this.selectedIDs = this.visibleDataList.map((i) => i.id);
+    this.toolInstance.render();
+  }
+  toStashDataList() {
+    if (this.selectedIDs.length > 0) {
+      this.stashDataList = _.cloneDeep(this.dataList.filter((i) => this.selectedIDs.includes(i.id)));
+    }
+  }
+  toUnStashDataList() {
+    if (this.stashDataList) {
+      const _stashDataList = this.stashDataList;
+      this.stashDataList = void 0;
+      return _stashDataList;
+    }
+    return void 0;
+  }
+  mergeStashData(setDataList) {
+    const stashList = this.toUnStashDataList();
+    if (!stashList) {
+      return;
+    }
+    const mergedDataList = _(this.dataList).keyBy("id").merge(_.keyBy(stashList, "id")).values().value();
+    setDataList(mergedDataList);
+    this.toolInstance.render();
+  }
+  isIdSelected(id) {
+    return this.selectedIDs.includes(id);
+  }
+  triggerKeyboardEvent(e, setDataList) {
+    if (e.ctrlKey) {
+      if (e.key === "v") {
+        this.mergeStashData(setDataList);
+        return true;
+      }
+      if (e.key === "a") {
+        this.selectAll();
+        return true;
+      }
+      if (e.key === "c") {
+        this.toStashDataList();
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+export { Selection as default };