@loaders.gl/ply 4.2.0-alpha.4 → 4.2.0-alpha.5

package/dist/lib/normalize-ply.js

@@ -1,86 +1,77 @@
 import { getMeshBoundingBox } from '@loaders.gl/schema';
 import { getPLYSchema } from "./get-ply-schema.js";
+/**
+ * @param header
+ * @param attributes
+ * @returns data and header
+ */
 export default function normalizePLY(plyHeader, plyAttributes, options) {
-  const attributes = getMeshAttributes(plyAttributes);
-  const boundingBox = 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
+    const attributes = getMeshAttributes(plyAttributes);
+    const boundingBox = getMeshBoundingBox(attributes);
+    const vertexCount = plyAttributes.indices.length || plyAttributes.vertices.length / 3;
+    // TODO - how to detect POINT CLOUDS vs MESHES?
+    // TODO - For Meshes, PLY quadrangles must be split?
+    const isTriangles = plyAttributes.indices && plyAttributes.indices.length > 0;
+    const mode = isTriangles ? 4 : 0; // TRIANGLES vs POINTS
+    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
     };
-  }
-  return plyMesh;
+    if (plyAttributes.indices.length > 0) {
+        plyMesh.indices = { value: new Uint32Array(plyAttributes.indices), size: 1 };
+    }
+    return plyMesh;
 }
+/**
+ * @param attributes
+ * @returns accessors []
+ */
+// eslint-disable-next-line complexity
 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
-          };
+    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;
+            // optional attributes data
+            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) {
+                    // TODO - normalized shoud be based on `uchar` flag in source data?
+                    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;
         }
-        break;
     }
-  }
-  return accessors;
+    return accessors;
 }
-//# sourceMappingURL=normalize-ply.js.map

package/dist/lib/parse-ply-in-batches.d.ts

@@ -1,4 +1,4 @@
-import { PLYMesh } from './ply-types';
+import { PLYMesh } from "./ply-types.js";
 /**
  * PARSER
  * @param iterator

package/dist/lib/parse-ply-in-batches.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-ply-in-batches.d.ts","sourceRoot":"","sources":["../../src/lib/parse-ply-in-batches.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAC,OAAO,EAAoD,MAAM,aAAa,CAAC;AAIvF;;;;GAIG;AACH,wBAAuB,iBAAiB,CACtC,QAAQ,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,EAC5D,OAAO,EAAE,GAAG,GACX,aAAa,CAAC,OAAO,CAAC,CAexB"}
+{"version":3,"file":"parse-ply-in-batches.d.ts","sourceRoot":"","sources":["../../src/lib/parse-ply-in-batches.ts"],"names":[],"mappings":"AAyBA,OAAO,EAAC,OAAO,EAAoD,uBAAoB;AAIvF;;;;GAIG;AACH,wBAAuB,iBAAiB,CACtC,QAAQ,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,EAC5D,OAAO,EAAE,GAAG,GACX,aAAa,CAAC,OAAO,CAAC,CAexB"}

package/dist/lib/parse-ply-in-batches.js

@@ -1,177 +1,246 @@
+// PLY Loader, adapted from THREE.js (MIT license)
+//
+// Attributions per original THREE.js source file:
+//
+// @author Wei Meng / http://about.me/menway
+//
+// Description: A loader for PLY ASCII files (known as the Polygon File Format
+// or the Stanford Triangle Format).
+//
+// Limitations: ASCII decoding assumes file is UTF-8.
+//
+// If the PLY file uses non standard property names, they can be mapped while
+// loading. For example, the following maps the properties
+// “diffuse_(red|green|blue)” in the file to standard color names.
+//
+// parsePLY(data, {
+//   propertyNameMapping: {
+//     diffuse_red: 'red',
+//     diffuse_green: 'green',
+//     diffuse_blue: 'blue'
+//   }
+// });
 import { makeLineIterator, makeTextDecoderIterator, forEach } from '@loaders.gl/loader-utils';
 import normalizePLY from "./normalize-ply.js";
 let currentElement;
+/**
+ * PARSER
+ * @param iterator
+ * @param options
+ */
 export async function* parsePLYInBatches(iterator, options) {
-  const lineIterator = makeLineIterator(makeTextDecoderIterator(iterator));
-  const header = await parsePLYHeader(lineIterator, options);
-  let attributes;
-  switch (header.format) {
-    case 'ascii':
-      attributes = await parseASCII(lineIterator, header);
-      break;
-    default:
-      throw new Error('Binary PLY can not yet be parsed in streaming mode');
-  }
-  yield normalizePLY(header, attributes, options);
+    const lineIterator = makeLineIterator(makeTextDecoderIterator(iterator));
+    const header = await parsePLYHeader(lineIterator, options);
+    let attributes;
+    switch (header.format) {
+        case 'ascii':
+            attributes = await parseASCII(lineIterator, header);
+            break;
+        default:
+            throw new Error('Binary PLY can not yet be parsed in streaming mode');
+        // attributes = await parseBinary(lineIterator, header);
+    }
+    yield normalizePLY(header, attributes, options);
 }
+/**
+ * Parses header
+ * @param lineIterator
+ * @param options
+ * @returns
+ */
 async function parsePLYHeader(lineIterator, options) {
-  const header = {
-    comments: [],
-    elements: []
-  };
-  await 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);
+    const header = {
+        comments: [],
+        elements: []
+        // headerLength
+    };
+    // Note: forEach does not reset iterator if exiting loop prematurely
+    // so that iteration can continue in a second loop
+    await forEach(lineIterator, (line) => {
+        line = line.trim();
+        // End of header
+        if (line === 'end_header') {
+            return true; // Returning true cancels `forEach`
         }
-        currentElement = {
-          name: lineValues[0],
-          count: parseInt(lineValues[1], 10),
-          properties: []
-        };
-        break;
-      case 'property':
-        const property = makePLYElementProperty(lineValues, options.propertyNameMapping);
-        currentElement.properties.push(property);
-        break;
-      default:
-        console.log('unhandled', lineType, lineValues);
+        // Ignore empty lines
+        if (line === '') {
+            // eslint-disable-next-line
+            return false; // Returning false does not cancel `forEach`
+        }
+        const lineValues = line.split(/\s+/);
+        const lineType = lineValues.shift();
+        line = lineValues.join(' ');
+        switch (lineType) {
+            case 'ply':
+                // First line magic characters, ignore
+                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 = makePLYElementProperty(lineValues, options.propertyNameMapping);
+                currentElement.properties.push(property);
+                break;
+            default:
+                // eslint-disable-next-line
+                console.log('unhandled', lineType, lineValues);
+        }
+        return false;
+    });
+    if (currentElement) {
+        header.elements.push(currentElement);
     }
-    return false;
-  });
-  if (currentElement) {
-    header.elements.push(currentElement);
-  }
-  return header;
+    return header;
 }
 function makePLYElementProperty(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]
-      };
-  }
+    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]
+            };
+    }
 }
+// ASCII PARSING
+/**
+ * @param lineIterator
+ * @param header
+ * @returns
+ */
 async function parseASCII(lineIterator, header) {
-  const attributes = {
-    indices: [],
-    vertices: [],
-    normals: [],
-    uvs: [],
-    colors: []
-  };
-  let currentElement = 0;
-  let currentElementCount = 0;
-  for await (let line of lineIterator) {
-    line = line.trim();
-    if (line !== '') {
-      if (currentElementCount >= header.elements[currentElement].count) {
-        currentElement++;
-        currentElementCount = 0;
-      }
-      const element = parsePLYElement(header.elements[currentElement].properties, line);
-      handleElement(attributes, header.elements[currentElement].name, element);
-      currentElementCount++;
+    // PLY ascii format specification, as per http://en.wikipedia.org/wiki/PLY_(file_format)
+    const attributes = {
+        indices: [],
+        vertices: [],
+        normals: [],
+        uvs: [],
+        colors: []
+    };
+    let currentElement = 0;
+    let currentElementCount = 0;
+    for await (let line of lineIterator) {
+        line = line.trim();
+        if (line !== '') {
+            if (currentElementCount >= header.elements[currentElement].count) {
+                currentElement++;
+                currentElementCount = 0;
+            }
+            const element = parsePLYElement(header.elements[currentElement].properties, line);
+            handleElement(attributes, header.elements[currentElement].name, element);
+            currentElementCount++;
+        }
     }
-  }
-  return attributes;
+    return attributes;
 }
+/**
+ * Parses ASCII number
+ * @param n
+ * @param type
+ * @returns ASCII number
+ */
+// eslint-disable-next-line complexity
 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);
-  }
+    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);
+    }
 }
+/**
+ * Parses ASCII element
+ * @param properties
+ * @param line
+ * @returns element
+ */
 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);
+    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;
+    return element;
 }
-function handleElement(buffer, elementName) {
-  let element = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  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.0, element.green / 255.0, element.blue / 255.0);
-      }
-      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;
-  }
+/**
+ * @param buffer
+ * @param elementName
+ * @param element
+ */
+// HELPER FUNCTIONS
+// eslint-disable-next-line complexity
+function handleElement(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.0, element.green / 255.0, element.blue / 255.0);
+            }
+            break;
+        case 'face':
+            const vertexIndices = element.vertex_indices || element.vertex_index; // issue #9338
+            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;
+    }
 }
-//# sourceMappingURL=parse-ply-in-batches.js.map

package/dist/lib/parse-ply.d.ts

@@ -1,4 +1,4 @@
-import type { PLYMesh } from './ply-types';
+import type { PLYMesh } from "./ply-types.js";
 export type ParsePLYOptions = {
     propertyNameMapping?: Record<string, string>;
 };

package/dist/lib/parse-ply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-ply.d.ts","sourceRoot":"","sources":["../../src/lib/parse-ply.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EACV,OAAO,EAMR,MAAM,aAAa,CAAC;AAGrB,MAAM,MAAM,eAAe,GAAG;IAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9C,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAc3F"}
+{"version":3,"file":"parse-ply.d.ts","sourceRoot":"","sources":["../../src/lib/parse-ply.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EACV,OAAO,EAMR,uBAAoB;AAGrB,MAAM,MAAM,eAAe,GAAG;IAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9C,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,EAAE,OAAO,GAAE,eAAoB,GAAG,OAAO,CAc3F"}