class Version {
  constructor(version) {
    this.version = version;
    var vmLength = version.indexOf('.') === -1 ? version.length : version.indexOf('.');
    this.versionMajor = parseInt(version.substr(0, vmLength));
    this.versionMinor = parseInt(version.substr(vmLength + 1));
    if (this.versionMinor.length === 0) {
      this.versionMinor = 0;
    }
  }
  newerThan(version) {
    var v = new Version(version);
    if (this.versionMajor > v.versionMajor) {
      return true;
    } else if (this.versionMajor === v.versionMajor && this.versionMinor > v.versionMinor) {
      return true;
    } else {
      return false;
    }
  }
  equalOrHigher(version) {
    var v = new Version(version);
    if (this.versionMajor > v.versionMajor) {
      return true;
    } else if (this.versionMajor === v.versionMajor && this.versionMinor >= v.versionMinor) {
      return true;
    } else {
      return false;
    }
  }
  upTo(version) {
    return !this.newerThan(version);
  }
}

/**
 * Some types of possible point attribute data formats
 *
 * @class
 */
var PointAttributeTypes = {
  DATA_TYPE_DOUBLE: {
    ordinal: 0,
    name: "double",
    size: 8
  },
  DATA_TYPE_FLOAT: {
    ordinal: 1,
    name: "float",
    size: 4
  },
  DATA_TYPE_INT8: {
    ordinal: 2,
    name: "int8",
    size: 1
  },
  DATA_TYPE_UINT8: {
    ordinal: 3,
    name: "uint8",
    size: 1
  },
  DATA_TYPE_INT16: {
    ordinal: 4,
    name: "int16",
    size: 2
  },
  DATA_TYPE_UINT16: {
    ordinal: 5,
    name: "uint16",
    size: 2
  },
  DATA_TYPE_INT32: {
    ordinal: 6,
    name: "int32",
    size: 4
  },
  DATA_TYPE_UINT32: {
    ordinal: 7,
    name: "uint32",
    size: 4
  },
  DATA_TYPE_INT64: {
    ordinal: 8,
    name: "int64",
    size: 8
  },
  DATA_TYPE_UINT64: {
    ordinal: 9,
    name: "uint64",
    size: 8
  }
};
var i = 0;
for (var obj in PointAttributeTypes) {
  PointAttributeTypes[i] = PointAttributeTypes[obj];
  i++;
}
class PointAttribute {
  constructor(name, type, numElements) {
    this.name = name;
    this.type = type;
    this.numElements = numElements;
    this.byteSize = this.numElements * this.type.size;
    this.description = "";
    this.range = [Infinity, -Infinity];
  }
}
PointAttribute.POSITION_CARTESIAN = new PointAttribute("POSITION_CARTESIAN", PointAttributeTypes.DATA_TYPE_FLOAT, 3);
PointAttribute.RGBA_PACKED = new PointAttribute("COLOR_PACKED", PointAttributeTypes.DATA_TYPE_INT8, 4);
PointAttribute.COLOR_PACKED = PointAttribute.RGBA_PACKED;
PointAttribute.RGB_PACKED = new PointAttribute("COLOR_PACKED", PointAttributeTypes.DATA_TYPE_INT8, 3);
PointAttribute.NORMAL_FLOATS = new PointAttribute("NORMAL_FLOATS", PointAttributeTypes.DATA_TYPE_FLOAT, 3);
PointAttribute.INTENSITY = new PointAttribute("INTENSITY", PointAttributeTypes.DATA_TYPE_UINT16, 1);
PointAttribute.CLASSIFICATION = new PointAttribute("CLASSIFICATION", PointAttributeTypes.DATA_TYPE_UINT8, 1);
PointAttribute.NORMAL_SPHEREMAPPED = new PointAttribute("NORMAL_SPHEREMAPPED", PointAttributeTypes.DATA_TYPE_UINT8, 2);
PointAttribute.NORMAL_OCT16 = new PointAttribute("NORMAL_OCT16", PointAttributeTypes.DATA_TYPE_UINT8, 2);
PointAttribute.NORMAL = new PointAttribute("NORMAL", PointAttributeTypes.DATA_TYPE_FLOAT, 3);
PointAttribute.RETURN_NUMBER = new PointAttribute("RETURN_NUMBER", PointAttributeTypes.DATA_TYPE_UINT8, 1);
PointAttribute.NUMBER_OF_RETURNS = new PointAttribute("NUMBER_OF_RETURNS", PointAttributeTypes.DATA_TYPE_UINT8, 1);
PointAttribute.SOURCE_ID = new PointAttribute("SOURCE_ID", PointAttributeTypes.DATA_TYPE_UINT16, 1);
PointAttribute.INDICES = new PointAttribute("INDICES", PointAttributeTypes.DATA_TYPE_UINT32, 1);
PointAttribute.SPACING = new PointAttribute("SPACING", PointAttributeTypes.DATA_TYPE_FLOAT, 1);
PointAttribute.GPS_TIME = new PointAttribute("GPS_TIME", PointAttributeTypes.DATA_TYPE_DOUBLE, 1);

/* import {Splat} from '../custom/objects/3dgs/Splat.js'  //暂时用不到
 import {MathUtils,Vector3,Quaternion} from "../../libs/three.js/build/three.module.js"; 
引用THREE的任何东西过来都会在打包时把THREE.js压缩进去，导致文件过大。所以是否要在此重写用到的类*/

var typedArrayMapping = {
  "int8": Int8Array,
  "int16": Int16Array,
  "int32": Int32Array,
  "int64": Float64Array,
  "uint8": Uint8Array,
  "uint16": Uint16Array,
  "uint32": Uint32Array,
  "uint64": Float64Array,
  "float": Float32Array,
  "double": Float64Array
};
var gs3dProplist = ['f_dc_0',
//color
'f_dc_1', 'f_dc_2', 'f_rest_0',
// has sh if not null  at origin inriav1parser.js
'f_rest_1', 'f_rest_2', 'f_rest_3', 'f_rest_4', 'f_rest_5', 'f_rest_6', 'f_rest_7', 'f_rest_8', 'f_rest_9', 'f_rest_10', 'f_rest_11', 'f_rest_12', 'f_rest_13', 'f_rest_14', 'f_rest_15', 'f_rest_16', 'f_rest_17', 'f_rest_18', 'f_rest_19', 'f_rest_20', 'f_rest_21', 'f_rest_22', 'f_rest_23', 'f_rest_24', 'f_rest_25', 'f_rest_26', 'f_rest_27', 'f_rest_28', 'f_rest_29', 'f_rest_30', 'f_rest_31', 'f_rest_32', 'f_rest_33', 'f_rest_34', 'f_rest_35', 'f_rest_36', 'f_rest_37', 'f_rest_38', 'f_rest_39', 'f_rest_40', 'f_rest_41', 'f_rest_42', 'f_rest_43', 'f_rest_44', 'opacity', 'scale_0', 'scale_1', 'scale_2', 'rot_0', 'rot_1', 'rot_2', 'rot_3'];
Potree = {};
onmessage = function onmessage(event) {
  performance.mark("binary-decoder-start");
  var buffer = event.data.buffer;
  var pointAttributes = event.data.pointAttributes;
  var numPoints = buffer.byteLength / pointAttributes.byteSize;
  var view = new DataView(buffer);
  var version = new Version(event.data.version);
  var nodeOffset = event.data.offset;
  var scale = event.data.scale;
  var spacing = event.data.spacing;
  var hasChildren = event.data.hasChildren;
  var name = event.data.name;
  var tightBoxMin = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
  var tightBoxMax = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
  var mean = [0, 0, 0];
  var pos = event.data.min; // add geometryNode.sceneNode.position  node的偏移

  var attributeBuffers = {};
  var inOffset = 0;
  var hasGS3D = pointAttributes.attributes.some(e => e.name == 'GS3D');
  var _loop = function _loop(pointAttribute) {
    if (pointAttribute.name === "POSITION_CARTESIAN") {
      var _buff = new ArrayBuffer(numPoints * 4 * 3);
      var positions = new Float32Array(_buff);
      for (var _j = 0; _j < numPoints; _j++) {
        var x = void 0,
          y = void 0,
          z = void 0;
        if (version.newerThan('1.3')) {
          x = view.getUint32(inOffset + _j * pointAttributes.byteSize + 0, true) * scale;
          y = view.getUint32(inOffset + _j * pointAttributes.byteSize + 4, true) * scale;
          z = view.getUint32(inOffset + _j * pointAttributes.byteSize + 8, true) * scale;
        } else {
          x = view.getFloat32(_j * pointAttributes.byteSize + 0, true) + nodeOffset[0];
          y = view.getFloat32(_j * pointAttributes.byteSize + 4, true) + nodeOffset[1];
          z = view.getFloat32(_j * pointAttributes.byteSize + 8, true) + nodeOffset[2];
        }
        positions[3 * _j + 0] = x;
        positions[3 * _j + 1] = y;
        positions[3 * _j + 2] = z;
        mean[0] += x / numPoints;
        mean[1] += y / numPoints;
        mean[2] += z / numPoints;
        tightBoxMin[0] = Math.min(tightBoxMin[0], x);
        tightBoxMin[1] = Math.min(tightBoxMin[1], y);
        tightBoxMin[2] = Math.min(tightBoxMin[2], z);
        tightBoxMax[0] = Math.max(tightBoxMax[0], x);
        tightBoxMax[1] = Math.max(tightBoxMax[1], y);
        tightBoxMax[2] = Math.max(tightBoxMax[2], z);
      }
      attributeBuffers[pointAttribute.name] = {
        buffer: _buff,
        attribute: pointAttribute
      };
      if (hasGS3D) {
        //add 
        var buff2 = new ArrayBuffer(numPoints * 4 * 4);
        var buff3 = new ArrayBuffer(numPoints * 4 * 4);
        var centersInt = new Int32Array(buff2);
        var centersFloat = new Float32Array(buff3);
        for (var _i = 0; _i < numPoints; _i++) {
          centersFloat[4 * _i + 0] = positions[3 * _i + 0] + pos[0];
          centersFloat[4 * _i + 1] = positions[3 * _i + 1] + pos[1];
          centersFloat[4 * _i + 2] = positions[3 * _i + 2] + pos[2];
          centersFloat[4 * _i + 3] = 1;
          centersInt[4 * _i + 0] = centersFloat[4 * _i + 0] * 1000;
          centersInt[4 * _i + 1] = centersFloat[4 * _i + 1] * 1000;
          centersInt[4 * _i + 2] = centersFloat[4 * _i + 2] * 1000;
          centersInt[4 * _i + 3] = 1000;
        }
        attributeBuffers['centersInt'] = {
          buffer: buff2,
          attribute: pointAttribute
        };
        attributeBuffers['centersFloat'] = {
          buffer: buff3,
          attribute: pointAttribute
        }; //暂时必须4位，以后再改cpp改为3位
      }
    } else if (pointAttribute.name === "rgba") {
      var _buff2 = new ArrayBuffer(numPoints * 4);
      var colors = new Uint8Array(_buff2);
      for (var _j2 = 0; _j2 < numPoints; _j2++) {
        colors[4 * _j2 + 0] = view.getUint8(inOffset + _j2 * pointAttributes.byteSize + 0);
        colors[4 * _j2 + 1] = view.getUint8(inOffset + _j2 * pointAttributes.byteSize + 1);
        colors[4 * _j2 + 2] = view.getUint8(inOffset + _j2 * pointAttributes.byteSize + 2);
      }
      attributeBuffers[pointAttribute.name] = {
        buffer: _buff2,
        attribute: pointAttribute
      };
    } else if (pointAttribute.name === "NORMAL_SPHEREMAPPED") {
      var _buff3 = new ArrayBuffer(numPoints * 4 * 3);
      var normals = new Float32Array(_buff3);
      for (var _j3 = 0; _j3 < numPoints; _j3++) {
        var bx = view.getUint8(inOffset + _j3 * pointAttributes.byteSize + 0);
        var by = view.getUint8(inOffset + _j3 * pointAttributes.byteSize + 1);
        var ex = bx / 255;
        var ey = by / 255;
        var nx = ex * 2 - 1;
        var ny = ey * 2 - 1;
        var nz = 1;
        var nw = -1;
        var l = nx * -nx + ny * -ny + nz * -nw;
        nz = l;
        nx = nx * Math.sqrt(l);
        ny = ny * Math.sqrt(l);
        nx = nx * 2;
        ny = ny * 2;
        nz = nz * 2 - 1;
        normals[3 * _j3 + 0] = nx;
        normals[3 * _j3 + 1] = ny;
        normals[3 * _j3 + 2] = nz;
      }
      attributeBuffers[pointAttribute.name] = {
        buffer: _buff3,
        attribute: pointAttribute
      };
    } else if (pointAttribute.name === "NORMAL_OCT16") {
      //只需要2 byte！ 原本需要12个byte
      var _buff4 = new ArrayBuffer(numPoints * 4 * 3);
      var _normals = new Float32Array(_buff4);
      for (var _j4 = 0; _j4 < numPoints; _j4++) {
        var _bx = view.getUint8(inOffset + _j4 * pointAttributes.byteSize + 0);
        var _by = view.getUint8(inOffset + _j4 * pointAttributes.byteSize + 1);
        var u = _bx / 255 * 2 - 1;
        var v = _by / 255 * 2 - 1;
        var _z = 1 - Math.abs(u) - Math.abs(v);
        var _x = 0;
        var _y = 0;
        if (_z >= 0) {
          _x = u;
          _y = v;
        } else {
          _x = -(v / Math.sign(v) - 1) / Math.sign(u);
          _y = -(u / Math.sign(u) - 1) / Math.sign(v);
        }
        var length = Math.sqrt(_x * _x + _y * _y + _z * _z); //因法线长度固定为1，所以只需要xy就能算出z（不过这里似乎是约定相加为1？）
        _x = _x / length; //x和y都只有一个byte，所以精度很低，只有256个分段            
        _y = _y / length;
        _z = _z / length;
        _normals[3 * _j4 + 0] = _x;
        _normals[3 * _j4 + 1] = _y;
        _normals[3 * _j4 + 2] = _z;
      }
      attributeBuffers[pointAttribute.name] = {
        buffer: _buff4,
        attribute: pointAttribute
      };
    } else if (pointAttribute.name === "NORMAL") {
      var _buff5 = new ArrayBuffer(numPoints * 4 * 3);
      var _normals2 = new Float32Array(_buff5);
      for (var _j5 = 0; _j5 < numPoints; _j5++) {
        var _x2 = view.getFloat32(inOffset + _j5 * pointAttributes.byteSize + 0, true);
        var _y2 = view.getFloat32(inOffset + _j5 * pointAttributes.byteSize + 4, true);
        var _z2 = view.getFloat32(inOffset + _j5 * pointAttributes.byteSize + 8, true);
        _normals2[3 * _j5 + 0] = _x2;
        _normals2[3 * _j5 + 1] = _y2;
        _normals2[3 * _j5 + 2] = _z2;
      }
      attributeBuffers[pointAttribute.name] = {
        buffer: _buff5,
        attribute: pointAttribute
      };
    } else if (pointAttribute.name === "IR" || pointAttribute.name === "TEMP") {
      //温度   ir是热成像的温度 temp是AI识别的温度

      var _buff6 = new ArrayBuffer(numPoints * 4); //原本数据是uint16但是shader没办法接收，只能转了
      var _f = new Float32Array(_buff6); //according to pointAttribute.type.name, 取值范围为 0 到 65535。
      var min = Infinity,
        max = -Infinity,
        _v;
      for (var _j6 = 0; _j6 < numPoints; _j6++) {
        //仿照position的写法 填入数据 
        _f[_j6] = _v = view.getUint16(inOffset + _j6 * pointAttributes.byteSize, true) / 10; //开尔文 
        _v != 0 && (min = Math.min(min, _v)); //==0可能是没探测到所以跳过
        _v != 0 && (max = Math.max(max, _v));
      } //ir or temp 里面的值除以10就是开尔文温度 
      attributeBuffers[pointAttribute.name] = {
        buffer: _buff6,
        attribute: pointAttribute
      };
      pointAttribute.range = [min, max]; //但每个geo范围不一样
    } else if (pointAttribute.name === "SEG") {
      //类型
      /* 
      1: concrete
      2: wood
      3: metal
      4: glass
      5: plastic
      6: electric_wire 
       */
      var _buff7 = new ArrayBuffer(numPoints * 4);
      var _f2 = new Float32Array(_buff7); //according to pointAttribute.type.name, 取值范围为 0 到 65535。

      for (var _j7 = 0; _j7 < numPoints; _j7++) {
        //仿照position的写法 填入数据 
        _f2[_j7] = view.getUint16(inOffset + _j7 * pointAttributes.byteSize, true);
      } //ir or temp 里面的值除以10就是开尔文温度哈
      attributeBuffers[pointAttribute.name] = {
        buffer: _buff7,
        attribute: pointAttribute
      };
    } else if (pointAttribute.name === "GS3D") {
      //add  见inriav1plyparser.js
      //////////////////////////////////////////////////////////
      var _buff8 = new ArrayBuffer(numPoints * pointAttribute.byteSize);
      var _f3 = new Float32Array(_buff8);
      for (var _j8 = 0; _j8 < numPoints; _j8++) {
        //仿照position的写法 填入数据
        for (var _i2 = 0; _i2 < pointAttribute.numElements; _i2++) {
          //f32[pointAttribute.numElements * j + i] = view.getUint32( inOffset + j * pointAttributes.byteSize + 4*i, true) * scale   ;
          _f3[pointAttribute.numElements * _j8 + _i2] = view.getFloat32(inOffset + _j8 * pointAttributes.byteSize + 4 * _i2, true); //+ nodeOffset[0];
          //是Uint32还是Float32？ PlyParserUtils.js中写的是getFloat32 （    rawVertex[fieldId] = vertexData.getFloat32(offset + fieldOffsets[fieldId], true);）
        }
      }
      attributeBuffers[pointAttribute.name] = {
        buffer: _buff8,
        attribute: pointAttribute
      };

      //得到颜色

      var _buff9 = new ArrayBuffer(numPoints * 4);
      var _colors = new Uint8Array(_buff9);
      var SH_C0 = 0.28209479177387814;
      var offset_opa = gs3dProplist.indexOf('opacity');
      var offset_col = gs3dProplist.indexOf('f_dc_0');
      var getColor = index => {
        var value = (0.5 + SH_C0 * _f3[index + offset_col]) * 255;
        return MathUtils.clamp(Math.floor(value), 0, 255);
      };
      var getOpacity = index => {
        var value = 1 / (1 + Math.exp(-_f3[index + offset_opa])) * 255;
        return THREE.MathUtils.clamp(Math.floor(value), 0, 255);
      };
      for (var _j9 = 0; _j9 < numPoints; _j9++) {
        _colors[4 * _j9 + 0] = getColor(_j9 * pointAttribute.numElements + 0);
        _colors[4 * _j9 + 1] = getColor(_j9 * pointAttribute.numElements + 1);
        _colors[4 * _j9 + 2] = getColor(_j9 * pointAttribute.numElements + 2);
        _colors[4 * _j9 + 3] = getOpacity(_j9 * pointAttribute.numElements);
      }
      attributeBuffers['rgba'] = {
        buffer: _buff9,
        attribute: pointAttribute
      };

      //compute cov:
      var _buff10 = new ArrayBuffer(numPoints * 24);
      var covs = new Float32Array(_buff10);
      var offset_scale = gs3dProplist.indexOf('scale_0'); //第49个数开始是      
      var offset_rot = gs3dProplist.indexOf('rot_0');
      var _scale2 = new Vector3();
      var quaternion = new Quaternion();
      var getScale = index => {
        var get = offset => {
          return Math.exp(_f3[index * pointAttribute.numElements + offset + offset_scale]);
        };
        _scale2.set(get(0), get(1), get(2));
      };
      var getQuatenion = index => {
        var get = offset => {
          return _f3[index * pointAttribute.numElements + offset + offset_rot];
        };
        //quaternion.set( get(0), get(1), get(2), get(3)) 
        quaternion.set(get(1), get(2), get(3), get(0)); //w放到最后 另外如果compressionLevel不是0的话还要再加一步，见this.fbf(sectionFloatArray[rotationBase + 1]
        //quaternion.normalize();
      };
      for (var _j10 = 0; _j10 < numPoints; _j10++) {
        getScale(_j10);
        getQuatenion(_j10);
        Splat.computeCovariance(_scale2, quaternion, null, covs, 6 * _j10);
      }
      attributeBuffers['covs'] = {
        buffer: _buff10,
        attribute: pointAttribute
      };

      ////////////////////////////////////////////////////////////////////////////////    
    } else {
      var _buff11 = new ArrayBuffer(numPoints * 4);
      var _f4 = new Float32Array(_buff11);
      var TypedArray = typedArrayMapping[pointAttribute.type.name];
      preciseBuffer = new TypedArray(numPoints);
      var [_min, _max] = [Infinity, -Infinity];
      var [_offset, _scale3] = [0, 1];
      var getterMap = {
        "int8": view.getInt8,
        "int16": view.getInt16,
        "int32": view.getInt32,
        "int64": view.getInt64,
        "uint8": view.getUint8,
        "uint16": view.getUint16,
        "uint32": view.getUint32,
        "uint64": view.getUint64,
        "float": view.getFloat32,
        "double": view.getFloat64
      };
      var _getter = getterMap[pointAttribute.type.name].bind(view);

      // compute offset and scale to pack larger types into 32 bit floats
      if (pointAttribute.type.size > 4) {
        for (var _j11 = 0; _j11 < numPoints; _j11++) {
          var _value = _getter(inOffset + _j11 * pointAttributes.byteSize, true);
          if (!Number.isNaN(_value)) {
            _min = Math.min(_min, _value);
            _max = Math.max(_max, _value);
          }
        }
        if (pointAttribute.initialRange != null) {
          _offset = pointAttribute.initialRange[0];
          _scale3 = 1 / (pointAttribute.initialRange[1] - pointAttribute.initialRange[0]);
        } else {
          _offset = _min;
          _scale3 = 1 / (_max - _min);
        }
      }
      for (var _j12 = 0; _j12 < numPoints; _j12++) {
        var _value2 = _getter(inOffset + _j12 * pointAttributes.byteSize, true);
        if (!Number.isNaN(_value2)) {
          _min = Math.min(_min, _value2);
          _max = Math.max(_max, _value2);
        }
        _f4[_j12] = (_value2 - _offset) * _scale3;
        preciseBuffer[_j12] = _value2;
      }
      pointAttribute.range = [_min, _max];
      attributeBuffers[pointAttribute.name] = {
        buffer: _buff11,
        preciseBuffer: preciseBuffer,
        attribute: pointAttribute,
        offset: _offset,
        scale: _scale3
      };
    }
    inOffset += pointAttribute.byteSize;
  };
  for (var pointAttribute of pointAttributes.attributes) {
    _loop(pointAttribute);
  }
  {
    // add indices
    var buff = new ArrayBuffer(numPoints * 4);
    var indices = new Uint32Array(buff);
    for (var i = 0; i < numPoints; i++) {
      indices[i] = i;
    }
    attributeBuffers["INDICES"] = {
      buffer: buff,
      attribute: PointAttribute.INDICES
    };
  }
  {
    // handle attribute vectors
    var vectors = pointAttributes.vectors;
    for (var vector of vectors) {
      var {
        name: _name,
        attributes
      } = vector;
      var numVectorElements = attributes.length;
      var _buffer = new ArrayBuffer(numVectorElements * numPoints * 4);
      var f32 = new Float32Array(_buffer);
      var iElement = 0;
      for (var sourceName of attributes) {
        var sourceBuffer = attributeBuffers[sourceName];
        var {
          offset,
          scale: _scale
        } = sourceBuffer;
        var _view = new DataView(sourceBuffer.buffer);
        var getter = _view.getFloat32.bind(_view);
        for (var j = 0; j < numPoints; j++) {
          var value = getter(j * 4, true);
          f32[j * numVectorElements + iElement] = value / _scale + offset;
        }
        iElement++;
      }
      var vecAttribute = new PointAttribute(_name, PointAttributeTypes.DATA_TYPE_FLOAT, 3);
      attributeBuffers[_name] = {
        buffer: _buffer,
        attribute: vecAttribute
      };
    }
  }
  performance.mark("binary-decoder-end");

  // { // print timings
  // 	//performance.measure("spacing", "spacing-start", "spacing-end");
  // 	performance.measure("binary-decoder", "binary-decoder-start", "binary-decoder-end");
  // 	let measure = performance.getEntriesByType("measure")[0];
  // 	let dpp = 1000 * measure.duration / numPoints;
  // 	let pps = parseInt(numPoints / (measure.duration / 1000));
  // 	let debugMessage = `${measure.duration.toFixed(3)} ms, ${numPoints} points, ${pps.toLocaleString()} points/sec`;
  // 	console.log(debugMessage);
  // }

  performance.clearMarks();
  performance.clearMeasures();
  var message = {
    buffer: buffer,
    mean: mean,
    attributeBuffers: attributeBuffers,
    tightBoundingBox: {
      min: tightBoxMin,
      max: tightBoxMax
    }
  };
  var transferables = [];
  for (var property in message.attributeBuffers) {
    transferables.push(message.attributeBuffers[property].buffer);
  }
  transferables.push(buffer);
  postMessage(message, transferables);
};