@loaders.gl/ply 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/index.cjs

@@ -0,0 +1,644 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  PLYLoader: () => PLYLoader2,
+  PLYWorkerLoader: () => PLYLoader
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ply-loader.ts
+var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var PLYLoader = {
+  name: "PLY",
+  id: "ply",
+  module: "ply",
+  // shapes: ['mesh', 'gltf', 'columnar-table'],
+  version: VERSION,
+  worker: true,
+  extensions: ["ply"],
+  mimeTypes: ["text/plain", "application/octet-stream"],
+  text: true,
+  binary: true,
+  tests: ["ply"],
+  options: {
+    ply: {}
+  }
+};
+
+// src/lib/normalize-ply.ts
+var import_schema2 = require("@loaders.gl/schema");
+
+// src/lib/get-ply-schema.ts
+var import_schema = require("@loaders.gl/schema");
+function getPLYSchema(plyHeader, attributes) {
+  const metadata = makeMetadataFromPlyHeader(plyHeader);
+  const schema = (0, import_schema.deduceMeshSchema)(attributes, metadata);
+  return schema;
+}
+function makeMetadataFromPlyHeader(plyHeader) {
+  const metadata = {};
+  metadata.ply_comments = JSON.stringify(plyHeader.comments);
+  metadata.ply_elements = JSON.stringify(plyHeader.elements);
+  if (plyHeader.format !== void 0) {
+    metadata.ply_format = plyHeader.format;
+  }
+  if (plyHeader.version !== void 0) {
+    metadata.ply_version = plyHeader.version;
+  }
+  if (plyHeader.headerLength !== void 0) {
+    metadata.ply_headerLength = plyHeader.headerLength.toString(10);
+  }
+  return metadata;
+}
+
+// src/lib/normalize-ply.ts
+function normalizePLY(plyHeader, plyAttributes, options) {
+  const attributes = getMeshAttributes(plyAttributes);
+  const boundingBox = (0, import_schema2.getMeshBoundingBox)(attributes);
+  const vertexCount = plyAttributes.indices.length || plyAttributes.vertices.length / 3;
+  const isTriangles = plyAttributes.indices && plyAttributes.indices.length > 0;
+  const mode = isTriangles ? 4 : 0;
+  const topology = isTriangles ? "triangle-list" : "point-list";
+  const schema = getPLYSchema(plyHeader, attributes);
+  const plyMesh = {
+    loader: "ply",
+    loaderData: plyHeader,
+    header: {
+      vertexCount,
+      boundingBox
+    },
+    schema,
+    attributes,
+    indices: { value: new Uint32Array(0), size: 0 },
+    mode,
+    topology
+  };
+  if (plyAttributes.indices.length > 0) {
+    plyMesh.indices = { value: new Uint32Array(plyAttributes.indices), size: 1 };
+  }
+  return plyMesh;
+}
+function getMeshAttributes(attributes) {
+  const accessors = {};
+  for (const attributeName of Object.keys(attributes)) {
+    switch (attributeName) {
+      case "vertices":
+        if (attributes.vertices.length > 0) {
+          accessors.POSITION = { value: new Float32Array(attributes.vertices), size: 3 };
+        }
+        break;
+      case "normals":
+        if (attributes.normals.length > 0) {
+          accessors.NORMAL = { value: new Float32Array(attributes.normals), size: 3 };
+        }
+        break;
+      case "uvs":
+        if (attributes.uvs.length > 0) {
+          accessors.TEXCOORD_0 = { value: new Float32Array(attributes.uvs), size: 2 };
+        }
+        break;
+      case "colors":
+        if (attributes.colors.length > 0) {
+          accessors.COLOR_0 = { value: new Uint8Array(attributes.colors), size: 3, normalized: true };
+        }
+        break;
+      case "indices":
+        break;
+      default:
+        if (attributes[attributeName].length > 0) {
+          accessors[attributeName] = { value: new Float32Array(attributes[attributeName]), size: 1 };
+        }
+        break;
+    }
+  }
+  return accessors;
+}
+
+// src/lib/parse-ply.ts
+function parsePLY(data, options = {}) {
+  let header;
+  let attributes;
+  if (data instanceof ArrayBuffer) {
+    const text = new TextDecoder().decode(data);
+    header = parseHeader(text, options);
+    attributes = header.format === "ascii" ? parseASCII(text, header) : parseBinary(data, header);
+  } else {
+    header = parseHeader(data, options);
+    attributes = parseASCII(data, header);
+  }
+  return normalizePLY(header, attributes);
+}
+function parseHeader(data, options) {
+  const PLY_HEADER_PATTERN = /ply([\s\S]*)end_header\s/;
+  let headerText = "";
+  let headerLength = 0;
+  const result = PLY_HEADER_PATTERN.exec(data);
+  if (result !== null) {
+    headerText = result[1];
+    headerLength = result[0].length;
+  }
+  const lines = headerText.split("\n");
+  const header = parseHeaderLines(lines, headerLength, options);
+  return header;
+}
+function parseHeaderLines(lines, headerLength, options) {
+  const header = {
+    comments: [],
+    elements: [],
+    headerLength
+  };
+  let lineType;
+  let lineValues;
+  let currentElement2 = null;
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    line = line.trim();
+    if (line === "") {
+      continue;
+    }
+    lineValues = line.split(/\s+/);
+    lineType = lineValues.shift();
+    line = lineValues.join(" ");
+    switch (lineType) {
+      case "format":
+        header.format = lineValues[0];
+        header.version = lineValues[1];
+        break;
+      case "comment":
+        header.comments.push(line);
+        break;
+      case "element":
+        if (currentElement2) {
+          header.elements.push(currentElement2);
+        }
+        currentElement2 = {
+          name: lineValues[0],
+          count: parseInt(lineValues[1], 10),
+          properties: []
+        };
+        break;
+      case "property":
+        if (currentElement2) {
+          const property = makePLYElementProperty(lineValues);
+          if ((options == null ? void 0 : options.propertyNameMapping) && property.name in (options == null ? void 0 : options.propertyNameMapping)) {
+            property.name = options == null ? void 0 : options.propertyNameMapping[property.name];
+          }
+          currentElement2.properties.push(property);
+        }
+        break;
+      default:
+        console.log("unhandled", lineType, lineValues);
+    }
+  }
+  if (currentElement2) {
+    header.elements.push(currentElement2);
+  }
+  return header;
+}
+function getPLYAttributes(header) {
+  const attributes = {
+    indices: [],
+    vertices: [],
+    normals: [],
+    uvs: [],
+    colors: []
+  };
+  for (const element of header.elements) {
+    if (element.name === "vertex") {
+      for (const property of element.properties) {
+        switch (property.name) {
+          case "x":
+          case "y":
+          case "z":
+          case "nx":
+          case "ny":
+          case "nz":
+          case "s":
+          case "t":
+          case "red":
+          case "green":
+          case "blue":
+            break;
+          default:
+            attributes[property.name] = [];
+            break;
+        }
+      }
+    }
+  }
+  return attributes;
+}
+function makePLYElementProperty(propertyValues) {
+  const type = propertyValues[0];
+  switch (type) {
+    case "list":
+      return {
+        type,
+        name: propertyValues[3],
+        countType: propertyValues[1],
+        itemType: propertyValues[2]
+      };
+    default:
+      return {
+        type,
+        name: propertyValues[1]
+      };
+  }
+}
+function parseASCIINumber(n, type) {
+  switch (type) {
+    case "char":
+    case "uchar":
+    case "short":
+    case "ushort":
+    case "int":
+    case "uint":
+    case "int8":
+    case "uint8":
+    case "int16":
+    case "uint16":
+    case "int32":
+    case "uint32":
+      return parseInt(n, 10);
+    case "float":
+    case "double":
+    case "float32":
+    case "float64":
+      return parseFloat(n);
+    default:
+      throw new Error(type);
+  }
+}
+function parsePLYElement(properties, line) {
+  const values = line.split(/\s+/);
+  const element = {};
+  for (let i = 0; i < properties.length; i++) {
+    if (properties[i].type === "list") {
+      const list = [];
+      const n = parseASCIINumber(values.shift(), properties[i].countType);
+      for (let j = 0; j < n; j++) {
+        list.push(parseASCIINumber(values.shift(), properties[i].itemType));
+      }
+      element[properties[i].name] = list;
+    } else {
+      element[properties[i].name] = parseASCIINumber(values.shift(), properties[i].type);
+    }
+  }
+  return element;
+}
+function parseASCII(data, header) {
+  const attributes = getPLYAttributes(header);
+  let result;
+  const patternBody = /end_header\s([\s\S]*)$/;
+  let body = "";
+  if ((result = patternBody.exec(data)) !== null) {
+    body = result[1];
+  }
+  const lines = body.split("\n");
+  let currentElement2 = 0;
+  let currentElementCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    line = line.trim();
+    if (line !== "") {
+      if (currentElementCount >= header.elements[currentElement2].count) {
+        currentElement2++;
+        currentElementCount = 0;
+      }
+      const element = parsePLYElement(header.elements[currentElement2].properties, line);
+      handleElement(attributes, header.elements[currentElement2].name, element);
+      currentElementCount++;
+    }
+  }
+  return attributes;
+}
+function handleElement(buffer, elementName, element = {}) {
+  if (elementName === "vertex") {
+    for (const propertyName of Object.keys(element)) {
+      switch (propertyName) {
+        case "x":
+          buffer.vertices.push(element.x, element.y, element.z);
+          break;
+        case "y":
+        case "z":
+          break;
+        case "nx":
+          if ("nx" in element && "ny" in element && "nz" in element) {
+            buffer.normals.push(element.nx, element.ny, element.nz);
+          }
+          break;
+        case "ny":
+        case "nz":
+          break;
+        case "s":
+          if ("s" in element && "t" in element) {
+            buffer.uvs.push(element.s, element.t);
+          }
+          break;
+        case "t":
+          break;
+        case "red":
+          if ("red" in element && "green" in element && "blue" in element) {
+            buffer.colors.push(element.red, element.green, element.blue);
+          }
+          break;
+        case "green":
+        case "blue":
+          break;
+        default:
+          buffer[propertyName].push(element[propertyName]);
+      }
+    }
+  } else if (elementName === "face") {
+    const vertexIndices = element.vertex_indices || element.vertex_index;
+    if (vertexIndices.length === 3) {
+      buffer.indices.push(vertexIndices[0], vertexIndices[1], vertexIndices[2]);
+    } else if (vertexIndices.length === 4) {
+      buffer.indices.push(vertexIndices[0], vertexIndices[1], vertexIndices[3]);
+      buffer.indices.push(vertexIndices[1], vertexIndices[2], vertexIndices[3]);
+    }
+  }
+}
+function binaryRead(dataview, at, type, littleEndian) {
+  switch (type) {
+    case "int8":
+    case "char":
+      return [dataview.getInt8(at), 1];
+    case "uint8":
+    case "uchar":
+      return [dataview.getUint8(at), 1];
+    case "int16":
+    case "short":
+      return [dataview.getInt16(at, littleEndian), 2];
+    case "uint16":
+    case "ushort":
+      return [dataview.getUint16(at, littleEndian), 2];
+    case "int32":
+    case "int":
+      return [dataview.getInt32(at, littleEndian), 4];
+    case "uint32":
+    case "uint":
+      return [dataview.getUint32(at, littleEndian), 4];
+    case "float32":
+    case "float":
+      return [dataview.getFloat32(at, littleEndian), 4];
+    case "float64":
+    case "double":
+      return [dataview.getFloat64(at, littleEndian), 8];
+    default:
+      throw new Error(type);
+  }
+}
+function binaryReadElement(dataview, at, properties, littleEndian) {
+  const element = {};
+  let result;
+  let read = 0;
+  for (let i = 0; i < properties.length; i++) {
+    if (properties[i].type === "list") {
+      const list = [];
+      result = binaryRead(dataview, at + read, properties[i].countType, littleEndian);
+      const n = result[0];
+      read += result[1];
+      for (let j = 0; j < n; j++) {
+        result = binaryRead(dataview, at + read, properties[i].itemType, littleEndian);
+        list.push(result[0]);
+        read += result[1];
+      }
+      element[properties[i].name] = list;
+    } else {
+      result = binaryRead(dataview, at + read, properties[i].type, littleEndian);
+      element[properties[i].name] = result[0];
+      read += result[1];
+    }
+  }
+  return [element, read];
+}
+function parseBinary(data, header) {
+  const attributes = getPLYAttributes(header);
+  const littleEndian = header.format === "binary_little_endian";
+  const body = new DataView(data, header.headerLength);
+  let result;
+  let loc = 0;
+  for (let currentElement2 = 0; currentElement2 < header.elements.length; currentElement2++) {
+    const count = header.elements[currentElement2].count;
+    for (let currentElementCount = 0; currentElementCount < count; currentElementCount++) {
+      result = binaryReadElement(
+        body,
+        loc,
+        header.elements[currentElement2].properties,
+        littleEndian
+      );
+      loc += result[1];
+      const element = result[0];
+      handleElement(attributes, header.elements[currentElement2].name, element);
+    }
+  }
+  return attributes;
+}
+
+// src/lib/parse-ply-in-batches.ts
+var import_loader_utils = require("@loaders.gl/loader-utils");
+var currentElement;
+async function* parsePLYInBatches(iterator, options) {
+  const lineIterator = (0, import_loader_utils.makeLineIterator)((0, import_loader_utils.makeTextDecoderIterator)(iterator));
+  const header = await parsePLYHeader(lineIterator, options);
+  let attributes;
+  switch (header.format) {
+    case "ascii":
+      attributes = await parseASCII2(lineIterator, header);
+      break;
+    default:
+      throw new Error("Binary PLY can not yet be parsed in streaming mode");
+  }
+  yield normalizePLY(header, attributes, options);
+}
+async function parsePLYHeader(lineIterator, options) {
+  const header = {
+    comments: [],
+    elements: []
+    // headerLength
+  };
+  await (0, import_loader_utils.forEach)(lineIterator, (line) => {
+    line = line.trim();
+    if (line === "end_header") {
+      return true;
+    }
+    if (line === "") {
+      return false;
+    }
+    const lineValues = line.split(/\s+/);
+    const lineType = lineValues.shift();
+    line = lineValues.join(" ");
+    switch (lineType) {
+      case "ply":
+        break;
+      case "format":
+        header.format = lineValues[0];
+        header.version = lineValues[1];
+        break;
+      case "comment":
+        header.comments.push(line);
+        break;
+      case "element":
+        if (currentElement) {
+          header.elements.push(currentElement);
+        }
+        currentElement = {
+          name: lineValues[0],
+          count: parseInt(lineValues[1], 10),
+          properties: []
+        };
+        break;
+      case "property":
+        const property = makePLYElementProperty2(lineValues, options.propertyNameMapping);
+        currentElement.properties.push(property);
+        break;
+      default:
+        console.log("unhandled", lineType, lineValues);
+    }
+    return false;
+  });
+  if (currentElement) {
+    header.elements.push(currentElement);
+  }
+  return header;
+}
+function makePLYElementProperty2(propertyValues, propertyNameMapping) {
+  const type = propertyValues[0];
+  switch (type) {
+    case "list":
+      return {
+        type,
+        name: propertyValues[3],
+        countType: propertyValues[1],
+        itemType: propertyValues[2]
+      };
+    default:
+      return {
+        type,
+        name: propertyValues[1]
+      };
+  }
+}
+async function parseASCII2(lineIterator, header) {
+  const attributes = {
+    indices: [],
+    vertices: [],
+    normals: [],
+    uvs: [],
+    colors: []
+  };
+  let currentElement2 = 0;
+  let currentElementCount = 0;
+  for await (let line of lineIterator) {
+    line = line.trim();
+    if (line !== "") {
+      if (currentElementCount >= header.elements[currentElement2].count) {
+        currentElement2++;
+        currentElementCount = 0;
+      }
+      const element = parsePLYElement2(header.elements[currentElement2].properties, line);
+      handleElement2(attributes, header.elements[currentElement2].name, element);
+      currentElementCount++;
+    }
+  }
+  return attributes;
+}
+function parseASCIINumber2(n, type) {
+  switch (type) {
+    case "char":
+    case "uchar":
+    case "short":
+    case "ushort":
+    case "int":
+    case "uint":
+    case "int8":
+    case "uint8":
+    case "int16":
+    case "uint16":
+    case "int32":
+    case "uint32":
+      return parseInt(n, 10);
+    case "float":
+    case "double":
+    case "float32":
+    case "float64":
+      return parseFloat(n);
+    default:
+      throw new Error(type);
+  }
+}
+function parsePLYElement2(properties, line) {
+  const values = line.split(/\s+/);
+  const element = {};
+  for (let i = 0; i < properties.length; i++) {
+    if (properties[i].type === "list") {
+      const list = [];
+      const n = parseASCIINumber2(values.shift(), properties[i].countType);
+      for (let j = 0; j < n; j++) {
+        list.push(parseASCIINumber2(values.shift(), properties[i].itemType));
+      }
+      element[properties[i].name] = list;
+    } else {
+      element[properties[i].name] = parseASCIINumber2(values.shift(), properties[i].type);
+    }
+  }
+  return element;
+}
+function handleElement2(buffer, elementName, element = {}) {
+  switch (elementName) {
+    case "vertex":
+      buffer.vertices.push(element.x, element.y, element.z);
+      if ("nx" in element && "ny" in element && "nz" in element) {
+        buffer.normals.push(element.nx, element.ny, element.nz);
+      }
+      if ("s" in element && "t" in element) {
+        buffer.uvs.push(element.s, element.t);
+      }
+      if ("red" in element && "green" in element && "blue" in element) {
+        buffer.colors.push(element.red / 255, element.green / 255, element.blue / 255);
+      }
+      break;
+    case "face":
+      const vertexIndices = element.vertex_indices || element.vertex_index;
+      if (vertexIndices.length === 3) {
+        buffer.indices.push(vertexIndices[0], vertexIndices[1], vertexIndices[2]);
+      } else if (vertexIndices.length === 4) {
+        buffer.indices.push(vertexIndices[0], vertexIndices[1], vertexIndices[3]);
+        buffer.indices.push(vertexIndices[1], vertexIndices[2], vertexIndices[3]);
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+// src/index.ts
+var PLYLoader2 = {
+  ...PLYLoader,
+  // Note: parsePLY supports both text and binary
+  parse: async (arrayBuffer, options) => parsePLY(arrayBuffer, options == null ? void 0 : options.ply),
+  // TODO - this may not detect text correctly?
+  parseTextSync: (arrayBuffer, options) => parsePLY(arrayBuffer, options == null ? void 0 : options.ply),
+  parseSync: (arrayBuffer, options) => parsePLY(arrayBuffer, options == null ? void 0 : options.ply),
+  parseInBatches: (arrayBuffer, options) => parsePLYInBatches(arrayBuffer, options == null ? void 0 : options.ply)
+};

package/dist/{esm/index.js → index.js}

@@ -1,6 +1,6 @@
-import { PLYLoader as PLYWorkerLoader } from './ply-loader';
-import { parsePLY } from './lib/parse-ply';
-import { parsePLYInBatches } from './lib/parse-ply-in-batches';
+import { PLYLoader as PLYWorkerLoader } from "./ply-loader.js";
+import { parsePLY } from "./lib/parse-ply.js";
+import { parsePLYInBatches } from "./lib/parse-ply-in-batches.js";
 export { PLYWorkerLoader };
 export const PLYLoader = {
   ...PLYWorkerLoader,

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["PLYLoader","PLYWorkerLoader","parsePLY","parsePLYInBatches","parse","arrayBuffer","options","ply","parseTextSync","parseSync","parseInBatches"],"sources":["../src/index.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';\nimport type {PLYMesh} from './lib/ply-types';\nimport {PLYLoader as PLYWorkerLoader} from './ply-loader';\nimport {ParsePLYOptions, parsePLY} from './lib/parse-ply';\nimport {parsePLYInBatches} from './lib/parse-ply-in-batches';\n\n// PLYLoader\n\nexport {PLYWorkerLoader};\n\nexport type PLYLoaderOptions = LoaderOptions & {\n  ply?: ParsePLYOptions;\n};\n\n/**\n * Loader for PLY - Polygon File Format\n */\nexport const PLYLoader: LoaderWithParser<PLYMesh, any, PLYLoaderOptions> = {\n  ...PLYWorkerLoader,\n  // Note: parsePLY supports both text and binary\n  parse: async (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply), // TODO - this may not detect text correctly?\n  parseTextSync: (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),\n  parseSync: (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),\n  parseInBatches: (arrayBuffer, options) => parsePLYInBatches(arrayBuffer, options?.ply)\n};\n"],"mappings":"SAIQA,SAAS,IAAIC,eAAe;AAAA,SACXC,QAAQ;AAAA,SACzBC,iBAAiB;AAIzB,SAAQF,eAAe;AASvB,OAAO,MAAMD,SAA2D,GAAG;EACzE,GAAGC,eAAe;EAElBG,KAAK,EAAE,MAAAA,CAAOC,WAAW,EAAEC,OAAO,KAAKJ,QAAQ,CAACG,WAAW,EAAEC,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEC,GAAG,CAAC;EAC1EC,aAAa,EAAEA,CAACH,WAAW,EAAEC,OAAO,KAAKJ,QAAQ,CAACG,WAAW,EAAEC,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEC,GAAG,CAAC;EAC5EE,SAAS,EAAEA,CAACJ,WAAW,EAAEC,OAAO,KAAKJ,QAAQ,CAACG,WAAW,EAAEC,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEC,GAAG,CAAC;EACxEG,cAAc,EAAEA,CAACL,WAAW,EAAEC,OAAO,KAAKH,iBAAiB,CAACE,WAAW,EAAEC,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAEC,GAAG;AACvF,CAAC"}

package/dist/lib/get-ply-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-ply-schema.js","names":["deduceMeshSchema","getPLYSchema","plyHeader","attributes","metadata","makeMetadataFromPlyHeader","schema","ply_comments","JSON","stringify","comments","ply_elements","elements","format","undefined","ply_format","version","ply_version","headerLength","ply_headerLength","toString"],"sources":["../../src/lib/get-ply-schema.ts"],"sourcesContent":["import {Schema, MeshAttributes, deduceMeshSchema} from '@loaders.gl/schema';\nimport type {PLYHeader} from './ply-types';\n\n/**\n * Gets schema from PLY header\n * @param plyHeader\n * @param metadata\n * @returns Schema\n */\nexport function getPLYSchema(plyHeader: PLYHeader, attributes: MeshAttributes): Schema {\n  const metadata = makeMetadataFromPlyHeader(plyHeader);\n  const schema = deduceMeshSchema(attributes, metadata);\n  return schema;\n}\n\n/**\n * Make arrow like schema metadata by PlyHeader properties\n * @param plyHeader\n * @returns\n */\nfunction makeMetadataFromPlyHeader(plyHeader: PLYHeader): Record<string, string> {\n  /* eslint-disable camelcase */\n  const metadata: Record<string, string> = {};\n  metadata.ply_comments = JSON.stringify(plyHeader.comments);\n  metadata.ply_elements = JSON.stringify(plyHeader.elements);\n  if (plyHeader.format !== undefined) {\n    metadata.ply_format = plyHeader.format;\n  }\n  if (plyHeader.version !== undefined) {\n    metadata.ply_version = plyHeader.version;\n  }\n  if (plyHeader.headerLength !== undefined) {\n    metadata.ply_headerLength = plyHeader.headerLength.toString(10);\n  }\n  return metadata;\n}\n"],"mappings":"AAAA,SAAgCA,gBAAgB,QAAO,oBAAoB;AAS3E,OAAO,SAASC,YAAYA,CAACC,SAAoB,EAAEC,UAA0B,EAAU;EACrF,MAAMC,QAAQ,GAAGC,yBAAyB,CAACH,SAAS,CAAC;EACrD,MAAMI,MAAM,GAAGN,gBAAgB,CAACG,UAAU,EAAEC,QAAQ,CAAC;EACrD,OAAOE,MAAM;AACf;AAOA,SAASD,yBAAyBA,CAACH,SAAoB,EAA0B;EAE/E,MAAME,QAAgC,GAAG,CAAC,CAAC;EAC3CA,QAAQ,CAACG,YAAY,GAAGC,IAAI,CAACC,SAAS,CAACP,SAAS,CAACQ,QAAQ,CAAC;EAC1DN,QAAQ,CAACO,YAAY,GAAGH,IAAI,CAACC,SAAS,CAACP,SAAS,CAACU,QAAQ,CAAC;EAC1D,IAAIV,SAAS,CAACW,MAAM,KAAKC,SAAS,EAAE;IAClCV,QAAQ,CAACW,UAAU,GAAGb,SAAS,CAACW,MAAM;EACxC;EACA,IAAIX,SAAS,CAACc,OAAO,KAAKF,SAAS,EAAE;IACnCV,QAAQ,CAACa,WAAW,GAAGf,SAAS,CAACc,OAAO;EAC1C;EACA,IAAId,SAAS,CAACgB,YAAY,KAAKJ,SAAS,EAAE;IACxCV,QAAQ,CAACe,gBAAgB,GAAGjB,SAAS,CAACgB,YAAY,CAACE,QAAQ,CAAC,EAAE,CAAC;EACjE;EACA,OAAOhB,QAAQ;AACjB"}

package/dist/{esm/lib → lib}/normalize-ply.js

@@ -1,5 +1,5 @@
 import { getMeshBoundingBox } from '@loaders.gl/schema';
-import { getPLYSchema } from './get-ply-schema';
+import { getPLYSchema } from "./get-ply-schema.js";
 export default function normalizePLY(plyHeader, plyAttributes, options) {
   const attributes = getMeshAttributes(plyAttributes);
   const boundingBox = getMeshBoundingBox(attributes);

package/dist/lib/normalize-ply.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-ply.js","names":["getMeshBoundingBox","getPLYSchema","normalizePLY","plyHeader","plyAttributes","options","attributes","getMeshAttributes","boundingBox","vertexCount","indices","length","vertices","isTriangles","mode","topology","schema","plyMesh","loader","loaderData","header","value","Uint32Array","size","accessors","attributeName","Object","keys","POSITION","Float32Array","normals","NORMAL","uvs","TEXCOORD_0","colors","COLOR_0","Uint8Array","normalized"],"sources":["../../src/lib/normalize-ply.ts"],"sourcesContent":["import type {MeshAttributes} from '@loaders.gl/schema';\nimport {getMeshBoundingBox} from '@loaders.gl/schema';\nimport type {PLYMesh, PLYHeader, PLYAttributes, MeshHeader} from './ply-types';\nimport {getPLYSchema} from './get-ply-schema';\n\n/**\n * @param header\n * @param attributes\n * @returns data and header\n */\nexport default function normalizePLY(\n  plyHeader: MeshHeader & PLYHeader,\n  plyAttributes: PLYAttributes,\n  options?: {}\n): PLYMesh {\n  const attributes = getMeshAttributes(plyAttributes);\n  const boundingBox = getMeshBoundingBox(attributes);\n  const vertexCount = plyAttributes.indices.length || plyAttributes.vertices.length / 3;\n\n  // TODO - how to detect POINT CLOUDS vs MESHES?\n  // TODO - For Meshes, PLY quadrangles must be split?\n  const isTriangles = plyAttributes.indices && plyAttributes.indices.length > 0;\n  const mode = isTriangles ? 4 : 0; // TRIANGLES vs POINTS\n  const topology = isTriangles ? 'triangle-list' : 'point-list';\n\n  const schema = getPLYSchema(plyHeader, attributes);\n\n  const plyMesh: PLYMesh = {\n    loader: 'ply',\n    loaderData: plyHeader,\n    header: {\n      vertexCount,\n      boundingBox\n    },\n    schema,\n    attributes,\n    indices: {value: new Uint32Array(0), size: 0},\n    mode,\n    topology\n  };\n\n  if (plyAttributes.indices.length > 0) {\n    plyMesh.indices = {value: new Uint32Array(plyAttributes.indices), size: 1};\n  }\n\n  return plyMesh;\n}\n\n/**\n * @param attributes\n * @returns accessors []\n */\n// eslint-disable-next-line complexity\nfunction getMeshAttributes(attributes: PLYAttributes): MeshAttributes {\n  const accessors: MeshAttributes = {};\n\n  for (const attributeName of Object.keys(attributes)) {\n    switch (attributeName) {\n      case 'vertices':\n        if (attributes.vertices.length > 0) {\n          accessors.POSITION = {value: new Float32Array(attributes.vertices), size: 3};\n        }\n        break;\n\n      // optional attributes data\n      case 'normals':\n        if (attributes.normals.length > 0) {\n          accessors.NORMAL = {value: new Float32Array(attributes.normals), size: 3};\n        }\n        break;\n\n      case 'uvs':\n        if (attributes.uvs.length > 0) {\n          accessors.TEXCOORD_0 = {value: new Float32Array(attributes.uvs), size: 2};\n        }\n        break;\n\n      case 'colors':\n        if (attributes.colors.length > 0) {\n          // TODO - normalized shoud be based on `uchar` flag in source data?\n          accessors.COLOR_0 = {value: new Uint8Array(attributes.colors), size: 3, normalized: true};\n        }\n        break;\n\n      case 'indices':\n        break;\n\n      default:\n        if (attributes[attributeName].length > 0) {\n          accessors[attributeName] = {value: new Float32Array(attributes[attributeName]), size: 1};\n        }\n        break;\n    }\n  }\n  return accessors;\n}\n"],"mappings":"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"}

package/dist/{esm/lib → lib}/parse-ply-in-batches.js

@@ -1,5 +1,5 @@
 import { makeLineIterator, makeTextDecoderIterator, forEach } from '@loaders.gl/loader-utils';
-import normalizePLY from './normalize-ply';
+import normalizePLY from "./normalize-ply.js";
 let currentElement;
 export async function* parsePLYInBatches(iterator, options) {
   const lineIterator = makeLineIterator(makeTextDecoderIterator(iterator));