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

package/es/core/pointCloud/PCDLoader.js

@@ -1,2 +1,256 @@
-import{Loader as z,FileLoader as C,LoaderUtils as v,BufferGeometry as _,Float32BufferAttribute as F,PointsMaterial as b,Points as L}from"three";import{COLOR_MAP_JET as B}from"@labelbee/lb-utils";class I extends z{constructor(a){super(a);this.littleEndian=!0}load(a,c,h,g){const i=this,l=new C(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(f){g?g(f):console.error(f),i.manager.itemError(a)}},h,g)}parse(a){function c(o,t){const p=o.length,n=new Uint8Array(t);let r=0,e=0,s,w,u;do if(s=o[r++],s<1<<5){if(s++,e+s>t)throw new Error("Output buffer is not large enough");if(r+s>p)throw new Error("Invalid compressed data");do n[e++]=o[r++];while(--s)}else{if(w=s>>5,u=e-((s&31)<<8)-1,r>=p)throw new Error("Invalid compressed data");if(w===7&&(w+=o[r++],r>=p))throw new Error("Invalid compressed data");if(u-=o[r++],e+w+2>t)throw new Error("Output buffer is not large enough");if(u<0)throw new Error("Invalid compressed data");if(u>=e)throw new Error("Invalid compressed data");do n[e++]=n[u++];while(--w+2)}while(r<p);return n}function h(o){const t={},p=o.search(/[\n\r]data\s(\S*)\s/i),n=/[\n\r]data\s(\S*)\s/i.exec(o.slice(p-1));if(t.data=n[1],t.headerLen=n[0].length+p,t.str=o.slice(0,t.headerLen),t.str=t.str.replace(/#.*/gi,""),t.version=/version (.*)/i.exec(t.str),t.fields=/fields (.*)/i.exec(t.str),t.size=/size (.*)/i.exec(t.str),t.type=/type (.*)/i.exec(t.str),t.count=/count (.*)/i.exec(t.str),t.width=/width (.*)/i.exec(t.str),t.height=/height (.*)/i.exec(t.str),t.viewpoint=/viewpoint (.*)/i.exec(t.str),t.points=/points (.*)/i.exec(t.str),t.version!==null&&(t.version=parseFloat(t.version[1])),t.fields=t.fields!==null?t.fields[1].split(" "):[],t.type!==null&&(t.type=t.type[1].split(" ")),t.width!==null&&(t.width=parseInt(t.width[1])),t.height!==null&&(t.height=parseInt(t.height[1])),t.viewpoint!==null&&(t.viewpoint=t.viewpoint[1]),t.points!==null&&(t.points=parseInt(t.points[1],10)),t.points===null&&(t.points=t.width*t.height),t.size!==null&&(t.size=t.size[1].split(" ").map(function(e){return parseInt(e,10)})),t.count!==null)t.count=t.count[1].split(" ").map(function(e){return parseInt(e,10)});else{t.count=[];for(let e=0,s=t.fields.length;e<s;e++)t.count.push(1)}t.offset={};let r=0;for(let e=0,s=t.fields.length;e<s;e++)t.data==="ascii"?t.offset[t.fields[e]]=e:(t.offset[t.fields[e]]=r,r+=t.size[e]*t.count[e]);return t.rowSize=r,t}const g=v.decodeText(new Uint8Array(a)),i=h(g),l=[],d=[],f=[];if(i.data==="ascii"){const{offset:o}=i,p=g.slice(i.headerLen).split(`
-`);for(let n=0,r=p.length;n<r;n++){if(p[n]==="")continue;const e=p[n].split(" ");if(o.x!==void 0&&(l.push(parseFloat(e[o.x])),l.push(parseFloat(e[o.y])),l.push(parseFloat(e[o.z]))),this.genColorByZ){const w=this.genColorByZ(parseFloat(e[o.x]),parseFloat(e[o.y]),parseFloat(e[o.z])).map(u=>u/255);f.push(...w)}o.normal_x!==void 0&&(d.push(parseFloat(e[o.normal_x])),d.push(parseFloat(e[o.normal_y])),d.push(parseFloat(e[o.normal_z])))}}if(i.data==="binary_compressed"){const o=new Uint32Array(a.slice(i.headerLen,i.headerLen+8)),t=o[0],p=o[1],n=c(new Uint8Array(a,i.headerLen+8,t),p),r=new DataView(n.buffer),{offset:e}=i;for(let s=0;s<i.points;s++)if(e.x!==void 0&&(l.push(r.getFloat32(i.points*e.x+i.size[0]*s,this.littleEndian)),l.push(r.getFloat32(i.points*e.y+i.size[1]*s,this.littleEndian)),l.push(r.getFloat32(i.points*e.z+i.size[2]*s,this.littleEndian))),e.normal_x!==void 0&&(d.push(r.getFloat32(i.points*e.normal_x+i.size[4]*s,this.littleEndian)),d.push(r.getFloat32(i.points*e.normal_y+i.size[5]*s,this.littleEndian)),d.push(r.getFloat32(i.points*e.normal_z+i.size[6]*s,this.littleEndian))),this.genColorByZ){const u=this.genColorByZ(r.getFloat32(i.points*e.x+i.size[0]*s,this.littleEndian),r.getFloat32(i.points*e.y+i.size[0]*s,this.littleEndian),r.getFloat32(i.points*e.z+i.size[0]*s,this.littleEndian)).map(E=>E/255);f.push(...u)}}if(i.data==="binary"){const o=new DataView(a,i.headerLen),{offset:t}=i;for(let p=0,n=0;p<i.points;p++,n+=i.rowSize)if(t.x!==void 0&&(l.push(o.getFloat32(n+t.x,this.littleEndian)),l.push(o.getFloat32(n+t.y,this.littleEndian)),l.push(o.getFloat32(n+t.z,this.littleEndian))),t.normal_x!==void 0&&(d.push(o.getFloat32(n+t.normal_x,this.littleEndian)),d.push(o.getFloat32(n+t.normal_y,this.littleEndian)),d.push(o.getFloat32(n+t.normal_z,this.littleEndian))),this.genColorByZ){const e=this.genColorByZ(o.getFloat32(n+t.x,this.littleEndian),o.getFloat32(n+t.y,this.littleEndian),o.getFloat32(n+t.z,this.littleEndian)).map(s=>s/255);f.push(...e)}}const x=new _;l.length>0&&x.setAttribute("position",new F(l,3)),d.length>0&&x.setAttribute("normal",new F(d,3)),f.length>0&&x.setAttribute("color",new F(f,3)),x.computeBoundingSphere();const y=new b({size:.01});return f.length>0?y.vertexColors=!0:y.color.setHex(16777215),new L(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=Z(h),i=B[g];return[i[0],i[1],i[2]]}}function Z(m){const a=-7,c=3,h=c-a;return m<a&&(m=a),m>c&&(m=c),Math.floor((m-a)/h*255)}export{I as PCDLoader};
+import { Loader, FileLoader, LoaderUtils, BufferGeometry, Float32BufferAttribute, PointsMaterial, Points } from 'three';
+import { COLOR_MAP_JET } from '@labelbee/lb-utils';
+
+class PCDLoader extends Loader {
+  constructor(manager) {
+    super(manager);
+    this.littleEndian = true;
+  }
+  load(url, onLoad, onProgress, onError) {
+    const scope = this;
+    const loader = new 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 = 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 BufferGeometry();
+    if (position.length > 0)
+      geometry.setAttribute("position", new Float32BufferAttribute(position, 3));
+    if (normal.length > 0)
+      geometry.setAttribute("normal", new Float32BufferAttribute(normal, 3));
+    if (color.length > 0)
+      geometry.setAttribute("color", new Float32BufferAttribute(color, 3));
+    geometry.computeBoundingSphere();
+    const material = new PointsMaterial({size: 0.01});
+    if (color.length > 0) {
+      material.vertexColors = true;
+    } else {
+      material.color.setHex(16777215);
+    }
+    return new 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 = 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);
+}
+
+export { PCDLoader };

package/es/core/pointCloud/annotation.js

@@ -1 +1,211 @@
-import{PointCloudUtils as d}from"@labelbee/lb-utils";import{EToolName as h,EPolygonPattern as T}from"../../constant/tool.js";import{CanvasScheduler as R}from"../../newCore/CanvasScheduler.js";import{PointCloud as j}from"./index.js";import{ToolScheduler as B,HybridToolUtils as E}from"../scheduler.js";var A=Object.defineProperty,V=Object.defineProperties,F=Object.getOwnPropertyDescriptors,y=Object.getOwnPropertySymbols,N=Object.prototype.hasOwnProperty,x=Object.prototype.propertyIsEnumerable,w=(n,t,o)=>t in n?A(n,t,{enumerable:!0,configurable:!0,writable:!0,value:o}):n[t]=o,g=(n,t)=>{for(var o in t||(t={}))N.call(t,o)&&w(n,o,t[o]);if(y)for(var o of y(t))x.call(t,o)&&w(n,o,t[o]);return n},m=(n,t)=>V(n,F(t));const S=n=>{const t=document.createElement("canvas");t.width=n.width,t.height=n.height;const o=t.getContext("2d");return o?(o.fillStyle="black",o.fillRect(0,0,n.width,n.height),t.toDataURL()):""};class U{constructor({size:t,container:o,pcdPath:a,extraProps:L,config:O,checkMode:_,toolName:c}){this.updateLineList=s=>{const l=s.map(i=>{var e;return m(g({},i),{pointList:(e=i==null?void 0:i.pointList)==null?void 0:e.map(r=>d.transferWorld2Canvas(r,this.toolInstance.size))})});this.toolScheduler.updateDataByToolName(h.Line,l)},this.updatePolygonList=(s,l)=>{let i=s.map(e=>{var r;const{polygon2d:I}=this.pointCloudInstance.getBoxTopPolygon2DCoordinate(e);return{id:e.id,sourceID:"",pointList:I,isRect:!0,valid:(r=e.valid)!=null?r:!0,attribute:e.attribute}});l&&(i=i.concat(l.map(e=>{var r;return m(g({},e),{pointList:(r=e==null?void 0:e.pointList)==null?void 0:r.map(I=>d.transferWorld2Canvas(I,this.toolInstance.size))})}))),this.toolScheduler.updateDataByToolName(h.PointCloudPolygon,i)},this.updatePointList=s=>{const l=s==null?void 0:s.map(i=>{var e;const{point2d:r}=this.pointCloudInstance.getSphereTopPoint2DCoordinate(i);return m(g({},r),{id:i.id,sourceID:"",valid:(e=i.valid)!=null?e:!0,attribute:i.attribute,textAttribute:""})});this.toolScheduler.updateDataByToolName(h.Point,l)};const b=this.getDefaultOrthographic(t),D=S(t),p=new Image;p.src=D;const C=new B({container:o,size:t,toolName:c}),v=new R({container:o}),f=new j({container:o,noAppend:!0,isOrthographicCamera:!0,orthographicParams:b});a&&f.loadPCDFile(a),v.createCanvas(f.renderer.domElement);const P={size:t,config:JSON.stringify(m(g({},O),{attributeConfigurable:!0,hideAttribute:!0})),imgNode:p,checkMode:_};L&&Object.assign(P,L);let u=[];E.isSingleTool(c)?u=[c]:u=c,u.forEach((s,l)=>{let i;if(s===h.PointCloudPolygon){const e=C.createOperation(s,p,P);e.eventBinding(),e.setPattern(T.Rect),this.toolInstance=e,this.toolInstance.eventBinding(),this.pointCloud2dOperation=e}else i=C.createOperation(s,p,P);l===u.length-1&&(this.toolInstance||(this.toolInstance=i,this.toolInstance.eventBinding()))}),this.pointCloudInstance=f,this.canvasScheduler=v,this.toolScheduler=C,this.config=O}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 o=S(t),a=new Image;a.src=o,a.onload=()=>{this.toolInstance.setImgNode(a),this.toolInstance.initImgPos()},this.pointCloud2dOperation.setCanvasSize(t)}addPolygonListOnTopView(t){const o=d.getBoxParamsFromResultList(t),a=d.getPolygonListFromResultList(t);this.updatePolygonList(o,a)}addLineListOnTopView(t){const o=d.getLineListFromResultList(t);this.updateLineList(o)}addPointListOnTopView(t){const o=d.getSphereParamsFromResultList(t);this.updatePointList(o)}updateData(t,o,a){!this.toolInstance||!this.pointCloudInstance||(this.pointCloudInstance.loadPCDFile(t,a==null?void 0:a.radius),this.addPolygonListOnTopView(o),this.addLineListOnTopView(o),this.addPointListOnTopView(o))}switchToCanvas(t){const o=this.toolScheduler.switchToCanvas(t);return o?(o.eventBinding(),this.toolInstance=o,o):this.toolInstance}initAllPosition(){this.pointCloudInstance.updateTopCamera(),this.pointCloud2dOperation.initPosition()}clearAllData(){this.pointCloudInstance.clearPointCloudAndRender(),this.pointCloud2dOperation.clearResult()}}export{U as PointCloudAnnotation};
+import { PointCloudUtils } from '@labelbee/lb-utils';
+import { EToolName, EPolygonPattern } from '../../constant/tool.js';
+import { CanvasScheduler } from '../../newCore/CanvasScheduler.js';
+import { PointCloud } from './index.js';
+import { ToolScheduler, HybridToolUtils } from '../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) => PointCloudUtils.transferWorld2Canvas(point, this.toolInstance.size))
+        });
+      });
+      this.toolScheduler.updateDataByToolName(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) => PointCloudUtils.transferWorld2Canvas(point, this.toolInstance.size))
+          });
+        }));
+      }
+      this.toolScheduler.updateDataByToolName(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(EToolName.Point, pointList);
+    };
+    const defaultOrthographic = this.getDefaultOrthographic(size);
+    const imgSrc = createEmptyImage(size);
+    const image = new Image();
+    image.src = imgSrc;
+    const toolScheduler = new ToolScheduler({container, size, toolName});
+    const canvasScheduler = new CanvasScheduler({container});
+    const pointCloud = new 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 (HybridToolUtils.isSingleTool(toolName)) {
+      toolList = [toolName];
+    } else {
+      toolList = toolName;
+    }
+    toolList.forEach((tool, i) => {
+      let toolInstance;
+      if (tool === EToolName.PointCloudPolygon) {
+        const pointCloudPolygonOperation = toolScheduler.createOperation(tool, image, defaultProps);
+        pointCloudPolygonOperation.eventBinding();
+        pointCloudPolygonOperation.setPattern(EPolygonPattern.Rect);
+        this.toolInstance = pointCloudPolygonOperation;
+        this.toolInstance.eventBinding();
+        this.pointCloud2dOperation = pointCloudPolygonOperation;
+      } else {
+        toolInstance = toolScheduler.createOperation(tool, 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 = PointCloudUtils.getBoxParamsFromResultList(result);
+    const polygonList = PointCloudUtils.getPolygonListFromResultList(result);
+    this.updatePolygonList(pointCloudDataList, polygonList);
+  }
+  addLineListOnTopView(result) {
+    const lineList = PointCloudUtils.getLineListFromResultList(result);
+    this.updateLineList(lineList);
+  }
+  addPointListOnTopView(result) {
+    const sphereList = 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();
+  }
+}
+
+export { PointCloudAnnotation };

package/es/core/pointCloud/cache.js

@@ -1 +1,49 @@
-import{PCDLoader as h}from"./PCDLoader.js";class i{constructor(){this.MAX_SIZE=50,this.cacheList=[],this.loadPCDFile=t=>new Promise((s,c)=>{const e=this.pointsMap.get(t),a=this.colorMap.get(t);if(e&&a){s({points:e,color:a});return}if(this.cacheList.length>this.MAX_SIZE){const o=this.cacheList.shift();o&&this.pointsMap.delete(o.src)}this.cacheList.push({src:t}),this.pcdLoader.load(t,o=>{const n=o.geometry.attributes.position.array,r=o.geometry.attributes.color.array;this.pointsMap.set(t,n),this.colorMap.set(t,r),s({points:n,color:r})},()=>{},o=>{c(o)})}),this.pcdLoader=new h,this.pointsMap=new Map,this.colorMap=new Map}static getInstance(){return this.instance==null&&(this.instance=new i),this.instance}updateColor(t,s){this.colorMap.set(t,s)}}export{i as PointCloudCache};
+import { PCDLoader } from './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();
+    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);
+  }
+}
+
+export { PointCloudCache };