@loaders.gl/ply 3.4.0-alpha.1 → 3.4.0-alpha.3

package/dist/ply-worker.js

@@ -222,7 +222,7 @@
   }
 
   // src/ply-loader.ts
-  var VERSION = true ? "3.4.0-alpha.1" : "latest";
+  var VERSION = true ? "3.4.0-alpha.3" : "latest";
   var PLYLoader = {
     name: "PLY",
     id: "ply",
@@ -821,15 +821,36 @@
   }
   function getMeshAttributes(attributes) {
     const accessors = {};
-    accessors.POSITION = { value: new Float32Array(attributes.vertices), size: 3 };
-    if (attributes.normals.length > 0) {
-      accessors.NORMAL = { value: new Float32Array(attributes.normals), size: 3 };
-    }
-    if (attributes.uvs.length > 0) {
-      accessors.TEXCOORD_0 = { value: new Float32Array(attributes.uvs), size: 2 };
-    }
-    if (attributes.colors.length > 0) {
-      accessors.COLOR_0 = { value: new Uint8Array(attributes.colors), size: 3, normalized: true };
+    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;
   }
@@ -898,35 +919,72 @@
           };
           break;
         case "property":
-          if (!currentElement2) {
-            break;
+          if (currentElement2) {
+            const property = makePLYElementProperty(lineValues);
+            if (options?.propertyNameMapping && property.name in options?.propertyNameMapping) {
+              property.name = options?.propertyNameMapping[property.name];
+            }
+            currentElement2.properties.push(property);
           }
-          currentElement2.properties.push(makePLYElementProperty(lineValues, options.propertyNameMapping));
           break;
         default:
           console.log("unhandled", lineType, lineValues);
       }
     }
-    if (currentElement2 !== void 0) {
+    if (currentElement2) {
       header.elements.push(currentElement2);
     }
     return header;
   }
-  function makePLYElementProperty(propertValues, propertyNameMapping) {
-    const property = {
-      type: propertValues[0]
+  function getPLYAttributes(header) {
+    const attributes = {
+      indices: [],
+      vertices: [],
+      normals: [],
+      uvs: [],
+      colors: []
     };
-    if (property.type === "list") {
-      property.name = propertValues[3];
-      property.countType = propertValues[1];
-      property.itemType = propertValues[2];
-    } else {
-      property.name = propertValues[1];
+    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;
+          }
+        }
+      }
     }
-    if (propertyNameMapping && property.name in propertyNameMapping) {
-      property.name = propertyNameMapping[property.name];
+    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]
+        };
     }
-    return property;
   }
   function parseASCIINumber(n, type) {
     switch (type) {
@@ -952,7 +1010,7 @@
         throw new Error(type);
     }
   }
-  function parseASCIIElement(properties, line) {
+  function parsePLYElement(properties, line) {
     const values = line.split(/\s+/);
     const element = {};
     for (let i = 0; i < properties.length; i++) {
@@ -970,13 +1028,7 @@
     return element;
   }
   function parseASCII(data, header) {
-    const attributes = {
-      indices: [],
-      vertices: [],
-      normals: [],
-      uvs: [],
-      colors: []
-    };
+    const attributes = getPLYAttributes(header);
     let result;
     const patternBody = /end_header\s([\s\S]*)$/;
     let body = "";
@@ -994,7 +1046,7 @@
           currentElement2++;
           currentElementCount = 0;
         }
-        const element = parseASCIIElement(header.elements[currentElement2].properties, line);
+        const element = parsePLYElement(header.elements[currentElement2].properties, line);
         handleElement(attributes, header.elements[currentElement2].name, element);
         currentElementCount++;
       }
@@ -1003,15 +1055,40 @@
   }
   function handleElement(buffer, elementName, element = {}) {
     if (elementName === "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, element.green, element.blue);
+      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;
@@ -1078,13 +1155,7 @@
     return [element, read];
   }
   function parseBinary(data, header) {
-    const attributes = {
-      indices: [],
-      vertices: [],
-      normals: [],
-      uvs: [],
-      colors: []
-    };
+    const attributes = getPLYAttributes(header);
     const littleEndian = header.format === "binary_little_endian";
     const body = new DataView(data, header.headerLength);
     let result;
@@ -1166,21 +1237,22 @@
     }
     return header;
   }
-  function makePLYElementProperty2(propertValues, propertyNameMapping) {
-    const property = {
-      type: propertValues[0]
-    };
-    if (property.type === "list") {
-      property.name = propertValues[3];
-      property.countType = propertValues[1];
-      property.itemType = propertValues[2];
-    } else {
-      property.name = propertValues[1];
-    }
-    if (propertyNameMapping && property.name in propertyNameMapping) {
-      property.name = propertyNameMapping[property.name];
+  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]
+        };
     }
-    return property;
   }
   async function parseASCII2(lineIterator, header) {
     const attributes = {
@@ -1199,7 +1271,7 @@
           currentElement2++;
           currentElementCount = 0;
         }
-        const element = parseASCIIElement2(header.elements[currentElement2].properties, line);
+        const element = parsePLYElement2(header.elements[currentElement2].properties, line);
         handleElement2(attributes, header.elements[currentElement2].name, element);
         currentElementCount++;
       }
@@ -1230,7 +1302,7 @@
         throw new Error(type);
     }
   }
-  function parseASCIIElement2(properties, line) {
+  function parsePLYElement2(properties, line) {
     const values = line.split(/\s+/);
     const element = {};
     for (let i = 0; i < properties.length; i++) {
@@ -1278,10 +1350,10 @@
   // src/index.ts
   var PLYLoader2 = {
     ...PLYLoader,
-    parse: async (arrayBuffer, options) => parsePLY(arrayBuffer, options),
-    parseTextSync: parsePLY,
-    parseSync: parsePLY,
-    parseInBatches: parsePLYInBatches
+    parse: async (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),
+    parseTextSync: (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),
+    parseSync: (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),
+    parseInBatches: (arrayBuffer, options) => parsePLYInBatches(arrayBuffer, options?.ply)
   };
 
   // src/workers/ply-worker.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/ply",
-  "version": "3.4.0-alpha.1",
+  "version": "3.4.0-alpha.3",
   "description": "Framework-independent loader for the PLY format",
   "license": "MIT",
   "publishConfig": {
@@ -34,8 +34,8 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/loader-utils": "3.4.0-alpha.1",
-    "@loaders.gl/schema": "3.4.0-alpha.1"
+    "@loaders.gl/loader-utils": "3.4.0-alpha.3",
+    "@loaders.gl/schema": "3.4.0-alpha.3"
   },
-  "gitHead": "4085b0323050e4361614471319a1fb4729547bbf"
+  "gitHead": "a954528dd1d78a1f128d8f6b07e4baeb7a296924"
 }

package/src/index.ts

@@ -1,7 +1,7 @@
 import type {LoaderWithParser} from '@loaders.gl/loader-utils';
 import {PLYLoader as PLYWorkerLoader} from './ply-loader';
-import parsePLY from './lib/parse-ply';
-import parsePLYInBatches from './lib/parse-ply-in-batches';
+import {parsePLY} from './lib/parse-ply';
+import {parsePLYInBatches} from './lib/parse-ply-in-batches';
 
 // PLYLoader
 
@@ -13,10 +13,10 @@ export {PLYWorkerLoader};
 export const PLYLoader = {
   ...PLYWorkerLoader,
   // Note: parsePLY supports both text and binary
-  parse: async (arrayBuffer, options) => parsePLY(arrayBuffer, options), // TODO - this may not detect text correctly?
-  parseTextSync: parsePLY,
-  parseSync: parsePLY,
-  parseInBatches: parsePLYInBatches
+  parse: async (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply), // TODO - this may not detect text correctly?
+  parseTextSync: (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),
+  parseSync: (arrayBuffer, options) => parsePLY(arrayBuffer, options?.ply),
+  parseInBatches: (arrayBuffer, options) => parsePLYInBatches(arrayBuffer, options?.ply)
 };
 
 export const _typecheckPLYLoader: LoaderWithParser = PLYLoader;

package/src/lib/normalize-ply.ts

@@ -50,25 +50,47 @@ export default function normalizePLY(
  * @param attributes
  * @returns accessors []
  */
+// eslint-disable-next-line complexity
 function getMeshAttributes(attributes: PLYAttributes): MeshAttributes {
   const accessors: MeshAttributes = {};
 
-  accessors.POSITION = {value: new Float32Array(attributes.vertices), size: 3};
+  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
+      // optional attributes data
+      case 'normals':
+        if (attributes.normals.length > 0) {
+          accessors.NORMAL = {value: new Float32Array(attributes.normals), size: 3};
+        }
+        break;
 
-  if (attributes.normals.length > 0) {
-    accessors.NORMAL = {value: new Float32Array(attributes.normals), size: 3};
-  }
+      case 'uvs':
+        if (attributes.uvs.length > 0) {
+          accessors.TEXCOORD_0 = {value: new Float32Array(attributes.uvs), size: 2};
+        }
+        break;
 
-  if (attributes.uvs.length > 0) {
-    accessors.TEXCOORD_0 = {value: new Float32Array(attributes.uvs), size: 2};
-  }
+      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;
 
-  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};
-  }
+      case 'indices':
+        break;
 
+      default:
+        if (attributes[attributeName].length > 0) {
+          accessors[attributeName] = {value: new Float32Array(attributes[attributeName]), size: 1};
+        }
+        break;
+    }
+  }
   return accessors;
 }

package/src/lib/parse-ply-in-batches.ts

@@ -23,16 +23,16 @@
 
 import {makeLineIterator, makeTextDecoderIterator, forEach} from '@loaders.gl/loader-utils';
 import normalizePLY from './normalize-ply';
-import {PLYMesh, PLYHeader, ASCIIElement, PLYAttributes} from './ply-types';
+import {PLYMesh, PLYHeader, PLYElement, PLYProperty, PLYAttributes} from './ply-types';
 
-let currentElement: ASCIIElement;
+let currentElement: PLYElement;
 
 /**
  * PARSER
  * @param iterator
  * @param options
  */
-export default async function* parsePLYInBatches(
+export async function* parsePLYInBatches(
   iterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,
   options: any
 ): AsyncIterable<PLYMesh> {
@@ -134,24 +134,22 @@ async function parsePLYHeader(
   return header;
 }
 
-function makePLYElementProperty(propertValues: string[], propertyNameMapping: []) {
-  const property: {[index: string]: string} = {
-    type: propertValues[0]
-  };
-
-  if (property.type === 'list') {
-    property.name = propertValues[3];
-    property.countType = propertValues[1];
-    property.itemType = propertValues[2];
-  } else {
-    property.name = propertValues[1];
-  }
-
-  if (propertyNameMapping && property.name in propertyNameMapping) {
-    property.name = propertyNameMapping[property.name];
+function makePLYElementProperty(propertyValues: string[], propertyNameMapping: []): PLYProperty {
+  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]
+      };
   }
-
-  return property;
 }
 
 // ASCII PARSING
@@ -182,7 +180,7 @@ async function parseASCII(lineIterator: AsyncIterable<string>, header: PLYHeader
         currentElementCount = 0;
       }
 
-      const element = parseASCIIElement(header.elements[currentElement].properties, line);
+      const element = parsePLYElement(header.elements[currentElement].properties, line);
       handleElement(attributes, header.elements[currentElement].name, element);
       currentElementCount++;
     }
@@ -229,7 +227,7 @@ function parseASCIINumber(n: string, type: string): number {
  * @param line
  * @returns element
  */
-function parseASCIIElement(properties: any[], line: string) {
+function parsePLYElement(properties: any[], line: string) {
   const values: any = line.split(/\s+/);
 
   const element = {};