@labelbee/lb-annotation 1.14.0-alpha.2 → 1.14.0-alpha.3

package/dist/core/pointCloud/PCDLoader.js

@@ -1,2 +1,260 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var THREE=require("three"),lbUtils=require("@labelbee/lb-utils");class PCDLoader extends THREE.Loader{constructor(a){super(a);this.littleEndian=!0}load(a,c,h,g){const i=this,l=new THREE.FileLoader(i.manager);l.setPath(i.path),l.setResponseType("arraybuffer"),l.setRequestHeader(i.requestHeader),l.setWithCredentials(i.withCredentials),l.load(a,function(d){try{c(i.parse(d))}catch(u){g?g(u):console.error(u),i.manager.itemError(a)}},h,g)}parse(a){function c(s,e){const p=s.length,n=new Uint8Array(e);let r=0,t=0,o,w,f;do if(o=s[r++],o<1<<5){if(o++,t+o>e)throw new Error("Output buffer is not large enough");if(r+o>p)throw new Error("Invalid compressed data");do n[t++]=s[r++];while(--o)}else{if(w=o>>5,f=t-((o&31)<<8)-1,r>=p)throw new Error("Invalid compressed data");if(w===7&&(w+=s[r++],r>=p))throw new Error("Invalid compressed data");if(f-=s[r++],t+w+2>e)throw new Error("Output buffer is not large enough");if(f<0)throw new Error("Invalid compressed data");if(f>=t)throw new Error("Invalid compressed data");do n[t++]=n[f++];while(--w+2)}while(r<p);return n}function h(s){const e={},p=s.search(/[\n\r]data\s(\S*)\s/i),n=/[\n\r]data\s(\S*)\s/i.exec(s.slice(p-1));if(e.data=n[1],e.headerLen=n[0].length+p,e.str=s.slice(0,e.headerLen),e.str=e.str.replace(/#.*/gi,""),e.version=/version (.*)/i.exec(e.str),e.fields=/fields (.*)/i.exec(e.str),e.size=/size (.*)/i.exec(e.str),e.type=/type (.*)/i.exec(e.str),e.count=/count (.*)/i.exec(e.str),e.width=/width (.*)/i.exec(e.str),e.height=/height (.*)/i.exec(e.str),e.viewpoint=/viewpoint (.*)/i.exec(e.str),e.points=/points (.*)/i.exec(e.str),e.version!==null&&(e.version=parseFloat(e.version[1])),e.fields=e.fields!==null?e.fields[1].split(" "):[],e.type!==null&&(e.type=e.type[1].split(" ")),e.width!==null&&(e.width=parseInt(e.width[1])),e.height!==null&&(e.height=parseInt(e.height[1])),e.viewpoint!==null&&(e.viewpoint=e.viewpoint[1]),e.points!==null&&(e.points=parseInt(e.points[1],10)),e.points===null&&(e.points=e.width*e.height),e.size!==null&&(e.size=e.size[1].split(" ").map(function(t){return parseInt(t,10)})),e.count!==null)e.count=e.count[1].split(" ").map(function(t){return parseInt(t,10)});else{e.count=[];for(let t=0,o=e.fields.length;t<o;t++)e.count.push(1)}e.offset={};let r=0;for(let t=0,o=e.fields.length;t<o;t++)e.data==="ascii"?e.offset[e.fields[t]]=t:(e.offset[e.fields[t]]=r,r+=e.size[t]*e.count[t]);return e.rowSize=r,e}const g=THREE.LoaderUtils.decodeText(new Uint8Array(a)),i=h(g),l=[],d=[],u=[];if(i.data==="ascii"){const{offset:s}=i,p=g.slice(i.headerLen).split(`
-`);for(let n=0,r=p.length;n<r;n++){if(p[n]==="")continue;const t=p[n].split(" ");if(s.x!==void 0&&(l.push(parseFloat(t[s.x])),l.push(parseFloat(t[s.y])),l.push(parseFloat(t[s.z]))),this.genColorByZ){const w=this.genColorByZ(parseFloat(t[s.x]),parseFloat(t[s.y]),parseFloat(t[s.z])).map(f=>f/255);u.push(...w)}s.normal_x!==void 0&&(d.push(parseFloat(t[s.normal_x])),d.push(parseFloat(t[s.normal_y])),d.push(parseFloat(t[s.normal_z])))}}if(i.data==="binary_compressed"){const s=new Uint32Array(a.slice(i.headerLen,i.headerLen+8)),e=s[0],p=s[1],n=c(new Uint8Array(a,i.headerLen+8,e),p),r=new DataView(n.buffer),{offset:t}=i;for(let o=0;o<i.points;o++)if(t.x!==void 0&&(l.push(r.getFloat32(i.points*t.x+i.size[0]*o,this.littleEndian)),l.push(r.getFloat32(i.points*t.y+i.size[1]*o,this.littleEndian)),l.push(r.getFloat32(i.points*t.z+i.size[2]*o,this.littleEndian))),t.normal_x!==void 0&&(d.push(r.getFloat32(i.points*t.normal_x+i.size[4]*o,this.littleEndian)),d.push(r.getFloat32(i.points*t.normal_y+i.size[5]*o,this.littleEndian)),d.push(r.getFloat32(i.points*t.normal_z+i.size[6]*o,this.littleEndian))),this.genColorByZ){const f=this.genColorByZ(r.getFloat32(i.points*t.x+i.size[0]*o,this.littleEndian),r.getFloat32(i.points*t.y+i.size[0]*o,this.littleEndian),r.getFloat32(i.points*t.z+i.size[0]*o,this.littleEndian)).map(F=>F/255);u.push(...f)}}if(i.data==="binary"){const s=new DataView(a,i.headerLen),{offset:e}=i;for(let p=0,n=0;p<i.points;p++,n+=i.rowSize)if(e.x!==void 0&&(l.push(s.getFloat32(n+e.x,this.littleEndian)),l.push(s.getFloat32(n+e.y,this.littleEndian)),l.push(s.getFloat32(n+e.z,this.littleEndian))),e.normal_x!==void 0&&(d.push(s.getFloat32(n+e.normal_x,this.littleEndian)),d.push(s.getFloat32(n+e.normal_y,this.littleEndian)),d.push(s.getFloat32(n+e.normal_z,this.littleEndian))),this.genColorByZ){const t=this.genColorByZ(s.getFloat32(n+e.x,this.littleEndian),s.getFloat32(n+e.y,this.littleEndian),s.getFloat32(n+e.z,this.littleEndian)).map(o=>o/255);u.push(...t)}}const x=new THREE.BufferGeometry;l.length>0&&x.setAttribute("position",new THREE.Float32BufferAttribute(l,3)),d.length>0&&x.setAttribute("normal",new THREE.Float32BufferAttribute(d,3)),u.length>0&&x.setAttribute("color",new THREE.Float32BufferAttribute(u,3)),x.computeBoundingSphere();const y=new THREE.PointsMaterial({size:.01});return u.length>0?y.vertexColors=!0:y.color.setHex(16777215),new THREE.Points(x,y)}genColorByCoord(a,c,h){return h<=0?[128,128,128]:h<5?[255,0,0]:h<10?[0,255,0]:[0,0,255]}genColorByZ(a,c,h){const g=getIndex(h),i=lbUtils.COLOR_MAP_JET[g];return[i[0],i[1],i[2]]}}function getIndex(m){const a=-7,c=3,h=c-a;return m<a&&(m=a),m>c&&(m=c),Math.floor((m-a)/h*255)}exports.PCDLoader=PCDLoader;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var THREE = require('three');
+var lbUtils = require('@labelbee/lb-utils');
+
+class PCDLoader extends THREE.Loader {
+  constructor(manager) {
+    super(manager);
+    this.littleEndian = true;
+  }
+  load(url, onLoad, onProgress, onError) {
+    const scope = this;
+    const loader = new THREE.FileLoader(scope.manager);
+    loader.setPath(scope.path);
+    loader.setResponseType("arraybuffer");
+    loader.setRequestHeader(scope.requestHeader);
+    loader.setWithCredentials(scope.withCredentials);
+    loader.load(url, function(data) {
+      try {
+        onLoad(scope.parse(data));
+      } catch (e) {
+        if (onError) {
+          onError(e);
+        } else {
+          console.error(e);
+        }
+        scope.manager.itemError(url);
+      }
+    }, onProgress, onError);
+  }
+  parse(data) {
+    function decompressLZF(inData, outLength) {
+      const inLength = inData.length;
+      const outData = new Uint8Array(outLength);
+      let inPtr = 0;
+      let outPtr = 0;
+      let ctrl;
+      let len;
+      let ref;
+      do {
+        ctrl = inData[inPtr++];
+        if (ctrl < 1 << 5) {
+          ctrl++;
+          if (outPtr + ctrl > outLength)
+            throw new Error("Output buffer is not large enough");
+          if (inPtr + ctrl > inLength)
+            throw new Error("Invalid compressed data");
+          do {
+            outData[outPtr++] = inData[inPtr++];
+          } while (--ctrl);
+        } else {
+          len = ctrl >> 5;
+          ref = outPtr - ((ctrl & 31) << 8) - 1;
+          if (inPtr >= inLength)
+            throw new Error("Invalid compressed data");
+          if (len === 7) {
+            len += inData[inPtr++];
+            if (inPtr >= inLength)
+              throw new Error("Invalid compressed data");
+          }
+          ref -= inData[inPtr++];
+          if (outPtr + len + 2 > outLength)
+            throw new Error("Output buffer is not large enough");
+          if (ref < 0)
+            throw new Error("Invalid compressed data");
+          if (ref >= outPtr)
+            throw new Error("Invalid compressed data");
+          do {
+            outData[outPtr++] = outData[ref++];
+          } while (--len + 2);
+        }
+      } while (inPtr < inLength);
+      return outData;
+    }
+    function parseHeader(data2) {
+      const PCDheader2 = {};
+      const result1 = data2.search(/[\n\r]data\s(\S*)\s/i);
+      const result2 = /[\n\r]data\s(\S*)\s/i.exec(data2.slice(result1 - 1));
+      PCDheader2.data = result2[1];
+      PCDheader2.headerLen = result2[0].length + result1;
+      PCDheader2.str = data2.slice(0, PCDheader2.headerLen);
+      PCDheader2.str = PCDheader2.str.replace(/#.*/gi, "");
+      PCDheader2.version = /version (.*)/i.exec(PCDheader2.str);
+      PCDheader2.fields = /fields (.*)/i.exec(PCDheader2.str);
+      PCDheader2.size = /size (.*)/i.exec(PCDheader2.str);
+      PCDheader2.type = /type (.*)/i.exec(PCDheader2.str);
+      PCDheader2.count = /count (.*)/i.exec(PCDheader2.str);
+      PCDheader2.width = /width (.*)/i.exec(PCDheader2.str);
+      PCDheader2.height = /height (.*)/i.exec(PCDheader2.str);
+      PCDheader2.viewpoint = /viewpoint (.*)/i.exec(PCDheader2.str);
+      PCDheader2.points = /points (.*)/i.exec(PCDheader2.str);
+      if (PCDheader2.version !== null)
+        PCDheader2.version = parseFloat(PCDheader2.version[1]);
+      PCDheader2.fields = PCDheader2.fields !== null ? PCDheader2.fields[1].split(" ") : [];
+      if (PCDheader2.type !== null)
+        PCDheader2.type = PCDheader2.type[1].split(" ");
+      if (PCDheader2.width !== null)
+        PCDheader2.width = parseInt(PCDheader2.width[1]);
+      if (PCDheader2.height !== null)
+        PCDheader2.height = parseInt(PCDheader2.height[1]);
+      if (PCDheader2.viewpoint !== null)
+        PCDheader2.viewpoint = PCDheader2.viewpoint[1];
+      if (PCDheader2.points !== null)
+        PCDheader2.points = parseInt(PCDheader2.points[1], 10);
+      if (PCDheader2.points === null)
+        PCDheader2.points = PCDheader2.width * PCDheader2.height;
+      if (PCDheader2.size !== null) {
+        PCDheader2.size = PCDheader2.size[1].split(" ").map(function(x) {
+          return parseInt(x, 10);
+        });
+      }
+      if (PCDheader2.count !== null) {
+        PCDheader2.count = PCDheader2.count[1].split(" ").map(function(x) {
+          return parseInt(x, 10);
+        });
+      } else {
+        PCDheader2.count = [];
+        for (let i = 0, l = PCDheader2.fields.length; i < l; i++) {
+          PCDheader2.count.push(1);
+        }
+      }
+      PCDheader2.offset = {};
+      let sizeSum = 0;
+      for (let i = 0, l = PCDheader2.fields.length; i < l; i++) {
+        if (PCDheader2.data === "ascii") {
+          PCDheader2.offset[PCDheader2.fields[i]] = i;
+        } else {
+          PCDheader2.offset[PCDheader2.fields[i]] = sizeSum;
+          sizeSum += PCDheader2.size[i] * PCDheader2.count[i];
+        }
+      }
+      PCDheader2.rowSize = sizeSum;
+      return PCDheader2;
+    }
+    const textData = THREE.LoaderUtils.decodeText(new Uint8Array(data));
+    const PCDheader = parseHeader(textData);
+    const position = [];
+    const normal = [];
+    const color = [];
+    if (PCDheader.data === "ascii") {
+      const {offset} = PCDheader;
+      const pcdData = textData.slice(PCDheader.headerLen);
+      const lines = pcdData.split("\n");
+      for (let i = 0, l = lines.length; i < l; i++) {
+        if (lines[i] === "")
+          continue;
+        const line = lines[i].split(" ");
+        if (offset.x !== void 0) {
+          position.push(parseFloat(line[offset.x]));
+          position.push(parseFloat(line[offset.y]));
+          position.push(parseFloat(line[offset.z]));
+        }
+        if (this.genColorByZ) {
+          const pdColor = this.genColorByZ(parseFloat(line[offset.x]), parseFloat(line[offset.y]), parseFloat(line[offset.z]));
+          const pdColorUnit8 = pdColor.map((hex) => hex / 255);
+          color.push(...pdColorUnit8);
+        }
+        if (offset.normal_x !== void 0) {
+          normal.push(parseFloat(line[offset.normal_x]));
+          normal.push(parseFloat(line[offset.normal_y]));
+          normal.push(parseFloat(line[offset.normal_z]));
+        }
+      }
+    }
+    if (PCDheader.data === "binary_compressed") {
+      const sizes = new Uint32Array(data.slice(PCDheader.headerLen, PCDheader.headerLen + 8));
+      const compressedSize = sizes[0];
+      const decompressedSize = sizes[1];
+      const decompressed = decompressLZF(new Uint8Array(data, PCDheader.headerLen + 8, compressedSize), decompressedSize);
+      const dataview = new DataView(decompressed.buffer);
+      const {offset} = PCDheader;
+      for (let i = 0; i < PCDheader.points; i++) {
+        if (offset.x !== void 0) {
+          position.push(dataview.getFloat32(PCDheader.points * offset.x + PCDheader.size[0] * i, this.littleEndian));
+          position.push(dataview.getFloat32(PCDheader.points * offset.y + PCDheader.size[1] * i, this.littleEndian));
+          position.push(dataview.getFloat32(PCDheader.points * offset.z + PCDheader.size[2] * i, this.littleEndian));
+        }
+        if (offset.normal_x !== void 0) {
+          normal.push(dataview.getFloat32(PCDheader.points * offset.normal_x + PCDheader.size[4] * i, this.littleEndian));
+          normal.push(dataview.getFloat32(PCDheader.points * offset.normal_y + PCDheader.size[5] * i, this.littleEndian));
+          normal.push(dataview.getFloat32(PCDheader.points * offset.normal_z + PCDheader.size[6] * i, this.littleEndian));
+        }
+        if (this.genColorByZ) {
+          const pdColor = this.genColorByZ(dataview.getFloat32(PCDheader.points * offset.x + PCDheader.size[0] * i, this.littleEndian), dataview.getFloat32(PCDheader.points * offset.y + PCDheader.size[0] * i, this.littleEndian), dataview.getFloat32(PCDheader.points * offset.z + PCDheader.size[0] * i, this.littleEndian));
+          const pdColorUnit8 = pdColor.map((hex) => hex / 255);
+          color.push(...pdColorUnit8);
+        }
+      }
+    }
+    if (PCDheader.data === "binary") {
+      const dataview = new DataView(data, PCDheader.headerLen);
+      const {offset} = PCDheader;
+      for (let i = 0, row = 0; i < PCDheader.points; i++, row += PCDheader.rowSize) {
+        if (offset.x !== void 0) {
+          position.push(dataview.getFloat32(row + offset.x, this.littleEndian));
+          position.push(dataview.getFloat32(row + offset.y, this.littleEndian));
+          position.push(dataview.getFloat32(row + offset.z, this.littleEndian));
+        }
+        if (offset.normal_x !== void 0) {
+          normal.push(dataview.getFloat32(row + offset.normal_x, this.littleEndian));
+          normal.push(dataview.getFloat32(row + offset.normal_y, this.littleEndian));
+          normal.push(dataview.getFloat32(row + offset.normal_z, this.littleEndian));
+        }
+        if (this.genColorByZ) {
+          const pdColor = this.genColorByZ(dataview.getFloat32(row + offset.x, this.littleEndian), dataview.getFloat32(row + offset.y, this.littleEndian), dataview.getFloat32(row + offset.z, this.littleEndian));
+          const pdColorUnit8 = pdColor.map((hex) => hex / 255);
+          color.push(...pdColorUnit8);
+        }
+      }
+    }
+    const geometry = new THREE.BufferGeometry();
+    if (position.length > 0)
+      geometry.setAttribute("position", new THREE.Float32BufferAttribute(position, 3));
+    if (normal.length > 0)
+      geometry.setAttribute("normal", new THREE.Float32BufferAttribute(normal, 3));
+    if (color.length > 0)
+      geometry.setAttribute("color", new THREE.Float32BufferAttribute(color, 3));
+    geometry.computeBoundingSphere();
+    const material = new THREE.PointsMaterial({size: 0.01});
+    if (color.length > 0) {
+      material.vertexColors = true;
+    } else {
+      material.color.setHex(16777215);
+    }
+    return new THREE.Points(geometry, material);
+  }
+  genColorByCoord(x, y, z) {
+    if (z <= 0) {
+      return [128, 128, 128];
+    }
+    if (z < 5) {
+      return [255, 0, 0];
+    }
+    if (z < 10) {
+      return [0, 255, 0];
+    }
+    return [0, 0, 255];
+  }
+  genColorByZ(x, y, z) {
+    const index = getIndex(z);
+    const color = lbUtils.COLOR_MAP_JET[index];
+    return [color[0], color[1], color[2]];
+  }
+}
+function getIndex(z) {
+  const minZ = -7;
+  const maxZ = 3;
+  const len = maxZ - minZ;
+  if (z < minZ) {
+    z = minZ;
+  }
+  if (z > maxZ) {
+    z = maxZ;
+  }
+  return Math.floor((z - minZ) / len * 255);
+}
+
+exports.PCDLoader = PCDLoader;

package/dist/core/pointCloud/annotation.js

@@ -1 +1,215 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var lbUtils=require("@labelbee/lb-utils"),tool=require("../../constant/tool.js"),CanvasScheduler=require("../../newCore/CanvasScheduler.js"),index=require("./index.js"),scheduler=require("../scheduler.js"),__defProp=Object.defineProperty,__defProps=Object.defineProperties,__getOwnPropDescs=Object.getOwnPropertyDescriptors,__getOwnPropSymbols=Object.getOwnPropertySymbols,__hasOwnProp=Object.prototype.hasOwnProperty,__propIsEnum=Object.prototype.propertyIsEnumerable,__defNormalProp=(i,t,e)=>t in i?__defProp(i,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):i[t]=e,__spreadValues=(i,t)=>{for(var e in t||(t={}))__hasOwnProp.call(t,e)&&__defNormalProp(i,e,t[e]);if(__getOwnPropSymbols)for(var e of __getOwnPropSymbols(t))__propIsEnum.call(t,e)&&__defNormalProp(i,e,t[e]);return i},__spreadProps=(i,t)=>__defProps(i,__getOwnPropDescs(t));const createEmptyImage=i=>{const t=document.createElement("canvas");t.width=i.width,t.height=i.height;const e=t.getContext("2d");return e?(e.fillStyle="black",e.fillRect(0,0,i.width,i.height),t.toDataURL()):""};class PointCloudAnnotation{constructor({size:t,container:e,pcdPath:a,extraProps:P,config:m,checkMode:v,toolName:d}){this.updateLineList=s=>{const l=s.map(n=>{var o;return __spreadProps(__spreadValues({},n),{pointList:(o=n==null?void 0:n.pointList)==null?void 0:o.map(r=>lbUtils.PointCloudUtils.transferWorld2Canvas(r,this.toolInstance.size))})});this.toolScheduler.updateDataByToolName(tool.EToolName.Line,l)},this.updatePolygonList=(s,l)=>{let n=s.map(o=>{var r;const{polygon2d:C}=this.pointCloudInstance.getBoxTopPolygon2DCoordinate(o);return{id:o.id,sourceID:"",pointList:C,isRect:!0,valid:(r=o.valid)!=null?r:!0,attribute:o.attribute}});l&&(n=n.concat(l.map(o=>{var r;return __spreadProps(__spreadValues({},o),{pointList:(r=o==null?void 0:o.pointList)==null?void 0:r.map(C=>lbUtils.PointCloudUtils.transferWorld2Canvas(C,this.toolInstance.size))})}))),this.toolScheduler.updateDataByToolName(tool.EToolName.PointCloudPolygon,n)},this.updatePointList=s=>{const l=s==null?void 0:s.map(n=>{var o;const{point2d:r}=this.pointCloudInstance.getSphereTopPoint2DCoordinate(n);return __spreadProps(__spreadValues({},r),{id:n.id,sourceID:"",valid:(o=n.valid)!=null?o:!0,attribute:n.attribute,textAttribute:""})});this.toolScheduler.updateDataByToolName(tool.EToolName.Point,l)};const O=this.getDefaultOrthographic(t),I=createEmptyImage(t),u=new Image;u.src=I;const p=new scheduler.ToolScheduler({container:e,size:t,toolName:d}),f=new CanvasScheduler.CanvasScheduler({container:e}),h=new index.PointCloud({container:e,noAppend:!0,isOrthographicCamera:!0,orthographicParams:O});a&&h.loadPCDFile(a),f.createCanvas(h.renderer.domElement);const g={size:t,config:JSON.stringify(__spreadProps(__spreadValues({},m),{attributeConfigurable:!0,hideAttribute:!0})),imgNode:u,checkMode:v};P&&Object.assign(g,P);let c=[];scheduler.HybridToolUtils.isSingleTool(d)?c=[d]:c=d,c.forEach((s,l)=>{let n;if(s===tool.EToolName.PointCloudPolygon){const o=p.createOperation(s,u,g);o.eventBinding(),o.setPattern(tool.EPolygonPattern.Rect),this.toolInstance=o,this.toolInstance.eventBinding(),this.pointCloud2dOperation=o}else n=p.createOperation(s,u,g);l===c.length-1&&(this.toolInstance||(this.toolInstance=n,this.toolInstance.eventBinding()))}),this.pointCloudInstance=h,this.canvasScheduler=f,this.toolScheduler=p,this.config=m}updateConfig(t){this.config=t,this.pointCloud2dOperation.setConfig(JSON.stringify(t))}getDefaultOrthographic(t){return{left:-t.width/2,right:t.width/2,top:t.height/2,bottom:-t.height/2,near:100,far:-100}}initSize(t){this.pointCloudInstance.updateTopCamera(),this.pointCloudInstance.setDefaultControls(),this.pointCloudInstance.initRenderer(),this.pointCloudInstance.initOrthographicCamera(this.getDefaultOrthographic(t)),this.pointCloudInstance.render();const e=createEmptyImage(t),a=new Image;a.src=e,a.onload=()=>{this.toolInstance.setImgNode(a),this.toolInstance.initImgPos()},this.pointCloud2dOperation.setCanvasSize(t)}addPolygonListOnTopView(t){const e=lbUtils.PointCloudUtils.getBoxParamsFromResultList(t),a=lbUtils.PointCloudUtils.getPolygonListFromResultList(t);this.updatePolygonList(e,a)}addLineListOnTopView(t){const e=lbUtils.PointCloudUtils.getLineListFromResultList(t);this.updateLineList(e)}addPointListOnTopView(t){const e=lbUtils.PointCloudUtils.getSphereParamsFromResultList(t);this.updatePointList(e)}updateData(t,e,a){!this.toolInstance||!this.pointCloudInstance||(this.pointCloudInstance.loadPCDFile(t,a==null?void 0:a.radius),this.addPolygonListOnTopView(e),this.addLineListOnTopView(e),this.addPointListOnTopView(e))}switchToCanvas(t){const e=this.toolScheduler.switchToCanvas(t);return e?(e.eventBinding(),this.toolInstance=e,e):this.toolInstance}initAllPosition(){this.pointCloudInstance.updateTopCamera(),this.pointCloud2dOperation.initPosition()}clearAllData(){this.pointCloudInstance.clearPointCloudAndRender(),this.pointCloud2dOperation.clearResult()}}exports.PointCloudAnnotation=PointCloudAnnotation;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var lbUtils = require('@labelbee/lb-utils');
+var tool = require('../../constant/tool.js');
+var CanvasScheduler = require('../../newCore/CanvasScheduler.js');
+var index = require('./index.js');
+var scheduler = require('../scheduler.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 createEmptyImage = (size) => {
+  const canvas = document.createElement("canvas");
+  canvas.width = size.width;
+  canvas.height = size.height;
+  const ctx = canvas.getContext("2d");
+  if (ctx) {
+    ctx.fillStyle = "black";
+    ctx.fillRect(0, 0, size.width, size.height);
+    return canvas.toDataURL();
+  }
+  return "";
+};
+class PointCloudAnnotation {
+  constructor({size, container, pcdPath, extraProps, config, checkMode, toolName}) {
+    this.updateLineList = (lineList) => {
+      const list = lineList.map((v) => {
+        var _a;
+        return __spreadProps(__spreadValues({}, v), {
+          pointList: (_a = v == null ? void 0 : v.pointList) == null ? void 0 : _a.map((point) => lbUtils.PointCloudUtils.transferWorld2Canvas(point, this.toolInstance.size))
+        });
+      });
+      this.toolScheduler.updateDataByToolName(tool.EToolName.Line, list);
+    };
+    this.updatePolygonList = (pointCloudDataList, extraList) => {
+      let polygonList = pointCloudDataList.map((v) => {
+        var _a;
+        const {polygon2d: pointList} = this.pointCloudInstance.getBoxTopPolygon2DCoordinate(v);
+        return {
+          id: v.id,
+          sourceID: "",
+          pointList,
+          isRect: true,
+          valid: (_a = v.valid) != null ? _a : true,
+          attribute: v.attribute
+        };
+      });
+      if (extraList) {
+        polygonList = polygonList.concat(extraList.map((v) => {
+          var _a;
+          return __spreadProps(__spreadValues({}, v), {
+            pointList: (_a = v == null ? void 0 : v.pointList) == null ? void 0 : _a.map((point) => lbUtils.PointCloudUtils.transferWorld2Canvas(point, this.toolInstance.size))
+          });
+        }));
+      }
+      this.toolScheduler.updateDataByToolName(tool.EToolName.PointCloudPolygon, polygonList);
+    };
+    this.updatePointList = (sphereList) => {
+      const pointList = sphereList == null ? void 0 : sphereList.map((v) => {
+        var _a;
+        const {point2d} = this.pointCloudInstance.getSphereTopPoint2DCoordinate(v);
+        return __spreadProps(__spreadValues({}, point2d), {
+          id: v.id,
+          sourceID: "",
+          valid: (_a = v.valid) != null ? _a : true,
+          attribute: v.attribute,
+          textAttribute: ""
+        });
+      });
+      this.toolScheduler.updateDataByToolName(tool.EToolName.Point, pointList);
+    };
+    const defaultOrthographic = this.getDefaultOrthographic(size);
+    const imgSrc = createEmptyImage(size);
+    const image = new Image();
+    image.src = imgSrc;
+    const toolScheduler = new scheduler.ToolScheduler({container, size, toolName});
+    const canvasScheduler = new CanvasScheduler.CanvasScheduler({container});
+    const pointCloud = new index.PointCloud({
+      container,
+      noAppend: true,
+      isOrthographicCamera: true,
+      orthographicParams: defaultOrthographic
+    });
+    if (pcdPath) {
+      pointCloud.loadPCDFile(pcdPath);
+    }
+    canvasScheduler.createCanvas(pointCloud.renderer.domElement);
+    const defaultProps = {
+      size,
+      config: JSON.stringify(__spreadProps(__spreadValues({}, config), {attributeConfigurable: true, hideAttribute: true})),
+      imgNode: image,
+      checkMode
+    };
+    if (extraProps) {
+      Object.assign(defaultProps, extraProps);
+    }
+    let toolList = [];
+    if (scheduler.HybridToolUtils.isSingleTool(toolName)) {
+      toolList = [toolName];
+    } else {
+      toolList = toolName;
+    }
+    toolList.forEach((tool$1, i) => {
+      let toolInstance;
+      if (tool$1 === tool.EToolName.PointCloudPolygon) {
+        const pointCloudPolygonOperation = toolScheduler.createOperation(tool$1, image, defaultProps);
+        pointCloudPolygonOperation.eventBinding();
+        pointCloudPolygonOperation.setPattern(tool.EPolygonPattern.Rect);
+        this.toolInstance = pointCloudPolygonOperation;
+        this.toolInstance.eventBinding();
+        this.pointCloud2dOperation = pointCloudPolygonOperation;
+      } else {
+        toolInstance = toolScheduler.createOperation(tool$1, image, defaultProps);
+      }
+      if (i === toolList.length - 1) {
+        if (!this.toolInstance) {
+          this.toolInstance = toolInstance;
+          this.toolInstance.eventBinding();
+        }
+      }
+    });
+    this.pointCloudInstance = pointCloud;
+    this.canvasScheduler = canvasScheduler;
+    this.toolScheduler = toolScheduler;
+    this.config = config;
+  }
+  updateConfig(config) {
+    this.config = config;
+    this.pointCloud2dOperation.setConfig(JSON.stringify(config));
+  }
+  getDefaultOrthographic(size) {
+    return {
+      left: -size.width / 2,
+      right: size.width / 2,
+      top: size.height / 2,
+      bottom: -size.height / 2,
+      near: 100,
+      far: -100
+    };
+  }
+  initSize(size) {
+    this.pointCloudInstance.updateTopCamera();
+    this.pointCloudInstance.setDefaultControls();
+    this.pointCloudInstance.initRenderer();
+    this.pointCloudInstance.initOrthographicCamera(this.getDefaultOrthographic(size));
+    this.pointCloudInstance.render();
+    const imgSrc = createEmptyImage(size);
+    const image = new Image();
+    image.src = imgSrc;
+    image.onload = () => {
+      this.toolInstance.setImgNode(image);
+      this.toolInstance.initImgPos();
+    };
+    this.pointCloud2dOperation.setCanvasSize(size);
+  }
+  addPolygonListOnTopView(result) {
+    const pointCloudDataList = lbUtils.PointCloudUtils.getBoxParamsFromResultList(result);
+    const polygonList = lbUtils.PointCloudUtils.getPolygonListFromResultList(result);
+    this.updatePolygonList(pointCloudDataList, polygonList);
+  }
+  addLineListOnTopView(result) {
+    const lineList = lbUtils.PointCloudUtils.getLineListFromResultList(result);
+    this.updateLineList(lineList);
+  }
+  addPointListOnTopView(result) {
+    const sphereList = lbUtils.PointCloudUtils.getSphereParamsFromResultList(result);
+    this.updatePointList(sphereList);
+  }
+  updateData(pcdPath, result, config) {
+    if (!this.toolInstance || !this.pointCloudInstance) {
+      return;
+    }
+    this.pointCloudInstance.loadPCDFile(pcdPath, config == null ? void 0 : config.radius);
+    this.addPolygonListOnTopView(result);
+    this.addLineListOnTopView(result);
+    this.addPointListOnTopView(result);
+  }
+  switchToCanvas(toolName) {
+    const newInstance = this.toolScheduler.switchToCanvas(toolName);
+    if (newInstance) {
+      newInstance.eventBinding();
+      this.toolInstance = newInstance;
+      return newInstance;
+    }
+    return this.toolInstance;
+  }
+  initAllPosition() {
+    this.pointCloudInstance.updateTopCamera();
+    this.pointCloud2dOperation.initPosition();
+  }
+  clearAllData() {
+    this.pointCloudInstance.clearPointCloudAndRender();
+    this.pointCloud2dOperation.clearResult();
+  }
+}
+
+exports.PointCloudAnnotation = PointCloudAnnotation;

package/dist/core/pointCloud/cache.js

@@ -1 +1,53 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var PCDLoader=require("./PCDLoader.js");class PointCloudCache{constructor(){this.MAX_SIZE=50,this.cacheList=[],this.loadPCDFile=t=>new Promise((s,n)=>{const o=this.pointsMap.get(t),i=this.colorMap.get(t);if(o&&i){s({points:o,color:i});return}if(this.cacheList.length>this.MAX_SIZE){const e=this.cacheList.shift();e&&this.pointsMap.delete(e.src)}this.cacheList.push({src:t}),this.pcdLoader.load(t,e=>{const r=e.geometry.attributes.position.array,a=e.geometry.attributes.color.array;this.pointsMap.set(t,r),this.colorMap.set(t,a),s({points:r,color:a})},()=>{},e=>{n(e)})}),this.pcdLoader=new PCDLoader.PCDLoader,this.pointsMap=new Map,this.colorMap=new Map}static getInstance(){return this.instance==null&&(this.instance=new PointCloudCache),this.instance}updateColor(t,s){this.colorMap.set(t,s)}}exports.PointCloudCache=PointCloudCache;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var PCDLoader = require('./PCDLoader.js');
+
+class PointCloudCache {
+  constructor() {
+    this.MAX_SIZE = 50;
+    this.cacheList = [];
+    this.loadPCDFile = (src) => {
+      return new Promise((resolve, reject) => {
+        const clonePoints = this.pointsMap.get(src);
+        const cloneColor = this.colorMap.get(src);
+        if (clonePoints && cloneColor) {
+          resolve({points: clonePoints, color: cloneColor});
+          return;
+        }
+        if (this.cacheList.length > this.MAX_SIZE) {
+          const firstCacheInfo = this.cacheList.shift();
+          if (firstCacheInfo) {
+            this.pointsMap.delete(firstCacheInfo.src);
+          }
+        }
+        this.cacheList.push({src});
+        this.pcdLoader.load(src, (points) => {
+          const pointsArray = points.geometry.attributes.position.array;
+          const colorArray = points.geometry.attributes.color.array;
+          this.pointsMap.set(src, pointsArray);
+          this.colorMap.set(src, colorArray);
+          resolve({points: pointsArray, color: colorArray});
+        }, () => {
+        }, (err) => {
+          reject(err);
+        });
+      });
+    };
+    this.pcdLoader = new PCDLoader.PCDLoader();
+    this.pointsMap = new Map();
+    this.colorMap = new Map();
+  }
+  static getInstance() {
+    if (this.instance == null) {
+      this.instance = new PointCloudCache();
+    }
+    return this.instance;
+  }
+  updateColor(src, color) {
+    this.colorMap.set(src, color);
+  }
+}
+
+exports.PointCloudCache = PointCloudCache;